feat: mcp sleep

main/CMakeLists.txt

@@ -651,14 +651,14 @@ elseif(CONFIG_BOARD_TYPE_ZHENGCHEN_1_54TFT_ML307)
     set(DEFAULT_EMOJI_COLLECTION twemoji_64)
 elseif(CONFIG_BOARD_TYPE_ZHENGCHEN_CAM)
     set(BOARD_TYPE "zhengchen-cam")
-    set(BUILTIN_TEXT_FONT font_puhui_basic_20_4)
+    set(BUILTIN_TEXT_FONT font_puhui_20_4)
     set(BUILTIN_ICON_FONT font_awesome_20_4)
-    set(DEFAULT_EMOJI_COLLECTION twemoji_64)
+    set(DEFAULT_EMOJI_COLLECTION main/boards/zhengchen-cam/custom-emojis)
 elseif(CONFIG_BOARD_TYPE_ZHENGCHEN_CAM_ML307)
     set(BOARD_TYPE "zhengchen-cam-ml307")
-    set(BUILTIN_TEXT_FONT font_puhui_basic_20_4)
+    set(BUILTIN_TEXT_FONT font_puhui_20_4)
     set(BUILTIN_ICON_FONT font_awesome_20_4)
-    set(DEFAULT_EMOJI_COLLECTION twemoji_64)    
+    set(DEFAULT_EMOJI_COLLECTION main/boards/zhengchen-cam/custom-emojis)
 elseif(CONFIG_BOARD_TYPE_SPOTPEAR_ESP32_S3_1_54_MUMA)
     set(BOARD_TYPE "sp-esp32-s3-1.54-muma")
     set(BUILTIN_TEXT_FONT font_puhui_basic_16_4)
@@ -912,6 +912,7 @@ idf_component_register(SRCS ${SOURCES}
                         efuse
                         bt
                         fatfs
+                        lwip
                     )
 
 # Use target_compile_definitions to define BOARD_TYPE, BOARD_NAME
@@ -1017,6 +1018,25 @@ function(build_default_assets_bin)
         list(APPEND BUILD_ARGS "--extra_files" "${DEFAULT_ASSETS_EXTRA_FILES}")
     endif()
 
+    set(DEFAULT_ASSETS_DEPENDS
+        ${SDKCONFIG}
+        ${PROJECT_DIR}/scripts/build_default_assets.py
+    )
+    if(DEFAULT_EMOJI_COLLECTION)
+        if(IS_ABSOLUTE "${DEFAULT_EMOJI_COLLECTION}")
+            set(DEFAULT_EMOJI_COLLECTION_PATH "${DEFAULT_EMOJI_COLLECTION}")
+        else()
+            set(DEFAULT_EMOJI_COLLECTION_PATH "${PROJECT_DIR}/${DEFAULT_EMOJI_COLLECTION}")
+        endif()
+        if(IS_DIRECTORY "${DEFAULT_EMOJI_COLLECTION_PATH}")
+            file(GLOB_RECURSE DEFAULT_EMOJI_COLLECTION_FILES CONFIGURE_DEPENDS
+                "${DEFAULT_EMOJI_COLLECTION_PATH}/*.png"
+                "${DEFAULT_EMOJI_COLLECTION_PATH}/*.gif"
+            )
+            list(APPEND DEFAULT_ASSETS_DEPENDS ${DEFAULT_EMOJI_COLLECTION_FILES})
+        endif()
+    endif()
+    
     list(APPEND BUILD_ARGS "--esp_sr_model_path" "${ESP_SR_MODEL_PATH}")
     list(APPEND BUILD_ARGS "--xiaozhi_fonts_path" "${XIAOZHI_FONTS_PATH}")
     
@@ -1024,9 +1044,7 @@ function(build_default_assets_bin)
     add_custom_command(
         OUTPUT ${GENERATED_ASSETS_BIN}
         COMMAND python ${PROJECT_DIR}/scripts/build_default_assets.py ${BUILD_ARGS}
-        DEPENDS
-            ${SDKCONFIG}
-            ${PROJECT_DIR}/scripts/build_default_assets.py
+        DEPENDS ${DEFAULT_ASSETS_DEPENDS}
         COMMENT "Building default assets.bin based on configuration"
         VERBATIM
     )

main/Kconfig.projbuild

@@ -133,6 +133,14 @@ choice BOARD_TYPE
         depends on IDF_TARGET_ESP32S3
 endchoice
 
+config ZHENGCHEN_CAM_USE_GIF_EMOJI
+    bool "Use GIF custom emojis for Zhengchen CAM"
+    depends on BOARD_TYPE_ZHENGCHEN_CAM || BOARD_TYPE_ZHENGCHEN_CAM_ML307
+    default n
+    help
+        When enabled, default assets use custom-emojis/gif.
+        When disabled, default assets use custom-emojis/png.
+
 choice
     depends on BOARD_TYPE_LILYGO_T_DISPLAY_P4
     prompt "Select the screen type"

main/application.cc

@@ -16,9 +16,49 @@
 #include <driver/gpio.h>
 #include <arpa/inet.h>
 #include <font_awesome.h>
+#include <lwip/apps/sntp.h>
+#include <time.h>
+#include <cstdlib>
 
 #define TAG "Application"
 
+namespace {
+constexpr const char* kDirectWebsocketUrl = "ws://172.19.0.240:8080";
+constexpr int kDirectWebsocketVersion = 3;
+constexpr bool kUseDirectWebsocketWithoutOta = true;
+constexpr int kDefaultFatigueListeningTimeoutSec = 12;
+constexpr int kDefaultFatigueIdleTimeoutSec = 12;
+constexpr int kDefaultFatigueCooldownSec = 60;
+constexpr const char* kDefaultFatigueEmotion = "wakeup";
+constexpr const char* kDefaultFatigueMessage = "你是不是又要睡着啦？快醒醒，我还要给你跳舞呢～";
+constexpr const char* kDefaultFatigueStatus = "打起精神";
+
+void StartDirectTimeSync() {
+    setenv("TZ", "CST-8", 1);
+    tzset();
+
+    static bool sntp_started = false;
+    if (sntp_started) {
+        return;
+    }
+    sntp_started = true;
+
+    sntp_setoperatingmode(SNTP_OPMODE_POLL);
+    sntp_setservername(0, "ntp.aliyun.com");
+    sntp_init();
+}
+
+void ConfigureDirectWebsocket() {
+    Settings settings("websocket", true);
+    if (settings.GetString("url") != kDirectWebsocketUrl) {
+        settings.SetString("url", kDirectWebsocketUrl);
+    }
+    if (settings.GetInt("version") != kDirectWebsocketVersion) {
+        settings.SetInt("version", kDirectWebsocketVersion);
+    }
+}
+} // namespace
+
 
 Application::Application() {
     event_group_ = xEventGroupCreate();
@@ -249,6 +289,7 @@ void Application::Run() {
             clock_ticks_++;
             auto display = Board::GetInstance().GetDisplay();
             display->UpdateStatusBar();
+            CheckFatigueReminder();
         
             // Print debug info every 10 seconds
             if (clock_ticks_ % 10 == 0) {
@@ -324,6 +365,16 @@ void Application::ActivationTask() {
     // Create OTA object for activation process
     ota_ = std::make_unique<Ota>();
 
+    if (kUseDirectWebsocketWithoutOta) {
+        ConfigureDirectWebsocket();
+        StartDirectTimeSync();
+        ESP_LOGI(TAG, "Using direct websocket without OTA: %s", kDirectWebsocketUrl);
+        CheckAssetsVersion();
+        InitializeProtocol();
+        xEventGroupSetBits(event_group_, MAIN_EVENT_ACTIVATION_DONE);
+        return;
+    }
+
     // Check for new assets version
     CheckAssetsVersion();
 
@@ -477,9 +528,12 @@ void Application::InitializeProtocol() {
 
     display->SetStatus(Lang::Strings::LOADING_PROTOCOL);
 
+    Settings websocket_settings("websocket", false);
+    bool has_direct_websocket_config = !websocket_settings.GetString("url").empty();
+
     if (ota_->HasMqttConfig()) {
         protocol_ = std::make_unique<MqttProtocol>();
-    } else if (ota_->HasWebsocketConfig()) {
+    } else if (ota_->HasWebsocketConfig() || has_direct_websocket_config) {
         protocol_ = std::make_unique<WebsocketProtocol>();
     } else {
         ESP_LOGW(TAG, "No protocol specified in the OTA config, using MQTT");
@@ -659,6 +713,108 @@ void Application::DismissAlert() {
     }
 }
 
+void Application::CheckFatigueReminder() {
+    auto state = GetDeviceState();
+    if (state != kDeviceStateListening) {
+        fatigue_silence_seconds_ = 0;
+        fatigue_reminder_triggered_in_listening_ = false;
+    }
+    if (state != kDeviceStateIdle) {
+        fatigue_idle_seconds_ = 0;
+    }
+
+    Settings settings("fatigue", false);
+    if (!settings.GetBool("enabled", true)) {
+        return;
+    }
+
+    int64_t now_us = esp_timer_get_time();
+    int cooldown_sec = settings.GetInt("cooldown_sec", kDefaultFatigueCooldownSec);
+    if (cooldown_sec < 10) {
+        cooldown_sec = 10;
+    } else if (cooldown_sec > 3600) {
+        cooldown_sec = 3600;
+    }
+    if (last_fatigue_reminder_time_us_ != 0 &&
+        now_us - last_fatigue_reminder_time_us_ < static_cast<int64_t>(cooldown_sec) * 1000000) {
+        return;
+    }
+
+    if (state == kDeviceStateIdle) {
+        fatigue_idle_seconds_++;
+
+        int idle_timeout_sec = settings.GetInt("idle_timeout_sec", kDefaultFatigueIdleTimeoutSec);
+        if (idle_timeout_sec < 3) {
+            idle_timeout_sec = 3;
+        } else if (idle_timeout_sec > 3600) {
+            idle_timeout_sec = 3600;
+        }
+        if (fatigue_idle_seconds_ >= idle_timeout_sec) {
+            fatigue_idle_seconds_ = 0;
+            last_fatigue_reminder_time_us_ = now_us;
+            TriggerFatigueReminder();
+        }
+        return;
+    }
+
+    if (state != kDeviceStateListening) {
+        return;
+    }
+
+    if (audio_service_.IsVoiceDetected()) {
+        fatigue_silence_seconds_ = 0;
+        fatigue_reminder_triggered_in_listening_ = false;
+        return;
+    }
+
+    fatigue_silence_seconds_++;
+    if (fatigue_reminder_triggered_in_listening_) {
+        return;
+    }
+
+    int timeout_sec = settings.GetInt("listening_timeout_sec", kDefaultFatigueListeningTimeoutSec);
+    if (timeout_sec < 3) {
+        timeout_sec = 3;
+    } else if (timeout_sec > 300) {
+        timeout_sec = 300;
+    }
+    if (fatigue_silence_seconds_ < timeout_sec) {
+        return;
+    }
+
+    fatigue_reminder_triggered_in_listening_ = true;
+    last_fatigue_reminder_time_us_ = now_us;
+    TriggerFatigueReminder();
+}
+
+void Application::TriggerFatigueReminder() {
+    Settings settings("fatigue", false);
+    std::string emotion = settings.GetString("emotion", kDefaultFatigueEmotion);
+    std::string message = settings.GetString("message", kDefaultFatigueMessage);
+    std::string sound_asset = settings.GetString("sound_asset");
+
+    ESP_LOGW(TAG, "Fatigue reminder triggered: silence=%ds, emotion=%s",
+             fatigue_silence_seconds_, emotion.c_str());
+
+    auto display = Board::GetInstance().GetDisplay();
+    display->SetStatus(kDefaultFatigueStatus);
+    display->SetEmotion(emotion.c_str());
+    display->SetChatMessage("assistant", message.c_str());
+
+    if (!sound_asset.empty()) {
+        void* ptr = nullptr;
+        size_t size = 0;
+        auto& assets = Assets::GetInstance();
+        if (assets.partition_valid() && assets.GetAssetData(sound_asset, ptr, size)) {
+            audio_service_.PlaySound(std::string_view(static_cast<const char*>(ptr), size));
+            return;
+        }
+        ESP_LOGW(TAG, "Fatigue sound asset not found: %s", sound_asset.c_str());
+    }
+
+    audio_service_.PlaySound(Lang::Sounds::OGG_POPUP);
+}
+
 void Application::ToggleChatState() {
     xEventGroupSetBits(event_group_, MAIN_EVENT_TOGGLE_CHAT);
 }
@@ -872,11 +1028,12 @@ void Application::HandleStateChangedEvent() {
             break;
         case kDeviceStateConnecting:
             display->SetStatus(Lang::Strings::CONNECTING);
-            display->SetEmotion("neutral");
             display->SetChatMessage("system", "");
+            display->SetEmotion("neutral");
             break;
         case kDeviceStateListening:
             display->SetStatus(Lang::Strings::LISTENING);
+            display->ClearChatMessages();
             display->SetEmotion("neutral");
 
             // Make sure the audio processor is running
@@ -1116,4 +1273,3 @@ void Application::ResetProtocol() {
         protocol_.reset();
     });
 }
-

main/application.h

@@ -140,6 +140,10 @@ private:
     bool aborted_ = false;
     bool assets_version_checked_ = false;
     bool play_popup_on_listening_ = false;  // Flag to play popup sound after state changes to listening
+    bool fatigue_reminder_triggered_in_listening_ = false;
+    int fatigue_silence_seconds_ = 0;
+    int fatigue_idle_seconds_ = 0;
+    int64_t last_fatigue_reminder_time_us_ = 0;
     int clock_ticks_ = 0;
     TaskHandle_t activation_task_handle_ = nullptr;
 
@@ -155,6 +159,8 @@ private:
     void HandleWakeWordDetectedEvent();
     void ContinueOpenAudioChannel(ListeningMode mode);
     void ContinueWakeWordInvoke(const std::string& wake_word);
+    void CheckFatigueReminder();
+    void TriggerFatigueReminder();
 
     // Activation task (runs in background)
     void ActivationTask();

main/boards/zhengchen-cam/custom-emojis/README.md

@@ -0,0 +1,57 @@
+# Custom Emojis
+
+Put your custom PNG files in `png/` and custom GIF files in `gif/`.
+
+The filename without extension is used as the emotion name. Directory names are
+not part of the emotion name, so `png/neutral.png` is loaded as `neutral`.
+
+The display code looks up images by names such as:
+
+- `neutral.png` or `neutral.gif`
+- `happy.png` or `happy.gif`
+- `sad.png` or `sad.gif`
+- `angry.png` or `angry.gif`
+- `thinking.png` or `thinking.gif`
+- `confused.png` or `confused.gif`
+- `surprised.png` or `surprised.gif`
+- `shocked.png` or `shocked.gif`
+- `sleepy.png` or `sleepy.gif`
+- `relaxed.png` or `relaxed.gif`
+
+Recommended minimum set:
+
+- `neutral`
+- `happy`
+- `thinking`
+- `sad`
+- `angry`
+
+Fatigue reminder:
+
+- Add `wakeup.gif` or `wakeup.png` to make the idle-fatigue reminder show a custom idol animation.
+- The reminder defaults to `wakeup` after 12 seconds of idle time or listening silence, then waits 60 seconds before it can trigger again.
+- Optional NVS settings in namespace `fatigue`:
+  - `enabled` (`bool`, default `true`)
+  - `idle_timeout_sec` (`int`, default `12`)
+  - `listening_timeout_sec` (`int`, default `12`)
+  - `cooldown_sec` (`int`, default `60`)
+  - `emotion` (`string`, default `wakeup`)
+  - `message` (`string`, default Chinese wake-up line)
+  - `sound_asset` (`string`, optional OGG filename in the assets partition)
+
+If an emotion-specific image is missing, the firmware falls back to `neutral`
+before using the built-in icon.
+
+For Zhengchen CAM boards, the build packages both subdirectories:
+
+- Put static/default faces in `png/`, such as `png/neutral.png`.
+- Put animated/special actions in `gif/`, such as `gif/wakeup.gif`.
+- If both folders contain the same emotion name, PNG wins. For example,
+  `png/neutral.png` is used before `gif/neutral.gif`.
+
+After adding or replacing files, run a full flash so the assets partition is
+updated:
+
+```bash
+idf.py flash
+```

main/display/lcd_display.cc

@@ -22,6 +22,60 @@ LV_FONT_DECLARE(BUILTIN_TEXT_FONT);
 LV_FONT_DECLARE(BUILTIN_ICON_FONT);
 LV_FONT_DECLARE(font_awesome_30_4);
 
+namespace {
+constexpr int kEmojiMaxScale = 1024;
+
+lv_coord_t ObjectHeight(lv_obj_t* obj) {
+    if (obj == nullptr) {
+        return 0;
+    }
+    if (lv_obj_has_flag(obj, LV_OBJ_FLAG_HIDDEN)) {
+        return 0;
+    }
+    lv_obj_update_layout(obj);
+    return lv_obj_get_height(obj);
+}
+
+void ApplyEmojiImageScale(lv_obj_t* image_obj, lv_obj_t* image_box, const lv_image_dsc_t* image_dsc,
+                          lv_coord_t top_reserved, lv_coord_t bottom_reserved) {
+    if (image_obj == nullptr || image_dsc == nullptr) {
+        return;
+    }
+
+    lv_coord_t image_width = image_dsc->header.w;
+    lv_coord_t image_height = image_dsc->header.h;
+    if (image_width <= 0 || image_height <= 0) {
+        lv_image_set_scale(image_obj, 256);
+        return;
+    }
+
+    lv_coord_t max_width = LV_HOR_RES;
+    lv_coord_t max_height = LV_VER_RES - top_reserved - bottom_reserved;
+    max_height = std::max<lv_coord_t>(max_height, 1);
+    lv_coord_t scale_w = max_width * 256 / image_width;
+    lv_coord_t scale_h = max_height * 256 / image_height;
+    lv_coord_t scale = std::min(scale_w, scale_h);
+    scale = std::min<lv_coord_t>(scale, kEmojiMaxScale);
+    scale = std::max<lv_coord_t>(scale, 1);
+    lv_coord_t scaled_width = image_width * scale / 256;
+    lv_coord_t scaled_height = image_height * scale / 256;
+
+    lv_image_set_scale(image_obj, scale);
+    lv_obj_set_size(image_obj, scaled_width, scaled_height);
+    lv_obj_t* align_obj = image_box != nullptr ? image_box : image_obj;
+    lv_obj_set_size(align_obj, scaled_width, scaled_height);
+    lv_obj_align(align_obj, LV_ALIGN_TOP_MID, 0, top_reserved + (max_height - scaled_height) / 2);
+    if (image_box != nullptr) {
+        lv_obj_center(image_obj);
+    }
+    ESP_LOGD(TAG, "Emoji image scale=%ld reserved=%ld/%ld size=%ldx%ld -> %ldx%ld",
+             static_cast<long>(scale), static_cast<long>(top_reserved),
+             static_cast<long>(bottom_reserved), static_cast<long>(image_width),
+             static_cast<long>(image_height),
+             static_cast<long>(scaled_width), static_cast<long>(scaled_height));
+}
+}  // namespace
+
 void LcdDisplay::InitializeLcdThemes() {
     auto text_font = std::make_shared<LvglBuiltInFont>(&BUILTIN_TEXT_FONT);
     auto icon_font = std::make_shared<LvglBuiltInFont>(&BUILTIN_ICON_FONT);
@@ -1136,6 +1190,9 @@ void LcdDisplay::SetEmotion(const char* emotion) {
 
     auto emoji_collection = static_cast<LvglTheme*>(current_theme_)->emoji_collection();
     auto image = emoji_collection != nullptr ? emoji_collection->GetEmojiImage(emotion) : nullptr;
+    if (image == nullptr && emoji_collection != nullptr && strcmp(emotion, "neutral") != 0) {
+        image = emoji_collection->GetEmojiImage("neutral");
+    }
     if (image == nullptr) {
         const char* utf8 = font_awesome_get_utf8(emotion);
         if (utf8 != nullptr && emoji_label_ != nullptr) {
@@ -1148,17 +1205,29 @@ void LcdDisplay::SetEmotion(const char* emotion) {
     }
 
     DisplayLockGuard lock(this);
+    bool use_full_screen_center = strcmp(emotion, "neutral") == 0;
+    lv_coord_t top_reserved = use_full_screen_center ? 0 : ObjectHeight(top_bar_);
+    lv_coord_t bottom_reserved = use_full_screen_center ? 0 : ObjectHeight(status_bar_) + ObjectHeight(bottom_bar_);
+    auto apply_emoji_layout = [this, top_reserved, bottom_reserved](const lv_image_dsc_t* image_dsc) {
+        ApplyEmojiImageScale(emoji_image_, emoji_box_, image_dsc, top_reserved, bottom_reserved);
+    };
+
     if (image->IsGif()) {
         // Create new GIF controller
         gif_controller_ = std::make_unique<LvglGif>(image->image_dsc());
 
         if (gif_controller_->IsLoaded()) {
             // Set up frame update callback
-            gif_controller_->SetFrameCallback(
-                [this]() { lv_image_set_src(emoji_image_, gif_controller_->image_dsc()); });
+            gif_controller_->SetFrameCallback([this, apply_emoji_layout]() {
+                auto frame = gif_controller_->image_dsc();
+                lv_image_set_src(emoji_image_, frame);
+                apply_emoji_layout(frame);
+            });
 
             // Set initial frame and start animation
-            lv_image_set_src(emoji_image_, gif_controller_->image_dsc());
+            auto frame = gif_controller_->image_dsc();
+            lv_image_set_src(emoji_image_, frame);
+            apply_emoji_layout(frame);
             gif_controller_->Start();
 
             // Show GIF, hide others
@@ -1169,7 +1238,9 @@ void LcdDisplay::SetEmotion(const char* emotion) {
             gif_controller_.reset();
         }
     } else {
-        lv_image_set_src(emoji_image_, image->image_dsc());
+        auto image_dsc = image->image_dsc();
+        lv_image_set_src(emoji_image_, image_dsc);
+        apply_emoji_layout(image_dsc);
         lv_obj_add_flag(emoji_label_, LV_OBJ_FLAG_HIDDEN);
         lv_obj_remove_flag(emoji_image_, LV_OBJ_FLAG_HIDDEN);
     }

main/display/lvgl_display/lvgl_display.cc

@@ -3,6 +3,7 @@
 #include <string>
 #include <cstdlib>
 #include <cstring>
+#include <ctime>
 #include <font_awesome.h>
 
 #include "lvgl_display.h"
@@ -22,6 +23,21 @@ LvglDisplay::LvglDisplay() {
             LvglDisplay *display = static_cast<LvglDisplay*>(arg);
             DisplayLockGuard lock(display);
             lv_obj_add_flag(display->notification_label_, LV_OBJ_FLAG_HIDDEN);
+            if (Application::GetInstance().GetDeviceState() == kDeviceStateIdle && display->time_label_ != nullptr) {
+                time_t now = time(NULL);
+                struct tm* tm = localtime(&now);
+                if (tm->tm_year >= 2025 - 1900) {
+                    char time_str[16];
+                    strftime(time_str, sizeof(time_str), "%H:%M", tm);
+                    lv_label_set_text(display->time_label_, time_str);
+                    lv_obj_remove_flag(display->time_label_, LV_OBJ_FLAG_HIDDEN);
+                    lv_obj_add_flag(display->status_label_, LV_OBJ_FLAG_HIDDEN);
+                    return;
+                }
+            }
+            if (display->time_label_ != nullptr) {
+                lv_obj_add_flag(display->time_label_, LV_OBJ_FLAG_HIDDEN);
+            }
             lv_obj_remove_flag(display->status_label_, LV_OBJ_FLAG_HIDDEN);
         },
         .arg = this,

scripts/build_default_assets.py

@@ -235,8 +235,14 @@ def process_emoji_collection(emoji_collection_dir, assets_dir):
         "buxue": ["thinking", "confused", "embarrassed"]
     }
     
-    # Copy each image from input directory to build/assets directory
+    seen_emoji_names = set()
+
+    # Copy each image from input directory to build/assets directory. Prefer PNG
+    # over GIF for duplicate emotion names so static defaults can coexist with
+    # animated special actions in sibling directories.
     for root, dirs, files in os.walk(emoji_collection_dir):
+        dirs.sort(key=lambda d: (0 if d == "png" else 1 if d == "gif" else 2, d))
+        files.sort(key=lambda f: (0 if f.lower().endswith(".png") else 1, f))
         for file in files:
             if file.lower().endswith(('.png', '.gif')):
                 # Copy file
@@ -245,6 +251,9 @@ def process_emoji_collection(emoji_collection_dir, assets_dir):
                 if copy_file(src_file, dst_file):
                     # Get filename without extension
                     filename_without_ext = os.path.splitext(file)[0]
+                    if filename_without_ext in seen_emoji_names:
+                        continue
+                    seen_emoji_names.add(filename_without_ext)
                     
                     # Add main emoji entry
                     emoji_list.append({
@@ -715,10 +724,21 @@ def get_emoji_collection_path(default_emoji_collection, xiaozhi_fonts_path, proj
     - PNG emoji collections from xiaozhi-fonts (e.g., emojis_32, twemoji_64)
     - GIF emoji collections from xiaozhi-fonts (e.g., noto-emoji_128, noto-emoji_64)
     - Otto GIF emoji collection (otto-gif)
+    - Custom project-relative or absolute directory paths
     """
     if not default_emoji_collection:
         return None
 
+    candidate_paths = []
+    if os.path.isabs(default_emoji_collection):
+        candidate_paths.append(default_emoji_collection)
+    elif project_root:
+        candidate_paths.append(os.path.join(project_root, default_emoji_collection))
+
+    for candidate_path in candidate_paths:
+        if os.path.isdir(candidate_path):
+            return candidate_path
+    
     # Special handling for otto-gif collection
     if default_emoji_collection == 'otto-gif':
         if project_root: