feat(rlcd): Waveshare ESP32-S3-RLCD-4.2 support on latest main

- ST7305 driver with persistent 15KB DMA buffer (fix use-after-free +
  WDT lockup that caused freeze after flash)
- Reset timing fix: 150ms after reset, 50ms after init
- DTS: i2s0 mclk 16, bclk 9, ws 45, out 8, in 10 - fixes GPIO5 conflict
- i2c0 uses esp32-i2c-master, SDMMC 1-bit
- device.properties: colorDepth 16, fontSize 20, DefaultDark
- Amp GPIO46 init in initBoot
- Buttons: two-button control GPIO18 (cycle) + GPIO0 (select)

Base: origin/main f9453d89

Devices/waveshare-esp32-s3-rlcd/CMakeLists.txt

@@ -0,0 +1,8 @@
+# Force CMake reload to detect new files module.cpp and Configuration.cpp
+file(GLOB_RECURSE SOURCE_FILES Source/*.c*)
+
+idf_component_register(
+    SRCS ${SOURCE_FILES}
+    INCLUDE_DIRS "Source"
+    REQUIRES Tactility ButtonControl ST7305 PwmBacklight driver
+)

Devices/waveshare-esp32-s3-rlcd/Source/Configuration.cpp

@@ -0,0 +1,41 @@
+#include "devices/Display.h"
+
+#include <Tactility/hal/Configuration.h>
+#include <ButtonControl.h>
+#include <driver/gpio.h>
+#include <tactility/log.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+static constexpr auto* TAG = "WaveshareRLCD";
+
+using namespace tt::hal;
+
+static DeviceVector createDevices() {
+    return {
+        createDisplay(),
+        ButtonControl::createTwoButtonControl(GPIO_NUM_18, GPIO_NUM_0) // KEY=18 cycles, BOOT=0 selects
+    };
+}
+
+static bool initBoot() {
+    // Amp enable GPIO46 active HIGH - keep LOW during boot to avoid pop,
+    // then HIGH after delay so speaker works for MCP / Mp3Player
+    gpio_config_t io_conf = {};
+    io_conf.intr_type = GPIO_INTR_DISABLE;
+    io_conf.mode = GPIO_MODE_OUTPUT;
+    io_conf.pin_bit_mask = (1ULL << GPIO_NUM_46);
+    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
+    io_conf.pull_up_en = GPIO_PULLUP_DISABLE;
+    gpio_config(&io_conf);
+    gpio_set_level(GPIO_NUM_46, 0);
+    vTaskDelay(pdMS_TO_TICKS(100));
+    gpio_set_level(GPIO_NUM_46, 1);
+    LOG_I(TAG, "Speaker amp GPIO46 enabled");
+    return true;
+}
+
+extern const Configuration hardwareConfiguration = {
+    .initBoot = initBoot,
+    .createDevices = createDevices
+};

Devices/waveshare-esp32-s3-rlcd/Source/devices/Display.cpp

@@ -0,0 +1,23 @@
+#include "Display.h"
+#include <St7305Display.h>
+
+std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay() {
+    auto configuration = std::make_unique<St7305Display::Configuration>(
+        SPI2_HOST,
+        GPIO_NUM_40, // CS
+        GPIO_NUM_5,  // DC
+        400,         // Width
+        300,         // Height
+        nullptr,     // Touch device
+        false,       // swapXY
+        false,       // mirrorX
+        false,       // mirrorY
+        true,        // invertColor - initial true to match existing inverted look, user can toggle via Settings->Display
+        0            // bufferSize (0 = default, which is full screen = 120,000 pixels)
+    );
+
+    configuration->resetPin = GPIO_NUM_41;
+
+    auto display = std::make_shared<St7305Display>(std::move(configuration));
+    return std::reinterpret_pointer_cast<tt::hal::display::DisplayDevice>(display);
+}

Devices/waveshare-esp32-s3-rlcd/Source/devices/Display.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <Tactility/hal/display/DisplayDevice.h>
+#include <memory>
+
+std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Devices/waveshare-esp32-s3-rlcd/Source/module.cpp

@@ -0,0 +1,21 @@
+#include <tactility/module.h>
+
+extern "C" {
+
+static error_t start() {
+    return ERROR_NONE;
+}
+
+static error_t stop() {
+    return ERROR_NONE;
+}
+
+struct Module waveshare_esp32_s3_rlcd_module = {
+    .name = "waveshare-esp32-s3-rlcd",
+    .start = start,
+    .stop = stop,
+    .symbols = nullptr,
+    .internal = nullptr
+};
+
+}

Devices/waveshare-esp32-s3-rlcd/device.properties

@@ -0,0 +1,26 @@
+general.vendor=WaveShare
+general.name=ESP32-S3-RLCD-4.2
+general.incubating=true
+
+apps.launcherAppId=Launcher
+# apps.autoStartAppId=ApWebServer
+
+hardware.target=ESP32S3
+hardware.flashSize=16MB
+hardware.spiRam=true
+hardware.spiRamMode=OCT
+hardware.spiRamSpeed=120M
+hardware.tinyUsb=true
+hardware.esptoolFlashFreq=120M
+hardware.bluetooth=true
+
+storage.userDataLocation=SD
+
+display.size=4.2"
+display.shape=rectangle
+display.dpi=120
+
+lvgl.colorDepth=16
+lvgl.uiDensity=compact
+lvgl.fontSize=20
+lvgl.theme=DefaultDark

Devices/waveshare-esp32-s3-rlcd/devicetree.yaml

@@ -0,0 +1,3 @@
+dependencies:
+- Platforms/platform-esp32
+dts: waveshare,esp32-s3-rlcd.dts

Devices/waveshare-esp32-s3-rlcd/waveshare,esp32-s3-rlcd.dts

@@ -0,0 +1,78 @@
+/dts-v1/;
+
+#include <tactility/bindings/root.h>
+#include <tactility/bindings/esp32_ble.h>
+#include <tactility/bindings/esp32_gpio.h>
+#include <tactility/bindings/esp32_i2c_master.h>
+#include <tactility/bindings/esp32_sdmmc.h>
+#include <tactility/bindings/esp32_spi.h>
+#include <tactility/bindings/esp32_i2s.h>
+#include <tactility/bindings/esp32_uart.h>
+#include <tactility/bindings/display_placeholder.h>
+
+/ {
+	compatible = "root";
+	model = "Waveshare ESP32-S3-RLCD-4.2";
+
+	ble0 {
+		compatible = "espressif,esp32-ble";
+		status = "disabled";
+	};
+
+	gpio0 {
+		compatible = "espressif,esp32-gpio";
+		gpio-count = <49>;
+	};
+
+	// Audio: ES7210 mic + speaker via I2S0
+	// Pins verified from working MicroPython board_config.py for WAVESHARE_RLCD:
+	// mclk=16, bclk=9, ws=45, tx=8 (DAC out), rx=10 (ES7210 mic in)
+	// NOTE: Display DC is GPIO5, so I2S must NOT use GPIO5 to avoid bus corruption
+	i2s0 {
+		compatible = "espressif,esp32-i2s";
+		port = <I2S_NUM_0>;
+		pin-bclk = <&gpio0 9 GPIO_FLAG_NONE>;
+		pin-ws = <&gpio0 45 GPIO_FLAG_NONE>;
+		pin-data-out = <&gpio0 8 GPIO_FLAG_NONE>;
+		pin-data-in = <&gpio0 10 GPIO_FLAG_NONE>;
+		pin-mclk = <&gpio0 16 GPIO_FLAG_NONE>;
+	};
+
+	i2c0 {
+		compatible = "espressif,esp32-i2c-master";
+		port = <I2C_NUM_0>;
+		clock-frequency = <400000>;
+		pin-sda = <&gpio0 13 GPIO_FLAG_NONE>;
+		pin-scl = <&gpio0 14 GPIO_FLAG_NONE>;
+	};
+
+	spi0 {
+		compatible = "espressif,esp32-spi";
+		host = <SPI2_HOST>;
+		cs-gpios = <&gpio0 40 GPIO_FLAG_NONE>;
+		pin-mosi = <&gpio0 12 GPIO_FLAG_NONE>;
+		pin-sclk = <&gpio0 11 GPIO_FLAG_NONE>;
+	
+		display {
+			compatible = "display-placeholder";
+		};
+	};
+
+	sdmmc0 {
+		compatible = "espressif,esp32-sdmmc";
+		pin-clk = <&gpio0 38 GPIO_FLAG_NONE>;
+		pin-cmd = <&gpio0 21 GPIO_FLAG_NONE>;
+		pin-d0 = <&gpio0 39 GPIO_FLAG_NONE>;
+		pin-d3 = <&gpio0 17 GPIO_FLAG_NONE>;
+		slot = <SDMMC_HOST_SLOT_1>;
+		bus-width = <1>;
+		pullups;
+	};
+
+	uart0 {
+		compatible = "espressif,esp32-uart";
+		port = <UART_NUM_0>;
+		pin-tx = <&gpio0 43 GPIO_FLAG_NONE>;
+		pin-rx = <&gpio0 44 GPIO_FLAG_NONE>;
+	};
+};

Drivers/ST7305/CMakeLists.txt

@@ -0,0 +1,5 @@
+idf_component_register(
+    SRC_DIRS "Source"
+    INCLUDE_DIRS "Source"
+    REQUIRES Tactility driver EspLcdCompat
+)

Drivers/ST7305/Source/St7305Display.cpp

@@ -0,0 +1,108 @@
+#include "St7305Display.h"
+#include "esp_lcd_st7305.h"
+
+#include <tactility/log.h>
+#include <esp_lcd_panel_ops.h>
+#include <esp_lvgl_port.h>
+
+static const char* TAG = "ST7305";
+
+bool St7305Display::createIoHandle(esp_lcd_panel_io_handle_t& outHandle) {
+    LOG_I(TAG, "Starting ST7305 SPI panel IO creation");
+
+    const esp_lcd_panel_io_spi_config_t panel_io_config = {
+        .cs_gpio_num = configuration->csPin,
+        .dc_gpio_num = configuration->dcPin,
+        .spi_mode = 0,
+        .pclk_hz = configuration->pixelClockFrequency,
+        .trans_queue_depth = configuration->transactionQueueDepth,
+        .on_color_trans_done = nullptr,
+        .user_ctx = nullptr,
+        .lcd_cmd_bits = 8,
+        .lcd_param_bits = 8,
+        .flags = {
+            .dc_high_on_cmd = 0,
+            .dc_low_on_data = 0,
+            .dc_low_on_param = 0,
+            .octal_mode = 0,
+            .quad_mode = 0,
+            .sio_mode = 0,
+            .lsb_first = 0,
+            .cs_high_active = 0
+        }
+    };
+
+    if (esp_lcd_new_panel_io_spi(configuration->spiHostDevice, &panel_io_config, &outHandle) != ESP_OK) {
+        LOG_E(TAG, "Failed to create panel SPI IO");
+        return false;
+    }
+
+    return true;
+}
+
+bool St7305Display::createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) {
+    const esp_lcd_panel_dev_config_t panel_config = {
+        .reset_gpio_num = configuration->resetPin,
+        .color_space = ESP_LCD_COLOR_SPACE_MONOCHROME,
+        .data_endian = LCD_RGB_DATA_ENDIAN_BIG,
+        .bits_per_pixel = 1,
+        .flags = {
+            .reset_active_high = false
+        },
+        .vendor_config = nullptr
+    };
+
+    if (esp_lcd_new_panel_st7305(ioHandle, &panel_config, &panelHandle) != ESP_OK) {
+        LOG_E(TAG, "Failed to create st7305 panel");
+        return false;
+    }
+
+    // ST7305 needs extra delay after reset before init — prevents freeze on fast boot
+    if (esp_lcd_panel_reset(panelHandle) != ESP_OK) {
+        LOG_E(TAG, "Failed to reset st7305 panel");
+        return false;
+    }
+    vTaskDelay(pdMS_TO_TICKS(150));
+
+    if (esp_lcd_panel_init(panelHandle) != ESP_OK) {
+        LOG_E(TAG, "Failed to init st7305 panel");
+        return false;
+    }
+    vTaskDelay(pdMS_TO_TICKS(50));
+
+    if (configuration->invertColor) {
+        if (esp_lcd_panel_invert_color(panelHandle, true) != ESP_OK) {
+            LOG_W(TAG, "Failed to apply initial invertColor");
+        }
+    }
+
+    return true;
+}
+
+lvgl_port_display_cfg_t St7305Display::getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) {
+    return lvgl_port_display_cfg_t {
+        .io_handle = ioHandle,
+        .panel_handle = panelHandle,
+        .control_handle = nullptr,
+        .buffer_size = configuration->bufferSize,
+        .double_buffer = false, // Monochrome displays usually use single buffering to save RAM
+        .trans_size = 0,
+        .hres = configuration->horizontalResolution,
+        .vres = configuration->verticalResolution,
+        .monochrome = true, // Enables esp_lvgl_port monochrome converter
+        .rotation = {
+            .swap_xy = false,
+            .mirror_x = true,
+            .mirror_y = false,
+        },
+        .color_format = LV_COLOR_FORMAT_RGB565, // Must be RGB565 for monochrome mode to trigger converter
+        .flags = {
+            .buff_dma = false,
+            .buff_spiram = false,
+            .sw_rotate = false,
+            .swap_bytes = false,
+            .full_refresh = true, // We want full refresh to rewrite the converted block format to ST7305
+            .direct_mode = false
+        }
+    };
+}

Drivers/ST7305/Source/St7305Display.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <EspLcdDisplay.h>
+#include <Tactility/hal/display/DisplayDevice.h>
+
+#include <driver/gpio.h>
+#include <driver/spi_common.h>
+#include <esp_lcd_panel_io.h>
+#include <esp_lcd_types.h>
+#include <functional>
+#include <lvgl.h>
+
+class St7305Display final : public EspLcdDisplay {
+
+public:
+
+    class Configuration {
+
+    public:
+
+        Configuration(
+            spi_host_device_t spiHostDevice,
+            gpio_num_t csPin,
+            gpio_num_t dcPin,
+            unsigned int horizontalResolution,
+            unsigned int verticalResolution,
+            std::shared_ptr<tt::hal::touch::TouchDevice> touch = nullptr,
+            bool swapXY = false,
+            bool mirrorX = false,
+            bool mirrorY = false,
+            bool invertColor = false,
+            uint32_t bufferSize = 0
+        ) : spiHostDevice(spiHostDevice),
+            csPin(csPin),
+            dcPin(dcPin),
+            horizontalResolution(horizontalResolution),
+            verticalResolution(verticalResolution),
+            swapXY(swapXY),
+            mirrorX(mirrorX),
+            mirrorY(mirrorY),
+            invertColor(invertColor),
+            bufferSize(bufferSize),
+            touch(std::move(touch))
+        {
+            if (this->bufferSize == 0) {
+                // For monochrome display, full pixel count is expected for buffer size
+                this->bufferSize = horizontalResolution * verticalResolution;
+            }
+        }
+
+        spi_host_device_t spiHostDevice;
+        gpio_num_t csPin;
+        gpio_num_t dcPin;
+        gpio_num_t resetPin = GPIO_NUM_NC;
+        unsigned int pixelClockFrequency = 10'000'000; // 10MHz SPI clock for ST7305
+        size_t transactionQueueDepth = 10;
+        unsigned int horizontalResolution;
+        unsigned int verticalResolution;
+        bool swapXY = false;
+        bool mirrorX = false;
+        bool mirrorY = false;
+        bool invertColor = false;
+        uint32_t bufferSize = 0;
+        std::shared_ptr<tt::hal::touch::TouchDevice> touch;
+        std::function<void(uint8_t)> _Nullable backlightDutyFunction = nullptr;
+    };
+
+private:
+
+    std::unique_ptr<Configuration> configuration;
+
+    bool createIoHandle(esp_lcd_panel_io_handle_t& ioHandle) override;
+
+    bool createPanelHandle(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t& panelHandle) override;
+
+    lvgl_port_display_cfg_t getLvglPortDisplayConfig(esp_lcd_panel_io_handle_t ioHandle, esp_lcd_panel_handle_t panelHandle) override;
+
+public:
+
+    explicit St7305Display(std::unique_ptr<Configuration> inConfiguration) :
+        configuration(std::move(inConfiguration))
+    {}
+
+    std::string getName() const override { return "ST7305"; }
+
+    std::string getDescription() const override { return "ST7305 monochrome reflective LCD display"; }
+
+    std::shared_ptr<tt::hal::touch::TouchDevice> _Nullable getTouchDevice() override { return configuration->touch; }
+
+    void setBacklightDuty(uint8_t backlightDuty) override {
+        if (configuration->backlightDutyFunction != nullptr) {
+            configuration->backlightDutyFunction(backlightDuty);
+        }
+    }
+
+    bool supportsBacklightDuty() const override { return configuration->backlightDutyFunction != nullptr; }
+
+};
+
+std::shared_ptr<tt::hal::display::DisplayDevice> createDisplay();

Drivers/ST7305/Source/esp_lcd_st7305.c

@@ -0,0 +1,300 @@
+#include "esp_lcd_st7305.h"
+#include "soc/soc_caps.h"
+#include "esp_check.h"
+#include "esp_lcd_types.h"
+#include <stdlib.h>
+#include <sys/cdefs.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_lcd_panel_interface.h"
+#include "esp_lcd_panel_io.h"
+#include "esp_lcd_panel_vendor.h"
+#include "esp_lcd_panel_ops.h"
+#include "esp_lcd_panel_commands.h"
+#include "driver/gpio.h"
+#include <string.h>
+#include "esp_log.h"
+
+static const char *TAG = "st7305";
+
+static esp_err_t panel_st7305_del(esp_lcd_panel_t *panel);
+static esp_err_t panel_st7305_reset(esp_lcd_panel_t *panel);
+static esp_err_t panel_st7305_init(esp_lcd_panel_t *panel);
+static esp_err_t panel_st7305_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data);
+static esp_err_t panel_st7305_invert_color(esp_lcd_panel_t *panel, bool invert_color_data);
+static esp_err_t panel_st7305_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y);
+static esp_err_t panel_st7305_swap_xy(esp_lcd_panel_t *panel, bool swap_axes);
+static esp_err_t panel_st7305_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap);
+static esp_err_t panel_st7305_disp_on_off(esp_lcd_panel_t *panel, bool off);
+
+typedef struct {
+    esp_lcd_panel_t base;
+    esp_lcd_panel_io_handle_t io;
+    int reset_gpio_num;
+    bool reset_level;
+    int x_gap;
+    int y_gap;
+    int width;
+    int height;
+    uint8_t rotation;
+    uint8_t madctl_val;
+    const st7305_lcd_init_cmd_t *init_cmds;
+    uint16_t init_cmds_size;
+    uint8_t *draw_buffer;
+} st7305_panel_t;
+
+static const st7305_lcd_init_cmd_t st7305_init_cmds[] = {
+    {0xD6, (uint8_t[]){0x17, 0x02}, 2, 0},           // NVM Load Control
+    {0xD1, (uint8_t[]){0x01}, 1, 0},                 // Booster Enable
+    {0xC0, (uint8_t[]){0x11, 0x04}, 2, 0},           // Gate Voltage Setting
+    {0xC1, (uint8_t[]){0x41, 0x41, 0x41, 0x41}, 4, 0}, // VSHP Setting
+    {0xC2, (uint8_t[]){0x19, 0x19, 0x19, 0x19}, 4, 0}, // VSLP Setting
+    {0xC4, (uint8_t[]){0x41, 0x41, 0x41, 0x41}, 4, 0}, // VSHN Setting
+    {0xC5, (uint8_t[]){0x19, 0x13, 0x19, 0x19}, 4, 0}, // VSLN Setting
+    {0xD8, (uint8_t[]){0xA6, 0xE9}, 2, 0},           // OSC Setting
+    {0xB2, (uint8_t[]){0x05}, 1, 0},                 // Frame Rate Control
+    {0xB3, (uint8_t[]){0xE5, 0xF6, 0x05, 0x46, 0x77, 0x77, 0x77, 0x77, 0x76, 0x45}, 10, 0}, // Gate EQ HPM
+    {0xB4, (uint8_t[]){0x05, 0x46, 0x77, 0x77, 0x77, 0x77, 0x76, 0x45}, 8, 0}, // Gate EQ LPM
+    {0x62, (uint8_t[]){0x32, 0x03, 0x1F}, 3, 0},    // Gate Timing Control
+    {0xB7, (uint8_t[]){0x13}, 1, 0},                // Source EQ Enable
+    {0xB0, (uint8_t[]){0x64}, 1, 0},                // Gate Line Setting: 300 line (0x64 = 100 * 3)
+    {0x11, NULL, 0, 200},                           // Sleep out
+    {0xC9, (uint8_t[]){0x00}, 1, 0},                // Source Voltage Select
+    {0x36, (uint8_t[]){0x48}, 1, 0},                // Memory Data Access Control (MX=1, DO=1)
+    {0x3A, (uint8_t[]){0x11}, 1, 0},                // Data Format Select: 1bpp
+    {0xB9, (uint8_t[]){0x20}, 1, 0},                // Gamma Mode Setting
+    {0xB8, (uint8_t[]){0x29}, 1, 0},                // Panel Setting
+    {0x21, NULL, 0, 0},                             // Display Inversion On
+    {0x2A, (uint8_t[]){0x12, 0x2A}, 2, 0},          // Column Address Setting
+    {0x2B, (uint8_t[]){0x00, 0xC7}, 2, 0},          // Row Address Setting
+    {0x35, (uint8_t[]){0x00}, 1, 0},                // TE Line
+    {0xD0, (uint8_t[]){0xFF}, 1, 0},                // Auto power down ON
+    {0x38, NULL, 0, 0},                             // High Power Mode ON
+    {0x29, NULL, 0, 100},                           // Display ON
+};
+
+esp_err_t esp_lcd_new_panel_st7305(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config,
+                                   esp_lcd_panel_handle_t *ret_panel)
+{
+    esp_err_t ret = ESP_OK;
+    st7305_panel_t *st7305 = NULL;
+    gpio_config_t io_conf = { 0 };
+
+    ESP_GOTO_ON_FALSE(io && panel_dev_config && ret_panel, ESP_ERR_INVALID_ARG, err, TAG, "invalid argument");
+    st7305 = (st7305_panel_t *)calloc(1, sizeof(st7305_panel_t));
+    ESP_GOTO_ON_FALSE(st7305, ESP_ERR_NO_MEM, err, TAG, "no mem for st7305 panel");
+
+    if (panel_dev_config->reset_gpio_num >= 0) {
+        io_conf.mode = GPIO_MODE_OUTPUT;
+        io_conf.pin_bit_mask = 1ULL << panel_dev_config->reset_gpio_num;
+        ESP_GOTO_ON_ERROR(gpio_config(&io_conf), err, TAG, "configure GPIO for RST line failed");
+    }
+    st7305->width = ST7305_WIDTH;
+    st7305->height = ST7305_HEIGHT;
+    st7305->madctl_val = 0x48; // MX=1, DO=1
+    st7305->rotation = 0;
+
+    st7305->io = io;
+    st7305->reset_gpio_num = panel_dev_config->reset_gpio_num;
+    st7305->reset_level = panel_dev_config->flags.reset_active_high;
+    if (panel_dev_config->vendor_config) {
+        st7305->init_cmds = ((st7305_vendor_config_t *)panel_dev_config->vendor_config)->init_cmds;
+        st7305->init_cmds_size = ((st7305_vendor_config_t *)panel_dev_config->vendor_config)->init_cmds_size;
+    } else {
+        st7305->init_cmds = st7305_init_cmds;
+        st7305->init_cmds_size = sizeof(st7305_init_cmds) / sizeof(st7305_lcd_init_cmd_t);
+    }
+    
+    st7305->draw_buffer = heap_caps_malloc(15000, MALLOC_CAP_DMA);
+    ESP_GOTO_ON_FALSE(st7305->draw_buffer, ESP_ERR_NO_MEM, err, TAG, "no mem for st7305 draw buffer");
+    memset(st7305->draw_buffer, 0, 15000);
+    st7305->base.del = panel_st7305_del;
+    st7305->base.reset = panel_st7305_reset;
+    st7305->base.init = panel_st7305_init;
+    st7305->base.draw_bitmap = panel_st7305_draw_bitmap;
+    st7305->base.invert_color = panel_st7305_invert_color;
+    st7305->base.set_gap = panel_st7305_set_gap;
+    st7305->base.mirror = panel_st7305_mirror;
+    st7305->base.swap_xy = panel_st7305_swap_xy;
+#if ESP_IDF_VERSION < ESP_IDF_VERSION_VAL(5, 0, 0)
+    st7305->base.disp_off = panel_st7305_disp_on_off;
+#else
+    st7305->base.disp_on_off = panel_st7305_disp_on_off;
+#endif
+    *ret_panel = &(st7305->base);
+    ESP_LOGD(TAG, "new st7305 panel @%p", st7305);
+
+    return ESP_OK;
+
+err:
+    if (st7305) {
+        if (panel_dev_config->reset_gpio_num >= 0) {
+            gpio_reset_pin(panel_dev_config->reset_gpio_num);
+        }
+        if (st7305->draw_buffer) {
+            free(st7305->draw_buffer);
+        }
+        free(st7305);
+    }
+    return ret;
+}
+
+static esp_err_t panel_st7305_del(esp_lcd_panel_t *panel)
+{
+    st7305_panel_t *st7305 = __containerof(panel, st7305_panel_t, base);
+    if (st7305->reset_gpio_num >= 0) {
+        gpio_reset_pin(st7305->reset_gpio_num);
+    }
+    if (st7305->draw_buffer) {
+        free(st7305->draw_buffer);
+    }
+    free(st7305);
+    return ESP_OK;
+}
+
+static esp_err_t panel_st7305_reset(esp_lcd_panel_t *panel)
+{
+    st7305_panel_t *st7305 = __containerof(panel, st7305_panel_t, base);
+    if (st7305->reset_gpio_num >= 0) {
+        gpio_set_level(st7305->reset_gpio_num, !st7305->reset_level);
+        vTaskDelay(pdMS_TO_TICKS(50));
+        gpio_set_level(st7305->reset_gpio_num, st7305->reset_level);
+        vTaskDelay(pdMS_TO_TICKS(20));
+        gpio_set_level(st7305->reset_gpio_num, !st7305->reset_level);
+        vTaskDelay(pdMS_TO_TICKS(50));
+    }
+    return ESP_OK;
+}
+
+static esp_err_t panel_st7305_init(esp_lcd_panel_t *panel)
+{
+    st7305_panel_t *st7305 = __containerof(panel, st7305_panel_t, base);
+    esp_lcd_panel_io_handle_t io = st7305->io;
+
+    for (size_t i = 0; i < st7305->init_cmds_size; i++) {
+        if (st7305->init_cmds[i].data_bytes > 0) {
+            esp_lcd_panel_io_tx_param(io, st7305->init_cmds[i].cmd,
+                                      st7305->init_cmds[i].data,
+                                      st7305->init_cmds[i].data_bytes);
+        } else {
+            esp_lcd_panel_io_tx_param(io, st7305->init_cmds[i].cmd, NULL, 0);
+        }
+        if (st7305->init_cmds[i].delay_ms > 0) {
+            vTaskDelay(pdMS_TO_TICKS(st7305->init_cmds[i].delay_ms));
+        }
+    }
+
+    // Explicitly clear display RAM to white
+    if (st7305->draw_buffer) {
+        memset(st7305->draw_buffer, 0xFF, 15000); // 0xFF is White
+        uint8_t caset[] = {0x12, 0x2A};
+        uint8_t raset[] = {0x00, 0xC7};
+        esp_lcd_panel_io_tx_param(io, ST7305_CMD_CASET, caset, sizeof(caset));
+        esp_lcd_panel_io_tx_param(io, ST7305_CMD_RASET, raset, sizeof(raset));
+        esp_lcd_panel_io_tx_color(io, ST7305_CMD_RAMWR, st7305->draw_buffer, 15000);
+        vTaskDelay(pdMS_TO_TICKS(50));
+    }
+
+    return ESP_OK;
+}
+
+static esp_err_t panel_st7305_draw_bitmap(esp_lcd_panel_t *panel, int x_start, int y_start, int x_end, int y_end, const void *color_data)
+{
+    st7305_panel_t *st7305 = __containerof(panel, st7305_panel_t, base);
+    esp_lcd_panel_io_handle_t io = st7305->io;
+
+    const uint8_t *src = (const uint8_t *)color_data;
+
+    // Convert from vertical-page format (SSD1306-style) to ST7305 landscape 2x4 block format
+    for (int y = 0; y < 300; y++) {
+        int inv_y = 299 - y;
+        int block_y = inv_y >> 2;
+        int local_y = inv_y & 3;
+
+        int src_y_div_8 = y >> 3;
+        int src_y_mod_8 = y & 7;
+        uint8_t src_bit_mask = 1 << src_y_mod_8;
+
+        for (int x = 0; x < 400; x++) {
+            int byte_x = x >> 1;
+            int local_x = x & 1;
+
+            int dest_byte_idx = byte_x * 75 + block_y;
+            int dest_bit_pos = 7 - ((local_y << 1) | local_x);
+
+            int src_byte_idx = 400 * src_y_div_8 + x;
+            
+            // Read standard vertical page byte bit
+            bool is_pixel_set = (src[src_byte_idx] & src_bit_mask) != 0;
+
+            // Invert the pixel logic if required, standard:
+            // esp_lvgl_port monochrome transform clears the bit (0) for light/chroma colors
+            // and sets the bit (1) for dark/black.
+            // In ST7305 display RAM, White/Light is 1, Black/Dark is 0.
+            // So we write: 1 (White) if is_pixel_set is false (light), and 0 (Black) if is_pixel_set is true (dark).
+            if (!is_pixel_set) {
+                st7305->draw_buffer[dest_byte_idx] |= (1 << dest_bit_pos);
+            } else {
+                st7305->draw_buffer[dest_byte_idx] &= ~(1 << dest_bit_pos);
+            }
+        }
+    }
+
+    uint8_t caset[] = {0x12, 0x2A};
+    uint8_t raset[] = {0x00, 0xC7};
+
+    esp_lcd_panel_io_tx_param(io, ST7305_CMD_CASET, caset, sizeof(caset));
+    esp_lcd_panel_io_tx_param(io, ST7305_CMD_RASET, raset, sizeof(raset));
+    esp_lcd_panel_io_tx_color(io, ST7305_CMD_RAMWR, st7305->draw_buffer, 15000);
+
+    return ESP_OK;
+}
+
+static esp_err_t panel_st7305_invert_color(esp_lcd_panel_t *panel, bool invert_color_data)
+{
+    st7305_panel_t *st7305 = __containerof(panel, st7305_panel_t, base);
+    return esp_lcd_panel_io_tx_param(st7305->io, invert_color_data ? ST7305_CMD_INVON : ST7305_CMD_INVOFF, NULL, 0);
+}
+
+static esp_err_t panel_st7305_mirror(esp_lcd_panel_t *panel, bool mirror_x, bool mirror_y)
+{
+    st7305_panel_t *st7305 = __containerof(panel, st7305_panel_t, base);
+    esp_lcd_panel_io_handle_t io = st7305->io;
+    if (mirror_x) {
+        st7305->madctl_val |= ST7305_MADCTL_MX;
+    } else {
+        st7305->madctl_val &= ~ST7305_MADCTL_MX;
+    }
+    if (mirror_y) {
+        st7305->madctl_val |= ST7305_MADCTL_MY;
+    } else {
+        st7305->madctl_val &= ~ST7305_MADCTL_MY;
+    }
+    return esp_lcd_panel_io_tx_param(io, ST7305_CMD_MADCTL, &st7305->madctl_val, 1);
+}
+
+static esp_err_t panel_st7305_swap_xy(esp_lcd_panel_t *panel, bool swap_axes)
+{
+    st7305_panel_t *st7305 = __containerof(panel, st7305_panel_t, base);
+    esp_lcd_panel_io_handle_t io = st7305->io;
+    if (swap_axes) {
+        st7305->madctl_val |= ST7305_MADCTL_MV;
+    } else {
+        st7305->madctl_val &= ~ST7305_MADCTL_MV;
+    }
+    return esp_lcd_panel_io_tx_param(io, ST7305_CMD_MADCTL, (uint8_t[]) { st7305->madctl_val }, 1);
+}
+
+static esp_err_t panel_st7305_set_gap(esp_lcd_panel_t *panel, int x_gap, int y_gap)
+{
+    st7305_panel_t *st7305 = __containerof(panel, st7305_panel_t, base);
+    st7305->x_gap = x_gap;
+    st7305->y_gap = y_gap;
+    return ESP_OK;
+}
+
+static esp_err_t panel_st7305_disp_on_off(esp_lcd_panel_t *panel, bool off)
+{
+    st7305_panel_t *st7305 = __containerof(panel, st7305_panel_t, base);
+    return esp_lcd_panel_io_tx_param(st7305->io, off ? ST7305_CMD_DISPOFF : ST7305_CMD_DISPON, NULL, 0);
+}

Drivers/ST7305/Source/esp_lcd_st7305.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <stdint.h>
+#include "esp_lcd_types.h"
+#include "esp_lcd_panel_vendor.h"
+#include "sdkconfig.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+    int cmd;                /*<! The specific LCD command */
+    const void *data;       /*<! Buffer that holds the command specific data */
+    size_t data_bytes;      /*<! Size of `data` in memory, in bytes */
+    unsigned int delay_ms;  /*<! Delay in milliseconds after this command */
+} st7305_lcd_init_cmd_t;
+
+typedef struct {
+    const st7305_lcd_init_cmd_t *init_cmds;
+    uint16_t init_cmds_size;
+} st7305_vendor_config_t;
+
+#define ST7305_WIDTH     400
+#define ST7305_HEIGHT    300
+
+#define ST7305_CMD_NOP      0x00
+#define ST7305_CMD_SWRESET  0x01
+#define ST7305_CMD_SLPOUT   0x11
+#define ST7305_CMD_NORON    0x13
+#define ST7305_CMD_INVOFF   0x20
+#define ST7305_CMD_INVON    0x21
+#define ST7305_CMD_DISPOFF  0x28
+#define ST7305_CMD_DISPON   0x29
+#define ST7305_CMD_CASET    0x2A
+#define ST7305_CMD_RASET    0x2B
+#define ST7305_CMD_RAMWR    0x2C
+#define ST7305_CMD_MADCTL   0x36
+
+#define ST7305_MADCTL_MY    0x80
+#define ST7305_MADCTL_MX    0x40
+#define ST7305_MADCTL_MV    0x20
+#define ST7305_MADCTL_ML    0x10
+
+esp_err_t esp_lcd_new_panel_st7305(const esp_lcd_panel_io_handle_t io, const esp_lcd_panel_dev_config_t *panel_dev_config, esp_lcd_panel_handle_t *ret_panel);
+
+#ifdef __cplusplus
+}
+#endif

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

@@ -553,14 +553,9 @@ 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;
     }
@@ -568,16 +563,14 @@ 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 (should_close_codec && codec != nullptr) {
+    if (codec != nullptr) {
         audio_codec_close(codec);
     }
 

Drivers/es8311-module/source/es8311.cpp

@@ -53,36 +53,16 @@ error_t open(Device* device, const struct AudioCodecStreamConfig* config) {
     };
 
     if (data->is_open) {
-        // ES8311 is configured for WORK_MODE_BOTH, so an already-open device
+        // open_direction == BOTH already serves INPUT-only or OUTPUT-only requests on the
-        // can serve the opposite direction without reopening, provided sample
+        // same sample settings -- only an exact direction mismatch (e.g. requesting BOTH
-        // settings match. Promote open_direction to BOTH when we see a
+        // while opened for INPUT only) needs a reopen.
-        // complementary request.
+        bool direction_compatible = data->open_direction == config->direction
-        bool is_complementary = (data->open_direction == AUDIO_CODEC_DIR_OUTPUT && config->direction == AUDIO_CODEC_DIR_INPUT)
+            || data->open_direction == AUDIO_CODEC_DIR_BOTH;
-                             || (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;
-        if (same_config) {
+        return same_config ? ERROR_NONE : ERROR_RESOURCE;
-            // 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) {

Tactility/Include/Tactility/settings/DisplaySettings.h

@@ -18,7 +18,6 @@ enum class ScreensaverType {
     Mystify,
     MatrixRain,
     StackChan,
-    McpScreen,
     Count           // Sentinel for bounds checking - must be last
 };
 
@@ -29,7 +28,6 @@ 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

@@ -1,14 +0,0 @@
-#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/AppManifestParsingInternal.h

@@ -14,9 +14,6 @@ bool isValidAppVersionName(const std::string& version);
 bool isValidAppVersionCode(const std::string& version);
 bool isValidName(const std::string& name);
 
-/** Parses a comma-separated flags string (e.g. "HideStatusBar,Hidden") into appFlags bitmask. */
-uint16_t parseAppFlagsString(const std::string& raw);
-
 /** Parses a V1 (sectioned INI, e.g. "[app]versionName=...") manifest map. */
 bool parseManifestV1(const std::map<std::string, std::string>& map, AppManifest& manifest);
 

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

@@ -1,3 +1,11 @@
 #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); } // namespace
+
+namespace tt::app::files {
+
+bool isSupportedAppFile(const std::string& filename);
+bool isSupportedImageFile(const std::string& filename);
+bool isSupportedTextFile(const std::string& filename);
+
+} // namespace

Tactility/Private/Tactility/mcp/McpSystem.h

@@ -1,77 +0,0 @@
-#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,7 +37,6 @@ 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();
@@ -64,7 +63,6 @@ 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,8 +76,6 @@ 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,8 +151,6 @@ 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
@@ -215,8 +213,6 @@ 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/AppManifestParsing.cpp

@@ -56,34 +56,6 @@ bool isValidName(const std::string& name) {
     });
 }
 
-uint16_t parseAppFlagsString(const std::string& raw) {
-    uint16_t flags = AppManifest::Flags::None;
-    if (raw.empty()) {
-        return flags;
-    }
-
-    auto parts = string::split(raw, ",");
-    for (auto& part : parts) {
-        std::string trimmed = string::trim(part, " \t\r\n");
-        if (trimmed.empty()) {
-            continue;
-        }
-        std::string lower = string::lowercase(trimmed);
-
-        if (lower == "hidestatusbar" || lower == "hide_statusbar" || lower == "hide-statusbar" || lower == "hide_status_bar") {
-            flags |= AppManifest::Flags::HideStatusBar;
-        } else if (lower == "hidden") {
-            flags |= AppManifest::Flags::Hidden;
-        } else if (lower == "none" || lower == "0" || lower == "") {
-            // keep as none, no additional flag
-        } else {
-            LOG_W(TAG, "Unknown app flag \"%s\" - ignoring", trimmed.c_str());
-        }
-    }
-
-    return flags;
-}
-
 /** The V1 format's first line is always the literal "[manifest]" section header; V2 files are flat from the first line onward. */
 static bool detectIsV1Format(const std::string& filePath) {
     std::string first_line;

Tactility/Source/app/AppManifestParsingV1.cpp

@@ -71,12 +71,6 @@ bool parseManifestV1(const std::map<std::string, std::string>& map, AppManifest&
         return false;
     }
 
-    // Optional: [app]flags - e.g. "HideStatusBar" or "HideStatusBar,Hidden"
-    auto flags_it = map.find("[app]flags");
-    if (flags_it != map.end()) {
-        manifest.appFlags = parseAppFlagsString(flags_it->second);
-    }
-
     return true;
 }
 

Tactility/Source/app/AppManifestParsingV2.cpp

@@ -71,12 +71,6 @@ bool parseManifestV2(const std::map<std::string, std::string>& map, AppManifest&
         return false;
     }
 
-    // Optional: app.flags - e.g. "HideStatusBar" or "HideStatusBar,Hidden"
-    auto flags_it = map.find("app.flags");
-    if (flags_it != map.end()) {
-        manifest.appFlags = parseAppFlagsString(flags_it->second);
-    }
-
     return true;
 }
 

Tactility/Source/app/display/Display.cpp

@@ -30,8 +30,6 @@ 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));
@@ -74,14 +72,6 @@ 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));
@@ -94,17 +84,11 @@ 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);
-                }
             }
         }
     }
@@ -287,33 +271,13 @@ 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\nMcpScreen");
+            lv_dropdown_set_options(screensaverDropdown, "None\nBouncing Balls\nMystify\nMatrix Rain\nStackChan");
             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,3 +1,29 @@
 #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"); } } // 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) {
+    // Currently only the PNG library is built into Tactility
+    return string::lowercase(filename).ends_with(".png");
+}
+
+bool isSupportedTextFile(const std::string& filename) {
+    std::string filename_lower = string::lowercase(filename);
+    return filename_lower.ends_with(".txt") ||
+        filename_lower.ends_with(".ini") ||
+        filename_lower.ends_with(".json") ||
+        filename_lower.ends_with(".yaml") ||
+        filename_lower.ends_with(".yml") ||
+        filename_lower.ends_with(".lua") ||
+        filename_lower.ends_with(".js") ||
+        filename_lower.ends_with(".properties");
+}
+
+} // namespace tt::app::filebrowser

Tactility/Source/app/files/View.cpp

@@ -1,5 +1,4 @@
 #include <Tactility/app/files/SupportedFiles.h>
-#include <Tactility/Bundle.h>
 #include <Tactility/app/files/View.h>
 
 #include <Tactility/Platform.h>
@@ -229,17 +228,9 @@ void View::viewFile(const std::string& path, const std::string& filename) {
         if (kernel::getPlatform() == kernel::PlatformEsp) {
             notes::start(processed_filepath);
         } else {
+            // Remove forward slash, because we need a relative path
             notes::start(processed_filepath.substr(1));
         }
-    } else if (isSupportedAudioFile(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.mp3player", bundle);
-        }
-#endif
     } else {
         LOG_W(TAG, "Opening files of this type is not supported");
     }

Tactility/Source/app/mcpoverride/McpOverrideApp.cpp

@@ -1,141 +0,0 @@
-#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

@@ -1,196 +0,0 @@
-#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/service/displayidle/DisplayIdle.cpp

@@ -7,13 +7,11 @@
 #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>
@@ -30,22 +28,6 @@ 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);
@@ -121,9 +103,6 @@ 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
@@ -200,28 +179,19 @@ void DisplayIdleService::tick() {
                 displayDimmed = false;
             }
         } else {
-            bool charging_blocks = cachedDisplaySettings.disableScreensaverWhenCharging && isDeviceCharging();
             if (!displayDimmed && inactive_ms >= cachedDisplaySettings.backlightTimeoutMs) {
-                if (charging_blocks) {
+                if (!lvgl::lock(100)) {
-                    // Skip screensaver while charging
+                    return; // Retry on next tick
-                } 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;
                 }
-            } else if (displayDimmed) {
+                activateScreensaver();
-                if (inactive_ms < kWakeActivityThresholdMs) {
+                lvgl::unlock();
-                    stopScreensaver();
+                // Turn off backlight for "None" screensaver (just black screen)
-                } else if (charging_blocks) {
+                if (cachedDisplaySettings.screensaverType == settings::display::ScreensaverType::None) {
-                    stopScreensaver();
+                    display->setBacklightDuty(0);
                 }
+                displayDimmed = true;
+            } else if (displayDimmed && (inactive_ms < kWakeActivityThresholdMs)) {
+                stopScreensaver();
             }
         }
     }
@@ -284,61 +254,6 @@ 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

@@ -1,100 +0,0 @@
-#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

@@ -1,30 +0,0 @@
-#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,8 +5,6 @@
 #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>
@@ -217,8 +215,7 @@ bool WebServerService::onStart(ServiceContext& service) {
         lock.lock();
         g_cachedSettings = settings::webserver::loadOrGetDefault();
         g_settingsCached = true;
-        auto mcpSettings = settings::mcp::loadOrGetDefault();
+        serverEnabled = g_cachedSettings.webServerEnabled;
-        serverEnabled = g_cachedSettings.webServerEnabled || mcpSettings.mcpEnabled;
     }
     // Subscribe to settings change events to refresh cache
     settingsEventSubscription = pubsub->subscribe([](WebServerEvent event) {
@@ -262,17 +259,13 @@ void WebServerService::onStop(ServiceContext& service) {
 void WebServerService::setEnabled(bool enabled) {
     auto lock = mutex.asScopedLock();
     lock.lock();
-
+    
     if (enabled) {
         if (!httpServer || !httpServer->isStarted()) {
             startServer();
         }
     } else {
-        // Stop only if both web server and MCP are disabled
+        if (httpServer && httpServer->isStarted()) {
-        auto wsSettings = settings::webserver::loadOrGetDefault();
-        auto mcpSettings = settings::mcp::loadOrGetDefault();
-        bool anyEnabled = wsSettings.webServerEnabled || mcpSettings.mcpEnabled;
-        if (!anyEnabled && httpServer && httpServer->isStarted()) {
             stopServer();
         }
     }
@@ -521,11 +514,6 @@ 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);
@@ -545,8 +533,6 @@ void WebServerService::stopServer() {
     httpServer->stop();
     httpServer.reset();
 
-    mcp::stopVideoStreamServer();
-
     // Stop AP mode WiFi if we started it
     if (apWifiInitialized || apNetif != nullptr) {
         stopApMode();
@@ -1039,24 +1025,15 @@ esp_err_t WebServerService::handleApiGet(httpd_req_t* request) {
     return ESP_FAIL;
 }
 
-// API POST dispatcher - all POST endpoints require authentication except MCP
+// API POST dispatcher - all POST endpoints require authentication
 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,7 +22,6 @@ 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();
@@ -84,8 +83,6 @@ static std::string toString(ScreensaverType type) {
             return "MatrixRain";
         case StackChan:
             return "StackChan";
-        case McpScreen:
-            return "McpScreen";
         default:
             std::unreachable();
     }
@@ -107,9 +104,6 @@ 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;
     }
@@ -165,19 +159,12 @@ 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;
 }
@@ -189,8 +176,7 @@ DisplaySettings getDefault() {
         .backlightDuty = 200,
         .backlightTimeoutEnabled = false,
         .backlightTimeoutMs = 60000,
-        .screensaverType = ScreensaverType::BouncingBalls,
+        .screensaverType = ScreensaverType::BouncingBalls
-        .disableScreensaverWhenCharging = false
     };
 }
 
@@ -210,7 +196,6 @@ 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

@@ -1,72 +0,0 @@
-#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

Tests/Tactility/Source/AppManifestParsingTest.cpp

@@ -81,70 +81,3 @@ TEST_CASE("parseManifestV2() should fail when the app id is invalid") {
     AppManifest manifest;
     CHECK_EQ(parseManifestV2(properties, manifest), false);
 }
-
-TEST_CASE("parseAppFlagsString() should parse various flag combinations") {
-    CHECK_EQ(parseAppFlagsString(""), 0);
-    CHECK_EQ(parseAppFlagsString("None"), 0);
-    CHECK_EQ(parseAppFlagsString("HideStatusBar"), AppManifest::Flags::HideStatusBar);
-    CHECK_EQ(parseAppFlagsString("hidden"), AppManifest::Flags::Hidden);
-    CHECK_EQ(parseAppFlagsString("HideStatusBar,Hidden"), AppManifest::Flags::HideStatusBar | AppManifest::Flags::Hidden);
-    CHECK_EQ(parseAppFlagsString(" hidestatusbar , hidden "), AppManifest::Flags::HideStatusBar | AppManifest::Flags::Hidden);
-    CHECK_EQ(parseAppFlagsString("HideStatusBar, Hidden"), AppManifest::Flags::HideStatusBar | AppManifest::Flags::Hidden);
-}
-
-TEST_CASE("parseManifest() should parse V1 flags for fullscreen") {
-    TestFile file("test-manifest-v1-flags.properties");
-    file.writeData(
-        "[manifest]\n"
-        "version=0.1\n"
-        "[target]\n"
-        "sdk=0.0.0\n"
-        "platforms=esp32\n"
-        "[app]\n"
-        "id=one.tactility.sdktest\n"
-        "versionName=0.1.0\n"
-        "versionCode=1\n"
-        "name=SDK Test\n"
-        "flags=HideStatusBar\n"
-    );
-
-    AppManifest manifest;
-    CHECK_EQ(parseManifest(file.getPath(), manifest), true);
-    CHECK_EQ(manifest.appFlags & AppManifest::Flags::HideStatusBar, AppManifest::Flags::HideStatusBar);
-}
-
-TEST_CASE("parseManifest() should parse V2 flags for fullscreen") {
-    TestFile file("test-manifest-v2-flags.properties");
-    file.writeData(
-        "manifest.version=0.1\n"
-        "target.sdk=0.0.0\n"
-        "target.platforms=esp32\n"
-        "app.id=one.tactility.sdktest\n"
-        "app.version.name=0.1.0\n"
-        "app.version.code=1\n"
-        "app.name=SDK Test\n"
-        "app.flags=HideStatusBar\n"
-    );
-
-    AppManifest manifest;
-    CHECK_EQ(parseManifest(file.getPath(), manifest), true);
-    CHECK_EQ(manifest.appFlags & AppManifest::Flags::HideStatusBar, AppManifest::Flags::HideStatusBar);
-}
-
-TEST_CASE("parseManifest() should parse combined flags") {
-    TestFile file("test-manifest-v2-flags2.properties");
-    file.writeData(
-        "manifest.version=0.1\n"
-        "target.sdk=0.0.0\n"
-        "target.platforms=esp32\n"
-        "app.id=one.tactility.sdktest\n"
-        "app.version.name=0.1.0\n"
-        "app.version.code=1\n"
-        "app.name=SDK Test\n"
-        "app.flags=HideStatusBar,Hidden\n"
-    );
-
-    AppManifest manifest;
-    CHECK_EQ(parseManifest(file.getPath(), manifest), true);
-    CHECK_EQ(manifest.appFlags, (AppManifest::Flags::HideStatusBar | AppManifest::Flags::Hidden));
-}