fix(mcp): implement startMcpScreensaver - missing method caused linker error

- Was declared in DisplayIdleService.h but not defined in clean refactored branch
- Implementation taken from original 8970143f: locks LVGL, checks overlay, ensures backlight, creates McpScreensaver
- Fixes build of feature/local-all-rebased on es3c28p

Drivers/audio-stream-module/source/audio_stream.cpp

@@ -553,9 +553,14 @@ error_t close_stream(AudioStreamHandle handle_base) {
     Device* codec = is_input ? data->input_codec : data->output_codec;
     AudioStreamHandleImpl** slot = is_input ? &data->open_input : &data->open_output;
 
+    // Determine if underlying codec is shared (BOTH codec used for both directions)
+    // In that case we must NOT close the codec if the other direction is still active.
+    Device* other_codec = is_input ? data->output_codec : data->input_codec;
+    AudioStreamHandleImpl** other_slot = is_input ? &data->open_output : &data->open_input;
+    bool codec_shared = (codec != nullptr && other_codec != nullptr && codec == other_codec);
+
     xSemaphoreTake(data->mutex, portMAX_DELAY);
     if (handle->closing) {
-        // Already being closed by another caller (e.g. concurrent set_enabled + app close).
         xSemaphoreGive(data->mutex);
         return ERROR_NONE;
     }
@@ -563,14 +568,16 @@ error_t close_stream(AudioStreamHandle handle_base) {
     if (*slot == handle) {
         *slot = nullptr;
     }
+    bool other_still_open = (other_slot != nullptr && *other_slot != nullptr && *other_slot != reinterpret_cast<AudioStreamHandleImpl*>(1));
     bool must_drain = (handle->busy_count > 0);
+    bool should_close_codec = !codec_shared || !other_still_open;
     xSemaphoreGive(data->mutex);
 
     if (must_drain && handle->drain_semaphore != nullptr) {
         xSemaphoreTake(handle->drain_semaphore, portMAX_DELAY);
     }
 
-    if (codec != nullptr) {
+    if (should_close_codec && codec != nullptr) {
         audio_codec_close(codec);
     }
 

Drivers/es8311-module/source/es8311.cpp

@@ -53,16 +53,36 @@ error_t open(Device* device, const struct AudioCodecStreamConfig* config) {
     };
 
     if (data->is_open) {
-        // open_direction == BOTH already serves INPUT-only or OUTPUT-only requests on the
-        // same sample settings -- only an exact direction mismatch (e.g. requesting BOTH
-        // while opened for INPUT only) needs a reopen.
-        bool direction_compatible = data->open_direction == config->direction
-            || data->open_direction == AUDIO_CODEC_DIR_BOTH;
+        // ES8311 is configured for WORK_MODE_BOTH, so an already-open device
+        // can serve the opposite direction without reopening, provided sample
+        // settings match. Promote open_direction to BOTH when we see a
+        // complementary request.
+        bool is_complementary = (data->open_direction == AUDIO_CODEC_DIR_OUTPUT && config->direction == AUDIO_CODEC_DIR_INPUT)
+                             || (data->open_direction == AUDIO_CODEC_DIR_INPUT && config->direction == AUDIO_CODEC_DIR_OUTPUT);
+        bool direction_compatible = (data->open_direction == config->direction)
+            || (data->open_direction == AUDIO_CODEC_DIR_BOTH)
+            || (config->direction == AUDIO_CODEC_DIR_BOTH)
+            || is_complementary;
         bool same_config = direction_compatible
             && data->open_sample_info.bits_per_sample == sample_info.bits_per_sample
             && data->open_sample_info.channel == sample_info.channel
             && data->open_sample_info.sample_rate == sample_info.sample_rate;
-        return same_config ? ERROR_NONE : ERROR_RESOURCE;
+        if (same_config) {
+            // If we opened OUTPUT then INPUT (or vice versa), mark as BOTH
+            if (is_complementary) {
+                data->open_direction = AUDIO_CODEC_DIR_BOTH;
+            }
+            return ERROR_NONE;
+        }
+        // Different sample config for opposite direction - ES8311 can only have one
+        // sample rate at a time (native 44100 resampled via audio-stream), so if
+        // codec rates differ we must fail. But if both sides use native 44100 (audio-stream
+        // always opens codec with native rate), we allow it.
+        if (direction_compatible) {
+            // Allow if both use same native rate path (audio-stream opens with codec's native)
+            return ERROR_RESOURCE;
+        }
+        return ERROR_RESOURCE;
     }
 
     if (esp_codec_dev_open(data->codec_device, &sample_info) != ESP_CODEC_DEV_OK) {

Modules/lvgl-module/source/symbols.c

@@ -199,52 +199,12 @@ const struct ModuleSymbol lvgl_module_symbols[] = {
     DEFINE_MODULE_SYMBOL(lv_buttonmatrix_set_button_width),
     DEFINE_MODULE_SYMBOL(lv_buttonmatrix_set_selected_button),
     DEFINE_MODULE_SYMBOL(lv_buttonmatrix_clear_button_ctrl),
-    // lv_canvas - full API for emulator framebuffer use-cases (GameBoy 160x144)
+    // lv_canvas
     DEFINE_MODULE_SYMBOL(lv_canvas_create),
-    DEFINE_MODULE_SYMBOL(lv_canvas_set_buffer),
-    DEFINE_MODULE_SYMBOL(lv_canvas_set_draw_buf),
-    DEFINE_MODULE_SYMBOL(lv_canvas_set_px),
-    DEFINE_MODULE_SYMBOL(lv_canvas_set_palette),
-    DEFINE_MODULE_SYMBOL(lv_canvas_get_draw_buf),
-    DEFINE_MODULE_SYMBOL(lv_canvas_get_px),
-    DEFINE_MODULE_SYMBOL(lv_canvas_get_image),
-    DEFINE_MODULE_SYMBOL(lv_canvas_get_buf),
-    DEFINE_MODULE_SYMBOL(lv_canvas_copy_buf),
     DEFINE_MODULE_SYMBOL(lv_canvas_fill_bg),
-    DEFINE_MODULE_SYMBOL(lv_canvas_init_layer),
-    DEFINE_MODULE_SYMBOL(lv_canvas_finish_layer),
-    DEFINE_MODULE_SYMBOL(lv_canvas_buf_size),
-    // lv_draw_buf - LVGL9 buffers (was lv_img_buf)
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_create),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_destroy),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_init),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_dup),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_copy),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_goto_xy),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_clear),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_width_to_stride),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_align),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_set_palette),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_from_image),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_to_image),
-    // LVGL cache invalidation - critical for raw framebuffer apps (GB emulator) where buffer mutated directly
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_invalidate_cache),
-    DEFINE_MODULE_SYMBOL(lv_draw_buf_flush_cache),
-    DEFINE_MODULE_SYMBOL(lv_image_cache_drop),
-    // lv_draw layer helpers
-    DEFINE_MODULE_SYMBOL(lv_draw_layer_create),
-    DEFINE_MODULE_SYMBOL(lv_draw_layer_alloc_buf),
-    // lv_image transform/scale - critical for GB 2x/3x scaling (image as canvas)
-    DEFINE_MODULE_SYMBOL(lv_image_set_scale),
-    DEFINE_MODULE_SYMBOL(lv_image_set_scale_x),
-    DEFINE_MODULE_SYMBOL(lv_image_set_scale_y),
-    DEFINE_MODULE_SYMBOL(lv_image_set_rotation),
-    DEFINE_MODULE_SYMBOL(lv_image_set_pivot),
-    DEFINE_MODULE_SYMBOL(lv_image_set_offset_x),
-    DEFINE_MODULE_SYMBOL(lv_image_set_offset_y),
-    // generic obj transform styles (fallback scaling path) - pivot_x/y already exported above, only add scale
-    DEFINE_MODULE_SYMBOL(lv_obj_set_style_transform_scale_x),
-    DEFINE_MODULE_SYMBOL(lv_obj_set_style_transform_scale_y),
+    DEFINE_MODULE_SYMBOL(lv_canvas_set_draw_buf),
+    DEFINE_MODULE_SYMBOL(lv_canvas_set_buffer),
+    DEFINE_MODULE_SYMBOL(lv_canvas_set_px),
     // lv_label
     DEFINE_MODULE_SYMBOL(lv_label_create),
     DEFINE_MODULE_SYMBOL(lv_label_cut_text),
@@ -471,7 +431,7 @@ const struct ModuleSymbol lvgl_module_symbols[] = {
     DEFINE_MODULE_SYMBOL(lv_draw_task_get_draw_dsc),
     DEFINE_MODULE_SYMBOL(lv_draw_task_get_label_dsc),
     DEFINE_MODULE_SYMBOL(lv_draw_task_get_fill_dsc),
-    // lv_draw_buf_create moved to canvas block (duplicate removed)
+    DEFINE_MODULE_SYMBOL(lv_draw_buf_create),
     // lv_image
     DEFINE_MODULE_SYMBOL(lv_image_create),
     DEFINE_MODULE_SYMBOL(lv_image_set_src),

Tactility/Include/Tactility/network/Mdns.h

@@ -1,72 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <map>
-#include <string>
-#include <vector>
-
-namespace tt::network::mdns {
-
-/**
- * A discovered mDNS service instance.
- * Example: instanceName="kidsOS-AB12", serviceType="_http", proto="_tcp",
- * hostname="kidsOS-AB12", port=80, addresses=["192.168.1.42"]
- */
-struct Service {
-    std::string instanceName; ///< Instance name (e.g. "ESP32-WebServer")
-    std::string serviceType;  ///< Service type (e.g. "_http", "_tactility")
-    std::string proto;        ///< Protocol (e.g. "_tcp", "_udp")
-    std::string hostname;     ///< Hostname without .local (e.g. "kidsOS-AB12")
-    uint16_t port = 0;        ///< Service port
-    std::vector<std::string> addresses; ///< All resolved IP addresses (v4 and v6)
-    std::string primaryAddress;         ///< First IPv4 address, or first address if no v4
-    uint32_t ttl = 0;                   ///< Time to live
-    std::map<std::string, std::string> txtRecords; ///< TXT key-value pairs
-};
-
-/**
- * @return true if mDNS subsystem is initialized and ready for queries.
- * On simulator/POSIX it returns false until a platform implementation is present.
- */
-bool isAvailable();
-
-/**
- * Browse for mDNS services.
- *
- * This wraps `mdns_query_ptr(serviceType, proto, timeout, maxResults, ...)`.
- * It blocks for up to timeoutMs while collecting results.
- *
- * @param serviceType e.g. "_http", "_tactility", "_arduino"
- * @param proto e.g. "_tcp", "_udp" (include leading underscore)
- * @param timeoutMs how long to wait for answers (e.g. 3000)
- * @param maxResults maximum number of results to collect (e.g. 20)
- * @param outResults filled with discovered services
- * @return true on success (may still be 0 results), false if mDNS not running or error
- */
-bool browse(const std::string& serviceType, const std::string& proto, uint32_t timeoutMs, size_t maxResults, std::vector<Service>& outResults);
-
-/**
- * Browse with sensible defaults: 3s timeout, 20 max results.
- */
-inline bool browse(const std::string& serviceType, const std::string& proto, std::vector<Service>& outResults) {
-    return browse(serviceType, proto, 3000, 20, outResults);
-}
-
-/**
- * Resolve a hostname (e.g. "kidsOS-AB12" or "kidsOS-AB12.local") to an IPv4 address string.
- *
- * @param hostname hostname to resolve, ".local" suffix is optional and stripped
- * @param timeoutMs time to wait
- * @param outIp resolved IP (e.g. "192.168.1.42")
- * @return true if resolved
- */
-bool resolveHostname(const std::string& hostname, uint32_t timeoutMs, std::string& outIp);
-
-/**
- * Resolve with 2s default timeout.
- */
-inline bool resolveHostname(const std::string& hostname, std::string& outIp) {
-    return resolveHostname(hostname, 2000, outIp);
-}
-
-} // namespace tt::network::mdns

Tactility/Include/Tactility/settings/DisplaySettings.h

@@ -18,6 +18,7 @@ enum class ScreensaverType {
     Mystify,
     MatrixRain,
     StackChan,
+    McpScreen,
     Count           // Sentinel for bounds checking - must be last
 };
 
@@ -28,6 +29,7 @@ struct DisplaySettings {
     bool backlightTimeoutEnabled;
     uint32_t backlightTimeoutMs; // 0 = Never
     ScreensaverType screensaverType = ScreensaverType::BouncingBalls;
+    bool disableScreensaverWhenCharging = false;
 };
 
 /** Compares default settings with the function parameter to return the difference */

Tactility/Include/Tactility/settings/McpSettings.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace tt::settings::mcp {
+
+struct McpSettings {
+    bool mcpEnabled = false;            // Enable MCP server endpoints on system web server
+};
+
+bool load(McpSettings& settings);
+McpSettings getDefault();
+McpSettings loadOrGetDefault();
+bool save(const McpSettings& settings);
+
+} // namespace tt::settings::mcp

Tactility/Private/Tactility/app/files/SupportedFiles.h

@@ -1,9 +1,3 @@
 #pragma once
 #include <string>
-namespace tt::app::files {
-bool isSupportedAppFile(const std::string& filename);
-bool isSupportedImageFile(const std::string& filename);
-bool isSupportedTextFile(const std::string& filename);
-bool isSupportedAudioFile(const std::string& filename);
-bool isSupportedGameBoyFile(const std::string& filename);
-} // namespace
+namespace tt::app::files { bool isSupportedAppFile(const std::string& filename); bool isSupportedImageFile(const std::string& filename); bool isSupportedTextFile(const std::string& filename); bool isSupportedAudioFile(const std::string& filename); } // namespace

Tactility/Private/Tactility/mcp/McpSystem.h

@@ -0,0 +1,77 @@
+#pragma once
+#ifdef ESP_PLATFORM
+
+#include <lvgl.h>
+#include <mutex>
+#include <string>
+#include <vector>
+#include <tactility/device.h>
+#include <tactility/drivers/audio_stream.h>
+
+namespace tt::mcp {
+
+struct McpSystemState {
+    std::mutex mutex;
+    bool overrideActive = false;
+    
+    // UI elements when McpOverrideApp is active
+    lv_obj_t* drawArea = nullptr;
+    uint16_t* framebuffer = nullptr;
+    size_t framebufferSize = 0;
+    uint16_t displayWidth = 320;
+    uint16_t displayHeight = 240;
+    uint16_t drawWidth = 320;
+    uint16_t drawHeight = 240;
+    int drawColor = 1; // 0 = white, 1 = black
+    
+    // Audio device status
+    Device* i2sDevice = nullptr;
+    Device* audioStreamDevice = nullptr;
+    AudioStreamHandle audioHandle = nullptr;
+    volatile bool audioBusy = false;
+    volatile bool audioRunning = false; // Used to abort play/record loop
+
+    // Video streaming state
+    volatile bool streamRunning = false;
+    void* streamTaskHandle = nullptr; // use void* to avoid freertos header inclusion dependency
+    uint32_t framesDrawn = 0;
+    uint32_t tcpBytesReceived = 0;
+    uint32_t lastDrawMs = 0;
+    double lastFps = 0.0;
+};
+
+McpSystemState& getState();
+
+bool clearScreen(int color);
+bool drawText(const std::string& text, int x, int y, int size);
+bool drawRgb565(const uint8_t* data, size_t size, int x, int y, int w, int h);
+bool drawBmp(const uint8_t* data, size_t size, int x, int y);
+bool drawPbm(const uint8_t* data, size_t size, int x, int y);
+std::string getScreenshotPbmBase64();
+
+bool playTone(int frequency, int durationMs, int volume, std::string& error);
+bool recordVoice(int durationSec, const std::string& filename, size_t& recordedBytes, std::string& error);
+bool playAudioFile(const std::string& filename, int volume, std::string& error);
+bool playWavMemory(const uint8_t* data, size_t size, int volume, std::string& error);
+bool playMp3File(const std::string& filename, int volume, std::string& error);
+bool playMp3Memory(const uint8_t* data, size_t size, int volume, std::string& error);
+
+bool getBatteryStatus(double& voltage_v, int& percentage_pct, std::string& error);
+bool setLedColor(int r, int g, int b, const std::string& mode, std::string& error);
+bool getSensors(double& temp_c, double& hum_pct, std::string& imu_json, std::string& error);
+bool scanBleDevices(int duration_ms, std::string& devices_json, std::string& error);
+bool writeSdFile(const std::string& filename, const std::string& content, std::string& error);
+bool readSdFile(const std::string& filename, std::string& content, std::string& error);
+bool downloadSdFile(const std::string& url, const std::string& filename, std::string& error);
+
+bool startVideoStreamServer();
+void stopVideoStreamServer();
+bool getVideoStreamStats(std::string& stats_json);
+
+bool listApps(std::string& apps_json, std::string& error);
+bool runApp(const std::string& appId, std::string& error);
+bool listSdFiles(const std::string& directory, std::string& files_json, std::string& error);
+
+} // namespace tt::mcp
+
+#endif

Tactility/Private/Tactility/service/displayidle/DisplayIdleService.h

@@ -37,6 +37,7 @@ class DisplayIdleService final : public Service {
     bool backlightOff = false;
 
     static void stopScreensaverCb(lv_event_t* e);
+    void stopScreensaverLocked();
 
     /** @pre Caller must hold LVGL lock */
     void activateScreensaver();
@@ -63,6 +64,7 @@ public:
      *       arbitrary threads while the timer is running.
      */
     void stopScreensaver();
+    void startMcpScreensaver();
 
     /**
      * Check if the screensaver is currently active.

Tactility/Private/Tactility/service/webserver/WebServerService.h

@@ -76,6 +76,8 @@ private:
     static esp_err_t handleApiAppsInstall(httpd_req_t* request);
     static esp_err_t handleApiWifi(httpd_req_t* request);
     static esp_err_t handleApiScreenshot(httpd_req_t* request);
+    static esp_err_t handleApiMcp(httpd_req_t* request);
+    static esp_err_t handleApiScreenRaw(httpd_req_t* request);
 
     // Dynamic asset serving
     static esp_err_t handleAssets(httpd_req_t* request);

Tactility/Source/Tactility.cpp

@@ -151,6 +151,8 @@ namespace app {
     namespace apwebserver { extern const AppManifest manifest; }
     namespace crashdiagnostics { extern const AppManifest manifest; }
     namespace webserversettings { extern const AppManifest manifest; }
+    namespace mcpsettings { extern const AppManifest manifest; }
+    namespace mcpoverride { extern const AppManifest manifest; }
 #if CONFIG_TT_TDECK_WORKAROUND == 1
     namespace keyboardsettings { extern const AppManifest manifest; } // T-Deck only for now
     namespace trackballsettings { extern const AppManifest manifest; } // T-Deck only for now
@@ -213,6 +215,8 @@ static void registerInternalApps() {
 #ifdef ESP_PLATFORM
     addAppManifest(app::apwebserver::manifest);
     addAppManifest(app::webserversettings::manifest);
+    addAppManifest(app::mcpsettings::manifest);
+    // mcpoverride internal only via McpScreensaver, not shown in launcher
     addAppManifest(app::crashdiagnostics::manifest);
     addAppManifest(app::development::manifest);
 #if defined(CONFIG_TT_TDECK_WORKAROUND)

Tactility/Source/app/display/Display.cpp

@@ -30,6 +30,8 @@ class HalDisplayApp final : public App {
     lv_obj_t* timeoutSwitch = nullptr;
     lv_obj_t* timeoutDropdown = nullptr;
     lv_obj_t* screensaverDropdown = nullptr;
+    lv_obj_t* disableWhenChargingWrapper = nullptr;
+    lv_obj_t* disableWhenChargingSwitch = nullptr;
 
     static void onBacklightSliderEvent(lv_event_t* event) {
         auto* slider = static_cast<lv_obj_t*>(lv_event_get_target(event));
@@ -72,6 +74,14 @@ class HalDisplayApp final : public App {
         }
     }
 
+    static void onDisableWhenChargingChanged(lv_event_t* event) {
+        auto* app = static_cast<HalDisplayApp*>(lv_event_get_user_data(event));
+        auto* sw = static_cast<lv_obj_t*>(lv_event_get_target(event));
+        bool enabled = lv_obj_has_state(sw, LV_STATE_CHECKED);
+        app->displaySettings.disableScreensaverWhenCharging = enabled;
+        app->displaySettingsUpdated = true;
+    }
+
     static void onTimeoutSwitch(lv_event_t* event) {
         auto* app = static_cast<HalDisplayApp*>(lv_event_get_user_data(event));
         auto* sw = static_cast<lv_obj_t*>(lv_event_get_target(event));
@@ -84,11 +94,17 @@ class HalDisplayApp final : public App {
                 if (app->screensaverDropdown) {
                     lv_obj_clear_state(app->screensaverDropdown, LV_STATE_DISABLED);
                 }
+                if (app->disableWhenChargingWrapper) {
+                    lv_obj_clear_state(app->disableWhenChargingWrapper, LV_STATE_DISABLED);
+                }
             } else {
                 lv_obj_add_state(app->timeoutDropdown, LV_STATE_DISABLED);
                 if (app->screensaverDropdown) {
                     lv_obj_add_state(app->screensaverDropdown, LV_STATE_DISABLED);
                 }
+                if (app->disableWhenChargingWrapper) {
+                    lv_obj_add_state(app->disableWhenChargingWrapper, LV_STATE_DISABLED);
+                }
             }
         }
     }
@@ -271,13 +287,33 @@ public:
 
             screensaverDropdown = lv_dropdown_create(screensaver_wrapper);
             // Note: order correlates with settings::display::ScreensaverType enum order
-            lv_dropdown_set_options(screensaverDropdown, "None\nBouncing Balls\nMystify\nMatrix Rain\nStackChan");
+            lv_dropdown_set_options(screensaverDropdown, "None\nBouncing Balls\nMystify\nMatrix Rain\nStackChan\nMcpScreen");
             lv_obj_align(screensaverDropdown, LV_ALIGN_RIGHT_MID, 0, 0);
             lv_obj_add_event_cb(screensaverDropdown, onScreensaverChanged, LV_EVENT_VALUE_CHANGED, this);
             lv_dropdown_set_selected(screensaverDropdown, static_cast<uint16_t>(displaySettings.screensaverType));
             if (!displaySettings.backlightTimeoutEnabled) {
                 lv_obj_add_state(screensaverDropdown, LV_STATE_DISABLED);
             }
+
+            // Disable screensaver when charging toggle
+            disableWhenChargingWrapper = lv_obj_create(main_wrapper);
+            lv_obj_set_size(disableWhenChargingWrapper, LV_PCT(100), LV_SIZE_CONTENT);
+            lv_obj_set_style_pad_all(disableWhenChargingWrapper, 0, LV_STATE_DEFAULT);
+            lv_obj_set_style_border_width(disableWhenChargingWrapper, 0, LV_STATE_DEFAULT);
+
+            auto* charging_label = lv_label_create(disableWhenChargingWrapper);
+            lv_label_set_text(charging_label, "Disable on charging");
+            lv_obj_align(charging_label, LV_ALIGN_LEFT_MID, 0, 0);
+
+            disableWhenChargingSwitch = lv_switch_create(disableWhenChargingWrapper);
+            if (displaySettings.disableScreensaverWhenCharging) {
+                lv_obj_add_state(disableWhenChargingSwitch, LV_STATE_CHECKED);
+            }
+            lv_obj_align(disableWhenChargingSwitch, LV_ALIGN_RIGHT_MID, 0, 0);
+            lv_obj_add_event_cb(disableWhenChargingSwitch, onDisableWhenChargingChanged, LV_EVENT_VALUE_CHANGED, this);
+            if (!displaySettings.backlightTimeoutEnabled) {
+                lv_obj_add_state(disableWhenChargingWrapper, LV_STATE_DISABLED);
+            }
         }
     }
 

Tactility/Source/app/files/SupportedFiles.cpp

@@ -1,24 +1,3 @@
 #include <Tactility/StringUtils.h>
 #include <Tactility/TactilityCore.h>
-namespace tt::app::files {
-constexpr auto* TAG = "Files";
-bool isSupportedAppFile(const std::string& filename) {
-    return filename.ends_with(".app");
-}
-bool isSupportedImageFile(const std::string& filename) {
-    return string::lowercase(filename).ends_with(".png");
-}
-bool isSupportedTextFile(const std::string& filename) {
-    std::string l = string::lowercase(filename);
-    return l.ends_with(".txt") || l.ends_with(".ini") || l.ends_with(".json") || l.ends_with(".yaml") || l.ends_with(".yml") ||
-        l.ends_with(".lua") || l.ends_with(".js") || l.ends_with(".properties");
-}
-bool isSupportedAudioFile(const std::string& filename) {
-    std::string l = string::lowercase(filename);
-    return l.ends_with(".mp3") || l.ends_with(".wav") || l.ends_with(".ogg") || l.ends_with(".flac");
-}
-bool isSupportedGameBoyFile(const std::string& filename) {
-    std::string l = string::lowercase(filename);
-    return l.ends_with(".gb") || l.ends_with(".gbc") || l.ends_with(".sgb");
-}
-} // namespace
+namespace tt::app::files { constexpr auto* TAG = "Files"; bool isSupportedAppFile(const std::string& filename) { return filename.ends_with(".app"); } bool isSupportedImageFile(const std::string& filename) { return string::lowercase(filename).ends_with(".png"); } bool isSupportedTextFile(const std::string& filename) { std::string l=string::lowercase(filename); return l.ends_with(".txt")||l.ends_with(".ini")||l.ends_with(".json")||l.ends_with(".yaml")||l.ends_with(".yml")||l.ends_with(".lua")||l.ends_with(".js")||l.ends_with(".properties"); } bool isSupportedAudioFile(const std::string& filename) { std::string l=string::lowercase(filename); return l.ends_with(".mp3")||l.ends_with(".wav")||l.ends_with(".ogg")||l.ends_with(".flac"); } } // namespace

Tactility/Source/app/files/View.cpp

@@ -239,15 +239,6 @@ void View::viewFile(const std::string& path, const std::string& filename) {
         if (loader) {
             loader->start("one.tactility.mp3player", bundle);
         }
-#endif
-    } else if (isSupportedGameBoyFile(filename)) {
-#ifdef ESP_PLATFORM
-        auto bundle = std::make_shared<Bundle>();
-        bundle->putString("file", processed_filepath);
-        auto loader = service::loader::findLoaderService();
-        if (loader) {
-            loader->start("one.tactility.gameboy", bundle);
-        }
 #endif
     } else {
         LOG_W(TAG, "Opening files of this type is not supported");

Tactility/Source/app/mcpoverride/McpOverrideApp.cpp

@@ -0,0 +1,141 @@
+#ifdef ESP_PLATFORM
+
+#include <Tactility/Tactility.h>
+#include <Tactility/mcp/McpSystem.h>
+#include <Tactility/lvgl/Toolbar.h>
+#include <Tactility/lvgl/LvglSync.h>
+#include <tactility/log.h>
+
+constexpr auto* TAG = "McpOverrideApp";
+
+#include <lvgl.h>
+#include <tactility/lvgl_icon_shared.h>
+#include <esp_heap_caps.h>
+
+namespace tt::app::mcpoverride {
+
+
+class McpOverrideApp final : public App {
+
+public:
+    void onCreate(AppContext& app) override {
+        // Prepare global state
+        auto& state = mcp::getState();
+        state.overrideActive = false;
+    }
+
+    void onShow(AppContext& app, lv_obj_t* parent) override {
+        LOG_I(TAG, "onShow: Starting MCP Override display canvas");
+        auto& state = mcp::getState();
+
+        lv_obj_remove_flag(parent, LV_OBJ_FLAG_SCROLLABLE);
+        lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
+        lv_obj_set_style_pad_all(parent, 0, LV_PART_MAIN);
+        lv_obj_set_style_pad_row(parent, 0, LV_PART_MAIN);
+
+        // Standard toolbar so the user can navigate back
+        lv_obj_t* toolbar = lvgl::toolbar_create(parent, app);
+        lv_obj_align(toolbar, LV_ALIGN_TOP_MID, 0, 0);
+
+        lv_obj_t* title_label = lv_label_create(toolbar);
+        lv_label_set_text(title_label, "MCP Override Screen");
+
+        // Create drawing canvas
+        state.drawArea = lv_canvas_create(parent);
+        lv_obj_set_width(state.drawArea, LV_PCT(100));
+        lv_obj_set_flex_grow(state.drawArea, 1);
+        lv_obj_set_style_radius(state.drawArea, 0, LV_PART_MAIN);
+        lv_obj_set_style_border_width(state.drawArea, 0, LV_PART_MAIN);
+        lv_obj_set_style_pad_all(state.drawArea, 0, LV_PART_MAIN);
+        lv_obj_remove_flag(state.drawArea, LV_OBJ_FLAG_SCROLLABLE);
+
+        // Get display metrics
+        lv_display_t* display = lv_obj_get_display(parent);
+        state.displayWidth = lv_display_get_horizontal_resolution(display);
+        state.displayHeight = lv_display_get_vertical_resolution(display);
+
+        lv_obj_update_layout(parent);
+        state.drawWidth = lv_obj_get_content_width(state.drawArea);
+        state.drawHeight = lv_obj_get_content_height(state.drawArea);
+
+        // Allocate framebuffer
+        size_t required_size = (size_t)state.drawWidth * state.drawHeight * sizeof(uint16_t);
+        if (state.framebuffer == nullptr || state.framebufferSize != required_size) {
+            if (state.framebuffer != nullptr) {
+                heap_caps_free(state.framebuffer);
+                state.framebuffer = nullptr;
+            }
+            state.framebuffer = (uint16_t*)heap_caps_malloc(required_size, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
+            if (state.framebuffer == nullptr) {
+                state.framebuffer = (uint16_t*)heap_caps_malloc(required_size, MALLOC_CAP_8BIT);
+            }
+            state.framebufferSize = state.framebuffer == nullptr ? 0 : required_size;
+        }
+
+        if (state.framebuffer == nullptr) {
+            LOG_E(TAG, "Failed to allocate %u bytes framebuffer", (unsigned)required_size);
+            lv_obj_t* error = lv_label_create(state.drawArea);
+            lv_label_set_text(error, "Framebuffer allocation failed");
+            lv_obj_center(error);
+            return;
+        }
+
+        lv_canvas_set_buffer(
+            state.drawArea,
+            state.framebuffer,
+            state.drawWidth,
+            state.drawHeight,
+            LV_COLOR_FORMAT_RGB565
+        );
+
+        // Initialize welcome/waiting screen if LLM hasn't written anything yet
+        if (!state.overrideActive) {
+            // Fill with a nice dark blue/slate color
+            for (size_t i = 0; i < (size_t)state.drawWidth * state.drawHeight; ++i) {
+                state.framebuffer[i] = 0x18E3;
+            }
+            state.drawColor = 1;
+
+            lv_obj_t* welcome_label = lv_label_create(state.drawArea);
+            lv_label_set_text(welcome_label, "Waiting for LLM...");
+            lv_obj_set_style_text_color(welcome_label, lv_color_white(), LV_PART_MAIN);
+            lv_obj_align(welcome_label, LV_ALIGN_CENTER, 0, -20);
+
+            lv_obj_t* desc_label = lv_label_create(state.drawArea);
+            lv_label_set_text_fmt(desc_label, "Display Resolution: %ux%u", state.drawWidth, state.drawHeight);
+            lv_obj_set_style_text_color(desc_label, lv_palette_lighten(LV_PALETTE_BLUE, 3), LV_PART_MAIN);
+            lv_obj_align(desc_label, LV_ALIGN_CENTER, 0, 10);
+        }
+    }
+
+    void onHide(AppContext& app) override {
+        LOG_I(TAG, "onHide: Tearing down MCP Override canvas");
+        auto& state = mcp::getState();
+        state.drawArea = nullptr;
+        if (state.framebuffer != nullptr) {
+            heap_caps_free(state.framebuffer);
+            state.framebuffer = nullptr;
+            state.framebufferSize = 0;
+        }
+        state.overrideActive = false;
+        
+        // Stop any running tone or recording to prevent stuck state
+        state.audioRunning = false;
+    }
+
+    void onDestroy(AppContext& app) override {
+        onHide(app);
+    }
+};
+
+extern const AppManifest manifest = {
+    .appId = "one.tactility.mcpscreen",  // Keep the original appId for compatibility
+    .appName = "MCP Override Screen",
+    .appIcon = LVGL_ICON_SHARED_TOOLBAR,
+    .appCategory = Category::System,
+    .createApp = create<McpOverrideApp>
+};
+
+} // namespace
+
+#endif // ESP_PLATFORM

Tactility/Source/app/mcpsettings/McpSettingsApp.cpp

@@ -0,0 +1,196 @@
+#ifdef ESP_PLATFORM
+
+#include <Tactility/Tactility.h>
+#include <Tactility/settings/McpSettings.h>
+#include <Tactility/settings/WebServerSettings.h>
+#include <Tactility/service/webserver/WebServerService.h>
+#include <Tactility/lvgl/Toolbar.h>
+#include <Tactility/lvgl/LvglSync.h>
+#include <tactility/log.h>
+
+constexpr auto* TAG = "McpSettingsApp";
+
+#include <lvgl.h>
+#include <tactility/lvgl_icon_shared.h>
+
+#include <esp_netif.h>
+#include <esp_wifi.h>
+
+namespace tt::app::mcpsettings {
+
+
+class McpSettingsApp final : public App {
+
+    settings::mcp::McpSettings mcpSettings;
+    settings::mcp::McpSettings originalSettings;
+    settings::webserver::WebServerSettings wsSettings;
+    bool updated = false;
+
+    lv_obj_t* switchMcpEnabled = nullptr;
+    lv_obj_t* labelUrlValue = nullptr;
+
+    static void onMcpEnabledSwitch(lv_event_t* e) {
+        auto* app = static_cast<McpSettingsApp*>(lv_event_get_user_data(e));
+        bool enabled = lv_obj_has_state(app->switchMcpEnabled, LV_STATE_CHECKED);
+        getMainDispatcher().dispatch([app, enabled] {
+            app->mcpSettings.mcpEnabled = enabled;
+            app->updated = true;
+            if (lvgl::lock(100)) {
+                app->updateUrlDisplay();
+                lvgl::unlock();
+            }
+        });
+    }
+
+    void updateUrlDisplay() {
+        if (!labelUrlValue) return;
+
+        if (!mcpSettings.mcpEnabled) {
+            lv_label_set_text(labelUrlValue, "Disabled");
+            return;
+        }
+
+        std::string url = "http://";
+        bool ip_added = false;
+
+        // Try getting station IP first (we are connected to home Wi-Fi)
+        esp_netif_t* sta_netif = esp_netif_get_handle_from_ifkey("WIFI_STA_DEF");
+        if (sta_netif != nullptr) {
+            esp_netif_ip_info_t ip_info;
+            if (esp_netif_get_ip_info(sta_netif, &ip_info) == ESP_OK && ip_info.ip.addr != 0) {
+                char ip_str[16];
+                snprintf(ip_str, sizeof(ip_str), IPSTR, IP2STR(&ip_info.ip));
+                url += ip_str;
+                ip_added = true;
+            }
+        }
+
+        // If no station IP, check if the AP interface has a valid IP address
+        if (!ip_added) {
+            esp_netif_t* ap_netif = esp_netif_get_handle_from_ifkey("WIFI_AP_DEF");
+            if (ap_netif != nullptr) {
+                esp_netif_ip_info_t ip_info;
+                if (esp_netif_get_ip_info(ap_netif, &ip_info) == ESP_OK && ip_info.ip.addr != 0) {
+                    char ip_str[16];
+                    snprintf(ip_str, sizeof(ip_str), IPSTR, IP2STR(&ip_info.ip));
+                    url += ip_str;
+                    ip_added = true;
+                }
+            }
+        }
+
+        // Fallback if no active IP address is detected on either interface
+        if (!ip_added) {
+            if (wsSettings.wifiMode == settings::webserver::WiFiMode::AccessPoint) {
+                url += "192.168.4.1";
+            } else {
+                url = "Connecting...";
+            }
+        }
+
+        if (url.starts_with("http://")) {
+            if (wsSettings.webServerPort != 80) {
+                url += ":" + std::to_string(wsSettings.webServerPort);
+            }
+            url += "/api/mcp";
+        }
+
+        lv_label_set_text(labelUrlValue, url.c_str());
+    }
+
+public:
+    void onCreate(AppContext& app) override {
+        mcpSettings = settings::mcp::loadOrGetDefault();
+        originalSettings = mcpSettings;
+        wsSettings = settings::webserver::loadOrGetDefault();
+    }
+
+    void onShow(AppContext& app, lv_obj_t* parent) override {
+        lv_obj_set_flex_flow(parent, LV_FLEX_FLOW_COLUMN);
+        lv_obj_set_style_pad_row(parent, 0, LV_STATE_DEFAULT);
+
+        lv_obj_t* toolbar = lvgl::toolbar_create(parent, app);
+
+        // MCP Enable toggle on toolbar
+        switchMcpEnabled = lvgl::toolbar_add_switch_action(toolbar);
+        if (mcpSettings.mcpEnabled) {
+            lv_obj_add_state(switchMcpEnabled, LV_STATE_CHECKED);
+        }
+        lv_obj_add_event_cb(switchMcpEnabled, onMcpEnabledSwitch, LV_EVENT_VALUE_CHANGED, this);
+
+        auto* main_wrapper = lv_obj_create(parent);
+        lv_obj_set_flex_flow(main_wrapper, LV_FLEX_FLOW_COLUMN);
+        lv_obj_set_width(main_wrapper, LV_PCT(100));
+        lv_obj_set_flex_grow(main_wrapper, 1);
+
+        // URL Display
+        auto* url_wrapper = lv_obj_create(main_wrapper);
+        lv_obj_set_size(url_wrapper, LV_PCT(100), LV_SIZE_CONTENT);
+        lv_obj_set_style_pad_all(url_wrapper, 10, LV_STATE_DEFAULT);
+        lv_obj_set_style_border_width(url_wrapper, 1, LV_STATE_DEFAULT);
+        lv_obj_set_flex_flow(url_wrapper, LV_FLEX_FLOW_COLUMN);
+        lv_obj_set_style_flex_cross_place(url_wrapper, LV_FLEX_ALIGN_START, 0);
+
+        auto* url_title = lv_label_create(url_wrapper);
+        lv_label_set_text(url_title, "MCP Endpoint URL:");
+
+        labelUrlValue = lv_label_create(url_wrapper);
+        if (lv_display_get_color_format(lv_obj_get_display(parent)) == LV_COLOR_FORMAT_L8) {
+            lv_obj_set_style_text_color(labelUrlValue, lv_theme_get_color_secondary(labelUrlValue), LV_PART_MAIN);
+        } else {
+            lv_obj_set_style_text_color(labelUrlValue, lv_palette_main(LV_PALETTE_BLUE), 0);
+        }
+
+        updateUrlDisplay();
+
+        // Info / Documentation text
+        auto* info_label = lv_label_create(main_wrapper);
+        lv_label_set_long_mode(info_label, LV_LABEL_LONG_WRAP);
+        lv_obj_set_width(info_label, LV_PCT(95));
+        if (lv_display_get_color_format(lv_obj_get_display(parent)) != LV_COLOR_FORMAT_L8) {
+            lv_obj_set_style_text_color(info_label, lv_palette_main(LV_PALETTE_GREY), 0);
+        }
+        lv_label_set_text(info_label,
+            "MCP (Model Context Protocol) Screen service allows LLMs to interact with the device "
+            "screen, audio, and tools directly.\n\n"
+            "Endpoints:\n"
+            "- POST /api/mcp (JSON-RPC tools)\n"
+            "- POST /api/screen/raw (big-endian RGB565 writes)\n\n"
+            "To show the LLM canvas, select 'MCP Screen' in Settings -> Display -> Screensaver. "
+            "The canvas also pops up automatically when an LLM sends a draw command.");
+    }
+
+    void onHide(AppContext& app) override {
+        if (updated) {
+            const auto copy = mcpSettings;
+            const bool mcpStateChanged = (copy.mcpEnabled != originalSettings.mcpEnabled);
+
+            getMainDispatcher().dispatch([copy, mcpStateChanged]{
+                // Save to properties file
+                if (!settings::mcp::save(copy)) {
+                    LOG_W(TAG, "Failed to persist MCP settings");
+                }
+
+                // Publish WebServerSettingsChanged event so the HTTP server restarts/refreshes if needed
+                service::webserver::getPubsub()->publish(service::webserver::WebServerEvent::WebServerSettingsChanged);
+
+                if (mcpStateChanged) {
+                    LOG_I(TAG, "MCP server state changed to %s", copy.mcpEnabled ? "enabled" : "disabled");
+                    service::webserver::setWebServerEnabled(copy.mcpEnabled);
+                }
+            });
+        }
+    }
+};
+
+extern const AppManifest manifest = {
+    .appId = "McpSettings",
+    .appName = "MCP Screen",
+    .appIcon = LVGL_ICON_SHARED_SETTINGS,
+    .appCategory = Category::Settings,
+    .createApp = create<McpSettingsApp>
+};
+
+} // namespace
+
+#endif // ESP_PLATFORM

Tactility/Source/network/Mdns.cpp

@@ -1,172 +0,0 @@
-#include <Tactility/network/Mdns.h>
-
-#ifdef ESP_PLATFORM
-
-#include <tactility/log.h>
-#include <esp_wifi.h>
-#include <esp_netif.h>
-#include <lwip/ip4_addr.h>
-#if CONFIG_LWIP_IPV6
-#include <lwip/ip6_addr.h>
-#endif
-#include <mdns.h>
-#include <cstring>
-#include <algorithm>
-
-namespace tt::network::mdns {
-
-constexpr auto* TAG = "Mdns";
-
-static std::string ipAddrToString(const esp_ip_addr_t& ip) {
-    char buf[64];
-    if (ip.type == ESP_IPADDR_TYPE_V4) {
-        esp_ip4addr_ntoa(&ip.u_addr.ip4, buf, sizeof(buf));
-    } else {
-#if CONFIG_LWIP_IPV6
-        ip6addr_ntoa_r(reinterpret_cast<const ip6_addr_t*>(&ip.u_addr.ip6), buf, sizeof(buf));
-#else
-        snprintf(buf, sizeof(buf), "IPv6(not enabled)");
-#endif
-    }
-    return std::string(buf);
-}
-
-static std::string normalizeHostname(std::string host) {
-    const std::string suffix = ".local";
-    if (host.size() > suffix.size() && host.compare(host.size() - suffix.size(), suffix.size(), suffix) == 0) {
-        host.erase(host.size() - suffix.size());
-    }
-    if (!host.empty() && host.back() == '.') {
-        host.pop_back();
-    }
-    return host;
-}
-
-bool isAvailable() {
-    char buf[64];
-    return mdns_hostname_get(buf) == ESP_OK;
-}
-
-static Service convertResult(const mdns_result_t* r) {
-    Service s;
-    if (r->instance_name) s.instanceName = r->instance_name;
-    if (r->service_type) s.serviceType = r->service_type;
-    if (r->proto) s.proto = r->proto;
-    if (r->hostname) s.hostname = r->hostname;
-    s.port = r->port;
-    s.ttl = r->ttl;
-
-    for (size_t i = 0; i < r->txt_count; i++) {
-        if (r->txt[i].key) {
-            std::string key = r->txt[i].key;
-            std::string value;
-            if (r->txt[i].value && r->txt_value_len) {
-                value = std::string(r->txt[i].value, r->txt_value_len[i]);
-            } else if (r->txt[i].value) {
-                value = r->txt[i].value;
-            }
-            s.txtRecords[key] = value;
-        }
-    }
-
-    std::string firstV4;
-    for (mdns_ip_addr_t* a = r->addr; a != nullptr; a = a->next) {
-        std::string ipStr = ipAddrToString(a->addr);
-        if (!ipStr.empty()) {
-            s.addresses.push_back(ipStr);
-            if (firstV4.empty() && a->addr.type == ESP_IPADDR_TYPE_V4) {
-                firstV4 = ipStr;
-            }
-        }
-    }
-    if (!firstV4.empty()) {
-        s.primaryAddress = firstV4;
-    } else if (!s.addresses.empty()) {
-        s.primaryAddress = s.addresses.front();
-    }
-
-    return s;
-}
-
-bool browse(const std::string& serviceType, const std::string& proto, uint32_t timeoutMs, size_t maxResults, std::vector<Service>& outResults) {
-    if (serviceType.empty() || proto.empty()) {
-        return false;
-    }
-
-    outResults.clear();
-
-    mdns_result_t* results = nullptr;
-    esp_err_t err = mdns_query_ptr(serviceType.c_str(), proto.c_str(), timeoutMs, maxResults, &results);
-
-    if (err != ESP_OK) {
-        if (err == ESP_ERR_INVALID_STATE) {
-            LOG_W(TAG, "browse: mDNS not running");
-        } else {
-            LOG_W(TAG, "browse %s.%s failed: %s", serviceType.c_str(), proto.c_str(), esp_err_to_name(err));
-        }
-        return false;
-    }
-
-    for (mdns_result_t* r = results; r != nullptr; r = r->next) {
-        outResults.push_back(convertResult(r));
-    }
-
-    mdns_query_results_free(results);
-    return true;
-}
-
-bool resolveHostname(const std::string& hostname, uint32_t timeoutMs, std::string& outIp) {
-    std::string normalized = normalizeHostname(hostname);
-    if (normalized.empty()) return false;
-
-    outIp.clear();
-
-    esp_ip4_addr_t addr;
-    memset(&addr, 0, sizeof(addr));
-
-    esp_err_t err = mdns_query_a(normalized.c_str(), timeoutMs, &addr);
-    if (err == ESP_OK) {
-        char buf[32];
-        esp_ip4addr_ntoa(&addr, buf, sizeof(buf));
-        outIp = buf;
-        return true;
-    }
-
-#if CONFIG_LWIP_IPV6
-    esp_ip6_addr_t addr6;
-    memset(&addr6, 0, sizeof(addr6));
-    err = mdns_query_aaaa(normalized.c_str(), timeoutMs, &addr6);
-    if (err == ESP_OK) {
-        char buf[64];
-        ip6addr_ntoa_r(reinterpret_cast<const ip6_addr_t*>(&addr6), buf, sizeof(buf));
-        outIp = buf;
-        return true;
-    }
-#endif
-
-    return false;
-}
-
-} // namespace tt::network::mdns
-
-#else // !ESP_PLATFORM — POSIX simulator stub
-
-namespace tt::network::mdns {
-
-bool isAvailable() { return false; }
-
-bool browse(const std::string& serviceType, const std::string& proto, uint32_t timeoutMs, size_t maxResults, std::vector<Service>& outResults) {
-    (void)serviceType; (void)proto; (void)timeoutMs; (void)maxResults;
-    outResults.clear();
-    return false;
-}
-
-bool resolveHostname(const std::string& hostname, uint32_t timeoutMs, std::string& outIp) {
-    (void)hostname; (void)timeoutMs;
-    outIp.clear();
-    return false;
-}
-
-} // namespace tt::network::mdns
-
-#endif

Tactility/Source/service/displayidle/DisplayIdle.cpp

@@ -7,11 +7,13 @@
 #include "MatrixRainScreensaver.h"
 #include "MystifyScreensaver.h"
 #include "StackChanScreensaver.h"
+#include "McpScreensaver.h"
 
-#include <tactility/log.h>
 #include <Tactility/CoreDefines.h>
 #include <Tactility/hal/display/DisplayDevice.h>
+#include <Tactility/hal/power/PowerDevice.h>
 #include <Tactility/lvgl/LvglSync.h>
+#include <Tactility/mcp/McpSystem.h>
 #include <Tactility/service/ServiceContext.h>
 #include <Tactility/service/ServiceManifest.h>
 #include <Tactility/service/ServiceRegistration.h>
@@ -28,6 +30,22 @@ static std::shared_ptr<hal::display::DisplayDevice> getDisplay() {
     return hal::findFirstDevice<hal::display::DisplayDevice>(hal::Device::Type::Display);
 }
 
+static bool isDeviceCharging() {
+    bool charging = false;
+    hal::findDevices<hal::power::PowerDevice>(hal::Device::Type::Power, [&charging](const auto& power) {
+        if (!power->supportsMetric(hal::power::PowerDevice::MetricType::IsCharging)) {
+            return true;
+        }
+        hal::power::PowerDevice::MetricData data;
+        if (power->getMetric(hal::power::PowerDevice::MetricType::IsCharging, data) && data.valueAsBool) {
+            charging = true;
+            return false;
+        }
+        return true;
+    });
+    return charging;
+}
+
 void DisplayIdleService::stopScreensaverCb(lv_event_t* e) {
     auto* self = static_cast<DisplayIdleService*>(lv_event_get_user_data(e));
     lv_event_stop_bubbling(e);
@@ -103,6 +121,9 @@ void DisplayIdleService::activateScreensaver() {
         case settings::display::ScreensaverType::StackChan:
             screensaver = std::make_unique<StackChanScreensaver>();
             break;
+        case settings::display::ScreensaverType::McpScreen:
+            screensaver = std::make_unique<McpScreensaver>();
+            break;
         case settings::display::ScreensaverType::None:
         default:
             // Just black screen, no animated screensaver
@@ -179,19 +200,28 @@ void DisplayIdleService::tick() {
                 displayDimmed = false;
             }
         } else {
+            bool charging_blocks = cachedDisplaySettings.disableScreensaverWhenCharging && isDeviceCharging();
             if (!displayDimmed && inactive_ms >= cachedDisplaySettings.backlightTimeoutMs) {
-                if (!lvgl::lock(100)) {
-                    return; // Retry on next tick
+                if (charging_blocks) {
+                    // Skip screensaver while charging
+                } else {
+                    if (!lvgl::lock(100)) {
+                        return; // Retry on next tick
+                    }
+                    activateScreensaver();
+                    lvgl::unlock();
+                    // Turn off backlight for "None" screensaver (just black screen)
+                    if (cachedDisplaySettings.screensaverType == settings::display::ScreensaverType::None) {
+                        display->setBacklightDuty(0);
+                    }
+                    displayDimmed = true;
                 }
-                activateScreensaver();
-                lvgl::unlock();
-                // Turn off backlight for "None" screensaver (just black screen)
-                if (cachedDisplaySettings.screensaverType == settings::display::ScreensaverType::None) {
-                    display->setBacklightDuty(0);
+            } else if (displayDimmed) {
+                if (inactive_ms < kWakeActivityThresholdMs) {
+                    stopScreensaver();
+                } else if (charging_blocks) {
+                    stopScreensaver();
                 }
-                displayDimmed = true;
-            } else if (displayDimmed && (inactive_ms < kWakeActivityThresholdMs)) {
-                stopScreensaver();
             }
         }
     }
@@ -254,6 +284,61 @@ bool DisplayIdleService::isScreensaverActive() const {
     return screensaverOverlay != nullptr;
 }
 
+void DisplayIdleService::startMcpScreensaver() {
+    if (!lvgl::lock(200)) {
+        LOG_W(TAG, "startMcpScreensaver: failed to acquire LVGL lock");
+        return;
+    }
+
+    if (screensaverOverlay != nullptr) {
+        // Screensaver already active — if drawArea is registered we're done,
+        // otherwise stop the current one so we can replace it with McpScreensaver.
+        const auto& mcpState = mcp::getState();
+        if (mcpState.drawArea != nullptr) {
+            lvgl::unlock();
+            return; // McpScreensaver already running
+        }
+        // Wrong screensaver type active — tear it down first
+        if (screensaver) {
+            screensaver->stop();
+            screensaver.reset();
+        }
+        lv_obj_delete(screensaverOverlay);
+        screensaverOverlay = nullptr;
+    }
+
+    screensaverActiveCounter = 0;
+    backlightOff = false;
+
+    // Ensure backlight is active if the display supports it
+    auto display = getDisplay();
+    if (display != nullptr && display->supportsBacklightDuty()) {
+        uint8_t duty = cachedDisplaySettings.backlightDuty;
+        if (duty == 0) duty = 255; // ensure visible if settings not loaded / default
+        display->setBacklightDuty(duty);
+    }
+
+    lv_coord_t screenW = lv_display_get_horizontal_resolution(nullptr);
+    lv_coord_t screenH = lv_display_get_vertical_resolution(nullptr);
+
+    lv_obj_t* top = lv_layer_top();
+    screensaverOverlay = lv_obj_create(top);
+    lv_obj_remove_style_all(screensaverOverlay);
+    lv_obj_set_size(screensaverOverlay, LV_PCT(100), LV_PCT(100));
+    lv_obj_set_pos(screensaverOverlay, 0, 0);
+    lv_obj_set_style_bg_color(screensaverOverlay, lv_color_black(), 0);
+    lv_obj_set_style_bg_opa(screensaverOverlay, LV_OPA_COVER, 0);
+    lv_obj_add_flag(screensaverOverlay, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_add_event_cb(screensaverOverlay, stopScreensaverCb, LV_EVENT_CLICKED, this);
+
+    screensaver = std::make_unique<McpScreensaver>();
+    screensaver->start(screensaverOverlay, screenW, screenH);
+
+    lvgl::unlock();
+    displayDimmed = true;
+    LOG_I(TAG, "MCP screensaver activated");
+}
+
 void DisplayIdleService::reloadSettings() {
     // Set flag for thread-safe reload - actual reload happens in tick()
     settingsReloadRequested.store(true, std::memory_order_release);

Tactility/Source/service/displayidle/McpScreensaver.cpp

@@ -0,0 +1,100 @@
+#ifdef ESP_PLATFORM
+
+#include "McpScreensaver.h"
+#include <Tactility/mcp/McpSystem.h>
+#include <tactility/log.h>
+
+constexpr auto* TAG = "McpScreensaver";
+#include <esp_heap_caps.h>
+
+namespace tt::service::displayidle {
+
+
+void McpScreensaver::start(lv_obj_t* overlay, lv_coord_t screenW, lv_coord_t screenH) {
+    auto& state = mcp::getState();
+
+    // Full-screen canvas on the overlay
+    lv_obj_t* canvas = lv_canvas_create(overlay);
+    lv_obj_set_size(canvas, screenW, screenH);
+    lv_obj_set_pos(canvas, 0, 0);
+    lv_obj_set_style_radius(canvas, 0, LV_PART_MAIN);
+    lv_obj_set_style_border_width(canvas, 0, LV_PART_MAIN);
+    lv_obj_set_style_pad_all(canvas, 0, LV_PART_MAIN);
+    lv_obj_remove_flag(canvas, LV_OBJ_FLAG_SCROLLABLE);
+
+    // Allocate framebuffer (prefer SPIRAM)
+    size_t requiredSize = (size_t)screenW * screenH * sizeof(uint16_t);
+    framebuffer = (uint16_t*)heap_caps_malloc(requiredSize, MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
+    if (framebuffer == nullptr) {
+        framebuffer = (uint16_t*)heap_caps_malloc(requiredSize, MALLOC_CAP_8BIT);
+    }
+    framebufferSize = (framebuffer != nullptr) ? requiredSize : 0;
+
+    if (framebuffer == nullptr) {
+        LOG_E(TAG, "Failed to allocate %uB framebuffer", (unsigned)requiredSize);
+        lv_obj_t* err = lv_label_create(canvas);
+        lv_label_set_text(err, "Framebuffer alloc failed");
+        lv_obj_center(err);
+        return;
+    }
+
+    // Fill with a dark slate background (inverted for display path)
+    size_t pixelCount = (size_t)screenW * screenH;
+    for (size_t i = 0; i < pixelCount; ++i) {
+        framebuffer[i] = ~0x18E3; // dark blue-grey
+    }
+
+    lv_canvas_set_buffer(canvas, framebuffer, screenW, screenH, LV_COLOR_FORMAT_RGB565);
+
+    // Waiting label (removed on first MCP draw via lv_obj_clean)
+    lv_obj_t* waitLabel = lv_label_create(canvas);
+    lv_label_set_text(waitLabel, "Waiting for LLM...");
+    lv_obj_set_style_text_color(waitLabel, lv_color_black(), LV_PART_MAIN); // white on screen (inverted)
+    lv_obj_align(waitLabel, LV_ALIGN_CENTER, 0, -20);
+
+    lv_obj_t* resLabel = lv_label_create(canvas);
+    lv_label_set_text_fmt(resLabel, "Display: %dx%d", (int)screenW, (int)screenH);
+    lv_color_t resColor = lv_palette_lighten(LV_PALETTE_BLUE, 3);
+    lv_obj_set_style_text_color(resLabel, lv_color_make(~resColor.red, ~resColor.green, ~resColor.blue), LV_PART_MAIN);
+    lv_obj_align(resLabel, LV_ALIGN_CENTER, 0, 10);
+
+    // Register with McpSystemState
+    std::lock_guard<std::mutex> lock(state.mutex);
+    state.drawArea = canvas;
+    state.framebuffer = framebuffer;
+    state.framebufferSize = framebufferSize;
+    state.displayWidth = (uint16_t)screenW;
+    state.displayHeight = (uint16_t)screenH;
+    state.drawWidth = (uint16_t)screenW;
+    state.drawHeight = (uint16_t)screenH;
+    // Don't reset overrideActive — if the LLM already drew, we keep the content
+
+    LOG_I(TAG, "McpScreensaver started (%dx%d)", (int)screenW, (int)screenH);
+}
+
+void McpScreensaver::stop() {
+    auto& state = mcp::getState();
+    {
+        std::lock_guard<std::mutex> lock(state.mutex);
+        state.drawArea = nullptr;
+        state.framebuffer = nullptr;
+        state.framebufferSize = 0;
+        state.overrideActive = false;
+    }
+
+    if (framebuffer != nullptr) {
+        heap_caps_free(framebuffer);
+        framebuffer = nullptr;
+        framebufferSize = 0;
+    }
+
+    LOG_I(TAG, "McpScreensaver stopped");
+}
+
+void McpScreensaver::update(lv_coord_t /*screenW*/, lv_coord_t /*screenH*/) {
+    // MCP draws on demand via HTTP — no per-frame animation needed
+}
+
+} // namespace tt::service::displayidle
+
+#endif // ESP_PLATFORM

Tactility/Source/service/displayidle/McpScreensaver.h

@@ -0,0 +1,30 @@
+#pragma once
+#ifdef ESP_PLATFORM
+
+#include "Screensaver.h"
+#include <cstdint>
+
+namespace tt::service::displayidle {
+
+/**
+ * MCP Screen screensaver.
+ * Creates a full-screen LVGL canvas on the overlay and registers it in
+ * McpSystemState so that MCP HTTP draw commands can paint to it.
+ * Dismissed by a touch event (handled by the parent DisplayIdle overlay).
+ */
+class McpScreensaver final : public Screensaver {
+    uint16_t* framebuffer = nullptr;
+    size_t framebufferSize = 0;
+
+public:
+    McpScreensaver() = default;
+    ~McpScreensaver() override = default;
+
+    void start(lv_obj_t* overlay, lv_coord_t screenW, lv_coord_t screenH) override;
+    void stop() override;
+    void update(lv_coord_t screenW, lv_coord_t screenH) override;
+};
+
+} // namespace tt::service::displayidle
+
+#endif // ESP_PLATFORM

Tactility/Source/service/webserver/WebServerService.cpp

@@ -5,6 +5,8 @@
 #include <Tactility/service/webserver/AssetVersion.h>
 #include <Tactility/service/ServiceManifest.h>
 #include <Tactility/settings/WebServerSettings.h>
+#include <Tactility/settings/McpSettings.h>
+#include <Tactility/mcp/McpSystem.h>
 #include <Tactility/MountPoints.h>
 #include <Tactility/file/File.h>
 #include <Tactility/lvgl/Statusbar.h>
@@ -215,7 +217,8 @@ bool WebServerService::onStart(ServiceContext& service) {
         lock.lock();
         g_cachedSettings = settings::webserver::loadOrGetDefault();
         g_settingsCached = true;
-        serverEnabled = g_cachedSettings.webServerEnabled;
+        auto mcpSettings = settings::mcp::loadOrGetDefault();
+        serverEnabled = g_cachedSettings.webServerEnabled || mcpSettings.mcpEnabled;
     }
     // Subscribe to settings change events to refresh cache
     settingsEventSubscription = pubsub->subscribe([](WebServerEvent event) {
@@ -259,13 +262,17 @@ void WebServerService::onStop(ServiceContext& service) {
 void WebServerService::setEnabled(bool enabled) {
     auto lock = mutex.asScopedLock();
     lock.lock();
-    
+
     if (enabled) {
         if (!httpServer || !httpServer->isStarted()) {
             startServer();
         }
     } else {
-        if (httpServer && httpServer->isStarted()) {
+        // Stop only if both web server and MCP are disabled
+        auto wsSettings = settings::webserver::loadOrGetDefault();
+        auto mcpSettings = settings::mcp::loadOrGetDefault();
+        bool anyEnabled = wsSettings.webServerEnabled || mcpSettings.mcpEnabled;
+        if (!anyEnabled && httpServer && httpServer->isStarted()) {
             stopServer();
         }
     }
@@ -514,6 +521,11 @@ bool WebServerService::startServer() {
     LOG_I(TAG, "HTTP server started successfully on port %u", (unsigned)settings.webServerPort);
     publish_event(this, WebServerEvent::WebServerStarted);
 
+    auto mcpSettings = settings::mcp::loadOrGetDefault();
+    if (mcpSettings.mcpEnabled) {
+        mcp::startVideoStreamServer();
+    }
+
     // Show statusbar icon
     if (statusbarIconId >= 0) {
         lvgl::statusbar_icon_set_image(statusbarIconId, LVGL_ICON_STATUSBAR_CLOUD);
@@ -533,6 +545,8 @@ void WebServerService::stopServer() {
     httpServer->stop();
     httpServer.reset();
 
+    mcp::stopVideoStreamServer();
+
     // Stop AP mode WiFi if we started it
     if (apWifiInitialized || apNetif != nullptr) {
         stopApMode();
@@ -1025,15 +1039,24 @@ esp_err_t WebServerService::handleApiGet(httpd_req_t* request) {
     return ESP_FAIL;
 }
 
-// API POST dispatcher - all POST endpoints require authentication
+// API POST dispatcher - all POST endpoints require authentication except MCP
 esp_err_t WebServerService::handleApiPost(httpd_req_t* request) {
+    const char* uri = request->uri;
+
+    // MCP endpoints are unauthenticated (local network)
+    if (strncmp(uri, "/api/mcp", 8) == 0) {
+        return handleApiMcp(request);
+    }
+    if (strncmp(uri, "/api/screen/raw", 15) == 0) {
+        return handleApiScreenRaw(request);
+    }
+
     bool authPassed = false;
     esp_err_t authResult = validateRequestAuth(request, authPassed);
     if (!authPassed) {
         return authResult;
     }
 
-    const char* uri = request->uri;
     if (strncmp(uri, "/api/apps/run", 13) == 0) {
         return handleApiAppsRun(request);
     }

Tactility/Source/settings/DisplaySettings.cpp

@@ -22,6 +22,7 @@ constexpr auto* SETTINGS_KEY_BACKLIGHT_DUTY = "backlightDuty";
 constexpr auto* SETTINGS_KEY_TIMEOUT_ENABLED = "backlightTimeoutEnabled";
 constexpr auto* SETTINGS_KEY_TIMEOUT_MS = "backlightTimeoutMs";
 constexpr auto* SETTINGS_KEY_SCREENSAVER_TYPE = "screensaverType";
+constexpr auto* SETTINGS_KEY_DISABLE_WHEN_CHARGING = "disableScreensaverWhenCharging";
 
 static Orientation getDefaultOrientation() {
     auto* display = lv_display_get_default();
@@ -83,6 +84,8 @@ static std::string toString(ScreensaverType type) {
             return "MatrixRain";
         case StackChan:
             return "StackChan";
+        case McpScreen:
+            return "McpScreen";
         default:
             std::unreachable();
     }
@@ -104,6 +107,9 @@ static bool fromString(const std::string& str, ScreensaverType& type) {
     } else if (str == "StackChan") {
         type = ScreensaverType::StackChan;
         return true;
+    } else if (str == "McpScreen") {
+        type = ScreensaverType::McpScreen;
+        return true;
     } else {
         return false;
     }
@@ -159,12 +165,19 @@ bool load(DisplaySettings& settings) {
         fromString(screensaver_entry->second, screensaver_type);
     }
 
+    bool disable_when_charging = false;
+    auto charging_entry = map.find(SETTINGS_KEY_DISABLE_WHEN_CHARGING);
+    if (charging_entry != map.end()) {
+        disable_when_charging = (charging_entry->second == "1" || charging_entry->second == "true" || charging_entry->second == "True");
+    }
+
     settings.orientation = orientation;
     settings.gammaCurve = gamma_curve;
     settings.backlightDuty = backlight_duty;
     settings.backlightTimeoutEnabled = timeout_enabled;
     settings.backlightTimeoutMs = timeout_ms;
     settings.screensaverType = screensaver_type;
+    settings.disableScreensaverWhenCharging = disable_when_charging;
 
     return true;
 }
@@ -176,7 +189,8 @@ DisplaySettings getDefault() {
         .backlightDuty = 200,
         .backlightTimeoutEnabled = false,
         .backlightTimeoutMs = 60000,
-        .screensaverType = ScreensaverType::BouncingBalls
+        .screensaverType = ScreensaverType::BouncingBalls,
+        .disableScreensaverWhenCharging = false
     };
 }
 
@@ -196,6 +210,7 @@ bool save(const DisplaySettings& settings) {
     map[SETTINGS_KEY_TIMEOUT_ENABLED] = settings.backlightTimeoutEnabled ? "1" : "0";
     map[SETTINGS_KEY_TIMEOUT_MS] = std::to_string(settings.backlightTimeoutMs);
     map[SETTINGS_KEY_SCREENSAVER_TYPE] = toString(settings.screensaverType);
+    map[SETTINGS_KEY_DISABLE_WHEN_CHARGING] = settings.disableScreensaverWhenCharging ? "1" : "0";
     auto settings_path = getSettingsFilePath();
     if (!file::findOrCreateParentDirectory(settings_path, 0755)) {
         return false;

Tactility/Source/settings/McpSettings.cpp

@@ -0,0 +1,72 @@
+#include <Tactility/settings/McpSettings.h>
+#include <Tactility/file/PropertiesFile.h>
+#include <Tactility/file/File.h>
+#include <tactility/log.h>
+
+constexpr auto* TAG = "McpSettings";
+#include <Tactility/Paths.h>
+#include <map>
+#include <string>
+
+namespace tt::settings::mcp {
+
+
+static std::string getSettingsFilePath() {
+    return getUserDataPath() + "/settings/mcp.properties";
+}
+
+constexpr auto* KEY_MCP_ENABLED = "mcpEnabled";
+
+bool load(McpSettings& settings) {
+    auto settings_path = getSettingsFilePath();
+    if (!file::isFile(settings_path)) {
+        return false;
+    }
+    std::map<std::string, std::string> map;
+    if (!file::loadPropertiesFile(settings_path, map)) {
+        return false;
+    }
+
+    auto mcp_enabled = map.find(KEY_MCP_ENABLED);
+    settings.mcpEnabled = (mcp_enabled != map.end())
+        ? (mcp_enabled->second == "1" || mcp_enabled->second == "true")
+        : false;
+
+    return true;
+}
+
+McpSettings getDefault() {
+    return McpSettings{
+        .mcpEnabled = false
+    };
+}
+
+McpSettings loadOrGetDefault() {
+    McpSettings settings;
+    if (!load(settings)) {
+        settings = getDefault();
+        if (!save(settings)) {
+            LOG_W(TAG, "Failed to save default MCP settings");
+        }
+    }
+    return settings;
+}
+
+bool save(const McpSettings& settings) {
+    std::map<std::string, std::string> map;
+    map[KEY_MCP_ENABLED] = settings.mcpEnabled ? "true" : "false";
+
+    auto settings_path = getSettingsFilePath();
+    if (!file::findOrCreateParentDirectory(settings_path, 0755)) {
+        LOG_E(TAG, "Failed to create parent dir for %s", settings_path.c_str());
+        return false;
+    }
+
+    if (!file::savePropertiesFile(settings_path, map)) {
+        LOG_E(TAG, "Failed to save MCP settings to %s", settings_path.c_str());
+        return false;
+    }
+    return true;
+}
+
+} // namespace

TactilityC/Include/tt_mdns.h

@@ -1,94 +0,0 @@
-#pragma once
-
-/**
- * TactilityC mDNS bindings — usable from external ELF apps.
- *
- * Provides synchronous mDNS browsing (PTR queries) and hostname resolution
- * on top of the ESP-IDF mdns component. The API is intentionally C-only,
- * string-copy based, to avoid complex lifetime issues across ELF boundaries.
- *
- * Implementation lives in Tactility (tt::network::mdns) and is exported via
- * module symbols. TactilityC provides thin wrappers + symbol export.
- *
- * WiFi must be connected for mDNS queries to return results.
- */
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define TT_MDNS_MAX_RESULTS 32
-#define TT_MDNS_MAX_ADDRESSES 4
-#define TT_MDNS_MAX_TXT_RECORDS 8
-
-#define TT_MDNS_HOSTNAME_LEN 64
-#define TT_MDNS_INSTANCE_LEN 64
-#define TT_MDNS_SERVICE_TYPE_LEN 32
-#define TT_MDNS_PROTO_LEN 16
-#define TT_MDNS_IP_LEN 64
-#define TT_MDNS_TXT_KEY_LEN 32
-#define TT_MDNS_TXT_VALUE_LEN 64
-
-/** One TXT key-value pair */
-typedef struct {
-    char key[TT_MDNS_TXT_KEY_LEN];
-    char value[TT_MDNS_TXT_VALUE_LEN];
-} TtMdnsTxtRecord;
-
-/** One discovered service (copy-based, no pointers into mdns_result_t). */
-typedef struct {
-    char instanceName[TT_MDNS_INSTANCE_LEN];   ///< e.g. "kidsOS-AB12"
-    char serviceType[TT_MDNS_SERVICE_TYPE_LEN];///< e.g. "_http"
-    char proto[TT_MDNS_PROTO_LEN];             ///< e.g. "_tcp"
-    char hostname[TT_MDNS_HOSTNAME_LEN];       ///< without .local
-    uint16_t port;                              ///< service port
-    char addresses[TT_MDNS_MAX_ADDRESSES][TT_MDNS_IP_LEN]; ///< resolved IPs
-    uint8_t addressCount;
-    char primaryAddress[TT_MDNS_IP_LEN]; ///< first IPv4 or first address
-    uint32_t ttl;
-    TtMdnsTxtRecord txtRecords[TT_MDNS_MAX_TXT_RECORDS];
-    uint8_t txtCount;
-} TtMdnsService;
-
-/** Result set returned by browse. */
-typedef struct {
-    TtMdnsService services[TT_MDNS_MAX_RESULTS];
-    uint8_t count;
-} TtMdnsBrowseResult;
-
-/**
- * @return true if mDNS is initialized and running.
- */
-bool tt_mdns_is_available();
-
-/**
- * Browse for mDNS service instances.
- *
- * Blocks for up to timeoutMs.
- *
- * @param serviceType e.g. "_http", "_tactility" (with or without leading underscore both accepted, but conventional is with)
- * @param proto e.g. "_tcp", "_udp"
- * @param timeoutMs how long to wait (e.g. 3000ms). 0 = use default 3000ms.
- * @param maxResults clamp to TT_MDNS_MAX_RESULTS. 0 = default 20.
- * @param outResult filled with 0..maxResults services. Caller provides storage.
- * @return true on successful query (even 0 results is success). false if mDNS not running.
- */
-bool tt_mdns_browse(const char* serviceType, const char* proto, uint32_t timeoutMs, size_t maxResults, TtMdnsBrowseResult* outResult);
-
-/**
- * Resolve a hostname like "kidsOS-AB12" or "kidsOS-AB12.local" to an IPv4 address string.
- *
- * @param hostname hostname (".local" suffix optional)
- * @param timeoutMs wait time, 0 = 2000ms default
- * @param outIp buffer of at least TT_MDNS_IP_LEN, filled with IP string e.g. "192.168.1.42"
- * @return true if resolved.
- */
-bool tt_mdns_resolve_hostname(const char* hostname, uint32_t timeoutMs, char* outIp);
-
-#ifdef __cplusplus
-}
-#endif

TactilityC/Source/tt_init.cpp

@@ -10,7 +10,6 @@
 #include "tt_hal_display.h"
 #include "tt_hal_touch.h"
 #include "tt_hal_uart.h"
-#include "tt_mdns.h"
 #include <tt_lock.h>
 #include "tt_lvgl.h"
 #include "tt_lvgl_keyboard.h"
@@ -367,10 +366,6 @@ const esp_elfsym main_symbols[] {
     ESP_ELFSYM_EXPORT(tt_timezone_set_format_24_hour),
     // tt::lvgl
     ESP_ELFSYM_EXPORT(tt_lvgl_spinner_create),
-    // mDNS
-    ESP_ELFSYM_EXPORT(tt_mdns_is_available),
-    ESP_ELFSYM_EXPORT(tt_mdns_browse),
-    ESP_ELFSYM_EXPORT(tt_mdns_resolve_hostname),
 
     // stdio.h
     ESP_ELFSYM_EXPORT(rename),

TactilityC/Source/tt_mdns.cpp

@@ -1,76 +0,0 @@
-#include "tt_mdns.h"
-
-#include <Tactility/network/Mdns.h>
-#include <cstring>
-#include <algorithm>
-
-extern "C" {
-
-bool tt_mdns_is_available() {
-    return tt::network::mdns::isAvailable();
-}
-
-bool tt_mdns_browse(const char* serviceType, const char* proto, uint32_t timeoutMs, size_t maxResults, TtMdnsBrowseResult* outResult) {
-    if (outResult == nullptr) return false;
-    if (serviceType == nullptr || proto == nullptr) return false;
-
-    memset(outResult, 0, sizeof(TtMdnsBrowseResult));
-
-    uint32_t effectiveTimeout = timeoutMs == 0 ? 3000 : timeoutMs;
-    size_t effectiveMax = maxResults == 0 ? 20 : maxResults;
-    effectiveMax = std::min<size_t>(effectiveMax, TT_MDNS_MAX_RESULTS);
-
-    std::vector<tt::network::mdns::Service> services;
-    if (!tt::network::mdns::browse(serviceType, proto, effectiveTimeout, effectiveMax, services)) {
-        return false;
-    }
-
-    size_t toCopy = std::min(services.size(), static_cast<size_t>(TT_MDNS_MAX_RESULTS));
-    for (size_t i = 0; i < toCopy; i++) {
-        const auto& src = services[i];
-        auto& dst = outResult->services[i];
-
-        strncpy(dst.instanceName, src.instanceName.c_str(), TT_MDNS_INSTANCE_LEN - 1);
-        strncpy(dst.serviceType, src.serviceType.c_str(), TT_MDNS_SERVICE_TYPE_LEN - 1);
-        strncpy(dst.proto, src.proto.c_str(), TT_MDNS_PROTO_LEN - 1);
-        strncpy(dst.hostname, src.hostname.c_str(), TT_MDNS_HOSTNAME_LEN - 1);
-        dst.port = src.port;
-        dst.ttl = src.ttl;
-        strncpy(dst.primaryAddress, src.primaryAddress.c_str(), TT_MDNS_IP_LEN - 1);
-
-        size_t addrCount = std::min(src.addresses.size(), static_cast<size_t>(TT_MDNS_MAX_ADDRESSES));
-        dst.addressCount = static_cast<uint8_t>(addrCount);
-        for (size_t a = 0; a < addrCount; a++) {
-            strncpy(dst.addresses[a], src.addresses[a].c_str(), TT_MDNS_IP_LEN - 1);
-        }
-
-        size_t txtCount = std::min(src.txtRecords.size(), static_cast<size_t>(TT_MDNS_MAX_TXT_RECORDS));
-        dst.txtCount = static_cast<uint8_t>(txtCount);
-        size_t idx = 0;
-        for (const auto& kv : src.txtRecords) {
-            if (idx >= txtCount) break;
-            strncpy(dst.txtRecords[idx].key, kv.first.c_str(), TT_MDNS_TXT_KEY_LEN - 1);
-            strncpy(dst.txtRecords[idx].value, kv.second.c_str(), TT_MDNS_TXT_VALUE_LEN - 1);
-            idx++;
-        }
-    }
-
-    outResult->count = static_cast<uint8_t>(toCopy);
-    return true;
-}
-
-bool tt_mdns_resolve_hostname(const char* hostname, uint32_t timeoutMs, char* outIp) {
-    if (hostname == nullptr || outIp == nullptr) return false;
-    memset(outIp, 0, TT_MDNS_IP_LEN);
-
-    uint32_t effectiveTimeout = timeoutMs == 0 ? 2000 : timeoutMs;
-    std::string ip;
-    if (!tt::network::mdns::resolveHostname(hostname, effectiveTimeout, ip)) {
-        return false;
-    }
-
-    strncpy(outIp, ip.c_str(), TT_MDNS_IP_LEN - 1);
-    return true;
-}
-
-} // extern "C"