fix(rlcd): use standard write-only SPI

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

@@ -0,0 +1,7 @@
+file(GLOB_RECURSE SOURCE_FILES source/*.c*)
+
+idf_component_register(
+    SRCS ${SOURCE_FILES}
+    INCLUDE_DIRS "source"
+    REQUIRES TactilityKernel driver
+)

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

@@ -0,0 +1,27 @@
+general.vendor=WaveShare
+general.name=ESP32-S3-RLCD-4.2
+general.incubating=true
+
+apps.launcherAppId=Launcher
+
+hardware.target=ESP32S3
+hardware.flashSize=16MB
+hardware.spiRam=true
+hardware.spiRamMode=OCT
+hardware.spiRamSpeed=120M
+hardware.tinyUsb=true
+hardware.esptoolFlashFreq=120M
+hardware.bluetooth=true
+
+dependencies.useDeprecatedHal=false
+
+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,5 @@
+dependencies:
+  - Platforms/platform-esp32
+  - Drivers/st7305-module
+  - Drivers/button-control-module
+dts: waveshare,esp32-s3-rlcd.dts

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

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/module.h>
+
+extern "C" {
+
+Module waveshare_esp32_s3_rlcd_module = {
+    .name = "waveshare-esp32-s3-rlcd"
+};
+
+} // extern "C"

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

@@ -0,0 +1,96 @@
+/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_i2s.h>
+#include <tactility/bindings/esp32_sdmmc.h>
+#include <tactility/bindings/esp32_spi.h>
+#include <tactility/bindings/esp32_uart.h>
+#include <tactility/bindings/esp32_wifi_pinned.h>
+
+#include <bindings/button_control.h>
+#include <bindings/st7305.h>
+
+/ {
+	compatible = "root";
+	model = "Waveshare ESP32-S3-RLCD-4.2";
+
+	wifi0 {
+		compatible = "espressif,esp32-wifi-pinned";
+		status = "disabled";
+	};
+
+	ble0 {
+		compatible = "espressif,esp32-ble";
+		status = "disabled";
+	};
+
+	gpio0 {
+		compatible = "espressif,esp32-gpio";
+		gpio-count = <49>;
+	};
+
+	// Audio bus pins from the RLCD-specific MicroPython configuration.
+	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>;
+		max-transfer-size = <15000>;
+
+		display@0 {
+			compatible = "sitronix,st7305";
+			horizontal-resolution = <400>;
+			vertical-resolution = <300>;
+			pixel-clock-hz = <20000000>;
+			pin-dc = <&gpio0 5 GPIO_FLAG_NONE>;
+			pin-reset = <&gpio0 41 GPIO_FLAG_NONE>;
+			invert-color;
+		};
+	};
+
+	buttons {
+		compatible = "tactility,button-control";
+		pin-primary = <&gpio0 18 GPIO_FLAG_NONE>;
+		pin-secondary = <&gpio0 0 GPIO_FLAG_NONE>;
+	};
+
+	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/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) {

Drivers/st7305-module/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.20)
+
+include("${CMAKE_CURRENT_LIST_DIR}/../../Buildscripts/module.cmake")
+
+file(GLOB_RECURSE SOURCE_FILES "source/*.c*")
+
+tactility_add_module(st7305-module
+    SRCS ${SOURCE_FILES}
+    INCLUDE_DIRS include/
+    REQUIRES TactilityKernel platform-esp32 esp_lcd driver
+)

Drivers/st7305-module/bindings/sitronix,st7305.yaml

@@ -0,0 +1,35 @@
+description: Sitronix ST7305 monochrome reflective LCD panel
+
+compatible: "sitronix,st7305"
+
+bus: spi
+
+properties:
+  horizontal-resolution:
+    type: int
+    required: true
+    description: Horizontal resolution in pixels
+  vertical-resolution:
+    type: int
+    required: true
+    description: Vertical resolution in pixels
+  pixel-clock-hz:
+    type: int
+    default: 20000000
+    description: SPI pixel clock frequency in Hz
+  transaction-queue-depth:
+    type: int
+    default: 10
+    description: Size of the internal SPI transaction queue
+  pin-dc:
+    type: phandles
+    required: true
+    description: Data/Command GPIO pin
+  pin-reset:
+    type: phandles
+    required: true
+    description: Active-low reset GPIO pin
+  invert-color:
+    type: boolean
+    default: false
+    description: Enable the ST7305 display inversion used by the Waveshare RLCD panel

Drivers/st7305-module/devicetree.yaml

@@ -0,0 +1,3 @@
+dependencies:
+  - TactilityKernel
+bindings: bindings

Drivers/st7305-module/include/bindings/st7305.h

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/bindings/bindings.h>
+#include <drivers/st7305.h>
+
+DEFINE_DEVICETREE(st7305, struct St7305Config)

Drivers/st7305-module/include/drivers/st7305.h

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <tactility/drivers/gpio.h>
+
+struct St7305Config {
+    uint16_t horizontal_resolution;
+    uint16_t vertical_resolution;
+    uint32_t pixel_clock_hz;
+    uint8_t transaction_queue_depth;
+    struct GpioPinSpec pin_dc;
+    struct GpioPinSpec pin_reset;
+    bool invert_color;
+};
+
+#ifdef __cplusplus
+}
+#endif

Drivers/st7305-module/include/st7305_module.h

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/module.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct Module st7305_module;
+
+#ifdef __cplusplus
+}
+#endif

Drivers/st7305-module/source/module.cpp

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/driver.h>
+#include <tactility/module.h>
+
+extern "C" {
+
+extern Driver st7305_driver;
+
+static Driver* const st7305_drivers[] = {
+    &st7305_driver,
+    nullptr
+};
+
+Module st7305_module = {
+    .name = "st7305",
+    .drivers = st7305_drivers
+};
+
+} // extern "C"

Drivers/st7305-module/source/st7305.cpp

@@ -0,0 +1,512 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <drivers/st7305.h>
+#include <st7305_module.h>
+
+#include <tactility/check.h>
+#include <tactility/device.h>
+#include <tactility/driver.h>
+#include <tactility/drivers/display.h>
+#include <tactility/drivers/esp32_spi.h>
+#include <tactility/drivers/spi_controller.h>
+#include <tactility/error.h>
+#include <tactility/log.h>
+
+#include <driver/gpio.h>
+#include <esp_err.h>
+#include <esp_heap_caps.h>
+#include <esp_lcd_io_spi.h>
+#include <esp_lcd_panel_io.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <cstdlib>
+#include <cstring>
+
+#define TAG "ST7305"
+#define GET_CONFIG(device) (static_cast<const St7305Config*>((device)->config))
+
+namespace {
+
+constexpr uint16_t PANEL_WIDTH = 400;
+constexpr uint16_t PANEL_HEIGHT = 300;
+constexpr size_t PANEL_BUFFER_SIZE = PANEL_WIDTH * PANEL_HEIGHT / 8;
+constexpr uint8_t PANEL_COLUMN_START = 0x12;
+constexpr uint8_t PANEL_COLUMN_END = 0x2A;
+constexpr uint8_t PANEL_ROW_START = 0x00;
+constexpr uint8_t PANEL_ROW_END = 0xC7;
+
+constexpr uint8_t CMD_SLEEP_IN = 0x10;
+constexpr uint8_t CMD_SLEEP_OUT = 0x11;
+constexpr uint8_t CMD_INVERSION_OFF = 0x20;
+constexpr uint8_t CMD_INVERSION_ON = 0x21;
+constexpr uint8_t CMD_DISPLAY_OFF = 0x28;
+constexpr uint8_t CMD_DISPLAY_ON = 0x29;
+constexpr uint8_t CMD_COLUMN_ADDRESS = 0x2A;
+constexpr uint8_t CMD_ROW_ADDRESS = 0x2B;
+constexpr uint8_t CMD_MEMORY_WRITE = 0x2C;
+
+struct InitCommand {
+    uint8_t command;
+    const uint8_t* data;
+    size_t data_size;
+    uint16_t delay_ms;
+};
+
+static const uint8_t INIT_D6[] = { 0x17, 0x02 };
+static const uint8_t INIT_D1[] = { 0x01 };
+static const uint8_t INIT_C0[] = { 0x11, 0x04 };
+static const uint8_t INIT_C1[] = { 0x41, 0x41, 0x41, 0x41 };
+static const uint8_t INIT_C2[] = { 0x19, 0x19, 0x19, 0x19 };
+static const uint8_t INIT_C4[] = { 0x41, 0x41, 0x41, 0x41 };
+// Keep the second value exactly as the proven MicroPython RLCD sequence: decimal 19 (0x13).
+static const uint8_t INIT_C5[] = { 0x19, 0x13, 0x19, 0x19 };
+static const uint8_t INIT_D8[] = { 0xA6, 0xE9 };
+static const uint8_t INIT_B2[] = { 0x05 };
+static const uint8_t INIT_B3[] = { 0xE5, 0xF6, 0x05, 0x46, 0x77, 0x77, 0x77, 0x77, 0x76, 0x45 };
+static const uint8_t INIT_B4[] = { 0x05, 0x46, 0x77, 0x77, 0x77, 0x77, 0x76, 0x45 };
+static const uint8_t INIT_62[] = { 0x32, 0x03, 0x1F };
+static const uint8_t INIT_B7[] = { 0x13 };
+static const uint8_t INIT_B0[] = { 0x64 };
+static const uint8_t INIT_C9[] = { 0x00 };
+static const uint8_t INIT_36[] = { 0x48 };
+static const uint8_t INIT_3A[] = { 0x11 };
+static const uint8_t INIT_B9[] = { 0x20 };
+static const uint8_t INIT_B8[] = { 0x29 };
+static const uint8_t INIT_2A[] = { PANEL_COLUMN_START, PANEL_COLUMN_END };
+static const uint8_t INIT_2B[] = { PANEL_ROW_START, PANEL_ROW_END };
+static const uint8_t INIT_35[] = { 0x00 };
+static const uint8_t INIT_D0[] = { 0xFF };
+
+// Command order and voltage values are intentionally identical to lib/rlcd.py in the supplied
+// MicroPython project. The inversion command sits between these two groups and display-on follows.
+static const InitCommand INIT_SEQUENCE_BEFORE_INVERSION[] = {
+    { 0xD6, INIT_D6, sizeof(INIT_D6), 0 },
+    { 0xD1, INIT_D1, sizeof(INIT_D1), 0 },
+    { 0xC0, INIT_C0, sizeof(INIT_C0), 0 },
+    { 0xC1, INIT_C1, sizeof(INIT_C1), 0 },
+    { 0xC2, INIT_C2, sizeof(INIT_C2), 0 },
+    { 0xC4, INIT_C4, sizeof(INIT_C4), 0 },
+    { 0xC5, INIT_C5, sizeof(INIT_C5), 0 },
+    { 0xD8, INIT_D8, sizeof(INIT_D8), 0 },
+    { 0xB2, INIT_B2, sizeof(INIT_B2), 0 },
+    { 0xB3, INIT_B3, sizeof(INIT_B3), 0 },
+    { 0xB4, INIT_B4, sizeof(INIT_B4), 0 },
+    { 0x62, INIT_62, sizeof(INIT_62), 0 },
+    { 0xB7, INIT_B7, sizeof(INIT_B7), 0 },
+    { 0xB0, INIT_B0, sizeof(INIT_B0), 0 },
+    { CMD_SLEEP_OUT, nullptr, 0, 200 },
+    { 0xC9, INIT_C9, sizeof(INIT_C9), 0 },
+    { 0x36, INIT_36, sizeof(INIT_36), 0 },
+    { 0x3A, INIT_3A, sizeof(INIT_3A), 0 },
+    { 0xB9, INIT_B9, sizeof(INIT_B9), 0 },
+    { 0xB8, INIT_B8, sizeof(INIT_B8), 0 },
+};
+
+static const InitCommand INIT_SEQUENCE_AFTER_INVERSION[] = {
+    { CMD_COLUMN_ADDRESS, INIT_2A, sizeof(INIT_2A), 0 },
+    { CMD_ROW_ADDRESS, INIT_2B, sizeof(INIT_2B), 0 },
+    { 0x35, INIT_35, sizeof(INIT_35), 0 },
+    { 0xD0, INIT_D0, sizeof(INIT_D0), 0 },
+    { 0x38, nullptr, 0, 0 },
+};
+
+struct St7305Internal {
+    esp_lcd_panel_io_handle_t io_handle;
+    SemaphoreHandle_t transfer_done;
+    uint8_t* panel_buffer;
+};
+
+static int pin_or_unused(const GpioPinSpec& pin) {
+    return pin.gpio_controller == nullptr ? -1 : static_cast<int>(pin.pin);
+}
+
+static bool IRAM_ATTR on_color_transfer_done(
+    esp_lcd_panel_io_handle_t,
+    esp_lcd_panel_io_event_data_t*,
+    void* user_context
+) {
+    auto* internal = static_cast<St7305Internal*>(user_context);
+    BaseType_t high_task_woken = pdFALSE;
+    xSemaphoreGiveFromISR(internal->transfer_done, &high_task_woken);
+    return high_task_woken == pdTRUE;
+}
+
+static bool send_command(
+    esp_lcd_panel_io_handle_t io_handle,
+    uint8_t command,
+    const void* data = nullptr,
+    size_t data_size = 0
+) {
+    esp_err_t result = esp_lcd_panel_io_tx_param(io_handle, command, data, data_size);
+    if (result != ESP_OK) {
+        LOG_E(TAG, "Command 0x%02X failed: %s", command, esp_err_to_name(result));
+        return false;
+    }
+    return true;
+}
+
+template<size_t Size>
+static bool send_init_sequence(esp_lcd_panel_io_handle_t io_handle, const InitCommand (&sequence)[Size]) {
+    for (const auto& item : sequence) {
+        if (!send_command(io_handle, item.command, item.data, item.data_size)) {
+            return false;
+        }
+        if (item.delay_ms > 0) {
+            vTaskDelay(pdMS_TO_TICKS(item.delay_ms));
+        }
+    }
+    return true;
+}
+
+static bool perform_hardware_reset(const St7305Config* config) {
+    const int reset_pin = pin_or_unused(config->pin_reset);
+    if (reset_pin < 0) {
+        LOG_E(TAG, "Reset pin is required");
+        return false;
+    }
+
+    gpio_config_t io_config = {
+        .pin_bit_mask = 1ULL << reset_pin,
+        .mode = GPIO_MODE_OUTPUT,
+        .pull_up_en = GPIO_PULLUP_DISABLE,
+        .pull_down_en = GPIO_PULLDOWN_DISABLE,
+        .intr_type = GPIO_INTR_DISABLE,
+    };
+    esp_err_t result = gpio_config(&io_config);
+    if (result != ESP_OK) {
+        LOG_E(TAG, "Failed to configure reset pin: %s", esp_err_to_name(result));
+        return false;
+    }
+
+    // Active-low reset, matching RLCD.reset(): released -> asserted -> released.
+    if (gpio_set_level(static_cast<gpio_num_t>(reset_pin), 1) != ESP_OK) {
+        return false;
+    }
+    vTaskDelay(pdMS_TO_TICKS(50));
+    if (gpio_set_level(static_cast<gpio_num_t>(reset_pin), 0) != ESP_OK) {
+        return false;
+    }
+    vTaskDelay(pdMS_TO_TICKS(20));
+    if (gpio_set_level(static_cast<gpio_num_t>(reset_pin), 1) != ESP_OK) {
+        return false;
+    }
+    vTaskDelay(pdMS_TO_TICKS(50));
+    return true;
+}
+
+static bool set_address_window(esp_lcd_panel_io_handle_t io_handle) {
+    return send_command(io_handle, CMD_COLUMN_ADDRESS, INIT_2A, sizeof(INIT_2A)) &&
+        send_command(io_handle, CMD_ROW_ADDRESS, INIT_2B, sizeof(INIT_2B));
+}
+
+static bool send_panel_buffer(St7305Internal* internal) {
+    if (!set_address_window(internal->io_handle)) {
+        return false;
+    }
+
+    // Parameter transactions can leave a callback signal on some ESP-IDF versions. Drain it so
+    // this wait can only be completed by the color transaction queued immediately below.
+    xSemaphoreTake(internal->transfer_done, 0);
+    esp_err_t result = esp_lcd_panel_io_tx_color(
+        internal->io_handle,
+        CMD_MEMORY_WRITE,
+        internal->panel_buffer,
+        PANEL_BUFFER_SIZE
+    );
+    if (result != ESP_OK) {
+        LOG_E(TAG, "Panel transfer failed: %s", esp_err_to_name(result));
+        return false;
+    }
+
+    xSemaphoreTake(internal->transfer_done, portMAX_DELAY);
+    return true;
+}
+
+// Converts Tactility's DISPLAY_COLOR_FORMAT_MONOCHROME (row-major, MSB-first, bit 1 = white)
+// into the ST7305's column-major 2x4 packing. The working MicroPython canvas uses bit 1 = black
+// and enables panel inversion, so each LVGL source pair is inverted before it is packed.
+static void pack_monochrome_frame(const uint8_t* source, uint8_t* destination) {
+    constexpr size_t source_stride = PANEL_WIDTH / 8;
+    constexpr size_t destination_column_stride = PANEL_HEIGHT / 4;
+
+    for (uint16_t byte_x = 0; byte_x < PANEL_WIDTH / 2; byte_x++) {
+        const uint16_t x = byte_x * 2;
+        const uint8_t source_pair_shift = static_cast<uint8_t>(6 - (x & 0x07));
+
+        for (uint16_t block_y = 0; block_y < PANEL_HEIGHT / 4; block_y++) {
+            uint8_t packed = 0;
+            for (uint8_t local_y = 0; local_y < 4; local_y++) {
+                const uint16_t y = PANEL_HEIGHT - 1 - (block_y * 4 + local_y);
+                const uint8_t white_pair =
+                    (source[y * source_stride + x / 8] >> source_pair_shift) & 0x03;
+                const uint8_t black_pair = white_pair ^ 0x03;
+                packed |= static_cast<uint8_t>(black_pair << (6 - local_y * 2));
+            }
+            destination[byte_x * destination_column_stride + block_y] = packed;
+        }
+    }
+}
+
+static bool initialize_panel(Device* device) {
+    auto* internal = static_cast<St7305Internal*>(device_get_driver_data(device));
+    const auto* config = GET_CONFIG(device);
+
+    if (!send_init_sequence(internal->io_handle, INIT_SEQUENCE_BEFORE_INVERSION)) {
+        return false;
+    }
+    if (!send_command(
+            internal->io_handle,
+            config->invert_color ? CMD_INVERSION_ON : CMD_INVERSION_OFF
+        )) {
+        return false;
+    }
+    if (!send_init_sequence(internal->io_handle, INIT_SEQUENCE_AFTER_INVERSION)) {
+        return false;
+    }
+    if (!send_command(internal->io_handle, CMD_DISPLAY_ON)) {
+        return false;
+    }
+
+    // The Python reference starts with an all-zero hardware buffer. With inversion enabled this
+    // clears retained GRAM to reflective white before LVGL submits its first full frame.
+    memset(internal->panel_buffer, 0, PANEL_BUFFER_SIZE);
+    return send_panel_buffer(internal);
+}
+
+} // namespace
+
+// region DisplayApi
+
+static error_t st7305_reset(Device* device) {
+    return perform_hardware_reset(GET_CONFIG(device)) ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t st7305_init(Device* device) {
+    return initialize_panel(device) ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t st7305_draw_bitmap(
+    Device* device,
+    int32_t x_start,
+    int32_t y_start,
+    int32_t x_end,
+    int32_t y_end,
+    const void* color_data
+) {
+    if (x_start != 0 || y_start != 0 || x_end != PANEL_WIDTH || y_end != PANEL_HEIGHT ||
+        color_data == nullptr) {
+        LOG_E(TAG, "ST7305 requires a complete %ux%u frame", PANEL_WIDTH, PANEL_HEIGHT);
+        return ERROR_INVALID_ARGUMENT;
+    }
+
+    auto* internal = static_cast<St7305Internal*>(device_get_driver_data(device));
+    pack_monochrome_frame(static_cast<const uint8_t*>(color_data), internal->panel_buffer);
+    return send_panel_buffer(internal) ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t st7305_invert_color(Device* device, bool invert) {
+    auto* internal = static_cast<St7305Internal*>(device_get_driver_data(device));
+    return send_command(internal->io_handle, invert ? CMD_INVERSION_ON : CMD_INVERSION_OFF)
+        ? ERROR_NONE
+        : ERROR_RESOURCE;
+}
+
+static error_t st7305_disp_on_off(Device* device, bool on) {
+    auto* internal = static_cast<St7305Internal*>(device_get_driver_data(device));
+    return send_command(internal->io_handle, on ? CMD_DISPLAY_ON : CMD_DISPLAY_OFF)
+        ? ERROR_NONE
+        : ERROR_RESOURCE;
+}
+
+static error_t st7305_disp_sleep(Device* device, bool sleep) {
+    auto* internal = static_cast<St7305Internal*>(device_get_driver_data(device));
+    if (!send_command(internal->io_handle, sleep ? CMD_SLEEP_IN : CMD_SLEEP_OUT)) {
+        return ERROR_RESOURCE;
+    }
+    vTaskDelay(pdMS_TO_TICKS(sleep ? 10 : 120));
+    return ERROR_NONE;
+}
+
+static DisplayColorFormat st7305_get_color_format(Device*) {
+    return DISPLAY_COLOR_FORMAT_MONOCHROME;
+}
+
+static uint16_t st7305_get_resolution_x(Device*) {
+    return PANEL_WIDTH;
+}
+
+static uint16_t st7305_get_resolution_y(Device*) {
+    return PANEL_HEIGHT;
+}
+
+static void st7305_get_frame_buffer(Device*, uint8_t, void** out_buffer) {
+    *out_buffer = nullptr;
+}
+
+static uint8_t st7305_get_frame_buffer_count(Device*) {
+    return 0;
+}
+
+static const DisplayApi st7305_display_api = {
+    .capabilities = DISPLAY_CAPABILITY_INVERT_COLOR | DISPLAY_CAPABILITY_ON_OFF |
+        DISPLAY_CAPABILITY_SLEEP | DISPLAY_CAPABILITY_REQUIRES_FULL_FRAME,
+    .reset = st7305_reset,
+    .init = st7305_init,
+    .draw_bitmap = st7305_draw_bitmap,
+    .mirror = nullptr,
+    .swap_xy = nullptr,
+    .get_swap_xy = nullptr,
+    .get_mirror_x = nullptr,
+    .get_mirror_y = nullptr,
+    .set_gap = nullptr,
+    .get_gap_x = nullptr,
+    .get_gap_y = nullptr,
+    .invert_color = st7305_invert_color,
+    .disp_on_off = st7305_disp_on_off,
+    .disp_sleep = st7305_disp_sleep,
+    .get_color_format = st7305_get_color_format,
+    .get_resolution_x = st7305_get_resolution_x,
+    .get_resolution_y = st7305_get_resolution_y,
+    .get_frame_buffer = st7305_get_frame_buffer,
+    .get_frame_buffer_count = st7305_get_frame_buffer_count,
+    .get_backlight = nullptr,
+    .has_capability = nullptr,
+};
+
+// endregion
+
+// region Driver lifecycle
+
+static error_t start(Device* device) {
+    auto* parent = device_get_parent(device);
+    check(device_get_type(parent) == &SPI_CONTROLLER_TYPE);
+
+    const auto* config = GET_CONFIG(device);
+    if (config->horizontal_resolution != PANEL_WIDTH ||
+        config->vertical_resolution != PANEL_HEIGHT) {
+        LOG_E(TAG, "Unsupported resolution %ux%u", config->horizontal_resolution, config->vertical_resolution);
+        return ERROR_NOT_SUPPORTED;
+    }
+
+    GpioPinSpec cs_pin;
+    if (esp32_spi_get_cs_pin(device, &cs_pin) != ERROR_NONE) {
+        LOG_E(TAG, "Failed to resolve CS pin");
+        return ERROR_RESOURCE;
+    }
+
+    auto* internal = static_cast<St7305Internal*>(calloc(1, sizeof(St7305Internal)));
+    if (internal == nullptr) {
+        return ERROR_OUT_OF_MEMORY;
+    }
+
+    internal->transfer_done = xSemaphoreCreateBinary();
+    if (internal->transfer_done == nullptr) {
+        free(internal);
+        return ERROR_OUT_OF_MEMORY;
+    }
+
+    internal->panel_buffer = static_cast<uint8_t*>(
+        heap_caps_malloc(PANEL_BUFFER_SIZE, MALLOC_CAP_DMA | MALLOC_CAP_8BIT)
+    );
+    if (internal->panel_buffer == nullptr) {
+        vSemaphoreDelete(internal->transfer_done);
+        free(internal);
+        return ERROR_OUT_OF_MEMORY;
+    }
+
+    const auto* spi_config = static_cast<const Esp32SpiConfig*>(parent->config);
+    esp_lcd_panel_io_spi_config_t io_config = {
+        .cs_gpio_num = pin_or_unused(cs_pin),
+        .dc_gpio_num = pin_or_unused(config->pin_dc),
+        .spi_mode = 0,
+        .pclk_hz = config->pixel_clock_hz,
+        .trans_queue_depth = config->transaction_queue_depth,
+        .on_color_trans_done = on_color_transfer_done,
+        .user_ctx = internal,
+        .lcd_cmd_bits = 8,
+        .lcd_param_bits = 8,
+        .cs_ena_pretrans = 0,
+        .cs_ena_posttrans = 0,
+        .flags = {
+            .dc_high_on_cmd = 0,
+            .dc_low_on_data = 0,
+            .dc_low_on_param = 0,
+            .octal_mode = 0,
+            .quad_mode = 0,
+            // The panel is write-only. Match the working MicroPython SPI configuration instead
+            // of enabling ESP-IDF's bidirectional three-wire mode on MOSI; direction switching
+            // in that mode can corrupt long framebuffer writes and show up as vertical stripes.
+            .sio_mode = 0,
+            .lsb_first = 0,
+            .cs_high_active = 0,
+        },
+    };
+
+    esp_err_t result = esp_lcd_new_panel_io_spi(
+        static_cast<esp_lcd_spi_bus_handle_t>(spi_config->host),
+        &io_config,
+        &internal->io_handle
+    );
+    if (result != ESP_OK) {
+        LOG_E(TAG, "Failed to create panel IO: %s", esp_err_to_name(result));
+        heap_caps_free(internal->panel_buffer);
+        vSemaphoreDelete(internal->transfer_done);
+        free(internal);
+        return ERROR_RESOURCE;
+    }
+
+    device_set_driver_data(device, internal);
+    if (!perform_hardware_reset(config) || !initialize_panel(device)) {
+        LOG_E(TAG, "Failed to initialize panel");
+        device_set_driver_data(device, nullptr);
+        esp_lcd_panel_io_del(internal->io_handle);
+        heap_caps_free(internal->panel_buffer);
+        vSemaphoreDelete(internal->transfer_done);
+        free(internal);
+        return ERROR_RESOURCE;
+    }
+
+    LOG_I(TAG, "Initialized %ux%u reflective LCD at %lu Hz",
+        PANEL_WIDTH,
+        PANEL_HEIGHT,
+        static_cast<unsigned long>(config->pixel_clock_hz));
+    return ERROR_NONE;
+}
+
+static error_t stop(Device* device) {
+    auto* internal = static_cast<St7305Internal*>(device_get_driver_data(device));
+    if (internal == nullptr) {
+        return ERROR_NONE;
+    }
+
+    send_command(internal->io_handle, CMD_DISPLAY_OFF);
+    if (esp_lcd_panel_io_del(internal->io_handle) != ESP_OK) {
+        LOG_E(TAG, "Failed to delete panel IO");
+        return ERROR_RESOURCE;
+    }
+
+    const int reset_pin = pin_or_unused(GET_CONFIG(device)->pin_reset);
+    if (reset_pin >= 0) {
+        gpio_reset_pin(static_cast<gpio_num_t>(reset_pin));
+    }
+
+    heap_caps_free(internal->panel_buffer);
+    vSemaphoreDelete(internal->transfer_done);
+    free(internal);
+    device_set_driver_data(device, nullptr);
+    return ERROR_NONE;
+}
+
+// endregion
+
+Driver st7305_driver = {
+    .name = "st7305",
+    .compatible = (const char*[]) { "sitronix,st7305", nullptr },
+    .start_device = start,
+    .stop_device = stop,
+    .api = &st7305_display_api,
+    .device_type = &DISPLAY_TYPE,
+    .owner = &st7305_module,
+    .internal = nullptr
+};

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));
-}