pohui_pohui/firmware
1
0
Fork 0
mirror of https://github.com/meshtastic/firmware.git synced 2025-06-08 06:02:05 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Cannedmessagemodule.h cleanup

Browse Source
This commit is contained in:
HarukiToreda 2025-05-24 20:46:33 -04:00
parent b2663d4b19
commit e974a58d18
1 changed files with 93 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
src/modules/CannedMessageModule.h
View File

@ -3,6 +3,10 @@
#include "ProtobufModule.h"
#include "input/InputBroker.h"
// ============================
// Enums & Defines
// ============================
enum cannedMessageModuleRunState {
CANNED_MESSAGE_RUN_STATE_DISABLED,
CANNED_MESSAGE_RUN_STATE_INACTIVE,
@ -25,6 +29,17 @@ enum cannedMessageDestinationType {
enum CannedMessageModuleIconType { shift, backspace, space, enter };
#define CANNED_MESSAGE_MODULE_MESSAGE_MAX_COUNT 50
#define CANNED_MESSAGE_MODULE_MESSAGES_SIZE 800
#ifndef CANNED_MESSAGE_MODULE_ENABLE
#define CANNED_MESSAGE_MODULE_ENABLE 0
#endif
// ============================
// Data Structures
// ============================
struct Letter {
String character;
float width;
@ -34,90 +49,57 @@ struct Letter {
int rectHeight;
};
#define CANNED_MESSAGE_MODULE_MESSAGE_MAX_COUNT 50
/**
* Sum of CannedMessageModuleConfig part sizes.
*/
#define CANNED_MESSAGE_MODULE_MESSAGES_SIZE 800
#ifndef CANNED_MESSAGE_MODULE_ENABLE
#define CANNED_MESSAGE_MODULE_ENABLE 0
#endif
struct NodeEntry {
meshtastic_NodeInfoLite *node;
uint32_t lastHeard;
};
class CannedMessageModule : public SinglePortModule, public Observable<const UIFrameEvent *>, private concurrency::OSThread
{
CallbackObserver<CannedMessageModule, const InputEvent *> inputObserver =
CallbackObserver<CannedMessageModule, const InputEvent *>(this, &CannedMessageModule::handleInputEvent);
private:
int displayHeight = 64; // Default to a common value, update dynamically
int destIndex = 0; // Tracks currently selected node/channel in selection mode
int scrollIndex = 0; // Tracks scrolling position in node selection grid
int visibleRows = 0;
bool needsUpdate = true;
String searchQuery;
std::vector<uint8_t> activeChannelIndices;
bool shouldRedraw = false;
unsigned long lastUpdateMillis = 0;
uint8_t lastAckHopStart = 0;
uint8_t lastAckHopLimit = 0;
public:
// ============================
// Main Class
// ============================
class CannedMessageModule : public SinglePortModule,
public Observable<const UIFrameEvent *>,
private concurrency::OSThread {
public:
CannedMessageModule();
// === Message navigation ===
const char *getCurrentMessage();
const char *getPrevMessage();
const char *getNextMessage();
const char *getMessageByIndex(int index);
const char *getNodeName(NodeNum node);
// === State/UI ===
bool shouldDraw();
bool hasMessages();
// void eventUp();
// void eventDown();
// void eventSelect();
void handleGetCannedMessageModuleMessages(const meshtastic_MeshPacket &req, meshtastic_AdminMessage *response);
void handleSetCannedMessageModuleMessages(const char *from_msg);
void showTemporaryMessage(const String &message);
void resetSearch();
void updateFilteredNodes();
std::vector<NodeEntry> filteredNodes;
String nodeSelectionInput;
String drawWithCursor(String text, int cursor);
// === Admin Handlers ===
void handleGetCannedMessageModuleMessages(const meshtastic_MeshPacket &req, meshtastic_AdminMessage *response);
void handleSetCannedMessageModuleMessages(const char *from_msg);
#ifdef RAK14014
cannedMessageModuleRunState getRunState() const { return runState; }
#endif
/*
-Override the wantPacket method. We need the Routing Messages to look for ACKs.
*/
virtual bool wantPacket(const meshtastic_MeshPacket *p) override
{
if (p->rx_rssi != 0) {
this->lastRxRssi = p->rx_rssi;
}
if (p->rx_snr > 0) {
this->lastRxSnr = p->rx_snr;
}
switch (p->decoded.portnum) {
case meshtastic_PortNum_ROUTING_APP:
return waitingForAck;
default:
return false;
}
// === Packet Interest Filter ===
virtual bool wantPacket(const meshtastic_MeshPacket *p) override {
if (p->rx_rssi != 0) lastRxRssi = p->rx_rssi;
if (p->rx_snr > 0) lastRxSnr = p->rx_snr;
return (p->decoded.portnum == meshtastic_PortNum_ROUTING_APP) ? waitingForAck : false;
}
protected:
protected:
// === Thread Entry Point ===
virtual int32_t runOnce() override;
// === Transmission ===
void sendText(NodeNum dest, ChannelIndex channel, const char *message, bool wantReplies);
int splitConfiguredMessages();
int getNextIndex();
int getPrevIndex();
@ -125,60 +107,81 @@ class CannedMessageModule : public SinglePortModule, public Observable<const UIF
#if defined(USE_VIRTUAL_KEYBOARD)
void drawKeyboard(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
String keyForCoordinates(uint x, uint y);
bool shift = false;
int charSet = 0;
void drawShiftIcon(OLEDDisplay *display, int x, int y, float scale = 1);
void drawBackspaceIcon(OLEDDisplay *display, int x, int y, float scale = 1);
void drawEnterIcon(OLEDDisplay *display, int x, int y, float scale = 1);
#endif
char highlight = 0x00;
// === Input Handling ===
int handleInputEvent(const InputEvent *event);
virtual bool wantUIFrame() override { return this->shouldDraw(); }
virtual bool wantUIFrame() override { return shouldDraw(); }
virtual Observable<const UIFrameEvent *> *getUIFrameObservable() override { return this; }
virtual bool interceptingKeyboardInput() override;
#if !HAS_TFT
virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) override;
#endif
virtual AdminMessageHandleResult handleAdminMessageForModule(const meshtastic_MeshPacket &mp,
meshtastic_AdminMessage *request,
meshtastic_AdminMessage *response) override;
virtual AdminMessageHandleResult handleAdminMessageForModule(
const meshtastic_MeshPacket &mp,
meshtastic_AdminMessage *request,
meshtastic_AdminMessage *response) override;
/** Called to handle a particular incoming message
* @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered
* for it
*/
virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
void loadProtoForModule();
bool saveProtoForModule();
void installDefaultCannedMessageModuleConfig();
int currentMessageIndex = -1;
cannedMessageModuleRunState runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
char payload = 0x00;
unsigned int cursor = 0;
String freetext = ""; // Text Buffer for Freetext Editor
NodeNum dest = NODENUM_BROADCAST;
ChannelIndex channel = 0;
cannedMessageDestinationType destSelect = CANNED_MESSAGE_DESTINATION_TYPE_NONE;
uint8_t numChannels = 0;
ChannelIndex indexChannels[MAX_NUM_CHANNELS] = {0};
NodeNum incoming = NODENUM_BROADCAST;
NodeNum lastSentNode = 0; // Tracks who the message was sent to (for ACK screen)
bool ack = false; // True means ACK, false means NAK (error_reason != NONE)
bool waitingForAck = false; // Are currently interested in routing packets?
bool lastAckWasRelayed = false;
float lastRxSnr = 0;
int32_t lastRxRssi = 0;
private:
// === Input Observers ===
CallbackObserver<CannedMessageModule, const InputEvent *> inputObserver =
CallbackObserver<CannedMessageModule, const InputEvent *>(this, &CannedMessageModule::handleInputEvent);
// === Display and UI ===
int displayHeight = 64;
int destIndex = 0;
int scrollIndex = 0;
int visibleRows = 0;
bool needsUpdate = true;
bool shouldRedraw = false;
unsigned long lastUpdateMillis = 0;
String searchQuery;
String nodeSelectionInput;
String freetext;
String temporaryMessage;
// === Message Storage ===
char messageStore[CANNED_MESSAGE_MODULE_MESSAGES_SIZE + 1];
char *messages[CANNED_MESSAGE_MODULE_MESSAGE_MAX_COUNT];
int messagesCount = 0;
int currentMessageIndex = -1;
// === Routing & Acknowledgment ===
NodeNum dest = NODENUM_BROADCAST; // Destination node for outgoing messages (default: broadcast)
NodeNum incoming = NODENUM_BROADCAST; // Source node from which last ACK/NACK was received
NodeNum lastSentNode = 0; // Tracks the most recent node we sent a message to (for UI display)
ChannelIndex channel = 0; // Channel index used when sending a message
uint8_t numChannels = 0; // Total number of channels available for selection
ChannelIndex indexChannels[MAX_NUM_CHANNELS] = {0}; // Cached channel indices available for this node
bool ack = false; // True = ACK received, False = NACK or failed
bool waitingForAck = false; // True if we're expecting an ACK and should monitor routing packets
bool lastAckWasRelayed = false; // True if the ACK was relayed through intermediate nodes
uint8_t lastAckHopStart = 0; // Hop start value from the received ACK packet
uint8_t lastAckHopLimit = 0; // Hop limit value from the received ACK packet
float lastRxSnr = 0; // SNR from last received ACK (used for diagnostics/UI)
int32_t lastRxRssi = 0; // RSSI from last received ACK (used for diagnostics/UI)
// === State Tracking ===
cannedMessageModuleRunState runState = CANNED_MESSAGE_RUN_STATE_INACTIVE;
cannedMessageDestinationType destSelect = CANNED_MESSAGE_DESTINATION_TYPE_NONE;
char highlight = 0x00;
char payload = 0x00;
unsigned int cursor = 0;
unsigned long lastTouchMillis = 0;
String temporaryMessage;
std::vector<uint8_t> activeChannelIndices;
std::vector<NodeEntry> filteredNodes;
#if defined(USE_VIRTUAL_KEYBOARD)
Letter keyboard[2][4][10] = {{{{"Q", 20, 0, 0, 0, 0},