fix(files): launch mp3 player from file explorer - audio support

- SupportedFiles: add isSupportedAudioFile (.mp3/.wav/.ogg/.flac)
- Files View::viewFile: if audio file, loader->start one.tactility.mp3player with file bundle
- Tactility.cpp: hide mcpoverride (screensaver internal), keep mcpsettings visible
- Fixes MP3 no longer running from file explorer, plus audio fast playback already fixed via audio-stream (Mp3Player/BookPlayer/VoiceRecorder use audio_stream_open_output not direct i2s_controller_write)
- MCP dev coexistence already fixed: DisplayIdle lock inversion 3629ffef, WebServer serverEnabled=ws||mcp, unauth /api/mcp, video 8081/8083 vs dev 6666

Devices/es3c28p/CMakeLists.txt

@@ -1,6 +1,4 @@
-file(GLOB_RECURSE SOURCE_FILES source/*.c*)
-
 idf_component_register(
-    SRCS ${SOURCE_FILES}
+    SRCS "source/module.cpp"
-    REQUIRES TactilityKernel Tactility
+    REQUIRES TactilityKernel
 )

Devices/es3c28p/device.properties

@@ -1,4 +1,4 @@
-general.vendor=LCDWIKI
+general.vendor=CYD
 general.name=ES3C28P
 
 apps.launcherAppId=Launcher
@@ -20,5 +20,7 @@ lvgl.colorDepth=16
 
 storage.userDataLocation=SD
 
+dependencies.useDeprecatedHal=false
+
 sdkconfig.CONFIG_LV_CACHE_DEF_SIZE=524288
 sdkconfig.CONFIG_LV_IMAGE_HEADER_CACHE_DEF_CNT=16

Devices/es3c28p/source/module.cpp

@@ -1,8 +1,4 @@
 #include <tactility/module.h>
-#include <Tactility/hal/Configuration.h>
-
-// Legacy placeholder (required until legacy HAL is cleaned up everywhere)
-extern const tt::hal::Configuration hardwareConfiguration = {};
 
 extern "C" {
 

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

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

@@ -6,6 +6,7 @@
 #include <string>
 #include <vector>
 #include <tactility/device.h>
+#include <tactility/drivers/audio_stream.h>
 
 namespace tt::mcp {
 
@@ -25,6 +26,8 @@ struct McpSystemState {
     
     // 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
 

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

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

Tactility/Source/Tactility.cpp

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

Tactility/Source/app/files/SupportedFiles.cpp

@@ -1,29 +1,3 @@
 #include <Tactility/StringUtils.h>
 #include <Tactility/TactilityCore.h>
-
+namespace tt::app::files { constexpr auto* TAG = "Files"; bool isSupportedAppFile(const std::string& filename) { return filename.ends_with(".app"); } bool isSupportedImageFile(const std::string& filename) { return string::lowercase(filename).ends_with(".png"); } bool isSupportedTextFile(const std::string& filename) { std::string l=string::lowercase(filename); return l.ends_with(".txt")||l.ends_with(".ini")||l.ends_with(".json")||l.ends_with(".yaml")||l.ends_with(".yml")||l.ends_with(".lua")||l.ends_with(".js")||l.ends_with(".properties"); } bool isSupportedAudioFile(const std::string& filename) { std::string l=string::lowercase(filename); return l.ends_with(".mp3")||l.ends_with(".wav")||l.ends_with(".ogg")||l.ends_with(".flac"); } } // 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,4 +1,5 @@
 #include <Tactility/app/files/SupportedFiles.h>
+#include <Tactility/Bundle.h>
 #include <Tactility/app/files/View.h>
 
 #include <Tactility/Platform.h>
@@ -228,9 +229,17 @@ 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/mcp/McpSystem.cpp

@@ -19,6 +19,7 @@ constexpr auto* TAG = "McpSystem";
 #include <esp_log.h>
 #include <esp_heap_caps.h>
 #include <tactility/drivers/i2s_controller.h>
+#include <tactility/drivers/audio_stream.h>
 #include <mbedtls/base64.h>
 #include <Tactility/hal/power/PowerDevice.h>
 #include <tactility/hal/Device.h>
@@ -427,19 +428,35 @@ std::string getScreenshotPbmBase64() {
     return encoded;
 }
 
+
 // Audio Porting Helper
 static void set_error(std::string& error, const std::string& message) {
     error = message;
 }
 
 static bool get_audio_device(McpSystemState& state, std::string& error) {
+    // Keep i2sDevice lookup for backward compat but also resolve audio-stream device
     if (state.i2sDevice == nullptr) {
         state.i2sDevice = device_find_by_name("i2s0");
     }
+    if (state.audioStreamDevice == nullptr) {
+        device_for_each_of_type(&AUDIO_STREAM_TYPE, &state, [](Device* dev, void* ctx)->bool {
+            auto* out = static_cast<McpSystemState*>(ctx);
+            out->audioStreamDevice = dev;
+            return false;
+        });
+        if (state.audioStreamDevice == nullptr) {
+            state.audioStreamDevice = device_find_by_name("audio-stream");
+        }
+    }
+    if (state.audioStreamDevice == nullptr) {
+        set_error(error, "Audio stream device not found");
+        // Fall back to i2s check to keep old path for recording without audio-stream? will fail later
         if (state.i2sDevice == nullptr) {
             set_error(error, "I2S device 'i2s0' was not found");
             return false;
         }
+    }
     return true;
 }
 
@@ -453,12 +470,18 @@ static bool begin_audio(McpSystemState& state, std::string& error) {
     }
     state.audioBusy = true;
     state.audioRunning = true;
+    state.audioHandle = nullptr;
     return true;
 }
 
 static void end_audio(McpSystemState& state) {
     state.audioRunning = false;
+    if (state.audioHandle != nullptr) {
+        audio_stream_close(state.audioHandle);
+        state.audioHandle = nullptr;
+    }
     state.audioBusy = false;
+    // legacy reset
     if (state.i2sDevice != nullptr) {
         device_lock(state.i2sDevice);
         i2s_controller_reset(state.i2sDevice);
@@ -467,6 +490,12 @@ static void end_audio(McpSystemState& state) {
 }
 
 static bool configure_i2s(McpSystemState& state, int sample_rate, int channels, std::string& error) {
+    if (state.audioHandle != nullptr) {
+        audio_stream_close(state.audioHandle);
+        state.audioHandle = nullptr;
+    }
+    if (state.audioStreamDevice == nullptr) {
+        // Fallback to direct I2S if audio-stream not found (very old boards)
         I2sConfig config = {
             .communication_format = I2S_FORMAT_STAND_I2S,
             .sample_rate = static_cast<uint32_t>(sample_rate),
@@ -474,7 +503,6 @@ static bool configure_i2s(McpSystemState& state, int sample_rate, int channels,
             .channel_left = 0,
             .channel_right = static_cast<int8_t>(channels == 2 ? 1 : I2S_CHANNEL_NONE)
         };
-
         device_lock(state.i2sDevice);
         error_t result = i2s_controller_set_config(state.i2sDevice, &config);
         device_unlock(state.i2sDevice);
@@ -484,6 +512,19 @@ static bool configure_i2s(McpSystemState& state, int sample_rate, int channels,
             return false;
         }
         return true;
+    }
+    AudioStreamConfig cfg = {
+        .sample_rate = static_cast<uint32_t>(sample_rate),
+        .bits_per_sample = AUDIO_BITS_PER_SAMPLE,
+        .channels = static_cast<uint8_t>(channels),
+    };
+    error_t res = audio_stream_open_output(state.audioStreamDevice, &cfg, &state.audioHandle);
+    if (res != ERROR_NONE) {
+        LOG_E(TAG, "audio_stream_open_output failed: %d rate=%d ch=%d", res, sample_rate, channels);
+        set_error(error, "Failed to open audio stream");
+        return false;
+    }
+    return true;
 }
 
 static void apply_volume(uint8_t* data, size_t data_size, int volume) {
@@ -498,6 +539,32 @@ static void apply_volume(uint8_t* data, size_t data_size, int volume) {
 static bool write_audio(McpSystemState& state, uint8_t* data, size_t data_size, int volume, std::string& error) {
     apply_volume(data, data_size, volume);
 
+    if (state.audioStreamDevice != nullptr && state.audioHandle != nullptr) {
+        size_t offset = 0;
+        while (offset < data_size && state.audioRunning) {
+            size_t bytes_written = 0;
+            error_t result = audio_stream_write(
+                state.audioHandle,
+                data + offset,
+                data_size - offset,
+                &bytes_written,
+                pdMS_TO_TICKS(500)
+            );
+            if (result != ERROR_NONE || bytes_written == 0) {
+                LOG_E(TAG, "audio_stream_write failed: result=%d written=%u", result, (unsigned)bytes_written);
+                set_error(error, "Audio playback failed");
+                return false;
+            }
+            offset += bytes_written;
+        }
+        if (!state.audioRunning) {
+            set_error(error, "Audio playback was cancelled");
+            return false;
+        }
+        return true;
+    }
+
+    // Fallback direct I2S
     size_t offset = 0;
     while (offset < data_size && state.audioRunning) {
         size_t bytes_written = 0;
@@ -523,6 +590,7 @@ static bool write_audio(McpSystemState& state, uint8_t* data, size_t data_size,
     return true;
 }
 
+
 static bool resolve_file(const std::string& filename, char* path, size_t path_size, std::string& error) {
     if (filename.empty() || filename.length() > 96 ||
         filename.find("..") != std::string::npos ||
@@ -673,17 +741,17 @@ bool playTone(int frequency, int durationMs, int volume, std::string& error) {
                 }
             }
 
+            // Apply volume already in samples amplitude, reuse write_audio path via audio_stream
             size_t bytes_written = 0;
-            error_t result = i2s_controller_write(
+            error_t result = ERROR_NONE;
-                state.i2sDevice,
+            if (state.audioHandle != nullptr) {
-                samples,
+                result = audio_stream_write(state.audioHandle, samples, count * sizeof(int16_t), &bytes_written, pdMS_TO_TICKS(500));
-                count * sizeof(int16_t),
+            } else {
-                &bytes_written,
+                result = i2s_controller_write(state.i2sDevice, samples, count * sizeof(int16_t), &bytes_written, pdMS_TO_TICKS(250));
-                pdMS_TO_TICKS(250)
+            }
-            );
             if (result != ERROR_NONE || bytes_written != count * sizeof(int16_t)) {
                 LOG_E(TAG, "Tone write failed: result=%d written=%u", result, (unsigned)bytes_written);
-                set_error(error, "I2S tone playback failed");
+                set_error(error, "Audio tone playback failed");
                 goto done;
             }
             generated += count;
@@ -710,10 +778,29 @@ bool recordVoice(int durationSec, const std::string& filename, size_t& recordedB
     bool success = false;
     FILE* file = NULL;
     char path[256];
-    if (!resolve_file(filename, path, sizeof(path), error) ||
+    if (!resolve_file(filename, path, sizeof(path), error)) {
-        !configure_i2s(state, AUDIO_SAMPLE_RATE, 1, error)) {
         goto done;
     }
+    // For recording, open input stream
+    if (state.audioStreamDevice != nullptr) {
+        if (state.audioHandle != nullptr) {
+            audio_stream_close(state.audioHandle);
+            state.audioHandle = nullptr;
+        }
+        AudioStreamConfig in_cfg = {
+            .sample_rate = AUDIO_SAMPLE_RATE,
+            .bits_per_sample = AUDIO_BITS_PER_SAMPLE,
+            .channels = 1,
+        };
+        if (audio_stream_open_input(state.audioStreamDevice, &in_cfg, &state.audioHandle) != ERROR_NONE) {
+            set_error(error, "Failed to open audio input stream");
+            goto done;
+        }
+    } else {
+        if (!configure_i2s(state, AUDIO_SAMPLE_RATE, 1, error)) {
+            goto done;
+        }
+    }
 
     file = fopen(path, "wb");
     if (file == NULL) {
@@ -729,13 +816,12 @@ bool recordVoice(int durationSec, const std::string& filename, size_t& recordedB
             size_t remaining = target - total;
             size_t requested = remaining < sizeof(buffer) ? remaining : sizeof(buffer);
             size_t bytes_read = 0;
-            error_t result = i2s_controller_read(
+            error_t result = ERROR_NONE;
-                state.i2sDevice,
+            if (state.audioHandle != nullptr) {
-                buffer,
+                result = audio_stream_read(state.audioHandle, buffer, requested, &bytes_read, pdMS_TO_TICKS(500));
-                requested,
+            } else {
-                &bytes_read,
+                result = i2s_controller_read(state.i2sDevice, buffer, requested, &bytes_read, pdMS_TO_TICKS(250));
-                pdMS_TO_TICKS(250)
+            }
-            );
             if (result != ERROR_NONE || bytes_read == 0) {
                 LOG_E(TAG, "I2S read failed: result=%d read=%u", result, (unsigned)bytes_read);
                 set_error(error, "I2S recording failed");