修复ESP-Hi报错 (#1643)

* Update esp_hi.cc

* Remove error check for event loop creation

If event loop already created, this function returns ESP_ERR_INVALID_STATE

---------

Co-authored-by: Xiaoxia <terrence@tenclass.com>

main/CMakeLists.txt

@@ -62,6 +62,8 @@ endfunction()
 set(BUILTIN_TEXT_FONT font_puhui_14_1)
 set(BUILTIN_ICON_FONT font_awesome_14_1)
 
+set(EMOTE_RESOLUTION "320_240")
+
 # Add board files according to BOARD_TYPE
 # Set default assets if the board uses partition table V2
 if(CONFIG_BOARD_TYPE_BREAD_COMPACT_WIFI)
@@ -90,11 +92,13 @@ elseif(CONFIG_BOARD_TYPE_ESP_BOX_3)
     set(BUILTIN_TEXT_FONT font_puhui_basic_20_4)
     set(BUILTIN_ICON_FONT font_awesome_20_4)
     set(DEFAULT_EMOJI_COLLECTION twemoji_64)
+    set(EMOTE_RESOLUTION "320_240")
 elseif(CONFIG_BOARD_TYPE_ESP_BOX)
     set(BOARD_TYPE "esp-box")
     set(BUILTIN_TEXT_FONT font_puhui_basic_20_4)
     set(BUILTIN_ICON_FONT font_awesome_20_4)
     set(DEFAULT_EMOJI_COLLECTION twemoji_64)
+    set(EMOTE_RESOLUTION "320_240")
 elseif(CONFIG_BOARD_TYPE_ESP_BOX_LITE)
     set(BOARD_TYPE "esp-box-lite")
     set(BUILTIN_TEXT_FONT font_puhui_basic_20_4)
@@ -212,6 +216,13 @@ elseif(CONFIG_BOARD_TYPE_ECHOEAR)
     set(BUILTIN_TEXT_FONT font_puhui_20_4)
     set(BUILTIN_ICON_FONT font_awesome_20_4)
     set(DEFAULT_EMOJI_COLLECTION twemoji_64)
+    set(EMOTE_RESOLUTION "360_360")
+    # set(EMOTE_EXTERNAL_PATH "${CMAKE_CURRENT_SOURCE_DIR}/boards/echoear/assets")
+elseif(CONFIG_BOARD_TYPE_ESP_SENSAIRSHUTTLE)
+    set(BOARD_TYPE "esp-sensairshuttle")
+    set(BUILTIN_TEXT_FONT font_puhui_basic_16_4)
+    set(BUILTIN_ICON_FONT font_awesome_16_4)
+    set(DEFAULT_EMOJI_COLLECTION twemoji_32)
 elseif(CONFIG_BOARD_TYPE_WAVESHARE_S3_AUDIO_BOARD)
     set(BOARD_TYPE "waveshare-s3-audio-board")
     set(BUILTIN_TEXT_FONT font_puhui_basic_16_4)
@@ -923,6 +934,14 @@ if ("${size}" AND "${offset}")
         get_assets_local_file("${CONFIG_CUSTOM_ASSETS_FILE}" ASSETS_LOCAL_FILE)
         esptool_py_flash_to_partition(flash "assets" "${ASSETS_LOCAL_FILE}")
         message(STATUS "Custom assets flash configured: ${ASSETS_LOCAL_FILE} -> assets partition")
+    elseif(CONFIG_FLASH_EXPRESSION_ASSETS)
+        set(ASSETS_NAME "expression_assets")
+        set(ASSETS_PARTITION "assets")
+        set(ASSETS_FILE "${CMAKE_BINARY_DIR}/${ASSETS_NAME}.bin")
+
+        build_speaker_assets_bin("${ASSETS_PARTITION}" ${EMOTE_RESOLUTION} ${ASSETS_FILE} ${CONFIG_MMAP_FILE_NAME_LENGTH})
+        message(STATUS "Generated emote assets: ${ASSETS_FILE} -> ${ASSETS_PARTITION} partition")
+        esptool_py_flash_to_partition(flash "${ASSETS_PARTITION}" "${ASSETS_FILE}")
     elseif(CONFIG_FLASH_NONE_ASSETS)
         message(STATUS "Assets flashing disabled (FLASH_NONE_ASSETS)")
     endif()

main/Kconfig.projbuild

@@ -8,7 +8,8 @@ config OTA_URL
 
 choice
     prompt "Flash Assets"
-    default FLASH_DEFAULT_ASSETS
+    default FLASH_DEFAULT_ASSETS if !USE_EMOTE_MESSAGE_STYLE
+    default FLASH_EXPRESSION_ASSETS if USE_EMOTE_MESSAGE_STYLE
     help
         Select the assets to flash.
 
@@ -16,8 +17,12 @@ choice
         bool "Do not flash assets"
     config FLASH_DEFAULT_ASSETS
         bool "Flash Default Assets"
+        depends on !USE_EMOTE_MESSAGE_STYLE
     config FLASH_CUSTOM_ASSETS
         bool "Flash Custom Assets"
+    config FLASH_EXPRESSION_ASSETS
+        bool "Flash Emote Assets"
+        depends on USE_EMOTE_MESSAGE_STYLE
 endchoice
 
 config CUSTOM_ASSETS_FILE
@@ -150,6 +155,9 @@ choice BOARD_TYPE
     config BOARD_TYPE_ESP_SPARKBOT
         bool "Espressif SparkBot"
         depends on IDF_TARGET_ESP32S3
+    config BOARD_TYPE_ESP_SENSAIRSHUTTLE
+        bool "Espressif ESP-SensairShuttle"
+        depends on IDF_TARGET_ESP32C5
     config BOARD_TYPE_ESP_SPOT_S3
         bool "Espressif Spot-S3"
         depends on IDF_TARGET_ESP32S3
@@ -582,7 +590,9 @@ choice DISPLAY_STYLE
 
     config USE_EMOTE_MESSAGE_STYLE
         bool "Emote animation style"
-        depends on BOARD_TYPE_ESP_BOX_3 || BOARD_TYPE_ECHOEAR || BOARD_TYPE_LICHUANG_DEV_S3
+        depends on BOARD_TYPE_ESP_BOX || BOARD_TYPE_ESP_BOX_3 \
+            || BOARD_TYPE_ECHOEAR || BOARD_TYPE_LICHUANG_DEV_S3 \
+            || BOARD_TYPE_ESP_SENSAIRSHUTTLE
 endchoice
 
 choice WAKE_WORD_TYPE

main/assets.cc

@@ -4,17 +4,19 @@
 #include "application.h"
 #include "lvgl_theme.h"
 #include "emote_display.h"
-#ifdef HAVE_LVGL
+#include "expression_emote.h"
+#if HAVE_LVGL
 #include "display/lcd_display.h"
+#include <spi_flash_mmap.h>
 #endif
 
 #include <esp_log.h>
-#include <spi_flash_mmap.h>
 #include <esp_timer.h>
 #include <cbin_font.h>
 
 
 #define TAG "Assets"
+#define PARTITION_LABEL "assets"
 
 struct mmap_assets_table {
     char asset_name[32];          /*!< Name of the asset */
@@ -24,19 +26,99 @@ struct mmap_assets_table {
     uint16_t asset_height;        /*!< Height of the asset */
 };
 
-
 Assets::Assets() {
+#if HAVE_LVGL
+    strategy_ = std::make_unique<Assets::LvglStrategy>();
+#else
+    strategy_ = std::make_unique<Assets::EmoteStrategy>();
+#endif
     // Initialize the partition
     InitializePartition();
 }
 
 Assets::~Assets() {
-    if (mmap_handle_ != 0) {
-        esp_partition_munmap(mmap_handle_);
+    UnApplyPartition();
+}
+
+bool Assets::FindPartition(Assets* assets) {
+    assets->partition_ = esp_partition_find_first(ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_ANY, PARTITION_LABEL);
+    if (assets->partition_ == nullptr) {
+        ESP_LOGI(TAG, "No assets partition found");
+        return false;
+    }
+    return true;
+}
+
+bool Assets::Apply() {
+    return strategy_ ? strategy_->Apply(this) : false;
+}
+
+bool Assets::InitializePartition() {
+    return strategy_ ? strategy_->InitializePartition(this) : false;
+}
+
+void Assets::UnApplyPartition() {
+    if (strategy_) {
+        strategy_->UnApplyPartition(this);
     }
 }
 
-uint32_t Assets::CalculateChecksum(const char* data, uint32_t length) {
+bool Assets::GetAssetData(const std::string& name, void*& ptr, size_t& size) {
+    return strategy_ ? strategy_->GetAssetData(this, name, ptr, size) : false;
+}
+
+bool Assets::LoadSrmodelsFromIndex(Assets* assets, cJSON* root) {
+    void* ptr = nullptr;
+    size_t size = 0;
+    bool need_delete_root = false;
+
+    // If root is not provided, parse index.json
+    if (root == nullptr) {
+        if (!assets->GetAssetData("index.json", ptr, size)) {
+            ESP_LOGE(TAG, "The index.json file is not found");
+            return false;
+        }
+
+        root = cJSON_ParseWithLength(static_cast<char*>(ptr), size);
+        if (root == nullptr) {
+            ESP_LOGE(TAG, "The index.json file is not valid");
+            return false;
+        }
+        need_delete_root = true;
+    }
+
+    cJSON* srmodels = cJSON_GetObjectItem(root, "srmodels");
+    if (cJSON_IsString(srmodels)) {
+        std::string srmodels_file = srmodels->valuestring;
+        if (assets->GetAssetData(srmodels_file, ptr, size)) {
+            if (assets->models_list_ != nullptr) {
+                esp_srmodel_deinit(assets->models_list_);
+                assets->models_list_ = nullptr;
+            }
+            assets->models_list_ = srmodel_load(static_cast<uint8_t*>(ptr));
+            if (assets->models_list_ != nullptr) {
+                auto& app = Application::GetInstance();
+                app.GetAudioService().SetModelsList(assets->models_list_);
+                if (need_delete_root) {
+                    cJSON_Delete(root);
+                }
+                return true;
+            } else {
+                ESP_LOGE(TAG, "Failed to load srmodels.bin");
+            }
+        } else {
+            ESP_LOGE(TAG, "The srmodels file %s is not found", srmodels_file.c_str());
+        }
+    }
+
+    if (need_delete_root) {
+        cJSON_Delete(root);
+    }
+    return false;
+}
+
+#if HAVE_LVGL
+uint32_t Assets::LvglStrategy::CalculateChecksum(const char* data, uint32_t length) {
     uint32_t checksum = 0;
     for (uint32_t i = 0; i < length; i++) {
         checksum += data[i];
@@ -44,40 +126,37 @@ uint32_t Assets::CalculateChecksum(const char* data, uint32_t length) {
     return checksum & 0xFFFF;
 }
 
-bool Assets::InitializePartition() {
-    partition_valid_ = false;
-    checksum_valid_ = false;
+bool Assets::LvglStrategy::InitializePartition(Assets* assets) {
+    assets->partition_valid_ = false;
     assets_.clear();
 
-    partition_ = esp_partition_find_first(ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_ANY, "assets");
-    if (partition_ == nullptr) {
-        ESP_LOGI(TAG, "No assets partition found");
+    if (!Assets::FindPartition(assets)) {
         return false;
     }
 
     int free_pages = spi_flash_mmap_get_free_pages(SPI_FLASH_MMAP_DATA);
     uint32_t storage_size = free_pages * 64 * 1024;
     ESP_LOGI(TAG, "The storage free size is %ld KB", storage_size / 1024);
-    ESP_LOGI(TAG, "The partition size is %ld KB", partition_->size / 1024);
-    if (storage_size < partition_->size) {
-        ESP_LOGE(TAG, "The free size %ld KB is less than assets partition required %ld KB", storage_size / 1024, partition_->size / 1024);
+    ESP_LOGI(TAG, "The partition size is %ld KB", assets->partition_->size / 1024);
+    if (storage_size < assets->partition_->size) {
+        ESP_LOGE(TAG, "The free size %ld KB is less than assets partition required %ld KB", storage_size / 1024, assets->partition_->size / 1024);
         return false;
     }
 
-    esp_err_t err = esp_partition_mmap(partition_, 0, partition_->size, ESP_PARTITION_MMAP_DATA, (const void**)&mmap_root_, &mmap_handle_);
+    esp_err_t err = esp_partition_mmap(assets->partition_, 0, assets->partition_->size, ESP_PARTITION_MMAP_DATA, (const void**)&mmap_root_, &mmap_handle_);
     if (err != ESP_OK) {
         ESP_LOGE(TAG, "Failed to mmap assets partition: %s", esp_err_to_name(err));
         return false;
     }
 
-    partition_valid_ = true;
+    assets->partition_valid_ = true;
 
     uint32_t stored_files = *(uint32_t*)(mmap_root_ + 0);
     uint32_t stored_chksum = *(uint32_t*)(mmap_root_ + 4);
     uint32_t stored_len = *(uint32_t*)(mmap_root_ + 8);
 
-    if (stored_len > partition_->size - 12) {
-        ESP_LOGD(TAG, "The stored_len (0x%lx) is greater than the partition size (0x%lx) - 12", stored_len, partition_->size);
+    if (stored_len > assets->partition_->size - 12) {
+        ESP_LOGD(TAG, "The stored_len (0x%lx) is greater than the partition size (0x%lx) - 12", stored_len, assets->partition_->size);
         return false;
     }
 
@@ -104,10 +183,37 @@ bool Assets::InitializePartition() {
     return checksum_valid_;
 }
 
-bool Assets::Apply() {
+void Assets::LvglStrategy::UnApplyPartition(Assets* assets) {
+    if (mmap_handle_ != 0) {
+        esp_partition_munmap(mmap_handle_);
+        mmap_handle_ = 0;
+        mmap_root_ = nullptr;
+    }
+    checksum_valid_ = false;
+    assets_.clear();
+    (void)assets; // Unused parameter
+}
+
+bool Assets::LvglStrategy::GetAssetData(Assets* assets, const std::string& name, void*& ptr, size_t& size) {
+    auto asset = assets_.find(name);
+    if (asset == assets_.end()) {
+        return false;
+    }
+    auto data = (const char*)(mmap_root_ + asset->second.offset);
+    if (data[0] != 'Z' || data[1] != 'Z') {
+        ESP_LOGE(TAG, "The asset %s is not valid with magic %02x%02x", name.c_str(), data[0], data[1]);
+        return false;
+    }
+
+    ptr = static_cast<void*>(const_cast<char*>(data + 2));
+    size = asset->second.size;
+    return true;
+}
+
+bool Assets::LvglStrategy::Apply(Assets* assets) {
     void* ptr = nullptr;
     size_t size = 0;
-    if (!GetAssetData("index.json", ptr, size)) {
+    if (!assets->GetAssetData("index.json", ptr, size)) {
         ESP_LOGE(TAG, "The index.json file is not found");
         return false;
     }
@@ -125,28 +231,9 @@ bool Assets::Apply() {
             return false;
         }
     }
-    
-    cJSON* srmodels = cJSON_GetObjectItem(root, "srmodels");
-    if (cJSON_IsString(srmodels)) {
-        std::string srmodels_file = srmodels->valuestring;
-        if (GetAssetData(srmodels_file, ptr, size)) {
-            if (models_list_ != nullptr) {
-                esp_srmodel_deinit(models_list_);
-                models_list_ = nullptr;
-            }
-            models_list_ = srmodel_load(static_cast<uint8_t*>(ptr));
-            if (models_list_ != nullptr) {
-                auto& app = Application::GetInstance();
-                app.GetAudioService().SetModelsList(models_list_);
-            } else {
-                ESP_LOGE(TAG, "Failed to load srmodels.bin");
-            }
-        } else {
-            ESP_LOGE(TAG, "The srmodels file %s is not found", srmodels_file.c_str());
-        }
-    }
 
-#ifdef HAVE_LVGL
+    Assets::LoadSrmodelsFromIndex(assets, root);
+
     auto& theme_manager = LvglThemeManager::GetInstance();
     auto light_theme = theme_manager.GetTheme("light");
     auto dark_theme = theme_manager.GetTheme("dark");
@@ -154,7 +241,7 @@ bool Assets::Apply() {
     cJSON* font = cJSON_GetObjectItem(root, "text_font");
     if (cJSON_IsString(font)) {
         std::string fonts_text_file = font->valuestring;
-        if (GetAssetData(fonts_text_file, ptr, size)) {
+        if (assets->GetAssetData(fonts_text_file, ptr, size)) {
             auto text_font = std::make_shared<LvglCBinFont>(ptr);
             if (text_font->font() == nullptr) {
                 ESP_LOGE(TAG, "Failed to load fonts.bin");
@@ -182,7 +269,7 @@ bool Assets::Apply() {
                 cJSON* file = cJSON_GetObjectItem(emoji, "file");
                 cJSON* eaf = cJSON_GetObjectItem(emoji, "eaf");
                 if (cJSON_IsString(name) && cJSON_IsString(file) && (NULL== eaf)) {
-                    if (!GetAssetData(file->valuestring, ptr, size)) {
+                    if (!assets->GetAssetData(file->valuestring, ptr, size)) {
                         ESP_LOGE(TAG, "Emoji %s image file %s is not found", name->valuestring, file->valuestring);
                         continue;
                     }
@@ -213,7 +300,7 @@ bool Assets::Apply() {
                 light_theme->set_chat_background_color(LvglTheme::ParseColor(background_color->valuestring));
             }
             if (cJSON_IsString(background_image)) {
-                if (!GetAssetData(background_image->valuestring, ptr, size)) {
+                if (!assets->GetAssetData(background_image->valuestring, ptr, size)) {
                     ESP_LOGE(TAG, "The background image file %s is not found", background_image->valuestring);
                     return false;
                 }
@@ -234,7 +321,7 @@ bool Assets::Apply() {
                 dark_theme->set_chat_background_color(LvglTheme::ParseColor(background_color->valuestring));
             }
             if (cJSON_IsString(background_image)) {
-                if (!GetAssetData(background_image->valuestring, ptr, size)) {
+                if (!assets->GetAssetData(background_image->valuestring, ptr, size)) {
                     ESP_LOGE(TAG, "The background image file %s is not found", background_image->valuestring);
                     return false;
                 }
@@ -262,137 +349,84 @@ bool Assets::Apply() {
             ESP_LOGI(TAG, "Set hide_subtitle to %s", hide ? "true" : "false");
         }
     }
-
-#elif defined(CONFIG_USE_EMOTE_MESSAGE_STYLE)
-    auto &board = Board::GetInstance();
-    auto display = board.GetDisplay();
-    auto emote_display = dynamic_cast<emote::EmoteDisplay*>(display);
-
-    cJSON* font = cJSON_GetObjectItem(root, "text_font");
-    if (cJSON_IsString(font)) {
-        std::string fonts_text_file = font->valuestring;
-        if (GetAssetData(fonts_text_file, ptr, size)) {
-            auto text_font = std::make_shared<LvglCBinFont>(ptr);
-            if (text_font->font() == nullptr) {
-                ESP_LOGE(TAG, "Failed to load fonts.bin");
-                return false;
-            }
-
-            if (emote_display) {
-                emote_display->AddTextFont(text_font);
-            }
-        } else {
-            ESP_LOGE(TAG, "The font file %s is not found", fonts_text_file.c_str());
-        }
-    }
-
-    cJSON* emoji_collection = cJSON_GetObjectItem(root, "emoji_collection");
-    if (cJSON_IsArray(emoji_collection)) {
-        int emoji_count = cJSON_GetArraySize(emoji_collection);
-        if (emote_display) {
-            for (int i = 0; i < emoji_count; i++) {
-                cJSON* icon = cJSON_GetArrayItem(emoji_collection, i);
-                if (cJSON_IsObject(icon)) {
-                    cJSON* name = cJSON_GetObjectItem(icon, "name");
-                    cJSON* file = cJSON_GetObjectItem(icon, "file");
-
-                    if (cJSON_IsString(name) && cJSON_IsString(file)) {
-                        if (GetAssetData(file->valuestring, ptr, size)) {
-                            cJSON* eaf = cJSON_GetObjectItem(icon, "eaf");
-                            bool lack_value = false;
-                            bool loop_value = false;
-                            int fps_value = 0;
-
-                            if (cJSON_IsObject(eaf)) {
-                                cJSON* lack = cJSON_GetObjectItem(eaf, "lack");
-                                cJSON* loop = cJSON_GetObjectItem(eaf, "loop");
-                                cJSON* fps = cJSON_GetObjectItem(eaf, "fps");
-
-                                lack_value = lack ? cJSON_IsTrue(lack) : false;
-                                loop_value = loop ? cJSON_IsTrue(loop) : false;
-                                fps_value = fps ? fps->valueint : 0;
-
-                                emote_display->AddEmojiData(name->valuestring, ptr, size,
-                                                          static_cast<uint8_t>(fps_value),
-                                                          loop_value, lack_value);
-                            }
-
-                        } else {
-                            ESP_LOGE(TAG, "Emoji \"%10s\" image file %s is not found", name->valuestring, file->valuestring);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    cJSON* icon_collection = cJSON_GetObjectItem(root, "icon_collection");
-    if (cJSON_IsArray(icon_collection)) {
-        if (emote_display) {
-            int icon_count = cJSON_GetArraySize(icon_collection);
-            for (int i = 0; i < icon_count; i++) {
-                cJSON* icon = cJSON_GetArrayItem(icon_collection, i);
-                if (cJSON_IsObject(icon)) {
-                    cJSON* name = cJSON_GetObjectItem(icon, "name");
-                    cJSON* file = cJSON_GetObjectItem(icon, "file");
-
-                    if (cJSON_IsString(name) && cJSON_IsString(file)) {
-                        if (GetAssetData(file->valuestring, ptr, size)) {
-                            emote_display->AddIconData(name->valuestring, ptr, size);
-                        } else {
-                            ESP_LOGE(TAG, "Icon \"%10s\" image file %s is not found", name->valuestring, file->valuestring);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    cJSON* layout_json = cJSON_GetObjectItem(root, "layout");
-    if (cJSON_IsArray(layout_json)) {
-        int layout_count = cJSON_GetArraySize(layout_json);
-
-        for (int i = 0; i < layout_count; i++) {
-            cJSON* layout_item = cJSON_GetArrayItem(layout_json, i);
-            if (cJSON_IsObject(layout_item)) {
-                cJSON* name = cJSON_GetObjectItem(layout_item, "name");
-                cJSON* align = cJSON_GetObjectItem(layout_item, "align");
-                cJSON* x = cJSON_GetObjectItem(layout_item, "x");
-                cJSON* y = cJSON_GetObjectItem(layout_item, "y");
-                cJSON* width = cJSON_GetObjectItem(layout_item, "width");
-                cJSON* height = cJSON_GetObjectItem(layout_item, "height");
-
-                if (cJSON_IsString(name) && cJSON_IsString(align) && cJSON_IsNumber(x) && cJSON_IsNumber(y)) {
-                    int width_val = cJSON_IsNumber(width) ? width->valueint : 0;
-                    int height_val = cJSON_IsNumber(height) ? height->valueint : 0;
-
-                    if (emote_display) {
-                        emote_display->AddLayoutData(name->valuestring, align->valuestring,
-                                                     x->valueint, y->valueint, width_val, height_val);
-                    }
-                } else {
-                    ESP_LOGW(TAG, "Invalid layout item %d: missing required fields", i);
-                }
-            }
-        }
-    }
-#endif
-
+    
     cJSON_Delete(root);
     return true;
 }
+#endif // HAVE_LVGL
+
+bool Assets::EmoteStrategy::InitializePartition(Assets* assets) {
+    assets->partition_valid_ = false;
+
+    if (!Assets::FindPartition(assets)) {
+        return false;
+    }
+
+    esp_err_t ret = ESP_ERR_INVALID_STATE;
+    auto display = Board::GetInstance().GetDisplay();
+    auto* emote_display = dynamic_cast<emote::EmoteDisplay*>(display);
+    if (emote_display && emote_display->GetEmoteHandle() != nullptr) {
+        const emote_data_t data = {
+            .type = EMOTE_SOURCE_PARTITION,
+            .source = {
+                .partition_label = PARTITION_LABEL,
+            },
+            .flags = {
+                .mmap_enable = true, //must be true here!!!
+            },
+        };
+        ret = emote_mount_assets(emote_display->GetEmoteHandle(), &data);
+    } else {
+        ESP_LOGE(TAG, "Emote display is not initialized");
+    }
+    assets->partition_valid_ = ((ret == ESP_OK) ? true : false);
+    return assets->partition_valid_;
+}
+
+void Assets::EmoteStrategy::UnApplyPartition(Assets* assets) {
+    auto display = Board::GetInstance().GetDisplay();
+    auto* emote_display = dynamic_cast<emote::EmoteDisplay*>(display);
+    if (emote_display && emote_display->GetEmoteHandle() != nullptr) {
+        emote_unmount_assets(emote_display->GetEmoteHandle());
+    }
+    (void)assets; // Unused parameter
+}
+
+bool Assets::EmoteStrategy::GetAssetData(Assets* assets, const std::string& name, void*& ptr, size_t& size) {
+    auto display = Board::GetInstance().GetDisplay();
+    auto* emote_display = dynamic_cast<emote::EmoteDisplay*>(display);
+    if (emote_display && emote_display->GetEmoteHandle() != nullptr) {
+        const uint8_t* data = nullptr;
+        size_t data_size = 0;
+        if (ESP_OK == emote_get_asset_data_by_name(emote_display->GetEmoteHandle(), name.c_str(), &data, &data_size)) {
+            ptr = const_cast<void*>(static_cast<const void*>(data));
+            size = data_size;
+            return true;
+        }
+        ESP_LOGE(TAG, "Failed to get asset data by name: %s", name.c_str());
+        return false;
+    }
+    (void)assets; // Unused parameter
+    return false;
+}
+
+bool Assets::EmoteStrategy::Apply(Assets* assets) {
+    Assets::LoadSrmodelsFromIndex(assets);
+
+    auto display = Board::GetInstance().GetDisplay();
+    auto* emote_display = dynamic_cast<emote::EmoteDisplay*>(display);
+
+    if (emote_display && emote_display->GetEmoteHandle() != nullptr) {
+        emote_load_assets(emote_display->GetEmoteHandle());
+    }
+    return true;
+}
 
 bool Assets::Download(std::string url, std::function<void(int progress, size_t speed)> progress_callback) {
     ESP_LOGI(TAG, "Downloading new version of assets from %s", url.c_str());
-    
+
     // 取消当前资源分区的内存映射
-    if (mmap_handle_ != 0) {
-        esp_partition_munmap(mmap_handle_);
-        mmap_handle_ = 0;
-        mmap_root_ = nullptr;
-    }
-    checksum_valid_ = false;
-    assets_.clear();
+    UnApplyPartition();
 
     // 下载新的资源文件
     auto network = Board::GetInstance().GetNetwork();
@@ -514,19 +548,3 @@ bool Assets::Download(std::string url, std::function<void(int progress, size_t s
 
     return true;
 }
-
-bool Assets::GetAssetData(const std::string& name, void*& ptr, size_t& size) {
-    auto asset = assets_.find(name);
-    if (asset == assets_.end()) {
-        return false;
-    }
-    auto data = (const char*)(mmap_root_ + asset->second.offset);
-    if (data[0] != 'Z' || data[1] != 'Z') {
-        ESP_LOGE(TAG, "The asset %s is not valid with magic %02x%02x", name.c_str(), data[0], data[1]);
-        return false;
-    }
-
-    ptr = static_cast<void*>(const_cast<char*>(data + 2));
-    size = asset->second.size;
-    return true;
-}

main/assets.h

@@ -1,14 +1,19 @@
 #ifndef ASSETS_H
 #define ASSETS_H
 
-#include <map>
 #include <string>
 #include <functional>
+#include <memory>
 
 #include <cJSON.h>
 #include <esp_partition.h>
 #include <model_path.h>
+#include <map>
+#include <string>
 
+#if HAVE_LVGL
+#include <spi_flash_mmap.h>
+#endif
 
 struct Asset {
     size_t size;
@@ -28,7 +33,6 @@ public:
     bool GetAssetData(const std::string& name, void*& ptr, size_t& size);
 
     inline bool partition_valid() const { return partition_valid_; }
-    inline bool checksum_valid() const { return checksum_valid_; }
     inline std::string default_assets_url() const { return default_assets_url_; }
 
 private:
@@ -37,16 +41,49 @@ private:
     Assets& operator=(const Assets&) = delete;
 
     bool InitializePartition();
-    uint32_t CalculateChecksum(const char* data, uint32_t length);
+    void UnApplyPartition();
+    static bool FindPartition(Assets* assets);
+    static bool LoadSrmodelsFromIndex(Assets* assets, cJSON* root = nullptr);
+  
+    class AssetStrategy {
+    public:
+        virtual ~AssetStrategy() = default;
+        virtual bool Apply(Assets* assets) = 0;
+        virtual bool InitializePartition(Assets* assets) = 0;
+        virtual void UnApplyPartition(Assets* assets) = 0;
+        virtual bool GetAssetData(Assets* assets, const std::string& name, void*& ptr, size_t& size) = 0;
+    };
+    
+    class LvglStrategy : public AssetStrategy {
+    public:
+        bool Apply(Assets* assets) override;
+        bool InitializePartition(Assets* assets) override;
+        void UnApplyPartition(Assets* assets) override;
+        bool GetAssetData(Assets* assets, const std::string& name, void*& ptr, size_t& size) override;
+    private:
+        static uint32_t CalculateChecksum(const char* data, uint32_t length);
+        std::map<std::string, Asset> assets_;
+        esp_partition_mmap_handle_t mmap_handle_ = 0;
+        const char* mmap_root_ = nullptr;
+        bool checksum_valid_ = false;
+    };
+    
+    class EmoteStrategy : public AssetStrategy {
+    public:
+        bool Apply(Assets* assets) override;
+        bool InitializePartition(Assets* assets) override;
+        void UnApplyPartition(Assets* assets) override;
+        bool GetAssetData(Assets* assets, const std::string& name, void*& ptr, size_t& size) override;
+    };
+    
+    // Strategy instance
+    std::unique_ptr<AssetStrategy> strategy_;
 
+protected:
     const esp_partition_t* partition_ = nullptr;
-    esp_partition_mmap_handle_t mmap_handle_ = 0;
-    const char* mmap_root_ = nullptr;
     bool partition_valid_ = false;
-    bool checksum_valid_ = false;
     std::string default_assets_url_;
     srmodel_list_t* models_list_ = nullptr;
-    std::map<std::string, Asset> assets_;
 };
 
 #endif

main/audio/audio_service.cc

@@ -2,6 +2,26 @@
 #include <esp_log.h>
 #include <cstring>
 
+#define RATE_CVT_CFG(_src_rate, _dest_rate, _channel)        \
+    (esp_ae_rate_cvt_cfg_t)                                  \
+    {                                                        \
+        .src_rate        = (uint32_t)(_src_rate),            \
+        .dest_rate       = (uint32_t)(_dest_rate),           \
+        .channel         = (uint8_t)(_channel),              \
+        .bits_per_sample = ESP_AUDIO_BIT16,                  \
+        .complexity      = 2,                                \
+        .perf_type       = ESP_AE_RATE_CVT_PERF_TYPE_SPEED,  \
+    }
+
+#define OPUS_DEC_CFG(_sample_rate, _frame_duration_ms)                                                    \
+    (esp_opus_dec_cfg_t)                                                                                  \
+    {                                                                                                     \
+        .sample_rate    = (uint32_t)(_sample_rate),                                                       \
+        .channel        = ESP_AUDIO_MONO,                                                                 \
+        .frame_duration = (esp_opus_dec_frame_duration_t)AS_OPUS_GET_FRAME_DRU_ENUM(_frame_duration_ms),  \
+        .self_delimited = false,                                                                          \
+    }
+
 #if CONFIG_USE_AUDIO_PROCESSOR
 #include "processors/afe_audio_processor.h"
 #else
@@ -17,7 +37,6 @@
 
 #define TAG "AudioService"
 
-
 AudioService::AudioService() {
     event_group_ = xEventGroupCreate();
 }
@@ -26,21 +45,51 @@ AudioService::~AudioService() {
     if (event_group_ != nullptr) {
         vEventGroupDelete(event_group_);
     }
+    if (opus_encoder_ != nullptr) {
+        esp_opus_enc_close(opus_encoder_);
+    }
+    if (opus_decoder_ != nullptr) {
+        esp_opus_dec_close(opus_decoder_);
+    }
+    if (input_resampler_ != nullptr) {
+        esp_ae_rate_cvt_close(input_resampler_);
+    }
+    if (output_resampler_ != nullptr) {
+        esp_ae_rate_cvt_close(output_resampler_);
+    }
 }
 
-
 void AudioService::Initialize(AudioCodec* codec) {
     codec_ = codec;
     codec_->Start();
 
-    /* Setup the audio codec */
-    opus_decoder_ = std::make_unique<OpusDecoderWrapper>(codec->output_sample_rate(), 1, OPUS_FRAME_DURATION_MS);
-    opus_encoder_ = std::make_unique<OpusEncoderWrapper>(16000, 1, OPUS_FRAME_DURATION_MS);
-    opus_encoder_->SetComplexity(0);
+    esp_opus_dec_cfg_t opus_dec_cfg = OPUS_DEC_CFG(codec->output_sample_rate(), OPUS_FRAME_DURATION_MS);
+    auto ret = esp_opus_dec_open(&opus_dec_cfg, sizeof(esp_opus_dec_cfg_t), &opus_decoder_);
+    if (opus_decoder_ == nullptr) {
+        ESP_LOGE(TAG, "Failed to create audio decoder, error code: %d", ret);
+    } else {
+        decoder_sample_rate_ = codec->output_sample_rate();
+        decoder_duration_ms_ = OPUS_FRAME_DURATION_MS;
+        decoder_frame_size_ = decoder_sample_rate_ / 1000 * OPUS_FRAME_DURATION_MS;
+    }
+    esp_opus_enc_config_t opus_enc_cfg = AS_OPUS_ENC_CONFIG();
+    ret = esp_opus_enc_open(&opus_enc_cfg, sizeof(esp_opus_enc_config_t), &opus_encoder_);
+    if (opus_encoder_ == nullptr) {
+        ESP_LOGE(TAG, "Failed to create audio encoder, error code: %d", ret);
+    } else {
+        encoder_sample_rate_ = 16000;
+        encoder_duration_ms_ = OPUS_FRAME_DURATION_MS;
+        esp_opus_enc_get_frame_size(opus_encoder_, &encoder_frame_size_, &encoder_outbuf_size_);
+        encoder_frame_size_ = encoder_frame_size_ / sizeof(int16_t);
+    }
 
     if (codec->input_sample_rate() != 16000) {
-        input_resampler_.Configure(codec->input_sample_rate(), 16000);
-        reference_resampler_.Configure(codec->input_sample_rate(), 16000);
+        esp_ae_rate_cvt_cfg_t input_resampler_cfg = RATE_CVT_CFG(
+            codec->input_sample_rate(), ESP_AUDIO_SAMPLE_RATE_16K, codec->input_channels());
+        auto resampler_ret = esp_ae_rate_cvt_open(&input_resampler_cfg, &input_resampler_);
+        if (input_resampler_ == nullptr) {
+            ESP_LOGE(TAG, "Failed to create input resampler, error code: %d", resampler_ret);
+        }
     }
 
 #if CONFIG_USE_AUDIO_PROCESSOR
@@ -114,7 +163,7 @@ void AudioService::Start() {
         AudioService* audio_service = (AudioService*)arg;
         audio_service->OpusCodecTask();
         vTaskDelete(NULL);
-    }, "opus_codec", 2048 * 13, this, 2, &opus_codec_task_handle_);
+    }, "opus_codec", 2048 * 12, this, 2, &opus_codec_task_handle_);
 }
 
 void AudioService::Stop() {
@@ -144,25 +193,15 @@ bool AudioService::ReadAudioData(std::vector<int16_t>& data, int sample_rate, in
         if (!codec_->InputData(data)) {
             return false;
         }
-        if (codec_->input_channels() == 2) {
-            auto mic_channel = std::vector<int16_t>(data.size() / 2);
-            auto reference_channel = std::vector<int16_t>(data.size() / 2);
-            for (size_t i = 0, j = 0; i < mic_channel.size(); ++i, j += 2) {
-                mic_channel[i] = data[j];
-                reference_channel[i] = data[j + 1];
-            }
-            auto resampled_mic = std::vector<int16_t>(input_resampler_.GetOutputSamples(mic_channel.size()));
-            auto resampled_reference = std::vector<int16_t>(reference_resampler_.GetOutputSamples(reference_channel.size()));
-            input_resampler_.Process(mic_channel.data(), mic_channel.size(), resampled_mic.data());
-            reference_resampler_.Process(reference_channel.data(), reference_channel.size(), resampled_reference.data());
-            data.resize(resampled_mic.size() + resampled_reference.size());
-            for (size_t i = 0, j = 0; i < resampled_mic.size(); ++i, j += 2) {
-                data[j] = resampled_mic[i];
-                data[j + 1] = resampled_reference[i];
-            }
-        } else {
-            auto resampled = std::vector<int16_t>(input_resampler_.GetOutputSamples(data.size()));
-            input_resampler_.Process(data.data(), data.size(), resampled.data());
+        if (input_resampler_ != nullptr) {
+            uint32_t in_sample_num = data.size() / codec_->input_channels();
+            uint32_t output_samples = 0;
+            esp_ae_rate_cvt_get_max_out_sample_num(input_resampler_, in_sample_num, &output_samples);
+            auto resampled = std::vector<int16_t>(output_samples * codec_->input_channels());
+            uint32_t actual_output = output_samples;
+            esp_ae_rate_cvt_process(input_resampler_, (esp_ae_sample_t)data.data(), in_sample_num,
+                                   (esp_ae_sample_t)resampled.data(), &actual_output);
+            resampled.resize(actual_output * codec_->input_channels());
             data = std::move(resampled);
         }
     } else {
@@ -316,25 +355,49 @@ void AudioService::OpusCodecTask() {
             task->timestamp = packet->timestamp;
 
             SetDecodeSampleRate(packet->sample_rate, packet->frame_duration);
-            if (opus_decoder_->Decode(std::move(packet->payload), task->pcm)) {
-                // Resample if the sample rate is different
-                if (opus_decoder_->sample_rate() != codec_->output_sample_rate()) {
-                    int target_size = output_resampler_.GetOutputSamples(task->pcm.size());
-                    std::vector<int16_t> resampled(target_size);
-                    output_resampler_.Process(task->pcm.data(), task->pcm.size(), resampled.data());
-                    task->pcm = std::move(resampled);
+            if (opus_decoder_ != nullptr) {
+                task->pcm.resize(decoder_frame_size_);
+                esp_audio_dec_in_raw_t raw = {
+                    .buffer = (uint8_t *)(packet->payload.data()),
+                    .len = (uint32_t)(packet->payload.size()),
+                    .consumed = 0,
+                    .frame_recover = ESP_AUDIO_DEC_RECOVERY_NONE,
+                };
+                esp_audio_dec_out_frame_t out_frame = {
+                    .buffer = (uint8_t *)(task->pcm.data()),
+                    .len = (uint32_t)(task->pcm.size() * sizeof(int16_t)),
+                    .decoded_size = 0,
+                };
+                esp_audio_dec_info_t dec_info = {};
+                std::unique_lock<std::mutex> decoder_lock(decoder_mutex_);
+                auto ret = esp_opus_dec_decode(opus_decoder_, &raw, &out_frame, &dec_info);
+                decoder_lock.unlock();
+                if (ret == ESP_AUDIO_ERR_OK) {
+                    task->pcm.resize(out_frame.decoded_size / sizeof(int16_t));
+                    if (decoder_sample_rate_ != codec_->output_sample_rate() && output_resampler_ != nullptr) {
+                        uint32_t target_size = 0;
+                        esp_ae_rate_cvt_get_max_out_sample_num(output_resampler_, task->pcm.size(), &target_size);
+                        std::vector<int16_t> resampled(target_size);
+                        uint32_t actual_output = target_size;
+                        esp_ae_rate_cvt_process(output_resampler_, (esp_ae_sample_t)task->pcm.data(), task->pcm.size(),
+                                                (esp_ae_sample_t)resampled.data(), &actual_output);
+                        resampled.resize(actual_output);
+                        task->pcm = std::move(resampled);
+                    }
+                    lock.lock();
+                    audio_playback_queue_.push_back(std::move(task));
+                    audio_queue_cv_.notify_all();
+                    debug_statistics_.decode_count++;
+                } else {
+                    ESP_LOGE(TAG, "Failed to decode audio after resize, error code: %d", ret);
+                    lock.lock();
                 }
-
-                lock.lock();
-                audio_playback_queue_.push_back(std::move(task));
-                audio_queue_cv_.notify_all();
             } else {
-                ESP_LOGE(TAG, "Failed to decode audio");
+                ESP_LOGE(TAG, "Audio decoder is not configured");
                 lock.lock();
             }
             debug_statistics_.decode_count++;
         }
-        
         /* Encode the audio to send queue */
         if (!audio_encode_queue_.empty() && audio_send_queue_.size() < MAX_SEND_PACKETS_IN_QUEUE) {
             auto task = std::move(audio_encode_queue_.front());
@@ -346,24 +409,42 @@ void AudioService::OpusCodecTask() {
             packet->frame_duration = OPUS_FRAME_DURATION_MS;
             packet->sample_rate = 16000;
             packet->timestamp = task->timestamp;
-            if (!opus_encoder_->Encode(std::move(task->pcm), packet->payload)) {
-                ESP_LOGE(TAG, "Failed to encode audio");
-                continue;
-            }
 
-            if (task->type == kAudioTaskTypeEncodeToSendQueue) {
-                {
-                    std::lock_guard<std::mutex> lock(audio_queue_mutex_);
-                    audio_send_queue_.push_back(std::move(packet));
+            if (opus_encoder_ != nullptr && task->pcm.size() == encoder_frame_size_) {
+                std::vector<uint8_t> buf(encoder_outbuf_size_);
+                esp_audio_enc_in_frame_t in = {
+                    .buffer = (uint8_t *)(task->pcm.data()),
+                    .len = (uint32_t)(encoder_frame_size_ * sizeof(int16_t)),
+                };
+                esp_audio_enc_out_frame_t out = {
+                    .buffer = buf.data(),
+                    .len = (uint32_t)encoder_outbuf_size_,
+                    .encoded_bytes = 0,
+                };
+                auto ret = esp_opus_enc_process(opus_encoder_, &in, &out);
+                if (ret == ESP_AUDIO_ERR_OK) {
+                    packet->payload.assign(buf.data(), buf.data() + out.encoded_bytes);
+
+                    if (task->type == kAudioTaskTypeEncodeToSendQueue) {
+                        {
+                            std::lock_guard<std::mutex> lock2(audio_queue_mutex_);
+                            audio_send_queue_.push_back(std::move(packet));
+                        }
+                        if (callbacks_.on_send_queue_available) {
+                            callbacks_.on_send_queue_available();
+                        }
+                    } else if (task->type == kAudioTaskTypeEncodeToTestingQueue) {
+                        std::lock_guard<std::mutex> lock2(audio_queue_mutex_);
+                        audio_testing_queue_.push_back(std::move(packet));
+                    }
+                    debug_statistics_.encode_count++;
+                } else {
+                    ESP_LOGE(TAG, "Failed to encode audio, error code: %d", ret);
                 }
-                if (callbacks_.on_send_queue_available) {
-                    callbacks_.on_send_queue_available();
-                }
-            } else if (task->type == kAudioTaskTypeEncodeToTestingQueue) {
-                std::lock_guard<std::mutex> lock(audio_queue_mutex_);
-                audio_testing_queue_.push_back(std::move(packet));
+            } else {
+                ESP_LOGE(TAG, "Failed to encode audio: encoder not configured or invalid frame size (got %u, expected %u)",
+                         task->pcm.size(), encoder_frame_size_);
             }
-            debug_statistics_.encode_count++;
             lock.lock();
         }
     }
@@ -372,17 +453,38 @@ void AudioService::OpusCodecTask() {
 }
 
 void AudioService::SetDecodeSampleRate(int sample_rate, int frame_duration) {
-    if (opus_decoder_->sample_rate() == sample_rate && opus_decoder_->duration_ms() == frame_duration) {
+    if (decoder_sample_rate_ == sample_rate && decoder_duration_ms_ == frame_duration) {
         return;
     }
-
-    opus_decoder_.reset();
-    opus_decoder_ = std::make_unique<OpusDecoderWrapper>(sample_rate, 1, frame_duration);
+    std::unique_lock<std::mutex> decoder_lock(decoder_mutex_);
+    if (opus_decoder_ != nullptr) {
+        esp_opus_dec_close(opus_decoder_);
+        opus_decoder_ = nullptr;
+    }
+    decoder_lock.unlock();
+    esp_opus_dec_cfg_t opus_dec_cfg = OPUS_DEC_CFG(sample_rate, frame_duration);
+    auto ret = esp_opus_dec_open(&opus_dec_cfg, sizeof(esp_opus_dec_cfg_t), &opus_decoder_);
+    if (opus_decoder_ == nullptr) {
+        ESP_LOGE(TAG, "Failed to create audio decoder, error code: %d", ret);
+        return;
+    }
+    decoder_sample_rate_ = sample_rate;
+    decoder_duration_ms_ = frame_duration;
+    decoder_frame_size_ = decoder_sample_rate_ / 1000 * frame_duration;
 
     auto codec = Board::GetInstance().GetAudioCodec();
-    if (opus_decoder_->sample_rate() != codec->output_sample_rate()) {
-        ESP_LOGI(TAG, "Resampling audio from %d to %d", opus_decoder_->sample_rate(), codec->output_sample_rate());
-        output_resampler_.Configure(opus_decoder_->sample_rate(), codec->output_sample_rate());
+    if (decoder_sample_rate_ != codec->output_sample_rate()) {
+        ESP_LOGI(TAG, "Resampling audio from %d to %d", decoder_sample_rate_, codec->output_sample_rate());
+        if (output_resampler_ != nullptr) {
+            esp_ae_rate_cvt_close(output_resampler_);
+            output_resampler_ = nullptr;
+        }
+        esp_ae_rate_cvt_cfg_t output_resampler_cfg = RATE_CVT_CFG(
+            decoder_sample_rate_, codec->output_sample_rate(), ESP_AUDIO_MONO);
+        auto resampler_ret = esp_ae_rate_cvt_open(&output_resampler_cfg, &output_resampler_);
+        if (output_resampler_ == nullptr) {
+            ESP_LOGE(TAG, "Failed to create output resampler, error code: %d", resampler_ret);
+        }
     }
 }
 
@@ -390,7 +492,6 @@ void AudioService::PushTaskToEncodeQueue(AudioTaskType type, std::vector<int16_t
     auto task = std::make_unique<AudioTask>();
     task->type = type;
     task->pcm = std::move(pcm);
-    
     /* Push the task to the encode queue */
     std::unique_lock<std::mutex> lock(audio_queue_mutex_);
 
@@ -580,18 +681,16 @@ void AudioService::PlaySound(const std::string_view& ogg) {
                 // 解析OpusHead包
                 if (pkt_len >= 19 && std::memcmp(pkt_ptr, "OpusHead", 8) == 0) {
                     seen_head = true;
-                    
                     // OpusHead结构：[0-7] "OpusHead", [8] version, [9] channel_count, [10-11] pre_skip
                     // [12-15] input_sample_rate, [16-17] output_gain, [18] mapping_family
                     if (pkt_len >= 12) {
                         uint8_t version = pkt_ptr[8];
                         uint8_t channel_count = pkt_ptr[9];
-                        
                         if (pkt_len >= 16) {
                             // 读取输入采样率 (little-endian)
-                            sample_rate = pkt_ptr[12] | (pkt_ptr[13] << 8) | 
+                            sample_rate = pkt_ptr[12] | (pkt_ptr[13] << 8) |
                                         (pkt_ptr[14] << 16) | (pkt_ptr[15] << 24);
-                            ESP_LOGI(TAG, "OpusHead: version=%d, channels=%d, sample_rate=%d", 
+                            ESP_LOGI(TAG, "OpusHead: version=%d, channels=%d, sample_rate=%d",
                                    version, channel_count, sample_rate);
                         }
                     }
@@ -626,7 +725,11 @@ bool AudioService::IsIdle() {
 
 void AudioService::ResetDecoder() {
     std::lock_guard<std::mutex> lock(audio_queue_mutex_);
-    opus_decoder_->ResetState();
+    std::unique_lock<std::mutex> decoder_lock(decoder_mutex_);
+    if (opus_decoder_ != nullptr) {
+        esp_opus_dec_reset(opus_decoder_);
+    }
+    decoder_lock.unlock();
     timestamp_queue_.clear();
     audio_decode_queue_.clear();
     audio_playback_queue_.clear();

main/audio/audio_service.h

@@ -12,10 +12,11 @@
 #include <freertos/event_groups.h>
 #include <esp_timer.h>
 #include <model_path.h>
-
-#include <opus_encoder.h>
-#include <opus_decoder.h>
-#include <opus_resampler.h>
+#include "esp_audio_enc.h"
+#include "esp_opus_enc.h"
+#include "esp_opus_dec.h"
+#include "esp_ae_rate_cvt.h"
+#include "esp_audio_types.h"
 
 #include "audio_codec.h"
 #include "audio_processor.h"
@@ -46,12 +47,34 @@
 #define AUDIO_POWER_TIMEOUT_MS 15000
 #define AUDIO_POWER_CHECK_INTERVAL_MS 1000
 
-
 #define AS_EVENT_AUDIO_TESTING_RUNNING      (1 << 0)
 #define AS_EVENT_WAKE_WORD_RUNNING          (1 << 1)
 #define AS_EVENT_AUDIO_PROCESSOR_RUNNING    (1 << 2)
 #define AS_EVENT_PLAYBACK_NOT_EMPTY         (1 << 3)
 
+#define AS_OPUS_GET_FRAME_DRU_ENUM(duration_ms)                   \
+    ((duration_ms) == 5 ? ESP_OPUS_ENC_FRAME_DURATION_5_MS :      \
+     (duration_ms) == 10 ? ESP_OPUS_ENC_FRAME_DURATION_10_MS :    \
+     (duration_ms) == 20 ? ESP_OPUS_ENC_FRAME_DURATION_20_MS :    \
+     (duration_ms) == 40 ? ESP_OPUS_ENC_FRAME_DURATION_40_MS :    \
+     (duration_ms) == 60 ? ESP_OPUS_ENC_FRAME_DURATION_60_MS :    \
+     (duration_ms) == 80 ? ESP_OPUS_ENC_FRAME_DURATION_80_MS :    \
+     (duration_ms) == 100 ? ESP_OPUS_ENC_FRAME_DURATION_100_MS :  \
+     (duration_ms) == 120 ? ESP_OPUS_ENC_FRAME_DURATION_120_MS : -1)
+
+#define AS_OPUS_ENC_CONFIG() {                                                                                    \
+        .sample_rate        = ESP_AUDIO_SAMPLE_RATE_16K,                                                          \
+        .channel            = ESP_AUDIO_MONO,                                                                     \
+        .bits_per_sample    = ESP_AUDIO_BIT16,                                                                    \
+        .bitrate            = ESP_OPUS_BITRATE_AUTO,                                                              \
+        .frame_duration     = (esp_opus_enc_frame_duration_t)AS_OPUS_GET_FRAME_DRU_ENUM(OPUS_FRAME_DURATION_MS),  \
+        .application_mode   = ESP_OPUS_ENC_APPLICATION_AUDIO,                                                     \
+        .complexity         = 0,                                                                                  \
+        .enable_fec         = false,                                                                              \
+        .enable_dtx         = true,                                                                               \
+        .enable_vbr         = true,                                                                               \
+    }
+
 struct AudioServiceCallbacks {
     std::function<void(void)> on_send_queue_available;
     std::function<void(const std::string&)> on_wake_word_detected;
@@ -116,11 +139,20 @@ private:
     std::unique_ptr<AudioProcessor> audio_processor_;
     std::unique_ptr<WakeWord> wake_word_;
     std::unique_ptr<AudioDebugger> audio_debugger_;
-    std::unique_ptr<OpusEncoderWrapper> opus_encoder_;
-    std::unique_ptr<OpusDecoderWrapper> opus_decoder_;
-    OpusResampler input_resampler_;
-    OpusResampler reference_resampler_;
-    OpusResampler output_resampler_;
+    void* opus_encoder_ = nullptr;
+    void* opus_decoder_ = nullptr;
+    std::mutex decoder_mutex_;
+    esp_ae_rate_cvt_handle_t input_resampler_ = nullptr;
+    esp_ae_rate_cvt_handle_t output_resampler_ = nullptr;
+    
+    // Encoder/Decoder state
+    int encoder_sample_rate_ = 16000;
+    int encoder_duration_ms_ = OPUS_FRAME_DURATION_MS;
+    int encoder_frame_size_ = 0;
+    int encoder_outbuf_size_ = 0;
+    int decoder_sample_rate_ = 0;
+    int decoder_duration_ms_ = OPUS_FRAME_DURATION_MS;
+    int decoder_frame_size_ = 0;
     DebugStatistics debug_statistics_;
     srmodel_list_t* models_list_ = nullptr;
 

main/audio/wake_words/afe_wake_word.cc

@@ -1,6 +1,5 @@
 #include "afe_wake_word.h"
 #include "audio_service.h"
-
 #include <esp_log.h>
 #include <sstream>
 
@@ -157,7 +156,7 @@ void AfeWakeWord::StoreWakeWordData(const int16_t* data, size_t samples) {
 }
 
 void AfeWakeWord::EncodeWakeWordData() {
-    const size_t stack_size = 4096 * 7;
+    const size_t stack_size = 4096 * 6;
     wake_word_opus_.clear();
     if (wake_word_encode_task_stack_ == nullptr) {
         wake_word_encode_task_stack_ = (StackType_t*)heap_caps_malloc(stack_size, MALLOC_CAP_SPIRAM);
@@ -172,20 +171,62 @@ void AfeWakeWord::EncodeWakeWordData() {
         auto this_ = (AfeWakeWord*)arg;
         {
             auto start_time = esp_timer_get_time();
-            auto encoder = std::make_unique<OpusEncoderWrapper>(16000, 1, OPUS_FRAME_DURATION_MS);
-            encoder->SetComplexity(0); // 0 is the fastest
-
+            // Create encoder
+            esp_opus_enc_config_t opus_enc_cfg = AS_OPUS_ENC_CONFIG();
+            void* encoder_handle = nullptr;
+            auto ret = esp_opus_enc_open(&opus_enc_cfg, sizeof(esp_opus_enc_config_t), &encoder_handle);
+            if (encoder_handle == nullptr) {
+                ESP_LOGE(TAG, "Failed to create audio encoder, error code: %d", ret);
+                std::lock_guard<std::mutex> lock(this_->wake_word_mutex_);
+                this_->wake_word_opus_.push_back(std::vector<uint8_t>());
+                this_->wake_word_cv_.notify_all();
+                return;
+            }
+            
+            // Get frame size
+            int frame_size = 0;
+            int outbuf_size = 0;
+            esp_opus_enc_get_frame_size(encoder_handle, &frame_size, &outbuf_size);
+            frame_size = frame_size / sizeof(int16_t);
+            
+            // Encode all PCM data
             int packets = 0;
+            std::vector<int16_t> in_buffer;
+            esp_audio_enc_in_frame_t in = {};
+            esp_audio_enc_out_frame_t out = {};
+            
             for (auto& pcm: this_->wake_word_pcm_) {
-                encoder->Encode(std::move(pcm), [this_](std::vector<uint8_t>&& opus) {
-                    std::lock_guard<std::mutex> lock(this_->wake_word_mutex_);
-                    this_->wake_word_opus_.emplace_back(std::move(opus));
-                    this_->wake_word_cv_.notify_all();
-                });
-                packets++;
+                if (in_buffer.empty()) {
+                    in_buffer = std::move(pcm);
+                } else {
+                    in_buffer.reserve(in_buffer.size() + pcm.size());
+                    in_buffer.insert(in_buffer.end(), pcm.begin(), pcm.end());
+                }
+                
+                while (in_buffer.size() >= frame_size) {
+                    std::vector<uint8_t> opus_buf(outbuf_size);
+                    in.buffer = (uint8_t *)(in_buffer.data());
+                    in.len = (uint32_t)(frame_size * sizeof(int16_t));
+                    out.buffer = opus_buf.data();
+                    out.len = outbuf_size;
+                    out.encoded_bytes = 0;
+                    
+                    ret = esp_opus_enc_process(encoder_handle, &in, &out);
+                    if (ret == ESP_AUDIO_ERR_OK) {
+                        std::lock_guard<std::mutex> lock(this_->wake_word_mutex_);
+                        this_->wake_word_opus_.emplace_back(opus_buf.data(), opus_buf.data() + out.encoded_bytes);
+                        this_->wake_word_cv_.notify_all();
+                        packets++;
+                    } else {
+                        ESP_LOGE(TAG, "Failed to encode audio, error code: %d", ret);
+                    }
+                    
+                    in_buffer.erase(in_buffer.begin(), in_buffer.begin() + frame_size);
+                }
             }
             this_->wake_word_pcm_.clear();
-
+            // Close encoder
+            esp_opus_enc_close(encoder_handle);
             auto end_time = esp_timer_get_time();
             ESP_LOGI(TAG, "Encode wake word opus %d packets in %ld ms", packets, (long)((end_time - start_time) / 1000));
 

main/audio/wake_words/custom_wake_word.cc

@@ -9,10 +9,8 @@
 #include <esp_mn_speech_commands.h>
 #include <cJSON.h>
 
-
 #define TAG "CustomWakeWord"
 
-
 CustomWakeWord::CustomWakeWord()
     : wake_word_pcm_(), wake_word_opus_() {
 }
@@ -218,20 +216,56 @@ void CustomWakeWord::EncodeWakeWordData() {
         auto this_ = (CustomWakeWord*)arg;
         {
             auto start_time = esp_timer_get_time();
-            auto encoder = std::make_unique<OpusEncoderWrapper>(16000, 1, OPUS_FRAME_DURATION_MS);
-            encoder->SetComplexity(0); // 0 is the fastest
-
+            // Create encoder
+            esp_opus_enc_config_t opus_enc_cfg = AS_OPUS_ENC_CONFIG();
+            void* encoder_handle = nullptr;
+            auto ret = esp_opus_enc_open(&opus_enc_cfg, sizeof(esp_opus_enc_config_t), &encoder_handle);
+            if (encoder_handle == nullptr) {
+                ESP_LOGE(TAG, "Failed to create audio encoder, error code: %d", ret);
+                std::lock_guard<std::mutex> lock(this_->wake_word_mutex_);
+                this_->wake_word_opus_.push_back(std::vector<uint8_t>());
+                this_->wake_word_cv_.notify_all();
+                return;
+            }
+            // Get frame size
+            int frame_size = 0;
+            int outbuf_size = 0;
+            esp_opus_enc_get_frame_size(encoder_handle, &frame_size, &outbuf_size);
+            frame_size = frame_size / sizeof(int16_t);
+            // Encode all PCM data
             int packets = 0;
+            std::vector<int16_t> in_buffer;
+            esp_audio_enc_in_frame_t in = {};
+            esp_audio_enc_out_frame_t out = {};
             for (auto& pcm: this_->wake_word_pcm_) {
-                encoder->Encode(std::move(pcm), [this_](std::vector<uint8_t>&& opus) {
-                    std::lock_guard<std::mutex> lock(this_->wake_word_mutex_);
-                    this_->wake_word_opus_.emplace_back(std::move(opus));
-                    this_->wake_word_cv_.notify_all();
-                });
-                packets++;
+                if (in_buffer.empty()) {
+                    in_buffer = std::move(pcm);
+                } else {
+                    in_buffer.reserve(in_buffer.size() + pcm.size());
+                    in_buffer.insert(in_buffer.end(), pcm.begin(), pcm.end());
+                }
+                while (in_buffer.size() >= frame_size) {
+                    std::vector<uint8_t> opus_buf(outbuf_size);
+                    in.buffer = (uint8_t *)(in_buffer.data());
+                    in.len = (uint32_t)(frame_size * sizeof(int16_t));
+                    out.buffer = opus_buf.data();
+                    out.len = outbuf_size;
+                    out.encoded_bytes = 0;
+                    ret = esp_opus_enc_process(encoder_handle, &in, &out);
+                    if (ret == ESP_AUDIO_ERR_OK) {
+                        std::lock_guard<std::mutex> lock(this_->wake_word_mutex_);
+                        this_->wake_word_opus_.emplace_back(opus_buf.data(), opus_buf.data() + out.encoded_bytes);
+                        this_->wake_word_cv_.notify_all();
+                        packets++;
+                    } else {
+                        ESP_LOGE(TAG, "Failed to encode audio, error code: %d", ret);
+                    }
+                    in_buffer.erase(in_buffer.begin(), in_buffer.begin() + frame_size);
+                }
             }
             this_->wake_word_pcm_.clear();
-
+            // Close encoder
+            esp_opus_enc_close(encoder_handle);
             auto end_time = esp_timer_get_time();
             ESP_LOGI(TAG, "Encode wake word opus %d packets in %ld ms", packets, (long)((end_time - start_time) / 1000));
 

main/boards/common/esp32_camera.cc

@@ -348,8 +348,8 @@ Esp32Camera::Esp32Camera(const esp_video_init_config_t& config) {
                 }
                 capture_count++;
             }
-            ESP_LOGI(TAG, "Camera init success, captured %d frames in %dms", capture_count,
-                     (xTaskGetTickCount() - start) * portTICK_PERIOD_MS);
+            ESP_LOGI(TAG, "Camera init success, captured %d frames in %lums", capture_count,
+                     (unsigned long)((xTaskGetTickCount() - start) * portTICK_PERIOD_MS));
             self->streaming_on_ = true;
             vTaskDelete(NULL);
         },

main/boards/common/ml307_board.cc

@@ -9,7 +9,6 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 #include <font_awesome.h>
-#include <opus_encoder.h>
 #include <utility>
 
 static const char *TAG = "Ml307Board";

main/boards/echoear/EchoEar.cc

@@ -471,7 +471,7 @@ private:
                 auto &app = Application::GetInstance();
                 auto &board = (EchoEar &)Board::GetInstance();
 
-                ESP_LOGI(TAG, "Touch event, TP_PIN_NUM_INT: %d", gpio_get_level(TP_PIN_NUM_INT));
+                ESP_LOGD(TAG, "Touch event, TP_PIN_NUM_INT: %d", gpio_get_level(TP_PIN_NUM_INT));
                 touchpad->UpdateTouchPoint();
                 auto touch_event = touchpad->CheckTouchEvent();
 

main/boards/echoear/config.json

@@ -5,8 +5,8 @@
             "name": "echoear",
              "sdkconfig_append": [
                  "CONFIG_USE_EMOTE_MESSAGE_STYLE=y",
-                 "CONFIG_FLASH_CUSTOM_ASSETS=y",
-                 "CONFIG_CUSTOM_ASSETS_FILE=\"https://dl.espressif.com/AE/wn9_nihaoxiaozhi_tts-font_puhui_common_20_4-echoear.bin\""
+                 "CONFIG_MMAP_FILE_NAME_LENGTH=32",
+                 "CONFIG_FLASH_EXPRESSION_ASSETS=y"
              ]
         }
     ]

main/boards/echoear/emote.json

@@ -1,22 +0,0 @@
-[
-    {"emote": "happy",       "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "laughing",    "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "funny",       "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "loving",      "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "embarrassed", "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "confident",   "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "delicious",   "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "sad",         "src": "Sad.eaf",       "loop": true,  "fps": 20},
-    {"emote": "crying",      "src": "cry.eaf",       "loop": true,  "fps": 20},
-    {"emote": "sleepy",      "src": "sleep.eaf",     "loop": true,  "fps": 20},
-    {"emote": "silly",       "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "angry",       "src": "angry.eaf",     "loop": true,  "fps": 20},
-    {"emote": "surprised",   "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "shocked",     "src": "shocked.eaf",   "loop": true,  "fps": 20},
-    {"emote": "thinking",    "src": "confused.eaf",  "loop": true,  "fps": 20},
-    {"emote": "winking",     "src": "neutral.eaf",   "loop": true,  "fps": 20},
-    {"emote": "relaxed",     "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "confused",    "src": "confused.eaf",  "loop": true,  "fps": 20},
-    {"emote": "neutral",     "src": "winking.eaf",   "loop": false, "fps": 20},
-    {"emote": "idle",        "src": "neutral.eaf",   "loop": false, "fps": 20}
-]

main/boards/echoear/layout.json

@@ -1,37 +0,0 @@
-[
-  {
-    "name": "eye_anim",
-    "align": "GFX_ALIGN_LEFT_MID",
-    "x": 10,
-    "y": 10
-  },
-  {
-    "name": "status_icon",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": -100,
-    "y": 38
-  },
-  {
-    "name": "toast_label",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": 0,
-    "y": 40,
-    "width": 160,
-    "height": 40
-  },
-  {
-    "name": "clock_label",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": 0,
-    "y": 40,
-    "width": 60,
-    "height": 50
-  },
-  {
-    "name": "listen_anim",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": 0,
-    "y": 25
-  }
-]
-  

main/boards/esp-box-3/emote.json

@@ -1,22 +0,0 @@
-[
-    {"emote": "happy",       "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "laughing",    "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "funny",       "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "loving",      "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "embarrassed", "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "confident",   "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "delicious",   "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "sad",         "src": "Sad.eaf",       "loop": true,  "fps": 20},
-    {"emote": "crying",      "src": "cry.eaf",       "loop": true,  "fps": 20},
-    {"emote": "sleepy",      "src": "sleep.eaf",     "loop": true,  "fps": 20},
-    {"emote": "silly",       "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "angry",       "src": "angry.eaf",     "loop": true,  "fps": 20},
-    {"emote": "surprised",   "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "shocked",     "src": "shocked.eaf",   "loop": true,  "fps": 20},
-    {"emote": "thinking",    "src": "confused.eaf",  "loop": true,  "fps": 20},
-    {"emote": "winking",     "src": "neutral.eaf",   "loop": true,  "fps": 20},
-    {"emote": "relaxed",     "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "confused",    "src": "confused.eaf",  "loop": true,  "fps": 20},
-    {"emote": "neutral",     "src": "winking.eaf",   "loop": false, "fps": 20},
-    {"emote": "idle",        "src": "neutral.eaf",   "loop": false, "fps": 20}
-]

main/boards/esp-box-3/layout.json

@@ -1,37 +0,0 @@
-[
-  {
-    "name": "eye_anim",
-    "align": "GFX_ALIGN_LEFT_MID",
-    "x": 10,
-    "y": 30
-  },
-  {
-    "name": "status_icon",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": -120,
-    "y": 18
-  },
-  {
-    "name": "toast_label",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": 0,
-    "y": 20,
-    "width": 200,
-    "height": 40
-  },
-  {
-    "name": "clock_label",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": 0,
-    "y": 20,
-    "width": 200,
-    "height": 50
-  },
-  {
-    "name": "listen_anim",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": 0,
-    "y": 5
-  }
-]
-  

main/boards/esp-box/esp_box_board.cc

@@ -1,6 +1,7 @@
 #include "wifi_board.h"
 #include "codecs/box_audio_codec.h"
 #include "display/lcd_display.h"
+#include "display/emote_display.h"
 #include "esp_lcd_ili9341.h"
 #include "application.h"
 #include "button.h"
@@ -38,7 +39,7 @@ class EspBox3Board : public WifiBoard {
 private:
     i2c_master_bus_handle_t i2c_bus_;
     Button boot_button_;
-    LcdDisplay* display_;
+    Display* display_;
 
     void InitializeI2c() {
         // Initialize I2C peripheral
@@ -125,8 +126,13 @@ private:
         esp_lcd_panel_swap_xy(panel, DISPLAY_SWAP_XY);
         esp_lcd_panel_mirror(panel, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
         esp_lcd_panel_disp_on_off(panel, true);
+        
+#if CONFIG_USE_EMOTE_MESSAGE_STYLE
+        display_ = new emote::EmoteDisplay(panel, panel_io, DISPLAY_WIDTH, DISPLAY_HEIGHT);
+#else
         display_ = new SpiLcdDisplay(panel_io, panel,
                                     DISPLAY_WIDTH, DISPLAY_HEIGHT, DISPLAY_OFFSET_X, DISPLAY_OFFSET_Y, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y, DISPLAY_SWAP_XY);
+#endif
     }
 
 public:

main/boards/esp-hi/esp_hi.cc

@@ -224,6 +224,7 @@ private:
         SetLedColor(0x00, 0x00, 0x00);
 
 #ifdef CONFIG_ESP_HI_WEB_CONTROL_ENABLED
+        esp_event_loop_create_default();
         ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED,
                                                  &wifi_event_handler, this));
 #endif //CONFIG_ESP_HI_WEB_CONTROL_ENABLED

main/boards/esp-sensairshuttle/README.md

@@ -0,0 +1,39 @@
+# ESP-SensairShuttle
+
+## 简介
+
+<div align="center">
+    <a href="https://docs.espressif.com/projects/esp-dev-kits/zh_CN/latest/esp32c5/esp-sensairshuttle/index.html">
+        <b> 开发版文档 </b>
+    </a>
+    |
+    <a href="#传感器--shuttleboard-子板支持">
+        <b> 传感器 & <i>ShuttleBoard</i> 文档 </b>
+    </a>
+</div>
+
+ESP-SensairShuttle 是乐鑫携手 Bosch Sensortec 面向**动作感知**与**大模型人机交互**场景联合推出的开发板。
+
+ESP-SensairShuttle 主控采用乐鑫 ESP32-C5-WROOM-1-N16R8 模组，具有 2.4 & 5 GHz 双频 Wi-Fi 6 (802.11ax)、Bluetooth® 5 (LE)、Zigbee 及 Thread (802.15.4) 无线通信能力。
+
+## 传感器 & _ShuttleBoard_ 子板支持
+
+即将推出，敬请期待。
+
+## 配置、编译命令
+
+由于 ESP-SensairShuttle 需要配置较多的 sdkconfig 选项，推荐使用编译脚本编译。
+
+**编译**
+
+```bash
+python ./scripts/release.py esp-sensairshuttle
+```
+
+如需手动编译，请参考 `main/boards/esp-sensairshuttle/config.json` 修改 menuconfig 对应选项。
+
+**烧录**
+
+```bash
+idf.py flash
+```

main/boards/esp-sensairshuttle/adc_pdm_audio_codec.cc

@@ -0,0 +1,249 @@
+#include "adc_pdm_audio_codec.h"
+
+#include <esp_log.h>
+#include <esp_timer.h>
+#include <driver/i2c.h>
+#include <driver/i2c_master.h>
+#include <driver/i2s_tdm.h>
+#include "adc_mic.h"
+#include "driver/i2s_pdm.h"
+#include "soc/gpio_sig_map.h"
+#include "soc/io_mux_reg.h"
+#include "hal/rtc_io_hal.h"
+#include "hal/gpio_ll.h"
+#include "settings.h"
+#include "config.h"
+
+static const char TAG[] = "AdcPdmAudioCodec";
+
+#define BSP_I2S_GPIO_CFG(_dout)       \
+    {                          \
+        .clk = GPIO_NUM_NC,    \
+        .dout = _dout,  \
+        .invert_flags = {      \
+            .clk_inv = false, \
+        },                     \
+    }
+
+/**
+ * @brief Mono Duplex I2S configuration structure
+ *
+ * This configuration is used by default in bsp_audio_init()
+ */
+#define BSP_I2S_DUPLEX_MONO_CFG(_sample_rate, _dout)                                                         \
+    {                                                                                                 \
+        .clk_cfg = I2S_PDM_TX_CLK_DEFAULT_CONFIG(_sample_rate),                                          \
+        .slot_cfg = I2S_PDM_TX_SLOT_DEFAULT_CONFIG(I2S_DATA_BIT_WIDTH_16BIT, I2S_SLOT_MODE_MONO), \
+        .gpio_cfg = BSP_I2S_GPIO_CFG(_dout),                                                                 \
+    }
+
+AdcPdmAudioCodec::AdcPdmAudioCodec(int input_sample_rate, int output_sample_rate,
+    uint32_t adc_mic_channel, gpio_num_t pdm_speak_p,gpio_num_t pdm_speak_n, gpio_num_t pa_ctl) {
+
+    input_reference_ = false;
+    input_sample_rate_ = input_sample_rate;
+    output_sample_rate_ = output_sample_rate;
+
+    uint8_t adc_channel[1] = {0};
+    adc_channel[0] = adc_mic_channel;
+
+    audio_codec_adc_cfg_t cfg = {
+        .handle = NULL,
+        .max_store_buf_size = 1024 * 2,
+        .conv_frame_size = 1024,
+        .unit_id = ADC_UNIT_1,
+        .adc_channel_list = adc_channel,
+        .adc_channel_num = sizeof(adc_channel) / sizeof(adc_channel[0]),
+        .sample_rate_hz = (uint32_t)input_sample_rate,
+    };
+    const audio_codec_data_if_t *adc_if = audio_codec_new_adc_data(&cfg);
+
+    esp_codec_dev_cfg_t codec_dev_cfg = {
+        .dev_type = ESP_CODEC_DEV_TYPE_IN,
+        .data_if = adc_if,
+    };
+    input_dev_ = esp_codec_dev_new(&codec_dev_cfg);
+    if (!input_dev_) {
+        ESP_LOGE(TAG, "Failed to create codec device");
+        return;
+    }
+
+    i2s_chan_config_t chan_cfg = I2S_CHANNEL_DEFAULT_CONFIG(I2S_NUM_0, I2S_ROLE_MASTER);
+    chan_cfg.auto_clear = true; // Auto clear the legacy data in the DMA buffer
+    ESP_ERROR_CHECK(i2s_new_channel(&chan_cfg, &tx_handle_, NULL));
+
+    i2s_pdm_tx_config_t pdm_cfg_default = BSP_I2S_DUPLEX_MONO_CFG((uint32_t)output_sample_rate, pdm_speak_p);
+    pdm_cfg_default.clk_cfg.up_sample_fs = AUDIO_PDM_UPSAMPLE_FS;
+    pdm_cfg_default.slot_cfg.sd_scale = I2S_PDM_SIG_SCALING_MUL_4;
+    pdm_cfg_default.slot_cfg.hp_scale = I2S_PDM_SIG_SCALING_MUL_4;
+    pdm_cfg_default.slot_cfg.lp_scale = I2S_PDM_SIG_SCALING_MUL_4;
+    pdm_cfg_default.slot_cfg.sinc_scale = I2S_PDM_SIG_SCALING_MUL_4;
+    const i2s_pdm_tx_config_t *p_i2s_cfg = &pdm_cfg_default;
+
+    ESP_ERROR_CHECK(i2s_channel_init_pdm_tx_mode(tx_handle_, p_i2s_cfg));
+
+    audio_codec_i2s_cfg_t i2s_cfg = {
+        .port = I2S_NUM_0,
+        .rx_handle = NULL,
+        .tx_handle = tx_handle_,
+    };
+
+    const audio_codec_data_if_t *i2s_data_if = audio_codec_new_i2s_data(&i2s_cfg);
+
+    codec_dev_cfg.dev_type = ESP_CODEC_DEV_TYPE_OUT;
+    codec_dev_cfg.codec_if = NULL;
+    codec_dev_cfg.data_if = i2s_data_if;
+    output_dev_ = esp_codec_dev_new(&codec_dev_cfg);
+
+    output_volume_ = 100;
+    if(pa_ctl != GPIO_NUM_NC) {
+        pa_ctrl_pin_ = pa_ctl;
+        gpio_config_t io_conf = {};
+        io_conf.intr_type = GPIO_INTR_DISABLE;
+        io_conf.mode = GPIO_MODE_OUTPUT;
+        io_conf.pin_bit_mask = (1ULL << pa_ctrl_pin_);
+        io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
+        io_conf.pull_up_en = GPIO_PULLUP_DISABLE;
+        gpio_config(&io_conf);
+    }
+    gpio_set_drive_capability(pdm_speak_p, GPIO_DRIVE_CAP_0);
+
+    if(pdm_speak_n != GPIO_NUM_NC){
+        PIN_FUNC_SELECT(IO_MUX_GPIO10_REG, PIN_FUNC_GPIO);
+        gpio_set_direction(pdm_speak_n, GPIO_MODE_OUTPUT);
+        esp_rom_gpio_connect_out_signal(pdm_speak_n, I2SO_SD_OUT_IDX, 1, 0); //反转输出 SD OUT 信号
+        gpio_set_drive_capability(pdm_speak_n, GPIO_DRIVE_CAP_0);
+    }
+
+    // 初始化输出定时器
+    esp_timer_create_args_t output_timer_args = {
+        .callback = &AdcPdmAudioCodec::OutputTimerCallback,
+        .arg = this,
+        .dispatch_method = ESP_TIMER_TASK,
+        .name = "output_timer"
+    };
+    ESP_ERROR_CHECK(esp_timer_create(&output_timer_args, &output_timer_));
+
+    ESP_LOGI(TAG, "AdcPdmAudioCodec initialized");
+}
+
+AdcPdmAudioCodec::~AdcPdmAudioCodec() {
+    // 删除定时器
+    if (output_timer_) {
+        esp_timer_stop(output_timer_);
+        esp_timer_delete(output_timer_);
+        output_timer_ = nullptr;
+    }
+
+    ESP_ERROR_CHECK(esp_codec_dev_close(output_dev_));
+    esp_codec_dev_delete(output_dev_);
+    ESP_ERROR_CHECK(esp_codec_dev_close(input_dev_));
+    esp_codec_dev_delete(input_dev_);
+}
+
+void AdcPdmAudioCodec::SetOutputVolume(int volume) {
+    ESP_ERROR_CHECK(esp_codec_dev_set_out_vol(output_dev_, volume));
+    AudioCodec::SetOutputVolume(volume);
+}
+
+void AdcPdmAudioCodec::EnableInput(bool enable) {
+    if (enable == input_enabled_) {
+        return;
+    }
+    if (enable) {
+        esp_codec_dev_sample_info_t fs = {
+            .bits_per_sample = 16,
+            .channel = 1,
+            .channel_mask = ESP_CODEC_DEV_MAKE_CHANNEL_MASK(0),
+            .sample_rate = (uint32_t)input_sample_rate_,
+            .mclk_multiple = 0,
+        };
+        ESP_ERROR_CHECK(esp_codec_dev_open(input_dev_, &fs));
+    } else {
+        ESP_ERROR_CHECK(esp_codec_dev_close(input_dev_));
+    }
+    AudioCodec::EnableInput(enable);
+}
+
+void AdcPdmAudioCodec::EnableOutput(bool enable) {
+    if (enable == output_enabled_) {
+        return;
+    }
+    if (enable) {
+        // Play 16bit 1 channel
+        esp_codec_dev_sample_info_t fs = {
+            .bits_per_sample = 16,
+            .channel = 1,
+            .channel_mask = 0,
+            .sample_rate = (uint32_t)output_sample_rate_,
+            .mclk_multiple = 0,
+        };
+        ESP_ERROR_CHECK(esp_codec_dev_open(output_dev_, &fs));
+        ESP_ERROR_CHECK(esp_codec_dev_set_out_vol(output_dev_, output_volume_));
+
+        // 强制按板卡配置重配PDM TX时钟，覆盖第三方库在set_fmt中的默认up_sample_fs
+        // 若通道已启用，先禁用再重配，最后再启用
+        ESP_ERROR_CHECK_WITHOUT_ABORT(i2s_channel_disable(tx_handle_));
+        i2s_pdm_tx_clk_config_t clk_cfg = I2S_PDM_TX_CLK_DEFAULT_CONFIG((uint32_t)output_sample_rate_);
+        clk_cfg.up_sample_fs = AUDIO_PDM_UPSAMPLE_FS;
+        ESP_ERROR_CHECK(i2s_channel_reconfig_pdm_tx_clock(tx_handle_, &clk_cfg));
+        ESP_ERROR_CHECK(i2s_channel_enable(tx_handle_));
+        if(pa_ctrl_pin_ != GPIO_NUM_NC){
+            gpio_set_level(pa_ctrl_pin_, 1);
+        }
+        // 启用输出时启动定时器
+        if (output_timer_) {
+            esp_timer_start_once(output_timer_, TIMER_TIMEOUT_US);
+        }
+
+    } else {
+        // 禁用输出时停止定时器
+        if (output_timer_) {
+            esp_timer_stop(output_timer_);
+        }
+        if(pa_ctrl_pin_ != GPIO_NUM_NC){
+            gpio_set_level(pa_ctrl_pin_, 0);
+        }
+        ESP_ERROR_CHECK(esp_codec_dev_close(output_dev_));
+    }
+    AudioCodec::EnableOutput(enable);
+}
+
+int AdcPdmAudioCodec::Read(int16_t* dest, int samples) {
+    if (input_enabled_) {
+        ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_read(input_dev_, (void*)dest, samples * sizeof(int16_t)));
+    }
+    return samples;
+}
+int AdcPdmAudioCodec::Write(const int16_t* data, int samples) {
+    if (output_enabled_) {
+        ESP_ERROR_CHECK_WITHOUT_ABORT(esp_codec_dev_write(output_dev_, (void*)data, samples * sizeof(int16_t)));
+        // 重置输出定时器
+        if (output_timer_) {
+            esp_timer_stop(output_timer_);
+            esp_timer_start_once(output_timer_, TIMER_TIMEOUT_US);
+        }
+    }
+    return samples;
+}
+
+void AdcPdmAudioCodec::Start() {
+    Settings settings("audio", false);
+    output_volume_ = settings.GetInt("output_volume", output_volume_);
+    if (output_volume_ <= 0) {
+        ESP_LOGW(TAG, "Output volume value (%d) is too small, setting to default (10)", output_volume_);
+        output_volume_ = 10;
+    }
+
+    EnableInput(true);
+    EnableOutput(true);
+    ESP_LOGI(TAG, "Audio codec started");
+}
+
+// 定时器回调函数实现
+void AdcPdmAudioCodec::OutputTimerCallback(void* arg) {
+    AdcPdmAudioCodec* codec = static_cast<AdcPdmAudioCodec*>(arg);
+    if (codec && codec->output_enabled_) {
+        codec->EnableOutput(false);
+    }
+}

main/boards/esp-sensairshuttle/adc_pdm_audio_codec.h

@@ -0,0 +1,37 @@
+#ifndef _BOX_AUDIO_CODEC_H
+#define _BOX_AUDIO_CODEC_H
+
+#include "audio_codec.h"
+
+#include <esp_codec_dev.h>
+#include <esp_codec_dev_defaults.h>
+#include <esp_timer.h>
+
+class AdcPdmAudioCodec : public AudioCodec {
+private:
+    esp_codec_dev_handle_t output_dev_ = nullptr;
+    esp_codec_dev_handle_t input_dev_ = nullptr;
+    gpio_num_t pa_ctrl_pin_ = GPIO_NUM_NC;
+
+    // 定时器相关成员变量
+    esp_timer_handle_t output_timer_ = nullptr;
+    static constexpr uint64_t TIMER_TIMEOUT_US = 120000; // 120ms = 120000us
+
+    // 定时器回调函数
+    static void OutputTimerCallback(void* arg);
+
+    virtual int Read(int16_t* dest, int samples) override;
+    virtual int Write(const int16_t* data, int samples) override;
+
+public:
+    AdcPdmAudioCodec(int input_sample_rate, int output_sample_rate,
+        uint32_t adc_mic_channel, gpio_num_t pdm_speak_p, gpio_num_t pdm_speak_n, gpio_num_t pa_ctl);
+    virtual ~AdcPdmAudioCodec();
+
+    virtual void SetOutputVolume(int volume) override;
+    virtual void EnableInput(bool enable) override;
+    virtual void EnableOutput(bool enable) override;
+    void Start();
+};
+
+#endif // _BOX_AUDIO_CODEC_H

main/boards/esp-sensairshuttle/config.h

@@ -0,0 +1,40 @@
+#ifndef _BOARD_CONFIG_H_
+#define _BOARD_CONFIG_H_
+
+#include <driver/gpio.h>
+
+#define AUDIO_INPUT_SAMPLE_RATE  16000
+#define AUDIO_OUTPUT_SAMPLE_RATE 24000
+
+#define AUDIO_PDM_UPSAMPLE_FS    480
+
+#define AUDIO_ADC_MIC_CHANNEL       5
+#define AUDIO_PDM_SPEAK_P_GPIO      GPIO_NUM_7
+#define AUDIO_PDM_SPEAK_N_GPIO      GPIO_NUM_8
+#define AUDIO_PA_CTL_GPIO           GPIO_NUM_1
+
+#define BOOT_BUTTON_GPIO            GPIO_NUM_28
+#define DISPLAY_MOSI_PIN            GPIO_NUM_23
+#define DISPLAY_CLK_PIN             GPIO_NUM_24
+#define DISPLAY_DC_PIN              GPIO_NUM_26
+#define DISPLAY_RST_PIN             GPIO_NUM_NC
+#define DISPLAY_CS_PIN              GPIO_NUM_25
+
+#define LCD_TP_SCL GPIO_NUM_3
+#define LCD_TP_SDA GPIO_NUM_2
+
+#define LCD_TYPE_ST7789_SERIAL
+#define DISPLAY_WIDTH           284
+#define DISPLAY_HEIGHT          240
+#define DISPLAY_MIRROR_X        false
+#define DISPLAY_MIRROR_Y        true
+#define DISPLAY_SWAP_XY         true
+
+#define DISPLAY_INVERT_COLOR    true
+#define DISPLAY_RGB_ORDER       LCD_RGB_ELEMENT_ORDER_RGB
+#define DISPLAY_OFFSET_X        36
+#define DISPLAY_OFFSET_Y        0
+#define DISPLAY_BACKLIGHT_OUTPUT_INVERT false
+#define DISPLAY_SPI_MODE        0
+
+#endif // _BOARD_CONFIG_H_

main/boards/esp-sensairshuttle/config.json

@@ -0,0 +1,28 @@
+{
+    "target": "esp32c5",
+    "builds": [
+        {
+            "name": "esp-sensairshuttle",
+            "sdkconfig_append": [
+                "CONFIG_IDF_TARGET=\"esp32c5\"",
+                "CONFIG_ESP_WIFI_DYNAMIC_RX_BUFFER_NUM=6",
+                "CONFIG_ESP_WIFI_AMPDU_TX_ENABLED=n",
+                "CONFIG_ESP_WIFI_ENABLE_WPA3_SAE=n",
+                "CONFIG_ESP_WIFI_ESPNOW_MAX_ENCRYPT_NUM=0",
+                "CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT=n",
+                "CONFIG_FREERTOS_IDLE_TASK_STACKSIZE=768",
+                "CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=2048",
+                "CONFIG_MBEDTLS_DYNAMIC_FREE_CONFIG_DATA=y",
+                "CONFIG_SPIRAM=y",
+                "CONFIG_SPIRAM_MALLOC_ALWAYSINTERNAL=3072",
+                "CONFIG_SPIRAM_TRY_ALLOCATE_WIFI_LWIP=y",
+                "CONFIG_LWIP_IPV6=n",
+                "CONFIG_USE_ESP_WAKE_WORD=y",
+                "CONFIG_SR_WN_WN9S_HIESP=y",
+                "CONFIG_USE_EMOTE_MESSAGE_STYLE=y",
+                "CONFIG_FLASH_CUSTOM_ASSETS=y",
+                "CONFIG_CUSTOM_ASSETS_FILE=\"https://dl.espressif.com/AE/wn9_nihaoxiaozhi_tts-font_puhui_common_20_4-echoear.bin\""
+            ]
+        }
+    ]
+}

main/boards/esp-sensairshuttle/esp-sensairshuttle.cc

@@ -0,0 +1,315 @@
+#include "wifi_board.h"
+#include "adc_pdm_audio_codec.h"
+#include "application.h"
+#include "button.h"
+#include "config.h"
+#include "mcp_server.h"
+#include <wifi_station.h>
+#include <esp_log.h>
+#include <driver/i2c_master.h>
+#include <driver/spi_common.h>
+#include <esp_wifi.h>
+#include <esp_event.h>
+
+#include "display/lcd_display.h"
+#include <esp_lcd_panel_vendor.h>
+#include <esp_lcd_panel_io.h>
+#include <esp_lcd_panel_ops.h>
+#include "esp_lcd_ili9341.h"
+
+#include "display/emote_display.h"
+
+#include "assets/lang_config.h"
+#include "anim_player.h"
+#include "led_strip.h"
+#include "driver/rmt_tx.h"
+#include "i2c_device.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+
+#include "sdkconfig.h"
+
+constexpr char TAG[] = "ESP_SensairShuttle";
+
+static const ili9341_lcd_init_cmd_t vendor_specific_init[] = {
+    // {cmd, { data }, data_size, delay_ms}
+    {0x11, NULL, 0, 120},                                          // Sleep Out
+    {0x36, (uint8_t []){0x00}, 1, 0},                              // Memory Data Access Control
+    {0x3A, (uint8_t []){0x05}, 1, 0},                              // Interface Pixel Format (16-bit)
+    {0xB2, (uint8_t []){0x0C, 0x0C, 0x00, 0x33, 0x33}, 5, 0},      // Porch Setting
+    {0xB7, (uint8_t []){0x05}, 1, 0},                              // Gate Control
+    {0xBB, (uint8_t []){0x21}, 1, 0},                              // VCOM Setting
+    {0xC0, (uint8_t []){0x2C}, 1, 0},                              // LCM Control
+    {0xC2, (uint8_t []){0x01}, 1, 0},                              // VDV and VRH Command Enable
+    {0xC3, (uint8_t []){0x15}, 1, 0},                              // VRH Set
+    {0xC6, (uint8_t []){0x0F}, 1, 0},                              // Frame Rate Control
+    {0xD0, (uint8_t []){0xA7}, 1, 0},                              // Power Control 1
+    {0xD0, (uint8_t []){0xA4, 0xA1}, 2, 0},                        // Power Control 1
+    {0xD6, (uint8_t []){0xA1}, 1, 0},                              // Gate output GND in sleep mode
+    {
+        0xE0, (uint8_t [])
+        {
+            0xF0, 0x05, 0x0E, 0x08, 0x0A, 0x17, 0x39, 0x54,
+            0x4E, 0x37, 0x12, 0x12, 0x31, 0x37
+        }, 14, 0
+    },                                                             // Positive Gamma Control
+    {
+        0xE1, (uint8_t [])
+        {
+            0xF0, 0x10, 0x14, 0x0D, 0x0B, 0x05, 0x39, 0x44,
+            0x4D, 0x38, 0x14, 0x14, 0x2E, 0x35
+        }, 14, 0
+    },                                                             // Negative Gamma Control
+    {0xE4, (uint8_t []){0x23, 0x00, 0x00}, 3, 0},                  // Gate position control
+    {0x21, NULL, 0, 0},                                            // Display Inversion On
+    {0x29, NULL, 0, 0},                                            // Display On
+    {0x2C, NULL, 0, 0},                                            // Memory Write
+};
+
+class Cst816d : public I2cDevice {
+public:
+    struct TouchPoint_t {
+        int num = 0;
+        int x = -1;
+        int y = -1;
+    };
+
+    enum TouchEvent {
+        TOUCH_NONE,
+        TOUCH_PRESS,
+        TOUCH_RELEASE,
+        TOUCH_HOLD
+    };
+
+    Cst816d(i2c_master_bus_handle_t i2c_bus, uint8_t addr) : I2cDevice(i2c_bus, addr)
+    {
+        read_buffer_ = new uint8_t[6];
+        was_touched_ = false;
+        press_count_ = 0;
+    }
+
+    ~Cst816d()
+    {
+        delete[] read_buffer_;
+    }
+
+    void UpdateTouchPoint()
+    {
+        ReadRegs(0x02, read_buffer_, 6);
+        tp_.num = read_buffer_[0] & 0x0F;
+        tp_.x = ((read_buffer_[1] & 0x0F) << 8) | read_buffer_[2];
+        tp_.y = ((read_buffer_[3] & 0x0F) << 8) | read_buffer_[4];
+    }
+
+    const TouchPoint_t &GetTouchPoint()
+    {
+        return tp_;
+    }
+
+    TouchEvent CheckTouchEvent()
+    {
+        bool is_touched = (tp_.num > 0);
+        TouchEvent event = TOUCH_NONE;
+
+        if (is_touched && !was_touched_) {
+            // Press event (transition from not touched to touched)
+            press_count_++;
+            event = TOUCH_PRESS;
+            ESP_LOGI(TAG, "TOUCH PRESS - count: %d, x: %d, y: %d", press_count_, tp_.x, tp_.y);
+        } else if (!is_touched && was_touched_) {
+            // Release event (transition from touched to not touched)
+            event = TOUCH_RELEASE;
+            ESP_LOGI(TAG, "TOUCH RELEASE - total presses: %d", press_count_);
+        } else if (is_touched && was_touched_) {
+            // Continuous touch (hold)
+            event = TOUCH_HOLD;
+            ESP_LOGD(TAG, "TOUCH HOLD - x: %d, y: %d", tp_.x, tp_.y);
+        }
+
+        // Update previous state
+        was_touched_ = is_touched;
+        return event;
+    }
+
+    int GetPressCount() const
+    {
+        return press_count_;
+    }
+
+    void ResetPressCount()
+    {
+        press_count_ = 0;
+    }
+
+private:
+    uint8_t* read_buffer_ = nullptr;
+    TouchPoint_t tp_;
+
+    // Touch state tracking
+    bool was_touched_;
+    int press_count_;
+};
+
+class EspSensairShuttle : public WifiBoard {
+private:
+    i2c_master_bus_handle_t i2c_bus_;
+    Cst816d* cst816d_;
+    Display* display_ = nullptr;
+    Button boot_button_;
+
+    void InitializeI2c()
+    {
+        i2c_master_bus_config_t i2c_bus_cfg = {
+            .i2c_port = I2C_NUM_0,
+            .sda_io_num = LCD_TP_SDA,
+            .scl_io_num = LCD_TP_SCL,
+            .clk_source = I2C_CLK_SRC_DEFAULT,
+            .glitch_ignore_cnt = 7,
+            .intr_priority = 0,
+            .trans_queue_depth = 0,
+            .flags = {
+                .enable_internal_pullup = 1,
+            },
+        };
+        ESP_ERROR_CHECK(i2c_new_master_bus(&i2c_bus_cfg, &i2c_bus_));
+    }
+
+    static void touch_event_task(void* arg)
+    {
+        Cst816d* touchpad = static_cast<Cst816d*>(arg);
+        if (touchpad == nullptr) {
+            ESP_LOGE(TAG, "Invalid touchpad pointer in touch_event_task");
+            vTaskDelete(NULL);
+            return;
+        }
+
+        while (true) {
+            touchpad->UpdateTouchPoint();
+            auto touch_event = touchpad->CheckTouchEvent();
+
+            if (touch_event == Cst816d::TOUCH_RELEASE) {
+                auto &app = Application::GetInstance();
+                auto &board = (EspSensairShuttle &)Board::GetInstance();
+
+                if (app.GetDeviceState() == kDeviceStateStarting) {
+                    board.EnterWifiConfigMode();
+                } else {
+                    app.ToggleChatState();
+                }
+            }
+
+            vTaskDelay(pdMS_TO_TICKS(50)); // Poll every 50ms
+        }
+    }
+
+    void InitializeCst816dTouchPad()
+    {
+        cst816d_ = new Cst816d(i2c_bus_, 0x15);
+        xTaskCreate(touch_event_task, "touch_task", 2 * 1024, cst816d_, 5, NULL);
+    }
+
+    void InitializeButtons()
+    {
+        boot_button_.OnClick([this]() {
+            auto& app = Application::GetInstance();
+            if (app.GetDeviceState() == kDeviceStateStarting) {
+                ESP_LOGI(TAG, "Boot button pressed, enter WiFi configuration mode");
+                EnterWifiConfigMode();
+                return;
+            }
+            app.ToggleChatState();
+        });
+    }
+
+    void InitializeSpi()
+    {
+        spi_bus_config_t buscfg = {};
+        buscfg.mosi_io_num = DISPLAY_MOSI_PIN;
+        buscfg.miso_io_num = GPIO_NUM_NC;
+        buscfg.sclk_io_num = DISPLAY_CLK_PIN;
+        buscfg.quadwp_io_num = GPIO_NUM_NC;
+        buscfg.quadhd_io_num = GPIO_NUM_NC;
+        buscfg.max_transfer_sz = DISPLAY_WIDTH * 10 * sizeof(uint16_t);
+        ESP_ERROR_CHECK(spi_bus_initialize(SPI2_HOST, &buscfg, SPI_DMA_CH_AUTO));
+    }
+
+    void InitializeLcdDisplay()
+    {
+        esp_lcd_panel_io_handle_t panel_io = nullptr;
+        esp_lcd_panel_handle_t panel = nullptr;
+
+        ESP_LOGD(TAG, "Install panel IO");
+        esp_lcd_panel_io_spi_config_t io_config = {};
+        io_config.cs_gpio_num = DISPLAY_CS_PIN;
+        io_config.dc_gpio_num = DISPLAY_DC_PIN;
+        io_config.spi_mode = DISPLAY_SPI_MODE;
+        io_config.pclk_hz = 40 * 1000 * 1000;
+        io_config.trans_queue_depth = 10;
+        io_config.lcd_cmd_bits = 8;
+        io_config.lcd_param_bits = 8;
+        ESP_ERROR_CHECK(esp_lcd_new_panel_io_spi(SPI2_HOST, &io_config, &panel_io));
+
+        ESP_LOGD(TAG, "Install LCD driver");
+        const ili9341_vendor_config_t vendor_config = {
+            .init_cmds = &vendor_specific_init[0],
+            .init_cmds_size = sizeof(vendor_specific_init) / sizeof(ili9341_lcd_init_cmd_t),
+        };
+
+        esp_lcd_panel_dev_config_t panel_config = {};
+        panel_config.reset_gpio_num = DISPLAY_RST_PIN;
+        panel_config.rgb_ele_order = DISPLAY_RGB_ORDER;
+        panel_config.bits_per_pixel = 16;
+        panel_config.vendor_config = (void *) &vendor_config;
+        ESP_ERROR_CHECK(esp_lcd_new_panel_ili9341(panel_io, &panel_config, &panel));
+
+        esp_lcd_panel_reset(panel);
+        esp_lcd_panel_init(panel);
+        esp_lcd_panel_invert_color(panel, DISPLAY_INVERT_COLOR);
+        esp_lcd_panel_set_gap(panel, DISPLAY_OFFSET_X, DISPLAY_OFFSET_Y);
+        esp_lcd_panel_mirror(panel, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y);
+        esp_lcd_panel_swap_xy(panel, DISPLAY_SWAP_XY);
+        ESP_LOGI(TAG, "LCD panel create success, %p", panel);
+
+#ifdef CONFIG_USE_EMOTE_MESSAGE_STYLE
+        display_ = new emote::EmoteDisplay(panel, panel_io, DISPLAY_WIDTH, DISPLAY_HEIGHT);
+#else
+        display_ = new SpiLcdDisplay(panel_io, panel,
+            DISPLAY_WIDTH, DISPLAY_HEIGHT, 0, 0, DISPLAY_MIRROR_X, DISPLAY_MIRROR_Y, DISPLAY_SWAP_XY);
+#endif
+
+    }
+
+public:
+    EspSensairShuttle() : boot_button_(BOOT_BUTTON_GPIO) {
+        InitializeI2c();
+        InitializeCst816dTouchPad();
+        InitializeButtons();
+        InitializeSpi();
+        InitializeLcdDisplay();
+    }
+
+    virtual AudioCodec* GetAudioCodec() override
+    {
+        static AdcPdmAudioCodec audio_codec(
+            AUDIO_INPUT_SAMPLE_RATE,
+            AUDIO_OUTPUT_SAMPLE_RATE,
+            AUDIO_ADC_MIC_CHANNEL,
+            AUDIO_PDM_SPEAK_P_GPIO,
+            AUDIO_PDM_SPEAK_N_GPIO,
+            AUDIO_PA_CTL_GPIO);
+        return &audio_codec;
+    }
+
+    virtual Display* GetDisplay() override
+    {
+        return display_;
+    }
+
+    Cst816d* GetTouchpad()
+    {
+        return cst816d_;
+    }
+};
+
+DECLARE_BOARD(EspSensairShuttle);

main/boards/lichuang-dev/emote.json

@@ -1,22 +0,0 @@
-[
-    {"emote": "happy",       "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "laughing",    "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "funny",       "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "loving",      "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "embarrassed", "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "confident",   "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "delicious",   "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "sad",         "src": "Sad.eaf",       "loop": true,  "fps": 20},
-    {"emote": "crying",      "src": "cry.eaf",       "loop": true,  "fps": 20},
-    {"emote": "sleepy",      "src": "sleep.eaf",     "loop": true,  "fps": 20},
-    {"emote": "silly",       "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "angry",       "src": "angry.eaf",     "loop": true,  "fps": 20},
-    {"emote": "surprised",   "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "shocked",     "src": "shocked.eaf",   "loop": true,  "fps": 20},
-    {"emote": "thinking",    "src": "confused.eaf",  "loop": true,  "fps": 20},
-    {"emote": "winking",     "src": "neutral.eaf",   "loop": true,  "fps": 20},
-    {"emote": "relaxed",     "src": "Happy.eaf",     "loop": true,  "fps": 20},
-    {"emote": "confused",    "src": "confused.eaf",  "loop": true,  "fps": 20},
-    {"emote": "neutral",     "src": "winking.eaf",   "loop": false, "fps": 20},
-    {"emote": "idle",        "src": "neutral.eaf",   "loop": false, "fps": 20}
-]

main/boards/lichuang-dev/layout.json

@@ -1,37 +0,0 @@
-[
-  {
-    "name": "eye_anim",
-    "align": "GFX_ALIGN_LEFT_MID",
-    "x": 10,
-    "y": 30
-  },
-  {
-    "name": "status_icon",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": -120,
-    "y": 18
-  },
-  {
-    "name": "toast_label",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": 0,
-    "y": 20,
-    "width": 200,
-    "height": 40
-  },
-  {
-    "name": "clock_label",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": 0,
-    "y": 20,
-    "width": 200,
-    "height": 50
-  },
-  {
-    "name": "listen_anim",
-    "align": "GFX_ALIGN_TOP_MID",
-    "x": 0,
-    "y": 5
-  }
-]
-  

main/display/emote_display.cc

@@ -5,6 +5,8 @@
 #include <memory>
 #include <unordered_map>
 #include <tuple>
+#include <algorithm>
+#include <cinttypes>
 
 // Standard C headers
 #include <sys/time.h>
@@ -14,18 +16,19 @@
 #include <esp_log.h>
 #include <esp_lcd_panel_io.h>
 #include <esp_timer.h>
+#include <lvgl.h>
 
 // FreeRTOS headers
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 
 // Project headers
-#include "assets.h"
 #include "assets/lang_config.h"
+#include "assets.h"
 #include "board.h"
 #include "gfx.h"
+#include "expression_emote.h"
 
-LV_FONT_DECLARE(BUILTIN_TEXT_FONT);
 
 namespace emote {
 
@@ -35,153 +38,32 @@ namespace emote {
 
 static const char* TAG = "EmoteDisplay";
 
-// UI Element Names - Centralized Management
-#define UI_ELEMENT_EYE_ANIM      "eye_anim"
-#define UI_ELEMENT_TOAST_LABEL   "toast_label"
-#define UI_ELEMENT_CLOCK_LABEL   "clock_label"
-#define UI_ELEMENT_LISTEN_ANIM   "listen_anim"
-#define UI_ELEMENT_STATUS_ICON   "status_icon"
-
-// Icon Names - Centralized Management
-#define ICON_MIC                 "icon_mic"
-#define ICON_BATTERY             "icon_Battery"
-#define ICON_SPEAKER_ZZZ         "icon_speaker_zzz"
-#define ICON_WIFI_FAILED         "icon_WiFi_failed"
-#define ICON_WIFI_OK             "icon_wifi"
-#define ICON_LISTEN              "listen"
-
-using FlushIoReadyCallback = std::function<bool(esp_lcd_panel_io_handle_t, esp_lcd_panel_io_event_data_t*, void*)>;
-using FlushCallback = std::function<void(gfx_handle_t, int, int, int, int, const void*)>;
-
-// ============================================================================
-// Global Variables
-// ============================================================================
-
-// UI element management
-static gfx_obj_t* g_obj_label_toast = nullptr;
-static gfx_obj_t* g_obj_label_clock = nullptr;
-static gfx_obj_t* g_obj_anim_eye = nullptr;
-static gfx_obj_t* g_obj_anim_listen = nullptr;
-static gfx_obj_t* g_obj_img_status = nullptr;
-
-// Track current icon to determine when to show time
-static std::string g_current_icon_type = ICON_WIFI_FAILED;
-static gfx_image_dsc_t g_icon_img_dsc;
-
-
 // ============================================================================
 // Forward Declarations
 // ============================================================================
 
 class EmoteDisplay;
-class EmoteEngine;
-
-enum class UIDisplayMode : uint8_t {
-    SHOW_LISTENING = 1,  // Show g_obj_anim_listen
-    SHOW_TIME = 2,      // Show g_obj_label_clock
-    SHOW_TIPS = 3       // Show g_obj_label_toast
-};
 
 // ============================================================================
 // Helper Functions
 // ============================================================================
 
-// Function to convert align string to GFX_ALIGN enum value
-char StringToGfxAlign(const std::string &align_str)
+static bool OnFlushIoReady(const esp_lcd_panel_io_handle_t panel_io,
+    esp_lcd_panel_io_event_data_t* const edata, void* user_ctx)
 {
-    static const std::unordered_map<std::string, char> align_map = {
-        {"GFX_ALIGN_DEFAULT",           GFX_ALIGN_DEFAULT},
-        {"GFX_ALIGN_TOP_LEFT",          GFX_ALIGN_TOP_LEFT},
-        {"GFX_ALIGN_TOP_MID",           GFX_ALIGN_TOP_MID},
-        {"GFX_ALIGN_TOP_RIGHT",         GFX_ALIGN_TOP_RIGHT},
-        {"GFX_ALIGN_LEFT_MID",          GFX_ALIGN_LEFT_MID},
-        {"GFX_ALIGN_CENTER",            GFX_ALIGN_CENTER},
-        {"GFX_ALIGN_RIGHT_MID",         GFX_ALIGN_RIGHT_MID},
-        {"GFX_ALIGN_BOTTOM_LEFT",       GFX_ALIGN_BOTTOM_LEFT},
-        {"GFX_ALIGN_BOTTOM_MID",        GFX_ALIGN_BOTTOM_MID},
-        {"GFX_ALIGN_BOTTOM_RIGHT",      GFX_ALIGN_BOTTOM_RIGHT},
-        {"GFX_ALIGN_OUT_TOP_LEFT",      GFX_ALIGN_OUT_TOP_LEFT},
-        {"GFX_ALIGN_OUT_TOP_MID",       GFX_ALIGN_OUT_TOP_MID},
-        {"GFX_ALIGN_OUT_TOP_RIGHT",     GFX_ALIGN_OUT_TOP_RIGHT},
-        {"GFX_ALIGN_OUT_LEFT_TOP",      GFX_ALIGN_OUT_LEFT_TOP},
-        {"GFX_ALIGN_OUT_LEFT_MID",      GFX_ALIGN_OUT_LEFT_MID},
-        {"GFX_ALIGN_OUT_LEFT_BOTTOM",   GFX_ALIGN_OUT_LEFT_BOTTOM},
-        {"GFX_ALIGN_OUT_RIGHT_TOP",     GFX_ALIGN_OUT_RIGHT_TOP},
-        {"GFX_ALIGN_OUT_RIGHT_MID",     GFX_ALIGN_OUT_RIGHT_MID},
-        {"GFX_ALIGN_OUT_RIGHT_BOTTOM",  GFX_ALIGN_OUT_RIGHT_BOTTOM},
-        {"GFX_ALIGN_OUT_BOTTOM_LEFT",   GFX_ALIGN_OUT_BOTTOM_LEFT},
-        {"GFX_ALIGN_OUT_BOTTOM_MID",    GFX_ALIGN_OUT_BOTTOM_MID},
-        {"GFX_ALIGN_OUT_BOTTOM_RIGHT",  GFX_ALIGN_OUT_BOTTOM_RIGHT}
-    };
-
-    const auto it = align_map.find(align_str);
-    if (it != align_map.cend()) {
-        return it->second;
+    emote_handle_t handle = static_cast<emote_handle_t>(user_ctx);
+    if (handle) {
+        emote_notify_flush_finished(handle);
     }
-
-    ESP_LOGW(TAG, "Unknown align string: %s, using GFX_ALIGN_DEFAULT", align_str.c_str());
-    return GFX_ALIGN_DEFAULT;
+    return true;
 }
 
-// ============================================================================
-// EmoteEngine Class Declaration
-// ============================================================================
-
-class EmoteEngine {
-public:
-    EmoteEngine(const esp_lcd_panel_handle_t panel, const esp_lcd_panel_io_handle_t panel_io,
-                const int width, const int height, EmoteDisplay* const display);
-    ~EmoteEngine();
-
-    void SetEyes(const std::string &emoji_name, const bool repeat, const int fps, EmoteDisplay* const display);
-    void SetIcon(const std::string &icon_name, EmoteDisplay* const display);
-
-    void* GetEngineHandle() const
-    {
-        return engine_handle_;
-    }
-
-    // Callback functions (public to be accessible from static helper functions)
-    static bool OnFlushIoReady(const esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t* const edata, void* const user_ctx);
-    static void OnFlush(const gfx_handle_t handle, const int x_start, const int y_start, const int x_end, const int y_end, const void* const color_data);
-
-private:
-    gfx_handle_t engine_handle_;
-};
-
-// ============================================================================
-// UI Management Functions
-// ============================================================================
-
-static void SetUIDisplayMode(const UIDisplayMode mode, EmoteDisplay* const display)
+// Flush callback for emote
+static void OnFlushCallback(int x_start, int y_start, int x_end, int y_end, const void* data, emote_handle_t handle)
 {
-    if (!display) {
-        ESP_LOGE(TAG, "SetUIDisplayMode: display is nullptr");
-        return;
-    }
-
-    gfx_obj_set_visible(g_obj_anim_listen, false);
-    gfx_obj_set_visible(g_obj_label_clock, false);
-    gfx_obj_set_visible(g_obj_label_toast, false);
-
-    // Show the selected control
-    switch (mode) {
-    case UIDisplayMode::SHOW_LISTENING: {
-        gfx_obj_set_visible(g_obj_anim_listen, true);
-        const AssetData emoji_data = display->GetIconData(ICON_LISTEN);
-        if (emoji_data.data) {
-            gfx_anim_set_src(g_obj_anim_listen, emoji_data.data, emoji_data.size);
-            gfx_anim_set_segment(g_obj_anim_listen, 0, 0xFFFF, 20, true);
-            gfx_anim_start(g_obj_anim_listen);
-        }
-        break;
-    }
-    case UIDisplayMode::SHOW_TIME:
-        gfx_obj_set_visible(g_obj_label_clock, true);
-        break;
-    case UIDisplayMode::SHOW_TIPS:
-        gfx_obj_set_visible(g_obj_label_toast, true);
-        break;
+    esp_lcd_panel_handle_t panel = (esp_lcd_panel_handle_t)emote_get_user_data(handle);
+    if (panel != nullptr) {
+        esp_lcd_panel_draw_bitmap(panel, x_start, y_start, x_end, y_end, data);
     }
 }
 
@@ -189,193 +71,44 @@ static void SetUIDisplayMode(const UIDisplayMode mode, EmoteDisplay* const displ
 // Graphics Initialization Functions
 // ============================================================================
 
-static void InitializeGraphics(const esp_lcd_panel_handle_t panel, gfx_handle_t* const engine_handle,
-                               const int width, const int height)
+static emote_handle_t InitializeEmote(const esp_lcd_panel_handle_t panel, const int width, const int height)
 {
-    if (!panel || !engine_handle) {
-        ESP_LOGE(TAG, "InitializeGraphics: Invalid parameters");
-        return;
+    if (!panel) {
+        ESP_LOGE(TAG, "Invalid panel");
+        return nullptr;
     }
 
-    gfx_core_config_t gfx_cfg = {
-        .flush_cb = EmoteEngine::OnFlush,
-        .user_data = panel,
+    emote_config_t emote_cfg = {
         .flags = {
             .swap = true,
             .double_buffer = true,
-            .buff_dma = true,
+            .buff_dma = false,
+        },
+        .gfx_emote = {
+            .h_res = width,
+            .v_res = height,
+            .fps = 30,
         },
-        .h_res = static_cast<uint32_t>(width),
-        .v_res = static_cast<uint32_t>(height),
-        .fps = 30,
         .buffers = {
-            .buf1 = nullptr,
-            .buf2 = nullptr,
             .buf_pixels = static_cast<size_t>(width * 16),
         },
-        .task = GFX_EMOTE_INIT_CONFIG()
+        .task = {
+            .task_priority = 5,
+            .task_stack = 6 * 1024,
+            .task_affinity = 0,
+            .task_stack_in_ext = false,
+        },
+        .flush_cb = OnFlushCallback,
+        .user_data = (void*)panel,
     };
 
-    gfx_cfg.task.task_stack_caps = MALLOC_CAP_DEFAULT;
-    gfx_cfg.task.task_affinity = 0;
-    gfx_cfg.task.task_priority = 5;
-    gfx_cfg.task.task_stack = 8 * 1024;
-
-    *engine_handle = gfx_emote_init(&gfx_cfg);
-}
-
-static void SetupUI(const gfx_handle_t engine_handle, EmoteDisplay* const display)
-{
-    if (!display) {
-        ESP_LOGE(TAG, "SetupUI: display is nullptr");
-        return;
+    emote_handle_t emote_handle = emote_init(&emote_cfg);
+    if (!emote_handle) {
+        ESP_LOGE(TAG, "Failed to initialize emote");
+        return nullptr;
     }
 
-    gfx_emote_set_bg_color(engine_handle, GFX_COLOR_HEX(0x000000));
-
-    g_obj_anim_eye = gfx_anim_create(engine_handle);
-    gfx_obj_align(g_obj_anim_eye, GFX_ALIGN_LEFT_MID, 10, 30);
-    gfx_anim_set_auto_mirror(g_obj_anim_eye, true);
-    gfx_obj_set_visible(g_obj_anim_eye, false);
-
-    g_obj_label_toast = gfx_label_create(engine_handle);
-    gfx_obj_align(g_obj_label_toast, GFX_ALIGN_TOP_MID, 0, 20);
-    gfx_obj_set_size(g_obj_label_toast, 200, 40);
-    gfx_label_set_text(g_obj_label_toast, Lang::Strings::INITIALIZING);
-    gfx_label_set_color(g_obj_label_toast, GFX_COLOR_HEX(0xFFFFFF));
-    gfx_label_set_text_align(g_obj_label_toast, GFX_TEXT_ALIGN_CENTER);
-    gfx_label_set_long_mode(g_obj_label_toast, GFX_LABEL_LONG_SCROLL);
-    gfx_label_set_scroll_speed(g_obj_label_toast, 20);
-    gfx_label_set_scroll_loop(g_obj_label_toast, true);
-    gfx_label_set_font(g_obj_label_toast, (gfx_font_t)&BUILTIN_TEXT_FONT);
-
-    g_obj_label_clock = gfx_label_create(engine_handle);
-    gfx_obj_align(g_obj_label_clock, GFX_ALIGN_TOP_MID, 0, 15);
-    gfx_obj_set_size(g_obj_label_clock, 200, 50);
-    gfx_label_set_text(g_obj_label_clock, "--:--");
-    gfx_label_set_color(g_obj_label_clock, GFX_COLOR_HEX(0xFFFFFF));
-    gfx_label_set_text_align(g_obj_label_clock, GFX_TEXT_ALIGN_CENTER);
-    gfx_label_set_font(g_obj_label_clock, (gfx_font_t)&BUILTIN_TEXT_FONT);
-
-    g_obj_anim_listen = gfx_anim_create(engine_handle);
-    gfx_obj_align(g_obj_anim_listen, GFX_ALIGN_TOP_MID, 0, 5);
-    gfx_anim_start(g_obj_anim_listen);
-    gfx_obj_set_visible(g_obj_anim_listen, false);
-
-    g_obj_img_status = gfx_img_create(engine_handle);
-    gfx_obj_align(g_obj_img_status, GFX_ALIGN_TOP_MID, -120, 18);
-
-    SetUIDisplayMode(UIDisplayMode::SHOW_TIPS, display);
-}
-
-static void RegisterCallbacks(const esp_lcd_panel_io_handle_t panel_io, const gfx_handle_t engine_handle)
-{
-    if (!panel_io) {
-        ESP_LOGE(TAG, "RegisterCallbacks: panel_io is nullptr");
-        return;
-    }
-
-    const esp_lcd_panel_io_callbacks_t cbs = {
-        .on_color_trans_done = EmoteEngine::OnFlushIoReady,
-    };
-    esp_lcd_panel_io_register_event_callbacks(panel_io, &cbs, engine_handle);
-}
-
-// ============================================================================
-// EmoteEngine Class Implementation
-// ============================================================================
-
-EmoteEngine::EmoteEngine(const esp_lcd_panel_handle_t panel, const esp_lcd_panel_io_handle_t panel_io,
-                         const int width, const int height, EmoteDisplay* const display)
-{
-    InitializeGraphics(panel, &engine_handle_, width, height);
-
-    if (display) {
-        gfx_emote_lock(engine_handle_);
-        SetupUI(engine_handle_, display);
-        gfx_emote_unlock(engine_handle_);
-    }
-
-    RegisterCallbacks(panel_io, engine_handle_);
-}
-
-EmoteEngine::~EmoteEngine()
-{
-    if (engine_handle_) {
-        gfx_emote_deinit(engine_handle_);
-        engine_handle_ = nullptr;
-    }
-}
-
-void EmoteEngine::SetEyes(const std::string &emoji_name, const bool repeat, const int fps, EmoteDisplay* const display)
-{
-    if (!engine_handle_) {
-        ESP_LOGE(TAG, "SetEyes: engine_handle_ is nullptr");
-        return;
-    }
-
-    if (!display) {
-        ESP_LOGE(TAG, "SetEyes: display is nullptr");
-        return;
-    }
-
-    const AssetData emoji_data = display->GetEmojiData(emoji_name);
-    if (emoji_data.data) {
-        DisplayLockGuard lock(display);
-        gfx_anim_set_src(g_obj_anim_eye, emoji_data.data, emoji_data.size);
-        gfx_anim_set_segment(g_obj_anim_eye, 0, 0xFFFF, fps, repeat);
-        gfx_obj_set_visible(g_obj_anim_eye, true);
-        gfx_anim_start(g_obj_anim_eye);
-    } else {
-        ESP_LOGW(TAG, "SetEyes: No emoji data found for %s", emoji_name.c_str());
-    }
-}
-
-void EmoteEngine::SetIcon(const std::string &icon_name, EmoteDisplay* const display)
-{
-    if (!engine_handle_) {
-        ESP_LOGE(TAG, "SetIcon: engine_handle_ is nullptr");
-        return;
-    }
-
-    if (!display) {
-        ESP_LOGE(TAG, "SetIcon: display is nullptr");
-        return;
-    }
-
-    const AssetData icon_data = display->GetIconData(icon_name);
-    if (icon_data.data) {
-        DisplayLockGuard lock(display);
-
-        std::memcpy(&g_icon_img_dsc.header, icon_data.data, sizeof(gfx_image_header_t));
-        g_icon_img_dsc.data = static_cast<const uint8_t*>(icon_data.data) + sizeof(gfx_image_header_t);
-        g_icon_img_dsc.data_size = icon_data.size - sizeof(gfx_image_header_t);
-
-        gfx_img_set_src(g_obj_img_status, &g_icon_img_dsc);
-    } else {
-        ESP_LOGW(TAG, "SetIcon: No icon data found for %s", icon_name.c_str());
-    }
-    g_current_icon_type = icon_name;
-}
-
-bool EmoteEngine::OnFlushIoReady(const esp_lcd_panel_io_handle_t panel_io,
-                                 esp_lcd_panel_io_event_data_t* const edata,
-                                 void* const user_ctx)
-{
-    gfx_handle_t handle = static_cast<gfx_handle_t>(user_ctx);
-    if (handle) {
-        gfx_emote_flush_ready(handle, true);
-    }
-    return false;
-}
-
-void EmoteEngine::OnFlush(const gfx_handle_t handle, const int x_start, const int y_start,
-                          const int x_end, const int y_end, const void* const color_data)
-{
-    auto* const panel = static_cast<esp_lcd_panel_handle_t>(gfx_emote_get_user_data(handle));
-    if (panel) {
-        esp_lcd_panel_draw_bitmap(panel, x_start, y_start, x_end, y_end, color_data);
-    }
+    return emote_handle;
 }
 
 // ============================================================================
@@ -385,131 +118,84 @@ void EmoteEngine::OnFlush(const gfx_handle_t handle, const int x_start, const in
 EmoteDisplay::EmoteDisplay(const esp_lcd_panel_handle_t panel, const esp_lcd_panel_io_handle_t panel_io,
                            const int width, const int height)
 {
-    InitializeEngine(panel, panel_io, width, height);
+    emote_handle_ = InitializeEmote(panel, width, height);
+
+    const esp_lcd_panel_io_callbacks_t cbs = {
+        .on_color_trans_done = OnFlushIoReady,
+    };
+    esp_lcd_panel_io_register_event_callbacks(panel_io, &cbs, emote_handle_);
 }
 
-EmoteDisplay::~EmoteDisplay() = default;
+EmoteDisplay::~EmoteDisplay()
+{
+    if (emote_handle_) {
+        emote_deinit(emote_handle_);
+        emote_handle_ = nullptr;
+    }
+}
 
 void EmoteDisplay::SetEmotion(const char* const emotion)
 {
-    if (!emotion) {
-        ESP_LOGE(TAG, "SetEmotion: emotion is nullptr");
-        return;
-    }
-
     ESP_LOGI(TAG, "SetEmotion: %s", emotion);
-    if (!engine_) {
-        return;
+    if (emote_handle_ && emotion && strlen(emotion) > 0) {
+        emote_set_anim_emoji(emote_handle_, emotion);
     }
-
-    const AssetData emoji_data = GetEmojiData(emotion);
-    bool repeat = emoji_data.loop;
-    int fps = emoji_data.fps > 0 ? emoji_data.fps : 20;
-
-    if (std::strcmp(emotion, "idle") == 0 || std::strcmp(emotion, "neutral") == 0) {
-        repeat = false;
-    }
-
-    DisplayLockGuard lock(this);
-    engine_->SetEyes(emotion, repeat, fps, this);
 }
 
 void EmoteDisplay::SetChatMessage(const char* const role, const char* const content)
 {
-    if (!engine_) {
-        return;
-    }
-
-    DisplayLockGuard lock(this);
-    if (content && strlen(content) > 0) {
-        gfx_label_set_text(g_obj_label_toast, content);
-        SetUIDisplayMode(UIDisplayMode::SHOW_TIPS, this);
+    ESP_LOGI(TAG, "SetChatMessage: %s, %s", role, content);
+    if (emote_handle_ && content && strlen(content) > 0) {
+        if ((std::strcmp(role, "system") == 0) && std::strstr(content, "xiaozhi.me")) {
+            size_t len = strlen(content);
+            char* new_content = new char[len + 1];
+            strcpy(new_content, content);
+            std::replace(new_content, new_content + len, static_cast<char>(0x0A), static_cast<char>(0x20));
+            emote_set_event_msg(emote_handle_, EMOTE_MGR_EVT_SYS, new_content);
+            delete[] new_content;
+        } else {
+            emote_set_event_msg(emote_handle_, EMOTE_MGR_EVT_SPEAK, content);
+        }
     }
 }
 
 void EmoteDisplay::SetStatus(const char* const status)
 {
-    if (!status) {
-        ESP_LOGE(TAG, "SetStatus: status is nullptr");
-        return;
-    }
-
-    if (!engine_) {
-        return;
-    }
-
-    DisplayLockGuard lock(this);
-
-    if (std::strcmp(status, Lang::Strings::LISTENING) == 0) {
-        SetUIDisplayMode(UIDisplayMode::SHOW_LISTENING, this);
-        engine_->SetEyes("happy", true, 20, this);
-        engine_->SetIcon(ICON_MIC, this);
-    } else if (std::strcmp(status, Lang::Strings::STANDBY) == 0) {
-        SetUIDisplayMode(UIDisplayMode::SHOW_TIME, this);
-        engine_->SetIcon(ICON_BATTERY, this);
-    } else if (std::strcmp(status, Lang::Strings::SPEAKING) == 0) {
-        SetUIDisplayMode(UIDisplayMode::SHOW_TIPS, this);
-        engine_->SetIcon(ICON_SPEAKER_ZZZ, this);
-    } else if (std::strcmp(status, Lang::Strings::ERROR) == 0) {
-        SetUIDisplayMode(UIDisplayMode::SHOW_TIPS, this);
-        engine_->SetIcon(ICON_WIFI_FAILED, this);
-    }
-
-    if (std::strcmp(status, Lang::Strings::CONNECTING) != 0) {
-        gfx_label_set_text(g_obj_label_toast, status);
+    ESP_LOGI(TAG, "SetStatus: %s", status);
+    if (emote_handle_ && status && strlen(status) > 0) {
+        if (std::strcmp(status, Lang::Strings::LISTENING) == 0) {
+            emote_set_event_msg(emote_handle_, EMOTE_MGR_EVT_LISTEN, NULL);
+        } else if (std::strcmp(status, Lang::Strings::STANDBY) == 0) {
+            emote_set_event_msg(emote_handle_, EMOTE_MGR_EVT_IDLE, NULL);
+        } else if (std::strcmp(status, Lang::Strings::SPEAKING) == 0) {
+            emote_set_event_msg(emote_handle_, EMOTE_MGR_EVT_SPEAK, NULL);
+        } else if (std::strcmp(status, Lang::Strings::ERROR) == 0) {
+            emote_set_event_msg(emote_handle_, EMOTE_MGR_EVT_SET, NULL);
+        }
     }
 }
 
 void EmoteDisplay::ShowNotification(const char* notification, int duration_ms)
 {
-    if (!notification || !engine_) {
-        return;
-    }
     ESP_LOGI(TAG, "ShowNotification: %s", notification);
-
-    DisplayLockGuard lock(this);
-    gfx_label_set_text(g_obj_label_toast, notification);
-    SetUIDisplayMode(UIDisplayMode::SHOW_TIPS, this);
+    if (emote_handle_ && notification && strlen(notification) > 0) {
+        emote_set_event_msg(emote_handle_, EMOTE_MGR_EVT_SYS, notification);
+    }
 }
 
 void EmoteDisplay::UpdateStatusBar(bool update_all)
 {
-    if (!engine_) {
+    ESP_LOGD(TAG, "UpdateStatusBar: %s", update_all ? "true" : "false");
+    if (!emote_handle_) {
         return;
     }
-
-    // Only display time when battery icon is shown
-    DisplayLockGuard lock(this);
-    if (g_current_icon_type == ICON_BATTERY) {
-        time_t now;
-        struct tm timeinfo;
-        time(&now);
-
-        setenv("TZ", "GMT+0", 1);
-        tzset();
-        localtime_r(&now, &timeinfo);
-
-        char time_str[6];
-        snprintf(time_str, sizeof(time_str), "%02d:%02d", timeinfo.tm_hour, timeinfo.tm_min);
-
-        DisplayLockGuard lock(this);
-        gfx_label_set_text(g_obj_label_clock, time_str);
-        SetUIDisplayMode(UIDisplayMode::SHOW_TIME, this);
-    }
 }
 
 void EmoteDisplay::SetPowerSaveMode(bool on)
 {
-    if (!engine_) {
-        return;
-    }
-
-    DisplayLockGuard lock(this);
     ESP_LOGI(TAG, "SetPowerSaveMode: %s", on ? "ON" : "OFF");
-    if (on) {
-        gfx_anim_stop(g_obj_anim_eye);
-    } else {
-        gfx_anim_start(g_obj_anim_eye);
+    if (!emote_handle_) {
+        return;
     }
 }
 
@@ -517,141 +203,47 @@ void EmoteDisplay::SetPreviewImage(const void* image)
 {
     if (image) {
         ESP_LOGI(TAG, "SetPreviewImage: Preview image not supported, using default icon");
-        if (engine_) {
-        }
     }
 }
 
 void EmoteDisplay::SetTheme(Theme* const theme)
 {
     ESP_LOGI(TAG, "SetTheme: %p", theme);
-
-}
-void EmoteDisplay::AddEmojiData(const std::string &name, const void* const data, const size_t size,
-                                uint8_t fps, bool loop, bool lack)
-{
-    emoji_data_map_[name] = AssetData(data, size, fps, loop, lack);
-    ESP_LOGD(TAG, "Added emoji data: %s, size: %d, fps: %d, loop: %s, lack: %s",
-             name.c_str(), size, fps, loop ? "true" : "false", lack ? "true" : "false");
-
-    DisplayLockGuard lock(this);
-    if (name == "happy") {
-        engine_->SetEyes("happy", loop, fps > 0 ? fps : 20, this);
-    }
-}
-
-void EmoteDisplay::AddIconData(const std::string &name, const void* const data, const size_t size)
-{
-    icon_data_map_[name] = AssetData(data, size);
-    ESP_LOGD(TAG, "Added icon data: %s, size: %d", name.c_str(), size);
-
-    DisplayLockGuard lock(this);
-    if (name == ICON_WIFI_FAILED) {
-        SetUIDisplayMode(UIDisplayMode::SHOW_TIPS, this);
-        engine_->SetIcon(ICON_WIFI_FAILED, this);
-    }
-}
-
-void EmoteDisplay::AddLayoutData(const std::string &name, const std::string &align_str,
-                                 const int x, const int y, const int width, const int height)
-{
-    const char align_enum = StringToGfxAlign(align_str);
-    ESP_LOGI(TAG, "layout: %-12s | %-20s(%d) | %4d, %4d | %4dx%-4d",
-             name.c_str(), align_str.c_str(), align_enum, x, y, width, height);
-
-    struct UIElement {
-        gfx_obj_t* obj;
-        const char* name;
-    };
-
-    const UIElement elements[] = {
-        {g_obj_anim_eye,     UI_ELEMENT_EYE_ANIM},
-        {g_obj_label_toast,  UI_ELEMENT_TOAST_LABEL},
-        {g_obj_label_clock,  UI_ELEMENT_CLOCK_LABEL},
-        {g_obj_anim_listen,  UI_ELEMENT_LISTEN_ANIM},
-        {g_obj_img_status,   UI_ELEMENT_STATUS_ICON}
-    };
-
-    DisplayLockGuard lock(this);
-    for (const auto &element : elements) {
-        if (name == element.name && element.obj) {
-            gfx_obj_align(element.obj, align_enum, x, y);
-            if (width > 0 && height > 0) {
-                gfx_obj_set_size(element.obj, width, height);
-            }
-            return;
-        }
-    }
-
-    ESP_LOGW(TAG, "AddLayoutData: UI element '%s' not found", name.c_str());
-}
-
-void EmoteDisplay::AddTextFont(std::shared_ptr<LvglFont> text_font)
-{
-    if (!text_font) {
-        ESP_LOGW(TAG, "AddTextFont: text_font is nullptr");
-        return;
-    }
-
-    text_font_ = text_font;
-    ESP_LOGD(TAG, "AddTextFont: Text font added successfully");
-
-    DisplayLockGuard lock(this);
-    if (g_obj_label_toast && text_font_) {
-        gfx_label_set_font(g_obj_label_toast, const_cast<void*>(static_cast<const void*>(text_font_->font())));
-    }
-    if (g_obj_label_clock && text_font_) {
-        gfx_label_set_font(g_obj_label_clock, const_cast<void*>(static_cast<const void*>(text_font_->font())));
-    }
-}
-
-AssetData EmoteDisplay::GetEmojiData(const std::string &name) const
-{
-    const auto it = emoji_data_map_.find(name);
-    if (it != emoji_data_map_.cend()) {
-        return it->second;
-    }
-    return AssetData();
-}
-
-AssetData EmoteDisplay::GetIconData(const std::string &name) const
-{
-    const auto it = icon_data_map_.find(name);
-    if (it != icon_data_map_.cend()) {
-        return it->second;
-    }
-    return AssetData();
-}
-
-EmoteEngine* EmoteDisplay::GetEngine() const
-{
-    return engine_.get();
-}
-
-void* EmoteDisplay::GetEngineHandle() const
-{
-    return engine_ ? engine_->GetEngineHandle() : nullptr;
-}
-
-void EmoteDisplay::InitializeEngine(const esp_lcd_panel_handle_t panel, const esp_lcd_panel_io_handle_t panel_io,
-                                    const int width, const int height)
-{
-    engine_ = std::make_unique<EmoteEngine>(panel, panel_io, width, height, this);
 }
 
 bool EmoteDisplay::Lock(const int timeout_ms)
 {
-    if (engine_ && engine_->GetEngineHandle()) {
-        gfx_emote_lock(engine_->GetEngineHandle());
-        return true;
-    }
-    return false;
+    (void)timeout_ms;
+    return true;
 }
 
 void EmoteDisplay::Unlock()
 {
-    if (engine_ && engine_->GetEngineHandle()) {
-        gfx_emote_unlock(engine_->GetEngineHandle());
+}
+
+bool EmoteDisplay::StopAnimDialog()
+{
+    ESP_LOGI(TAG, "StopAnimDialog");
+    if (emote_handle_) {
+        return emote_stop_anim_dialog(emote_handle_);
+    }
+    return false;
+}
+
+bool EmoteDisplay::InsertAnimDialog(const char* emoji_name, uint32_t duration_ms)
+{
+    ESP_LOGI(TAG, "InsertAnimDialog: %s, %" PRIu32, emoji_name, duration_ms);
+    if (emote_handle_ && emoji_name) {
+        return emote_insert_anim_dialog(emote_handle_, emoji_name, duration_ms);
+    }
+    return false;
+}
+
+void EmoteDisplay::RefreshAll()
+{
+    if (emote_handle_) {
+        emote_notify_all_refresh(emote_handle_);
+        return;
     }
 }
 

main/display/emote_display.h

@@ -1,59 +1,14 @@
 #pragma once
 
 #include "display.h"
-#include "lvgl_font.h"
 #include <memory>
-#include <functional>
-#include <map>
 #include <string>
 #include <esp_lcd_panel_io.h>
 #include <esp_lcd_panel_ops.h>
+#include "expression_emote.h"
 
 namespace emote {
 
-// Simple data structure for storing asset data without LVGL dependency
-struct AssetData {
-    const void* data;
-    size_t size;
-    union {
-        uint8_t flags;  // 1 byte for all animation flags
-        struct {
-            uint8_t fps : 6;    // FPS (0-63) - 6 bits
-            uint8_t loop : 1;   // Loop animation - 1 bit
-            uint8_t lack : 1;   // Lack animation - 1 bit
-        };
-    };
-
-    AssetData() : data(nullptr), size(0), flags(0) {}
-    AssetData(const void* d, size_t s) : data(d), size(s), flags(0) {}
-    AssetData(const void* d, size_t s, uint8_t f, bool l, bool k)
-        : data(d), size(s)
-    {
-        fps = f > 63 ? 63 : f;  // 限制 FPS 到 6 位范围
-        loop = l;
-        lack = k;
-    }
-};
-
-// Layout element data structure
-struct LayoutData {
-    char align;  // Store as char instead of string
-    int x;
-    int y;
-    int width;
-    int height;
-    bool has_size;
-
-    LayoutData() : align(0), x(0), y(0), width(0), height(0), has_size(false) {}
-    LayoutData(char a, int x_pos, int y_pos, int w = 0, int h = 0)
-        : align(a), x(x_pos), y(y_pos), width(w), height(h), has_size(w > 0 && h > 0) {}
-};
-
-// Function to convert align string to GFX_ALIGN enum value
-char StringToGfxAlign(const std::string &align_str);
-
-class EmoteEngine;
-
 class EmoteDisplay : public Display {
 public:
     EmoteDisplay(esp_lcd_panel_handle_t panel, esp_lcd_panel_io_handle_t panel_io, int width, int height);
@@ -68,34 +23,19 @@ public:
     virtual void SetPowerSaveMode(bool on) override;
     virtual void SetPreviewImage(const void* image);
 
-    void AddEmojiData(const std::string &name, const void* data, size_t size, uint8_t fps = 0, bool loop = false, bool lack = false);
-    void AddIconData(const std::string &name, const void* data, size_t size);
-    void AddLayoutData(const std::string &name, const std::string &align_str, int x, int y, int width = 0, int height = 0);
-    void AddTextFont(std::shared_ptr<LvglFont> text_font);
-    AssetData GetEmojiData(const std::string &name) const;
-    AssetData GetIconData(const std::string &name) const;
+    bool StopAnimDialog();
+    bool InsertAnimDialog(const char* emoji_name, uint32_t duration_ms);
 
-    EmoteEngine* GetEngine() const;
-    void* GetEngineHandle() const;
+    void RefreshAll();
 
-    inline std::shared_ptr<LvglFont> text_font() const
-    {
-        return text_font_;
-    }
+    // Get emote handle for internal use
+    emote_handle_t GetEmoteHandle() const { return emote_handle_; }
 
 private:
-    void InitializeEngine(esp_lcd_panel_handle_t panel, esp_lcd_panel_io_handle_t panel_io, int width, int height);
     virtual bool Lock(int timeout_ms = 0) override;
     virtual void Unlock() override;
 
-    std::unique_ptr<EmoteEngine> engine_;
-
-    // Font management
-    std::shared_ptr<LvglFont> text_font_ = nullptr;
-
-    // Non-LVGL asset data storage
-    std::map<std::string, AssetData> emoji_data_map_;
-    std::map<std::string, AssetData> icon_data_map_;
+    emote_handle_t emote_handle_ = nullptr;
 
 };
 

main/idf_component.yml

@@ -19,7 +19,8 @@ dependencies:
   espressif/esp_lcd_panel_io_additions: ^1.0.1
   78/esp_lcd_nv3023: ~1.0.0
   78/esp-wifi-connect: ~3.0.2
-  78/esp-opus-encoder: ~2.4.1
+  espressif/esp_audio_effects: ~1.2.0
+  espressif/esp_audio_codec: ~2.4.0
   78/esp-ml307: ~3.5.3
   78/xiaozhi-fonts: ~1.5.5
   espressif/led_strip: ~3.0.1
@@ -44,7 +45,7 @@ dependencies:
   esp_lvgl_port: ~2.6.0
   espressif/esp_io_expander_tca95xx_16bit: ^2.0.0
   espressif2022/image_player: ^1.1.1
-  espressif2022/esp_emote_gfx: ==2.0.0
+  espressif2022/esp_emote_expression: ^0.1.0
   espressif/adc_mic: ^0.2.1
   espressif/esp_mmap_assets: '>=1.2'
   txp666/otto-emoji-gif-component:

scripts/release.py

@@ -278,7 +278,7 @@ if __name__ == "__main__":
 
     # Compile mode
     board_type_input: str = args.board
-    name_filter: str | None = args.name
+    name_filter: Optional[str] = args.name
 
     # Check board_type in CMakeLists
     if board_type_input != "all" and not _board_type_exists(board_type_input):

scripts/spiffs_assets/build_all.py

@@ -15,8 +15,6 @@ import os
 import sys
 import shutil
 import subprocess
-import argparse
-from pathlib import Path
 
 
 def ensure_dir(directory):
@@ -31,7 +29,7 @@ def get_file_path(base_dir, filename):
     return os.path.join(base_dir, f"{filename}.bin" if not filename.startswith("emojis_") else filename)
 
 
-def build_assets(wakenet_model, text_font, emoji_collection, target_board, build_dir, final_dir):
+def build_assets(wakenet_model, text_font, emoji_collection, build_dir, final_dir):
     """Build assets.bin using build.py with given parameters"""
     
     # Prepare arguments for build.py
@@ -48,15 +46,8 @@ def build_assets(wakenet_model, text_font, emoji_collection, target_board, build
     if emoji_collection != "none":
         emoji_path = os.path.join("../../components/xiaozhi-fonts/build", emoji_collection)
         cmd.extend(["--emoji_collection", emoji_path])
-
-    if target_board != "none":
-        res_path = os.path.join("../../managed_components/espressif2022__esp_emote_gfx/emoji_large", "")
-        cmd.extend(["--res_path", res_path])
-
-        target_board_path = os.path.join("../../main/boards/", f"{target_board}")
-        cmd.extend(["--target_board", target_board_path])
     
-    print(f"\n正在构建: {wakenet_model}-{text_font}-{emoji_collection}-{target_board}")
+    print(f"\n正在构建: {wakenet_model}-{text_font}-{emoji_collection}")
     print(f"执行命令: {' '.join(cmd)}")
     
     try:
@@ -64,10 +55,7 @@ def build_assets(wakenet_model, text_font, emoji_collection, target_board, build
         result = subprocess.run(cmd, check=True, cwd=os.path.dirname(__file__))
         
         # Generate output filename
-        if(target_board != "none"):
-            output_name = f"{wakenet_model}-{text_font}-{target_board}.bin"
-        else:
-            output_name = f"{wakenet_model}-{text_font}-{emoji_collection}.bin"
+        output_name = f"{wakenet_model}-{text_font}-{emoji_collection}.bin"
         
         # Copy generated assets.bin to final directory with new name
         src_path = os.path.join(build_dir, "assets.bin")
@@ -90,15 +78,6 @@ def build_assets(wakenet_model, text_font, emoji_collection, target_board, build
 
 
 def main():
-    # Parse command line arguments
-    parser = argparse.ArgumentParser(description='构建多个 SPIFFS assets 分区')
-    parser.add_argument('--mode',
-                       choices=['emoji_collections', 'emoji_target_boards'],
-                       default='emoji_collections',
-                       help='选择运行模式: emoji_collections 或 emoji_target_boards (默认: emoji_collections)')
-
-    args = parser.parse_args()
-    
     # Configuration
     wakenet_models = [
         "none",
@@ -119,11 +98,6 @@ def main():
         "emojis_32",
         "emojis_64",
     ]
-
-    emoji_target_boards = [
-        "esp-box-3",
-        "echoear",
-    ]
     
     # Get script directory
     script_dir = os.path.dirname(os.path.abspath(__file__))
@@ -137,33 +111,20 @@ def main():
     ensure_dir(final_dir)
     
     print("开始构建多个 SPIFFS assets 分区...")
-    print(f"运行模式: {args.mode}")
     print(f"输出目录: {final_dir}")
     
+    # Calculate total combinations
+    total_combinations = len(wakenet_models) * len(text_fonts) * len(emoji_collections)
+    
     # Track successful builds
     successful_builds = 0
     
-    if args.mode == 'emoji_collections':
-        # Calculate total combinations for emoji_collections mode
-        total_combinations = len(wakenet_models) * len(text_fonts) * len(emoji_collections)
-        
-        # Build all combinations with emoji_collections
-        for wakenet_model in wakenet_models:
-            for text_font in text_fonts:
-                for emoji_collection in emoji_collections:
-                    if build_assets(wakenet_model, text_font, emoji_collection, "none", build_dir, final_dir):
-                        successful_builds += 1
-                        
-    elif args.mode == 'emoji_target_boards':
-        # Calculate total combinations for emoji_target_boards mode
-        total_combinations = len(wakenet_models) * len(text_fonts) * len(emoji_target_boards)
-        
-        # Build all combinations with emoji_target_boards
-        for wakenet_model in wakenet_models:
-            for text_font in text_fonts:
-                for emoji_target_board in emoji_target_boards:
-                    if build_assets(wakenet_model, text_font, "none", emoji_target_board, build_dir, final_dir):
-                        successful_builds += 1
+    # Build all combinations with emoji_collections
+    for wakenet_model in wakenet_models:
+        for text_font in text_fonts:
+            for emoji_collection in emoji_collections:
+                if build_assets(wakenet_model, text_font, emoji_collection, build_dir, final_dir):
+                    successful_builds += 1
     
     print(f"\n构建完成!")
     print(f"成功构建: {successful_builds}/{total_combinations}")