: SinglePortModule("canned", meshtastic_PortNum_TEXT_MESSAGE_APP), concurrency::OSThread("CannedMessage")

{

this->loadProtoForModule();

if ((this->splitConfiguredMessages() <= 0) && (cardkb_found.address == 0x00) && !INPUTBROKER_MATRIX_TYPE) {

LOG_INFO("CannedMessageModule: No messages are configured. Module is disabled");

this->updateState(CANNED_MESSAGE_RUN_STATE_DISABLED);

disable();

} else {

LOG_INFO("CannedMessageModule is enabled");

moduleConfig.canned_message.enabled = true;

this->inputObserver.observe(inputBroker);

}

{

// Do NOT override explicit broadcast replies

// Only reuse lastDest in LaunchRepeatDestination()

if (newDest == 0) {

dest = NODENUM_BROADCAST;

} else {

dest = newDest;

}

channel = newChannel;

lastDest = dest;

lastChannel = channel;

lastDestSet = true;

// Upon activation, highlight "[Select Destination]"

int selectDestination = 0;

for (int i = 0; i < messagesCount; ++i) {

if (strcmp(messages[i], "[Select Destination]") == 0) {

selectDestination = i;

break;

}

}

currentMessageIndex = selectDestination;

// This triggers the canned message list

updateState(CANNED_MESSAGE_RUN_STATE_ACTIVE, true);

UIFrameEvent e;

e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

notifyObservers(&e);

LOG_DEBUG("[CannedMessage] LaunchWithDestination dest=0x%08x ch=%d", dest, channel);

{

if (!lastDestSet) {

LaunchWithDestination(NODENUM_BROADCAST, 0);

} else {

LaunchWithDestination(lastDest, lastChannel);

}

{

// Do NOT override explicit broadcast replies

// Only reuse lastDest in LaunchRepeatDestination()

if (newDest == 0) {

dest = NODENUM_BROADCAST;

} else {

dest = newDest;

}

channel = newChannel;

lastDest = dest;

lastChannel = channel;

lastDestSet = true;

updateState(CANNED_MESSAGE_RUN_STATE_FREETEXT, true);

UIFrameEvent e;

e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

notifyObservers(&e);

LOG_DEBUG("[CannedMessage] LaunchFreetextWithDestination dest=0x%08x ch=%d", dest, channel);

{

int i = 0;

String canned_messages = cannedMessageModuleConfig.messages;

// Copy all message parts into the buffer

strncpy(this->messageBuffer, canned_messages.c_str(), sizeof(this->messageBuffer));

// Temporary array to allow for insertion

const char *tempMessages[CANNED_MESSAGE_MODULE_MESSAGE_MAX_COUNT + 3] = {0};

int tempCount = 0;

// Insert at position 0 (top)

tempMessages[tempCount++] = "[Select Destination]";

#if defined(USE_VIRTUAL_KEYBOARD)

// Add a "Free Text" entry at the top if using a touch screen virtual keyboard

tempMessages[tempCount++] = "[-- Free Text --]";

#else

if (osk_found && screen) {

tempMessages[tempCount++] = "[-- Free Text --]";

}

#endif

// First message always starts at buffer start

tempMessages[tempCount++] = this->messageBuffer;

int upTo = strlen(this->messageBuffer) - 1;

// Walk buffer, splitting on '|'

while (i < upTo) {

if (this->messageBuffer[i] == '|') {

this->messageBuffer[i] = '\0'; // End previous message

if (tempCount >= CANNED_MESSAGE_MODULE_MESSAGE_MAX_COUNT)

break;

tempMessages[tempCount++] = (this->messageBuffer + i + 1);

}

i += 1;

}

// Add [Exit] as the last entry

tempMessages[tempCount++] = "[Exit]";

// Copy to the member array

for (int k = 0; k < tempCount; ++k) {

this->messages[k] = (char *)tempMessages[k];

}

this->messagesCount = tempCount;

return this->messagesCount;

{

(void)buffer;

char header[96];

if (this->dest == NODENUM_BROADCAST) {

const char *channelName = channels.getName(this->channel);

snprintf(header, sizeof(header), "To: #%s", channelName ? channelName : "?");

} else {

snprintf(header, sizeof(header), "To: @%s", getNodeName(this->dest));

}

const int maxWidth = std::max(0, display->getWidth() - x);

char truncatedHeader[96];

graphics::UIRenderer::truncateStringWithEmotes(display, header, truncatedHeader, sizeof(truncatedHeader), maxWidth);

graphics::UIRenderer::drawStringWithEmotes(display, x, y, truncatedHeader, FONT_HEIGHT_SMALL, 1, false);

{

int previousDestIndex = destIndex;

searchQuery = "";

updateDestinationSelectionList();

// Adjust scrollIndex so previousDestIndex is still visible

int totalEntries = activeChannelIndices.size() + filteredNodes.size();

this->visibleRows = (displayHeight - FONT_HEIGHT_SMALL * 2) / FONT_HEIGHT_SMALL;

if (this->visibleRows < 1)

this->visibleRows = 1;

int maxScrollIndex = std::max(0, totalEntries - visibleRows);

scrollIndex = std::min(std::max(previousDestIndex - (visibleRows / 2), 0), maxScrollIndex);

lastUpdateMillis = millis();

requestFocus();

{

static size_t lastNumMeshNodes = 0;

static String lastSearchQuery = "";

size_t numMeshNodes = nodeDB->getNumMeshNodes();

bool nodesChanged = (numMeshNodes != lastNumMeshNodes);

lastNumMeshNodes = numMeshNodes;

// Early exit if nothing changed

if (searchQuery == lastSearchQuery && !nodesChanged)

return;

lastSearchQuery = searchQuery;

needsUpdate = false;

this->filteredNodes.clear();

this->activeChannelIndices.clear();

NodeNum myNodeNum = nodeDB->getNodeNum();

String lowerSearchQuery = searchQuery;

lowerSearchQuery.toLowerCase();

// Preallocate space to reduce reallocation

this->filteredNodes.reserve(numMeshNodes);

for (size_t i = 0; i < numMeshNodes; ++i) {

meshtastic_NodeInfoLite *node = nodeDB->getMeshNodeByIndex(i);

if (!node || node->num == myNodeNum || !nodeInfoLiteHasUser(node) || node->public_key.size != 32)

continue;

const String &nodeName = node->long_name;

if (searchQuery.length() == 0) {

this->filteredNodes.push_back({node, sinceLastSeen(node)});

} else {

// Avoid unnecessary lowercase conversion if already matched

String lowerNodeName = nodeName;

lowerNodeName.toLowerCase();

if (lowerNodeName.indexOf(lowerSearchQuery) != -1) {

this->filteredNodes.push_back({node, sinceLastSeen(node)});

}

}

}

meshtastic_MeshPacket *p = allocDataPacket();

p->pki_encrypted = true;

p->channel = 0;

// Populate active channels

std::vector<String> seenChannels;

seenChannels.reserve(channels.getNumChannels());

for (uint8_t i = 0; i < channels.getNumChannels(); ++i) {

String name = channels.getName(i);

if (name.length() > 0 && std::find(seenChannels.begin(), seenChannels.end(), name) == seenChannels.end()) {

this->activeChannelIndices.push_back(i);

seenChannels.push_back(name);

}

}

scrollIndex = 0; // Show first result at the top

destIndex = 0; // Highlight the first entry

if (nodesChanged && runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION) {

LOG_INFO("Nodes changed, forcing UI refresh.");

screen->forceDisplay();

}

{

// Grow the row only when an emote is taller than the font.

const auto metrics =

graphics::EmoteRenderer::analyzeLine(nullptr, text ? text : "", 0, graphics::emotes, graphics::numEmotes, emoteSpacing);

return std::max(minimumHeight, metrics.tallestHeight + 2);

{

// Center mixed text and emotes inside the row height.

const auto metrics = graphics::EmoteRenderer::analyzeLine(nullptr, text ? text : "", FONT_HEIGHT_SMALL, graphics::emotes,

graphics::numEmotes, emoteSpacing);

const int contentHeight = std::max(FONT_HEIGHT_SMALL, metrics.tallestHeight);

const int drawY = y + ((rowHeight - contentHeight) / 2);

graphics::EmoteRenderer::drawStringWithEmotes(display, x, drawY, text ? text : "", FONT_HEIGHT_SMALL, graphics::emotes,

graphics::numEmotes, emoteSpacing, false);

{

// Fall back to one full emote or one UTF-8 glyph when width is tiny.

if (!text || !*text)

return 0;

const size_t textLen = strlen(text);

size_t matchLen = 0;

if (graphics::EmoteRenderer::findEmoteAt(text, textLen, 0, matchLen, graphics::emotes, graphics::numEmotes))

return matchLen;

return graphics::EmoteRenderer::utf8CharLen(static_cast<uint8_t>(text[0]));

int emoteSpacing = 2)

{

// Wrap onto multiple rows without splitting emotes.

if (!display || !text || maxWidth <= 0)

return;

constexpr size_t kLineBufferSize = 256;

char lineBuffer[kLineBufferSize];

const size_t textLen = strlen(text);

size_t offset = 0;

int yCursor = y;

while (offset < textLen) {

size_t copied = graphics::EmoteRenderer::truncateToWidth(display, text + offset, lineBuffer, sizeof(lineBuffer), maxWidth,

"", graphics::emotes, graphics::numEmotes, emoteSpacing);

size_t consumed = copied;

if (copied == 0) {

consumed = firstWrappedTokenLen(text + offset);

if (consumed == 0)

break;

const size_t fallbackLen = std::min(consumed, sizeof(lineBuffer) - 1);

memcpy(lineBuffer, text + offset, fallbackLen);

lineBuffer[fallbackLen] = '\0';

consumed = fallbackLen;

} else if (text[offset + copied] != '\0') {

// Prefer wrapping at the last space when a full line does not fit.

size_t lastSpace = copied;

while (lastSpace > 0 && lineBuffer[lastSpace - 1] != ' ')

--lastSpace;

if (lastSpace > 0) {

consumed = lastSpace;

while (consumed > 0 && lineBuffer[consumed - 1] == ' ')

--consumed;

lineBuffer[consumed] = '\0';

}

}

if (lineBuffer[0]) {

const int rowHeight = getRowHeightForEmoteText(lineBuffer, minimumRowHeight, emoteSpacing);

drawCenteredEmoteText(display, x, yCursor, rowHeight, lineBuffer, emoteSpacing);

yCursor += rowHeight;

}

offset += std::max<size_t>(consumed, 1);

while (offset < textLen && text[offset] == ' ')

++offset;

}

{

// Block ALL input if an alert banner is active

if (screen && screen->isOverlayBannerShowing()) {

return 0;

}

// Tab key: Always allow switching between canned/destination screens

if (event->kbchar == INPUT_BROKER_MSG_TAB && handleTabSwitch(event))

return 1;

// Matrix keypad: If matrix key, trigger action select for canned message

if (event->inputEvent == INPUT_BROKER_MATRIXKEY) {

updateState(CANNED_MESSAGE_RUN_STATE_ACTION_SELECT, true);

payload = INPUT_BROKER_MATRIXKEY;

currentMessageIndex = event->kbchar - 1;

lastTouchMillis = millis();

return 1;

}

// Always normalize navigation/select buttons for further handlers

bool isUp = isUpEvent(event);

bool isDown = isDownEvent(event);

bool isSelect = isSelectEvent(event);

// Route event to handler for current UI state (no double-handling)

switch (runState) {

// Node/Channel destination selection mode: Handles character search, arrows, select, cancel, backspace

case CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION:

if (handleDestinationSelectionInput(event, isUp, isDown, isSelect))

return 1;

return 0; // prevent fall-through to selector input

// Free text input mode: Handles character input, cancel, backspace, select, etc.

case CANNED_MESSAGE_RUN_STATE_FREETEXT:

return handleFreeTextInput(event); // All allowed input for this state

// Virtual keyboard mode: Show virtual keyboard and handle input

// If sending, block all input except global/system (handled above)

case CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE:

return 1;

// If sending, block all input except global/system (handled above)

case CANNED_MESSAGE_RUN_STATE_EMOTE_PICKER:

return handleEmotePickerInput(event);

case CANNED_MESSAGE_RUN_STATE_INACTIVE:

if (event->inputEvent == INPUT_BROKER_ALT_LONG) {

LaunchWithDestination(NODENUM_BROADCAST);

return 1;

}

// Printable char (ASCII) opens free text compose

if (event->kbchar >= 32 && event->kbchar <= 126) {

updateState(CANNED_MESSAGE_RUN_STATE_FREETEXT, true);

UIFrameEvent e;

e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

notifyObservers(&e);

// Immediately process the input in the new state (freetext)

return handleFreeTextInput(event);

}

return 0;

break;

// (Other states can be added here as needed)

default:

break;

}

// If no state handler above processed the event, let the message selector try to handle it

// (Handles up/down/select on canned message list, exit/return)

if (handleMessageSelectorInput(event, isUp, isDown, isSelect))

return 1;

// Default: event not handled by canned message system, allow others to process

return 0;

{

runState = newState;

if (runState == CANNED_MESSAGE_RUN_STATE_FREETEXT) {

inputBroker->menuMode =

false; // Allow any key input to be sent to the message composer instead of being interpreted as menu navigation

} else {

inputBroker->menuMode = true; // Re-enable menu navigation for destination selection

}

if (shouldRequestFocus) {

requestFocus();

}

{

return event->inputEvent == INPUT_BROKER_UP ||

((runState == CANNED_MESSAGE_RUN_STATE_ACTIVE || runState == CANNED_MESSAGE_RUN_STATE_EMOTE_PICKER ||

runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION) &&

(event->inputEvent == INPUT_BROKER_LEFT || event->inputEvent == INPUT_BROKER_ALT_PRESS));

{

return event->inputEvent == INPUT_BROKER_DOWN ||

((runState == CANNED_MESSAGE_RUN_STATE_ACTIVE || runState == CANNED_MESSAGE_RUN_STATE_EMOTE_PICKER ||

runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION) &&

(event->inputEvent == INPUT_BROKER_RIGHT || event->inputEvent == INPUT_BROKER_USER_PRESS));

{

if (event->kbchar != 0x09)

return false;

const cannedMessageModuleRunState targetState = (runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION)

? CANNED_MESSAGE_RUN_STATE_FREETEXT

: CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION;

destIndex = 0;

scrollIndex = 0;

if (targetState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION)

updateDestinationSelectionList();

updateState(targetState, true);

UIFrameEvent e;

e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

notifyObservers(&e);

screen->forceDisplay();

return true;

{

// Override isDown and isSelect ONLY for destination selector behavior

if (runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION) {

if (event->inputEvent == INPUT_BROKER_USER_PRESS) {

isDown = true;

} else if (event->inputEvent == INPUT_BROKER_SELECT) {

isSelect = true;

}

}

if (event->kbchar >= 32 && event->kbchar <= 126 && !isUp && !isDown && event->inputEvent != INPUT_BROKER_LEFT &&

event->inputEvent != INPUT_BROKER_RIGHT && event->inputEvent != INPUT_BROKER_SELECT) {

this->searchQuery += (char)event->kbchar;

needsUpdate = true;

if ((millis() - lastFilterUpdate) > filterDebounceMs) {

runOnce(); // update filter immediately

lastFilterUpdate = millis();

}

return 1;

}

size_t numMeshNodes = filteredNodes.size();

int totalEntries = numMeshNodes + activeChannelIndices.size();

int columns = 1;

int totalRows = totalEntries;

int maxScrollIndex = std::max(0, totalRows - visibleRows);

scrollIndex = clamp(scrollIndex, 0, maxScrollIndex);

// Handle backspace

if (event->inputEvent == INPUT_BROKER_BACK) {

if (searchQuery.length() > 0) {

searchQuery.remove(searchQuery.length() - 1);

needsUpdate = true;

runOnce();

}

if (searchQuery.length() == 0) {

resetSearch();

needsUpdate = false;

}

return 1;

}

if (isUp) {

if (destIndex > 0) {

destIndex--;

} else if (totalEntries > 0) {

destIndex = totalEntries - 1;

}

if ((destIndex / columns) < scrollIndex)

scrollIndex = destIndex / columns;

else if ((destIndex / columns) >= (scrollIndex + visibleRows))

scrollIndex = (destIndex / columns) - visibleRows + 1;

screen->forceDisplay(true);

return 1;

}

if (isDown) {

if (destIndex + 1 < totalEntries) {

destIndex++;

} else if (totalEntries > 0) {

destIndex = 0;

scrollIndex = 0;

}

if ((destIndex / columns) >= (scrollIndex + visibleRows))

scrollIndex = (destIndex / columns) - visibleRows + 1;

screen->forceDisplay(true);

return 1;

}

// SELECT

if (isSelect) {

if (destIndex < static_cast<int>(activeChannelIndices.size())) {

dest = NODENUM_BROADCAST;

channel = activeChannelIndices[destIndex];

lastDest = dest;

lastChannel = channel;

lastDestSet = true;

} else {

int nodeIndex = destIndex - static_cast<int>(activeChannelIndices.size());

if (nodeIndex >= 0 && nodeIndex < static_cast<int>(filteredNodes.size())) {

const meshtastic_NodeInfoLite *selectedNode = filteredNodes[nodeIndex].node;

if (selectedNode) {

dest = selectedNode->num;

channel = selectedNode->channel;

// Already saves here, but for clarity, also:

lastDest = dest;

lastChannel = channel;

lastDestSet = true;

}

}

}

updateState(returnToCannedList ? CANNED_MESSAGE_RUN_STATE_ACTIVE : CANNED_MESSAGE_RUN_STATE_FREETEXT, true);

returnToCannedList = false;

screen->forceDisplay(true);

return 1;

}

// CANCEL

if (event->inputEvent == INPUT_BROKER_CANCEL || event->inputEvent == INPUT_BROKER_ALT_LONG) {

updateState(returnToCannedList ? CANNED_MESSAGE_RUN_STATE_ACTIVE : CANNED_MESSAGE_RUN_STATE_FREETEXT, true);

returnToCannedList = false;

searchQuery = "";

// UIFrameEvent e;

// e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

// notifyObservers(&e);

screen->forceDisplay(true);

return 1;

}

return 0;

{

// Override isDown and isSelect ONLY for canned message list behavior

if (runState == CANNED_MESSAGE_RUN_STATE_ACTIVE) {

if (event->inputEvent == INPUT_BROKER_USER_PRESS) {

isDown = true;

} else if (event->inputEvent == INPUT_BROKER_SELECT) {

isSelect = true;

}

}

if (runState == CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION)

return false;

// Handle Cancel key: go inactive, clear UI state

if (runState != CANNED_MESSAGE_RUN_STATE_INACTIVE &&

(event->inputEvent == INPUT_BROKER_CANCEL || event->inputEvent == INPUT_BROKER_ALT_LONG)) {

updateState(CANNED_MESSAGE_RUN_STATE_INACTIVE);

freetext = "";

cursor = 0;

payload = 0;

currentMessageIndex = -1;

// Notify UI that we want to redraw/close this screen

UIFrameEvent e;

e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

notifyObservers(&e);

screen->forceDisplay();

return true;

}

bool handled = false;

// Handle up/down navigation

if (isUp && messagesCount > 0) {

updateState(CANNED_MESSAGE_RUN_STATE_ACTION_UP);

handled = true;

} else if (isDown && messagesCount > 0) {

updateState(CANNED_MESSAGE_RUN_STATE_ACTION_DOWN);

handled = true;

} else if (isSelect) {

const char *current = messages[currentMessageIndex];

// [Select Destination] triggers destination selection UI

if (strcmp(current, "[Select Destination]") == 0) {

returnToCannedList = true;

updateState(CANNED_MESSAGE_RUN_STATE_DESTINATION_SELECTION, true);

destIndex = 0;

scrollIndex = 0;

updateDestinationSelectionList(); // Make sure list is fresh

screen->forceDisplay();

return true;

}

// [Exit] returns to the main/inactive screen

if (strcmp(current, "[Exit]") == 0) {

// Set runState to inactive so we return to main UI

updateState(CANNED_MESSAGE_RUN_STATE_INACTIVE);

currentMessageIndex = -1;

// Notify UI to regenerate frame set and redraw

UIFrameEvent e;

e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

notifyObservers(&e);

screen->forceDisplay();

return true;

}

// [Free Text] triggers the free text input (virtual keyboard)

#if defined(USE_VIRTUAL_KEYBOARD)

if (strcmp(current, "[-- Free Text --]") == 0) {

updateState(CANNED_MESSAGE_RUN_STATE_FREETEXT, true);

UIFrameEvent e;

e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

notifyObservers(&e);

return true;

}

#else

if (strcmp(current, "[-- Free Text --]") == 0) {

if (osk_found && screen) {

char headerBuffer[64];

if (this->dest == NODENUM_BROADCAST) {

snprintf(headerBuffer, sizeof(headerBuffer), "To: #%s", channels.getName(this->channel));

} else {

snprintf(headerBuffer, sizeof(headerBuffer), "To: @%s", getNodeName(this->dest));

}

screen->showTextInput(headerBuffer, "", 300000, [this](const std::string &text) {

if (!text.empty()) {

this->freetext = text.c_str();

this->payload = CANNED_MESSAGE_RUN_STATE_FREETEXT;

updateState(CANNED_MESSAGE_RUN_STATE_SENDING_ACTIVE);

currentMessageIndex = -1;

UIFrameEvent e;

e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

this->notifyObservers(&e);

screen->forceDisplay();

setIntervalFromNow(500);

return;

} else {

// Don't delete virtual keyboard immediately - it might still be executing

// Instead, just clear the callback and reset banner to stop input processing

graphics::NotificationRenderer::textInputCallback = nullptr;

graphics::NotificationRenderer::resetBanner();

// Return to inactive state

this->updateState(CANNED_MESSAGE_RUN_STATE_INACTIVE);

this->currentMessageIndex = -1;

this->freetext = "";

this->cursor = 0;

// Force display update to show normal screen

UIFrameEvent e;

e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

this->notifyObservers(&e);

screen->forceDisplay();

// Schedule cleanup for next loop iteration to ensure safe deletion

setIntervalFromNow(50);

return;

}

});

return true;

}

}

#endif

// Normal canned message selection

if (runState == CANNED_MESSAGE_RUN_STATE_INACTIVE || runState == CANNED_MESSAGE_RUN_STATE_DISABLED) {

} else {

#if CANNED_MESSAGE_ADD_CONFIRMATION

const int savedIndex = currentMessageIndex;

graphics::menuHandler::showConfirmationBanner("Send message?", [this, savedIndex]() {

this->currentMessageIndex = savedIndex;

this->payload = this->runState;

this->updateState(CANNED_MESSAGE_RUN_STATE_ACTION_SELECT);

this->setIntervalFromNow(0);

});

#else

payload = runState;

updateState(CANNED_MESSAGE_RUN_STATE_ACTION_SELECT);

#endif

// Do not immediately set runState; wait for confirmation

handled = true;

}

}

if (handled) {

requestFocus();

if (runState == CANNED_MESSAGE_RUN_STATE_ACTION_SELECT)

setIntervalFromNow(0);

else

runOnce();

}

return handled;

{

// Always process only if in FREETEXT mode

if (runState != CANNED_MESSAGE_RUN_STATE_FREETEXT)

return false;

#if defined(USE_VIRTUAL_KEYBOARD)

// Cancel (dismiss freetext screen)

if (event->inputEvent == INPUT_BROKER_LEFT) {

updateState(CANNED_MESSAGE_RUN_STATE_INACTIVE);

freetext = "";

cursor = 0;

payload = 0;

currentMessageIndex = -1;

// Notify UI that we want to redraw/close this screen

UIFrameEvent e;

e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

notifyObservers(&e);

screen->forceDisplay();

return true;

}

// Touch input (virtual keyboard) handling

// Only handle if touch coordinates present (CardKB won't set these)

if (event->touchX != 0 || event->touchY != 0) {

String keyTapped = keyForCoordinates(event->touchX, event->touchY);

bool valid = false;

if (keyTapped == "⇧") {

highlight = -1;

payload = 0x00;

shift = !shift;

valid = true;

} else if (keyTapped == "⌫") {

#ifndef RAK14014

highlight = keyTapped[0];

#endif

payload = 0x08;

shift = false;

valid = true;

} else if (keyTapped == "123" || keyTapped == "ABC") {

highlight = -1;

payload = 0x00;

charSet = (charSet == 0 ? 1 : 0);

valid = true;

} else if (keyTapped == " ") {

#ifndef RAK14014

highlight = keyTapped[0];

#endif

payload = keyTapped[0];

shift = false;

valid = true;

}

// Touch enter/submit

else if (keyTapped == "↵") {

updateState(CANNED_MESSAGE_RUN_STATE_ACTION_SELECT); // Send the message!

payload = CANNED_MESSAGE_RUN_STATE_FREETEXT;

currentMessageIndex = -1;

shift = false;

valid = true;

} else if (!(keyTapped == "")) {

#ifndef RAK14014

highlight = keyTapped[0];

#endif

payload = shift ? keyTapped[0] : std::tolower(keyTapped[0]);

shift = false;

valid = true;

}

if (valid) {

lastTouchMillis = millis();

runOnce();

payload = 0;

return true; // STOP: We handled a VKB touch

}

}

#endif // USE_VIRTUAL_KEYBOARD

// All hardware keys fall through to here (CardKB, physical, etc.)

if (event->kbchar == INPUT_BROKER_MSG_EMOTE_LIST) {

updateState(CANNED_MESSAGE_RUN_STATE_EMOTE_PICKER);

screen->forceDisplay();

return true;

}

// Confirm select (Enter)

bool isSelect = isSelectEvent(event);

if (isSelect) {

LOG_DEBUG("[SELECT] handleFreeTextInput: runState=%d, dest=%u, channel=%d, freetext='%s'", (int)runState, dest, channel,

freetext.c_str());

if (dest == 0)

dest = NODENUM_BROADCAST;

// Defensive: If channel isn't valid, pick the first available channel

if (channel >= channels.getNumChannels())

channel = 0;

payload = CANNED_MESSAGE_RUN_STATE_FREETEXT;

currentMessageIndex = -1;

updateState(CANNED_MESSAGE_RUN_STATE_ACTION_SELECT);

lastTouchMillis = millis();

runOnce();

return true;

}

// Backspace

if (event->inputEvent == INPUT_BROKER_BACK && this->freetext.length() > 0) {

payload = 0x08;

lastTouchMillis = millis();

requestFocus();

runOnce();

return true;

}

// Move cursor left

if (event->inputEvent == INPUT_BROKER_LEFT) {

payload = INPUT_BROKER_LEFT;

lastTouchMillis = millis();

requestFocus();

runOnce();

return true;

}

// Move cursor right

if (event->inputEvent == INPUT_BROKER_RIGHT) {

payload = INPUT_BROKER_RIGHT;

lastTouchMillis = millis();

requestFocus();

runOnce();

return true;

}

// Cancel (dismiss freetext screen)

if (event->inputEvent == INPUT_BROKER_CANCEL || event->inputEvent == INPUT_BROKER_ALT_LONG ||

(event->inputEvent == INPUT_BROKER_BACK && this->freetext.length() == 0)) {

updateState(CANNED_MESSAGE_RUN_STATE_INACTIVE);

freetext = "";

cursor = 0;

payload = 0;

currentMessageIndex = -1;

// Notify UI that we want to redraw/close this screen

UIFrameEvent e;

e.action = UIFrameEvent::Action::REGENERATE_FRAMESET;

notifyObservers(&e);

screen->forceDisplay();

return true;

}

// Tab (switch destination)

if (event->kbchar == INPUT_BROKER_MSG_TAB) {

return handleTabSwitch(event); // Reuse tab logic

}

// Printable ASCII (add char to draft)

if (event->kbchar >= 32 && event->kbchar <= 126) {

payload = event->kbchar;

lastTouchMillis = millis();

runOnce();

return true;

}

return false;

{

int numEmotes = graphics::numEmotes;

// Override isDown and isSelect ONLY for emote picker behavior

bool isUp = isUpEvent(event);

bool isDown = isDownEvent(event);

bool isSelect = isSelectEvent(event);

if (runState == CANNED_MESSAGE_RUN_STATE_EMOTE_PICKER) {

if (event->inputEvent == INPUT_BROKER_USER_PRESS) {

isDown = true;

} else if (event->inputEvent == INPUT_BROKER_SELECT) {

isSelect = true;

}

}