Look into tophone queue for the received packet.

- only works if we don't have a phone connected, but that is probably dsired
- this will send a copy of device-originating text messgaes to a connected phone. Breaking change.
- this will iterate the tophone queue by deconstructing and reconstructing it every time we look for an ID. Probably also mangles the queue oder since it aborts when a ID is found.
- Can we navigate the packet pool instead? If so, how?
- Let's keep this in draft state for now

src/mesh/MeshService.cpp

@@ -140,6 +140,22 @@ void MeshService::reloadOwner(bool shouldSave)
     }
 }
 
+// search the queue for a request id and return the matching nodenum
+NodeNum MeshService::getNodenumFromRequestId(uint32_t request_id)
+{
+    NodeNum nodenum = 0;
+    for (int i = 0; i < toPhoneQueue.numUsed(); i++) {
+        meshtastic_MeshPacket *p = toPhoneQueue.dequeuePtr(0);
+        // put it right back on the queue
+        toPhoneQueue.enqueue(p, 0);
+        if (p->id == request_id) {
+            nodenum = p->to;
+            break;
+        }
+    }
+    return nodenum;
+}
+
 /**
  *  Given a ToRadio buffer parse it and properly handle it (setup radio, owner or send packet into the mesh)
  * Called by PhoneAPI.handleToRadio.  Note: p is a scratch buffer, this function is allowed to write to it but it can not keep a

src/mesh/MeshService.h

@@ -82,6 +82,9 @@ class MeshService
     /// Return the next MqttClientProxyMessage packet destined to the phone.
     meshtastic_MqttClientProxyMessage *getMqttClientProxyMessageForPhone() { return toPhoneMqttProxyQueue.dequeuePtr(0); }
 
+    // search the queue for a request id and return the matching nodenum
+    NodeNum getNodenumFromRequestId(uint32_t request_id);
+
     // Release QueueStatus packet to pool
     void releaseQueueStatusToPool(meshtastic_QueueStatus *p) { queueStatusPool.release(p); }
 

src/mesh/TypedQueue.h

@@ -27,6 +27,8 @@ template <class T> class TypedQueue
 
     bool isEmpty() { return uxQueueMessagesWaiting(h) == 0; }
 
+    int numUsed() { return uxQueueMessagesWaiting(h); }
+
     /** euqueue a packet.  Also, maxWait used to default to portMAX_DELAY, but we now want to callers to THINK about what blocking
      * they want */
     bool enqueue(T x, TickType_t maxWait)
@@ -80,6 +82,8 @@ template <class T> class TypedQueue
 
     bool isEmpty() { return q.empty(); }
 
+    int numUsed() { return q.size(); }
+
     bool enqueue(T x, TickType_t maxWait = portMAX_DELAY)
     {
         if (reader) {

src/modules/CannedMessageModule.cpp

@@ -233,7 +233,9 @@ void CannedMessageModule::sendText(NodeNum dest, const char *message, bool wantR
 
     LOG_INFO("Sending message id=%d, dest=%x, msg=%.*s\n", p->id, p->to, p->decoded.payload.size, p->decoded.payload.bytes);
 
-    service.sendToMesh(p);
+    service.sendToMesh(
+        p, RX_SRC_LOCAL,
+        true); // send to mesh, cc to phone. Even if there's no phone connected, this stores the message to match ACKs
 }
 
 int32_t CannedMessageModule::runOnce()
@@ -245,7 +247,7 @@ int32_t CannedMessageModule::runOnce()
     // LOG_DEBUG("Check status\n");
     UIFrameEvent e = {false, true};
     if ((this->runState == CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE) ||
-        (this->runState == CANNED_MESSAGE_RUN_STATE_ACK_RECEIVED)) {
+        (this->runState == CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED)) {
         // TODO: might have some feedback of sendig state
         this->runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
         e.frameChanged = true;
@@ -484,14 +486,15 @@ void CannedMessageModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *st
 {
     char buffer[50];
 
-    if (cannedMessageModule->runState == CANNED_MESSAGE_RUN_STATE_ACK_RECEIVED) {
+    if (cannedMessageModule->runState == CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED) {
         display->setTextAlignment(TEXT_ALIGN_CENTER);
         display->setFont(FONT_MEDIUM);
         String displayString;
-        if (this->ack)
+        if (this->ack) {
             displayString = "Delivered to\n%s";
-        else
+        } else {
             displayString = "Delivery failed\nto %s";
+        }
         display->drawStringf(display->getWidth() / 2 + x, 0 + y + 12, buffer, displayString,
                              cannedMessageModule->getNodeName(this->incoming));
     } else if (cannedMessageModule->runState == CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE) {
@@ -564,8 +567,8 @@ ProcessMessage CannedMessageModule::handleReceived(const meshtastic_MeshPacket &
         if (mp.decoded.request_id != 0) {
             UIFrameEvent e = {false, true};
             e.frameChanged = true;
-            this->runState = CANNED_MESSAGE_RUN_STATE_ACK_RECEIVED;
-            this->incoming = mp.decoded.request_id;
+            this->runState = CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED;
+            this->incoming = service.getNodenumFromRequestId(mp.decoded.request_id);
             meshtastic_Routing decoded = meshtastic_Routing_init_default;
             pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, meshtastic_Routing_fields, &decoded);
             this->ack = decoded.error_reason == meshtastic_Routing_Error_NONE;

src/modules/CannedMessageModule.h

@@ -9,7 +9,7 @@ enum cannedMessageModuleRunState {
     CANNED_MESSAGE_RUN_STATE_ACTIVE,
     CANNED_MESSAGE_RUN_STATE_FREETEXT,
     CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE,
-    CANNED_MESSAGE_RUN_STATE_ACK_RECEIVED,
+    CANNED_MESSAGE_RUN_STATE_ACK_NACK_RECEIVED,
     CANNED_MESSAGE_RUN_STATE_ACTION_SELECT,
     CANNED_MESSAGE_RUN_STATE_ACTION_UP,
     CANNED_MESSAGE_RUN_STATE_ACTION_DOWN,