Add StatusMessage module and config overrides (#9351)

* Add StatusMessage module and config overrides

* Trunk

* Don't reboot node simply for a StatusMessage config update

src/modules/AdminModule.cpp

@@ -905,10 +905,11 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c)
 
 bool AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c)
 {
+    bool shouldReboot = true;
     // If we are in an open transaction or configuring MQTT or Serial (which have validation), defer disabling Bluetooth
     // Otherwise, disable Bluetooth to prevent the phone from interfering with the config
-    if (!hasOpenEditTransaction &&
-        !IS_ONE_OF(c.which_payload_variant, meshtastic_ModuleConfig_mqtt_tag, meshtastic_ModuleConfig_serial_tag)) {
+    if (!hasOpenEditTransaction && !IS_ONE_OF(c.which_payload_variant, meshtastic_ModuleConfig_mqtt_tag,
+                                              meshtastic_ModuleConfig_serial_tag, meshtastic_ModuleConfig_statusmessage_tag)) {
         disableBluetooth();
     }
 
@@ -1000,8 +1001,14 @@ bool AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c)
         moduleConfig.has_paxcounter = true;
         moduleConfig.paxcounter = c.payload_variant.paxcounter;
         break;
+    case meshtastic_ModuleConfig_statusmessage_tag:
+        LOG_INFO("Set module config: StatusMessage");
+        moduleConfig.has_statusmessage = true;
+        moduleConfig.statusmessage = c.payload_variant.statusmessage;
+        shouldReboot = false;
+        break;
     }
-    saveChanges(SEGMENT_MODULECONFIG);
+    saveChanges(SEGMENT_MODULECONFIG, shouldReboot);
     return true;
 }
 
@@ -1180,6 +1187,11 @@ void AdminModule::handleGetModuleConfig(const meshtastic_MeshPacket &req, const
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_paxcounter_tag;
             res.get_module_config_response.payload_variant.paxcounter = moduleConfig.paxcounter;
             break;
+        case meshtastic_AdminMessage_ModuleConfigType_STATUSMESSAGE_CONFIG:
+            LOG_INFO("Get module config: StatusMessage");
+            res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_statusmessage_tag;
+            res.get_module_config_response.payload_variant.statusmessage = moduleConfig.statusmessage;
+            break;
         }
 
         // NOTE: The phone app needs to know the ls_secsvalue so it can properly expect sleep behavior.

src/modules/Modules.cpp

@@ -90,6 +90,9 @@
 #if !MESHTASTIC_EXCLUDE_DROPZONE
 #include "modules/DropzoneModule.h"
 #endif
+#if !MESHTASTIC_EXCLUDE_STATUS
+#include "modules/StatusMessageModule.h"
+#endif
 
 #if defined(HAS_HARDWARE_WATCHDOG)
 #include "watchdog/watchdogThread.h"
@@ -150,6 +153,9 @@ void setupModules()
 #if !MESHTASTIC_EXCLUDE_DROPZONE
     dropzoneModule = new DropzoneModule();
 #endif
+#if !MESHTASTIC_EXCLUDE_STATUS
+    statusMessageModule = new StatusMessageModule();
+#endif
 #if !MESHTASTIC_EXCLUDE_GENERIC_THREAD_MODULE
     new GenericThreadModule();
 #endif

src/modules/StatusMessageModule.cpp

@@ -0,0 +1,41 @@
+#if !MESHTASTIC_EXCLUDE_STATUS
+
+#include "StatusMessageModule.h"
+#include "MeshService.h"
+#include "ProtobufModule.h"
+
+StatusMessageModule *statusMessageModule;
+
+int32_t StatusMessageModule::runOnce()
+{
+    if (moduleConfig.has_statusmessage && moduleConfig.statusmessage.node_status[0] != '\0') {
+        // create and send message with the status message set
+        meshtastic_StatusMessage ourStatus = meshtastic_StatusMessage_init_zero;
+        strncpy(ourStatus.status, moduleConfig.statusmessage.node_status, sizeof(ourStatus.status));
+        ourStatus.status[sizeof(ourStatus.status) - 1] = '\0'; // ensure null termination
+        meshtastic_MeshPacket *p = allocDataPacket();
+        p->decoded.payload.size = pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes),
+                                                     meshtastic_StatusMessage_fields, &ourStatus);
+        p->to = NODENUM_BROADCAST;
+        p->decoded.want_response = false;
+        p->priority = meshtastic_MeshPacket_Priority_BACKGROUND;
+        p->channel = 0;
+        service->sendToMesh(p);
+    }
+
+    return 1000 * 12 * 60 * 60;
+}
+
+ProcessMessage StatusMessageModule::handleReceived(const meshtastic_MeshPacket &mp)
+{
+    if (mp.which_payload_variant == meshtastic_MeshPacket_decoded_tag) {
+        meshtastic_StatusMessage incomingMessage;
+        if (pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, meshtastic_StatusMessage_fields,
+                                 &incomingMessage)) {
+            LOG_INFO("Received a NodeStatus message %s", incomingMessage.status);
+        }
+    }
+    return ProcessMessage::CONTINUE;
+}
+
+#endif

src/modules/StatusMessageModule.h

@@ -0,0 +1,35 @@
+#pragma once
+#if !MESHTASTIC_EXCLUDE_STATUS
+#include "SinglePortModule.h"
+#include "configuration.h"
+
+class StatusMessageModule : public SinglePortModule, private concurrency::OSThread
+{
+
+  public:
+    /** Constructor
+     * name is for debugging output
+     */
+    StatusMessageModule()
+        : SinglePortModule("statusMessage", meshtastic_PortNum_NODE_STATUS_APP), concurrency::OSThread("StatusMessage")
+    {
+        if (moduleConfig.has_statusmessage && moduleConfig.statusmessage.node_status[0] != '\0') {
+            this->setInterval(2 * 60 * 1000);
+        } else {
+            this->setInterval(1000 * 12 * 60 * 60);
+        }
+        // TODO: If we have a string, set the initial delay (15 minutes maybe)
+    }
+
+    virtual int32_t runOnce() override;
+
+  protected:
+    /** Called to handle a particular incoming message
+     */
+    virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
+
+  private:
+};
+
+extern StatusMessageModule *statusMessageModule;
+#endif