Unify the native display config between legacy display and MUI (#6838)

* Add missed include

* Another Warning fix

* Add another HAS_SCREEN

* Namespace fixes

* Removed depricated destination types and re-factored destination screen

* Get rid of Arduino Strings

* Clean up after Copilot

* SixthLine Def, Screen Rename

Added Sixth Line Definition Screen Rename, and Automatic Line Adjustment

* Consistency is hard - fixed "Sixth"

* System Frame Updates

Adjusted line construction to ensure we fit maximum content per screen.

* Fix up notifications

* Add a couple more ifdef HAS_SCREEN lines

* Add screen->isOverlayBannerShowing()

* Don't forget the invert!

* Adjust Nodelist Center Divider

Adjust Nodelist Center Divider

* Fix variable casting

* Fix entryText variable as empty before update to fix validation

* Altitude is int32_t

* Update PowerTelemetry to have correct data type

* Fix cppcheck warnings (#6945)

* Fix cppcheck warnings

* Adjust logic in Power.cpp for power sensor

---------

Co-authored-by: Jason P <applewiz@mac.com>

* More pixel wrangling so things line up NodeList edition

* Adjust NodeList alignments and plumb some background padding for a possible title fix

* Better alignment for banner notifications

* Move title into drawCommonHeader; initial screen tested

* Fonts make spacing items difficult

* Improved beeping booping and other buzzer based feedback (#6947)

* Improved beeping booping and other buzzer based feedback

* audible button feedback (#6949)

* Refactor

---------

Co-authored-by: todd-herbert <herbert.todd@gmail.com>

* Sandpapered the corners of the notification popup

* Finalize drawCommonHeader migration

* Update Title of Favorite Node Screens

* Update node metric alignment on LoRa screen

* Update the border for popups to separate it from background

* Update PaxcounterModule.cpp with CommonHeader

* Update WiFi screen with CommonHeader and related data reflow

* It was not, in fact, pointing up

* Fix build on wismeshtap

* T-deck trackball debounce

* Fix uptime on Device Focused page to actually detail

* Update Sys screen for new uptime, add label to Freq/Chan on LoRa

* Don't display DOP any longer, make Uptime consistent

* Revert Uptime change on Favorites, Apply to Device Focused

* Label the satelite number to avoid confusion

* Boop boop boop boop

* Correct GPS positioning and string consistency across strings for GPS

* Fix GPS text alignment

* Enable canned messages by default

* Don't wake screen on new nodes

* Cannedmessage list emote support added

* Fn+e emote picker for freetext screen

* Actually block CannedInput actions while display is shown

* Add selection menu to bannerOverlay

* Off by one

* Move to unified text layouts and spacing

* Still my Fav without an "e"

* Fully remove EVENT_NODEDB_UPDATED

* Simply LoRa screen

* Make some char pointers const to fix compilation on native targets

* Update drawCompassNorth to include radius

* Fix warning

* button thread cleanup

* Pull OneButton handling from PowerFSM and add MUI switch (#6973)

* Trunk

* Onebutton Menu Support

* Add temporary clock icon

* Add gps location to fsi

* Banner message state reset

* Cast to char to satisfy compiler

* Better fast handling of input during banner

* Fix warning

* Derp

* oops

* Update ref

* Wire buzzer_mode

* remove legacy string->print()

* Only init screen if one found

* Unsigned Char

* More buttonThread cleaning

* screen.cpp button handling cleanup

* The Great Event Rename of 2025

* Fix the Radiomaster

* Missed trackball type change

* Remove unused function

* Make ButtonThread an InputBroker

* Coffee hadn't kicked in yet

* Add clock icon for Navigation Bar

* Restore clock screen definition code - whoops

* ExternalNotifications now observe inputBroker

* Clock rework (#6992)

* Move Clock bits into ClockRenderer space

* Rework clock into all device navigation

* T-Watch Actually Builds Different

* Compile fix

---------

Co-authored-by: Jonathan Bennett <jbennett@incomsystems.biz>

* Add AM/PM to Digital Clock

* Flip Seconds and AM/PM on Clock Display

* Tik-tok pixels are hard

* Fix builds on Thinknode M1

* Check for GPS and don't crash

* Don't endif til the end

* Rework the OneButton thread to be much less of a mess. (#6997)

* Rework the OneButton thread to be much less of a mess. And break lots of targets temporarily

* Update src/input/ButtonThread.h

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* fix GPS toggle

* Send the shutdown event, not just the kbchar

* Honor the back button in a notificaiton popup

* Draw the right size box for popup with options

* Try to un-break all the things

---------

Co-authored-by: Ben Meadors <benmmeadors@gmail.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* 24-hour Clock Should have leading zero, but not 12-hour

* Fixup some compile errors

* Add intRoutine to ButtonThread init, to get more responsive user button back

* Add Timezone picker

* Fix Warning

* Optionally set the initial selection for the chooser popup

* Make back buttons work in canned messages

* Drop the wrapper classes

* LonPressTime now configurable

* Clock Frame can not longer be blank; just add valid time

* Back buttons everywhere!

* Key Verification confirm banner

* Make Elecrow M* top button a back button

* Add settings saves

* EInk responsiveness fixes

* Linux Input Fixes

* Add Native Trackball/Joystick support, and move UserButton to Input

* No Flight Stick Mode

* Send input event

* Add Channel Utilization to Device Focused frame

* Don't shift screens when we draw new ones

* Add showOverlayBanner arguments to no-op

* trunk

* Default Native trackball to NC

* Fix crash in simulator mode

* Add longLong button press

* Get the args right

* Adjust Bluetooth Pairing Screen to account for bottom navigation.

* Trackball everywhere, and unPhone buttons

* Remap visionmaster secondary button to TB_UP

* Kill ScanAndSelect

* trunk

* No longer need the canned messages input filter

* All Canned All the time

* Fix stm32 compile error regarding inputBroker

* Unify tft lineheights (#7033)

* Create variable line heights based upon SCREEN_HEIGHT

* Refactor textPositions into method -> getTextPositions

* Update SharedUIDisplay.h

---------

Co-authored-by: Jason P <applewiz@mac.com>

* Adjust top distance for larger displays

* Adjust icon sizes for larger displays

* Fix Paxcounter compile errors after code updates

* Pixel wrangling to make larger screens fit better

* Alert frame has precedence over banner -- for now

* Unify on ALT_BUTTON

* Align AM/PM to the digit, not the segment on larger displays

* Move some global pin defines into configuration.h

* Scaffolding for BMM150 9-axis gyro

* Alt button behavior

* Don't add the blank GPS frames without HAS_GPS

* EVENT_NODEDB_UPDATED has been retired

* Clean out LOG_WARN messages from debugging

* Add dismiss message function

* Minor buttonThread cleanup

* Add BMM150 support

* Clean up last warning from dev

* Simplify bmm150 init return logic

* Add option to reply to messages

* Add minimal menu upon selecting home screen

* Move Messages to slot 2, rename GPS to Position, move variables nearer functional usage in Screen.cpp

* Properly dismiss message

* T-Deck Trackball press is not user button

* Add select on favorite frame to launch cannedMessage DM

* Minor wording change

* Less capital letters

* Fix empty message check, time isn't reliable

* drop dead code

* Make UIRenderer a static class instead of namespace

* Fix the select on favorite

* Check if message is empty early and then 'return'

* Add kb_found, and show the option to launch freetype if appropriate

* Ignore impossible touchscreen touches

* Auto scroll fix

* Move linebreak after "from" for banners to maximize screen usage.

* Center "No messages to show" on Message frame

* Start consolidating buzzer behavior

* Fixed signed / unsigned warning

* Cast second parameter of max() to make some targets happy

* Cast kbchar to (char) to make arduino string happy

* Shorten the notice of "No messages"

* Add buzzer mode chooser

* Add regionPicker to Lora icon

* Reduce line spacing and reorder Position screen to resolve overlapping issues

* Update message titles, fix GPS icons, add Back options

* Leftover boops

* Remove chirp

* Make the region selection dismissable when a region is already set

* Add read-aloud functionality on messages w/ esp8266sam

* "Last Heard" is a better label

* tweak the beep

* 5 options

* properly tear down freetext upon cancel

* de-convelute canned messages just a bit

* Correct height of Mail icon in navigation bar

* Remove unused warning

* Consolidate time methods into TimeFormatters

* Oops

* Change LoRa Picker Cancel to Back

* Tweak selection characters on Banner

* Message render not scrolling on 5th line

* More fixes for message scrolling

* Remove the safety next on text overflow - we found that root cause

* Add pin definitions to fix compilation for obscure target

* Don't let the touchscreen send unitialized kbchar values

* Make virtual KB just a bit quicker

* No more double tap, swipe!

* Left is left, and Right is right

* Update horizontal lightning bolt design

* Move from solid to dashed separator for Message Frame

* Single emote feature fix

* Manually sort overlapping elements for now

* Freetext and clearer choices

* Fix ESP32 InkHUD builds on the unify-tft branch (#7087)

* Remove BaseUI branding

* Capitalization is fun

* Revert Meshtastic Boot Frame Changes

* Add ANZ_433 LoRa region to picker

* Update settings.json

---------

Co-authored-by: HarukiToreda <116696711+HarukiToreda@users.noreply.github.com>
Co-authored-by: Ben Meadors <benmmeadors@gmail.com>
Co-authored-by: Jason P <applewiz@mac.com>
Co-authored-by: todd-herbert <herbert.todd@gmail.com>
Co-authored-by: Thomas Göttgens <tgoettgens@gmail.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

src/modules/KeyVerificationModule.cpp

@@ -0,0 +1,310 @@
+#if !MESHTASTIC_EXCLUDE_PKI
+#include "KeyVerificationModule.h"
+#include "MeshService.h"
+#include "RTC.h"
+#include "main.h"
+#include "modules/AdminModule.h"
+#include <SHA256.h>
+
+KeyVerificationModule *keyVerificationModule;
+
+KeyVerificationModule::KeyVerificationModule()
+    : ProtobufModule("KeyVerification", meshtastic_PortNum_KEY_VERIFICATION_APP, &meshtastic_KeyVerification_msg)
+{
+    ourPortNum = meshtastic_PortNum_KEY_VERIFICATION_APP;
+}
+
+AdminMessageHandleResult KeyVerificationModule::handleAdminMessageForModule(const meshtastic_MeshPacket &mp,
+                                                                            meshtastic_AdminMessage *request,
+                                                                            meshtastic_AdminMessage *response)
+{
+    updateState();
+    if (request->which_payload_variant == meshtastic_AdminMessage_key_verification_tag && mp.from == 0) {
+        LOG_WARN("Handling Key Verification Admin Message type %u", request->key_verification.message_type);
+
+        if (request->key_verification.message_type == meshtastic_KeyVerificationAdmin_MessageType_INITIATE_VERIFICATION &&
+            currentState == KEY_VERIFICATION_IDLE) {
+            sendInitialRequest(request->key_verification.remote_nodenum);
+
+        } else if (request->key_verification.message_type ==
+                       meshtastic_KeyVerificationAdmin_MessageType_PROVIDE_SECURITY_NUMBER &&
+                   request->key_verification.has_security_number && currentState == KEY_VERIFICATION_SENDER_AWAITING_NUMBER &&
+                   request->key_verification.nonce == currentNonce) {
+            processSecurityNumber(request->key_verification.security_number);
+
+        } else if (request->key_verification.message_type == meshtastic_KeyVerificationAdmin_MessageType_DO_VERIFY &&
+                   request->key_verification.nonce == currentNonce) {
+            auto remoteNodePtr = nodeDB->getMeshNode(currentRemoteNode);
+            remoteNodePtr->bitfield |= NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
+            resetToIdle();
+        } else if (request->key_verification.message_type == meshtastic_KeyVerificationAdmin_MessageType_DO_NOT_VERIFY) {
+            resetToIdle();
+        }
+        return AdminMessageHandleResult::HANDLED;
+    }
+    return AdminMessageHandleResult::NOT_HANDLED;
+}
+
+bool KeyVerificationModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_KeyVerification *r)
+{
+    updateState();
+    if (mp.pki_encrypted == false)
+        return false;
+    if (mp.from != currentRemoteNode) // because the inital connection request is handled in allocReply()
+        return false;
+    if (currentState == KEY_VERIFICATION_IDLE) {
+        return false; // if we're idle, the only acceptable message is an init, which should be handled by allocReply()
+
+    } else if (currentState == KEY_VERIFICATION_SENDER_HAS_INITIATED && r->nonce == currentNonce && r->hash2.size == 32 &&
+               r->hash1.size == 0) {
+        memcpy(hash2, r->hash2.bytes, 32);
+        if (screen)
+            screen->showOverlayBanner("Enter Security Number", 30000);
+
+        meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
+        cn->level = meshtastic_LogRecord_Level_WARNING;
+        sprintf(cn->message, "Enter Security Number for Key Verification");
+        cn->which_payload_variant = meshtastic_ClientNotification_key_verification_number_request_tag;
+        cn->payload_variant.key_verification_number_request.nonce = currentNonce;
+        strncpy(cn->payload_variant.key_verification_number_request.remote_longname, // should really check for nulls, etc
+                nodeDB->getMeshNode(currentRemoteNode)->user.long_name,
+                sizeof(cn->payload_variant.key_verification_number_request.remote_longname));
+        service->sendClientNotification(cn);
+        LOG_INFO("Received hash2");
+        currentState = KEY_VERIFICATION_SENDER_AWAITING_NUMBER;
+        return true;
+
+    } else if (currentState == KEY_VERIFICATION_RECEIVER_AWAITING_HASH1 && r->hash1.size == 32 && r->nonce == currentNonce) {
+        if (memcmp(hash1, r->hash1.bytes, 32) == 0) {
+            memset(message, 0, sizeof(message));
+            sprintf(message, "Verification: \n");
+            generateVerificationCode(message + 15);
+            sprintf(message + 24, "\nACCEPT\nREJECT");
+            LOG_INFO("Hash1 matches!");
+            if (screen) {
+                screen->showOverlayBanner(message, 30000, 2, [=](int selected) {
+                    if (selected == 0) {
+                        auto remoteNodePtr = nodeDB->getMeshNode(currentRemoteNode);
+                        remoteNodePtr->bitfield |= NODEINFO_BITFIELD_IS_KEY_MANUALLY_VERIFIED_MASK;
+                    }
+                });
+            }
+            meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
+            cn->level = meshtastic_LogRecord_Level_WARNING;
+            sprintf(cn->message, "Final confirmation for incoming manual key verification %s", message);
+            cn->which_payload_variant = meshtastic_ClientNotification_key_verification_final_tag;
+            cn->payload_variant.key_verification_final.nonce = currentNonce;
+            strncpy(cn->payload_variant.key_verification_final.remote_longname, // should really check for nulls, etc
+                    nodeDB->getMeshNode(currentRemoteNode)->user.long_name,
+                    sizeof(cn->payload_variant.key_verification_final.remote_longname));
+            cn->payload_variant.key_verification_final.isSender = false;
+            service->sendClientNotification(cn);
+
+            currentState = KEY_VERIFICATION_RECEIVER_AWAITING_USER;
+            return true;
+        }
+    }
+    return false;
+}
+
+bool KeyVerificationModule::sendInitialRequest(NodeNum remoteNode)
+{
+    LOG_DEBUG("keyVerification start");
+    // generate nonce
+    updateState();
+    if (currentState != KEY_VERIFICATION_IDLE) {
+        return false;
+    }
+    currentNonce = random();
+    currentNonceTimestamp = getTime();
+    currentRemoteNode = remoteNode;
+    meshtastic_KeyVerification KeyVerification = meshtastic_KeyVerification_init_zero;
+    KeyVerification.nonce = currentNonce;
+    KeyVerification.hash2.size = 0;
+    KeyVerification.hash1.size = 0;
+    meshtastic_MeshPacket *p = allocDataProtobuf(KeyVerification);
+    p->to = remoteNode;
+    p->channel = 0;
+    p->pki_encrypted = true;
+    p->decoded.want_response = true;
+    p->priority = meshtastic_MeshPacket_Priority_HIGH;
+    service->sendToMesh(p, RX_SRC_LOCAL, true);
+
+    currentState = KEY_VERIFICATION_SENDER_HAS_INITIATED;
+    return true;
+}
+
+meshtastic_MeshPacket *KeyVerificationModule::allocReply()
+{
+    SHA256 hash;
+    NodeNum ourNodeNum = nodeDB->getNodeNum();
+    updateState();
+    if (currentState != KEY_VERIFICATION_IDLE) { // TODO: cooldown period
+        LOG_WARN("Key Verification requested, but already in a request");
+        return nullptr;
+    } else if (!currentRequest->pki_encrypted) {
+        LOG_WARN("Key Verification requested, but not in a PKI packet");
+        return nullptr;
+    }
+    currentState = KEY_VERIFICATION_RECEIVER_AWAITING_HASH1;
+
+    auto req = *currentRequest;
+    const auto &p = req.decoded;
+    meshtastic_KeyVerification scratch;
+    meshtastic_KeyVerification response;
+    meshtastic_MeshPacket *responsePacket = nullptr;
+    pb_decode_from_bytes(p.payload.bytes, p.payload.size, &meshtastic_KeyVerification_msg, &scratch);
+
+    currentNonce = scratch.nonce;
+    response.nonce = scratch.nonce;
+    currentRemoteNode = req.from;
+    currentNonceTimestamp = getTime();
+    currentSecurityNumber = random(1, 999999);
+
+    // generate hash1
+    hash.reset();
+    hash.update(&currentSecurityNumber, sizeof(currentSecurityNumber));
+    hash.update(&currentNonce, sizeof(currentNonce));
+    hash.update(&currentRemoteNode, sizeof(currentRemoteNode));
+    hash.update(&ourNodeNum, sizeof(ourNodeNum));
+    hash.update(currentRequest->public_key.bytes, currentRequest->public_key.size);
+    hash.update(owner.public_key.bytes, owner.public_key.size);
+    hash.finalize(hash1, 32);
+
+    // generate hash2
+    hash.reset();
+    hash.update(&currentNonce, sizeof(currentNonce));
+    hash.update(hash1, 32);
+    hash.finalize(hash2, 32);
+    response.hash1.size = 0;
+    response.hash2.size = 32;
+    memcpy(response.hash2.bytes, hash2, 32);
+
+    responsePacket = allocDataProtobuf(response);
+
+    responsePacket->pki_encrypted = true;
+    if (screen) {
+        snprintf(message, 25, "Security Number \n%03u %03u", currentSecurityNumber / 1000, currentSecurityNumber % 1000);
+        screen->showOverlayBanner(message, 30000);
+        LOG_WARN("%s", message);
+    }
+    meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
+    cn->level = meshtastic_LogRecord_Level_WARNING;
+    sprintf(cn->message, "Incoming Key Verification.\nSecurity Number\n%03u %03u", currentSecurityNumber / 1000,
+            currentSecurityNumber % 1000);
+    cn->which_payload_variant = meshtastic_ClientNotification_key_verification_number_inform_tag;
+    cn->payload_variant.key_verification_number_inform.nonce = currentNonce;
+    strncpy(cn->payload_variant.key_verification_number_inform.remote_longname, // should really check for nulls, etc
+            nodeDB->getMeshNode(currentRemoteNode)->user.long_name,
+            sizeof(cn->payload_variant.key_verification_number_inform.remote_longname));
+    cn->payload_variant.key_verification_number_inform.security_number = currentSecurityNumber;
+    service->sendClientNotification(cn);
+    LOG_WARN("Security Number %04u, nonce %llu", currentSecurityNumber, currentNonce);
+    return responsePacket;
+}
+
+void KeyVerificationModule::processSecurityNumber(uint32_t incomingNumber)
+{
+    SHA256 hash;
+    NodeNum ourNodeNum = nodeDB->getNodeNum();
+    uint8_t scratch_hash[32] = {0};
+    LOG_WARN("received security number: %u", incomingNumber);
+    meshtastic_NodeInfoLite *remoteNodePtr = nullptr;
+    remoteNodePtr = nodeDB->getMeshNode(currentRemoteNode);
+    if (remoteNodePtr == nullptr || !remoteNodePtr->has_user || remoteNodePtr->user.public_key.size != 32) {
+        currentState = KEY_VERIFICATION_IDLE;
+        return; // should we throw an error here?
+    }
+    LOG_WARN("hashing ");
+    // calculate hash1
+    hash.reset();
+    hash.update(&incomingNumber, sizeof(incomingNumber));
+    hash.update(&currentNonce, sizeof(currentNonce));
+    hash.update(&ourNodeNum, sizeof(ourNodeNum));
+    hash.update(&currentRemoteNode, sizeof(currentRemoteNode));
+    hash.update(owner.public_key.bytes, owner.public_key.size);
+
+    hash.update(remoteNodePtr->user.public_key.bytes, remoteNodePtr->user.public_key.size);
+    hash.finalize(hash1, 32);
+
+    hash.reset();
+    hash.update(&currentNonce, sizeof(currentNonce));
+    hash.update(hash1, 32);
+    hash.finalize(scratch_hash, 32);
+
+    if (memcmp(scratch_hash, hash2, 32) != 0) {
+        LOG_WARN("Hash2 did not match");
+        return; // should probably throw an error of some sort
+    }
+    currentSecurityNumber = incomingNumber;
+
+    meshtastic_KeyVerification KeyVerification = meshtastic_KeyVerification_init_zero;
+    KeyVerification.nonce = currentNonce;
+    KeyVerification.hash2.size = 0;
+    KeyVerification.hash1.size = 32;
+    memcpy(KeyVerification.hash1.bytes, hash1, 32);
+    meshtastic_MeshPacket *p = allocDataProtobuf(KeyVerification);
+    p->to = currentRemoteNode;
+    p->channel = 0;
+    p->pki_encrypted = true;
+    p->decoded.want_response = true;
+    p->priority = meshtastic_MeshPacket_Priority_HIGH;
+    service->sendToMesh(p, RX_SRC_LOCAL, true);
+    currentState = KEY_VERIFICATION_SENDER_AWAITING_USER;
+    memset(message, 0, sizeof(message));
+    sprintf(message, "Verification: \n");
+    generateVerificationCode(message + 15); // send the toPhone packet
+    if (screen) {
+        screen->showOverlayBanner(message, 30000);
+    }
+    meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
+    cn->level = meshtastic_LogRecord_Level_WARNING;
+    sprintf(cn->message, "Final confirmation for outgoing manual key verification %s", message);
+    cn->which_payload_variant = meshtastic_ClientNotification_key_verification_final_tag;
+    cn->payload_variant.key_verification_final.nonce = currentNonce;
+    strncpy(cn->payload_variant.key_verification_final.remote_longname, // should really check for nulls, etc
+            nodeDB->getMeshNode(currentRemoteNode)->user.long_name,
+            sizeof(cn->payload_variant.key_verification_final.remote_longname));
+    cn->payload_variant.key_verification_final.isSender = true;
+    service->sendClientNotification(cn);
+    LOG_INFO(message);
+
+    return;
+}
+
+void KeyVerificationModule::updateState()
+{
+    if (currentState != KEY_VERIFICATION_IDLE) {
+        // check for the 30 second timeout
+        if (currentNonceTimestamp < getTime() - 60) {
+            resetToIdle();
+        } else {
+            currentNonceTimestamp = getTime();
+        }
+    }
+}
+
+void KeyVerificationModule::resetToIdle()
+{
+    memset(hash1, 0, 32);
+    memset(hash2, 0, 32);
+    currentNonce = 0;
+    currentNonceTimestamp = 0;
+    currentSecurityNumber = 0;
+    currentRemoteNode = 0;
+    currentState = KEY_VERIFICATION_IDLE;
+}
+
+void KeyVerificationModule::generateVerificationCode(char *readableCode)
+{
+    for (int i = 0; i < 4; i++) {
+        // drop the two highest significance bits, then encode as a base64
+        readableCode[i] = (hash1[i] >> 2) + 48; // not a standardized base64, but workable and avoids having a dictionary.
+    }
+    readableCode[4] = ' ';
+    for (int i = 5; i < 9; i++) {
+        // drop the two highest significance bits, then encode as a base64
+        readableCode[i] = (hash1[i] >> 2) + 48; // not a standardized base64, but workable and avoids having a dictionary.
+    }
+}
+#endif