Merge branch 'bugfix/disable_agent_within_apps' into 'master'

Closes espressif#33

See merge request ae_group/esp-brookesia!25

Author: Lzw655

apps/brookesia_app_ai_profile/idf_component.yml

@@ -1,7 +1,7 @@
 version: 0.6.0
 dependencies:
   brookesia_core:
-    version: "0.6.*"
+    version: "*"
     public: true
 
   espressif/esp-lib-utils:

apps/brookesia_app_calculator/idf_component.yml

@@ -1,7 +1,7 @@
 version: 0.6.0
 dependencies:
   brookesia_core:
-    version: "0.6.*"
+    version: "*"
     public: true
 
   espressif/esp-lib-utils:

apps/brookesia_app_game_2048/esp_brookesia_app_game_2048.cpp

@@ -377,6 +377,8 @@ lv_obj_t *Game2048::addBackgroundCell(lv_obj_t *parent)
     // Background
     lv_obj_set_style_bg_color(cell, CELL_BG_COLOR, 0);
     lv_obj_set_style_bg_opa(cell, CELL_OPA_1, 0);
+    // Others
+    lv_obj_remove_flag(cell, LV_OBJ_FLAG_SCROLLABLE);
 
     return cell;
 }
@@ -435,7 +437,8 @@ void Game2048::generateForegroundCell()
     lv_obj_set_style_bg_color(cell, CELL_BG_COLOR, 0);
     lv_obj_set_style_opa(cell, CELL_OPA_2, 0);
     // Others
-    lv_obj_clear_flag(cell, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_remove_flag(cell, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_remove_flag(cell, LV_OBJ_FLAG_SCROLLABLE);
 
     lv_obj_t *label = lv_label_create(cell);
     lv_label_set_text_fmt(label, "%d", 1 << target_weight);

apps/brookesia_app_game_2048/idf_component.yml

@@ -1,7 +1,7 @@
 version: 0.6.0
 dependencies:
   brookesia_core:
-    version: "0.6.*"
+    version: "*"
     public: true
 
   espressif/esp-lib-utils:

apps/brookesia_app_settings/esp_brookesia_app_settings_manager.cpp

@@ -62,8 +62,8 @@
 #define VERSION_STR(x, y, z)                           _VERSION_STR(x, y, z)
 #define UI_SCREEN_ABOUT_SYSTEM_OS_NAME                  "FreeRTOS"
 #define UI_SCREEN_ABOUT_SYSTEM_UI_NAME                  "ESP-Brookesia & LVGL"
-#define UI_SCREEN_ABOUT_SYSTEM_UI_BROOKESIA_VERSION     VERSION_STR(ESP_BROOKESIA_VER_MAJOR, ESP_BROOKESIA_VER_MINOR ,\
-                                                                    ESP_BROOKESIA_VER_PATCH)
+#define UI_SCREEN_ABOUT_SYSTEM_UI_BROOKESIA_VERSION     VERSION_STR(BROOKESIA_CORE_VER_MAJOR, BROOKESIA_CORE_VER_MINOR ,\
+                                                                    BROOKESIA_CORE_VER_PATCH)
 #define UI_SCREEN_ABOUT_SYSTEM_UI_LVGL_VERSION          VERSION_STR(LVGL_VERSION_MAJOR, LVGL_VERSION_MINOR, \
                                                                     LVGL_VERSION_PATCH)
 #define UI_SCREEN_ABOUT_DEVICE_MANUFACTURER             "Espressif"

apps/brookesia_app_settings/idf_component.yml

@@ -1,7 +1,7 @@
 version: 0.6.0
 dependencies:
   brookesia_core:
-    version: "0.6.*"
+    version: "*"
     public: true
 
   espressif/esp-lib-utils:

apps/brookesia_app_settings/stylesheets/360_360/screen_about.hpp

@@ -57,7 +57,7 @@ constexpr SettingsUI_ScreenAboutData SETTINGS_UI_360_360_SCREEN_ABOUT_DATA()
         },
         .cell_confs = {
             [(int)SettingsUI_ScreenAboutCellIndex::SYSTEM_FIRMWARE_VERSION] =
-            SETTINGS_UI_360_360_SCREEN_ABOUT_ELEMENT_CONF_SYSTEM_NAME("Firmware version"),
+            SETTINGS_UI_360_360_SCREEN_ABOUT_ELEMENT_CONF_SYSTEM_NAME("Firmware"),
             [(int)SettingsUI_ScreenAboutCellIndex::SYSTEM_OS_NAME] =
             SETTINGS_UI_360_360_SCREEN_ABOUT_ELEMENT_CONF_SYSTEM_NAME("OS"),
             [(int)SettingsUI_ScreenAboutCellIndex::SYSTEM_OS_VERSION] =

apps/brookesia_app_squareline_demo/idf_component.yml

@@ -1,7 +1,7 @@
 version: 0.6.0
 dependencies:
   brookesia_core:
-    version: "0.6.*"
+    version: "*"
     public: true
 
   espressif/esp-lib-utils:

core/brookesia_core/CHANGELOG.md

@@ -1,5 +1,12 @@
 # ChangeLog
 
+## v0.6.0-beta2 - 2025-07-08
+
+### Bugfixes:
+
+* fix(ai_framework): prevent Agent from being awakened within apps
+* fix(systems): shorten animation filename to avoid warning
+
 ## v0.6.0-beta1 - 2025-07-04
 
 ### Breaking Changes:

core/brookesia_core/ai_framework/agent/esp_brookesia_ai_agent.cpp

@@ -143,6 +143,36 @@ bool Agent::del()
     return ret;
 }
 
+bool Agent::pause()
+{
+    ESP_UTILS_LOG_TRACE_GUARD_WITH_THIS();
+
+    if (_flags.is_paused) {
+        ESP_UTILS_LOGW("Already paused");
+        return true;
+    }
+
+    coze_chat_app_pause();
+    _flags.is_paused = true;
+
+    return true;
+}
+
+bool Agent::resume()
+{
+    ESP_UTILS_LOG_TRACE_GUARD_WITH_THIS();
+
+    if (!_flags.is_paused) {
+        ESP_UTILS_LOGW("Not paused");
+        return true;
+    }
+
+    coze_chat_app_resume();
+    _flags.is_paused = false;
+
+    return true;
+}
+
 bool Agent::setCurrentRobotIndex(int index)
 {
     ESP_UTILS_LOG_TRACE_GUARD_WITH_THIS();
@@ -189,7 +219,7 @@ bool Agent::sendChatEvent(const ChatEvent &event, bool clear_queue, int wait_fin
     ESP_UTILS_LOG_TRACE_GUARD_WITH_THIS();
 
     ESP_UTILS_LOGD(
-        "Param: event(%d), clear_queue(%d), wait_finish_timeout_ms(%d)", static_cast<int>(event),
+        "Param: event(%s), clear_queue(%d), wait_finish_timeout_ms(%d)", chatEventToString(event).c_str(),
         clear_queue, wait_finish_timeout_ms
     );
     ESP_UTILS_CHECK_FALSE_RETURN(_flags.is_begun, false, "Not begun");
@@ -210,7 +240,7 @@ bool Agent::sendChatEvent(const ChatEvent &event, bool clear_queue, int wait_fin
             while (!_chat_event_queue.empty()) {
                 auto event_wrapper_tmp = _chat_event_queue.front();
                 _chat_event_queue.pop();
-                ESP_UTILS_LOGD("Pop event: %d", static_cast<int>(event_wrapper_tmp.event));
+                ESP_UTILS_LOGD("Pop event: %s", chatEventToString(event_wrapper_tmp.event).c_str());
             }
         }
         _chat_event_queue.push(event_wrapper);
@@ -223,7 +253,8 @@ bool Agent::sendChatEvent(const ChatEvent &event, bool clear_queue, int wait_fin
     }
 
     ESP_UTILS_LOGD(
-        "Wait chat event finish: %d, timeout_ms(%d)", static_cast<int>(event_wrapper.event), wait_finish_timeout_ms
+        "Wait chat event finish: %s, timeout_ms(%d)", chatEventToString(event_wrapper.event).c_str(),
+        wait_finish_timeout_ms
     );
     auto future = event_wrapper.promise->get_future();
     ESP_UTILS_CHECK_FALSE_RETURN(
@@ -257,6 +288,56 @@ void Agent::releaseInstance()
     }
 }
 
+std::string Agent::chatStateToString(const ChatState &state)
+{
+    switch (state) {
+    case ChatState::ChatStateDeinit:
+        return "Deinit";
+    case ChatState::ChatStateIniting:
+        return "Initing";
+    case ChatState::ChatStateInited:
+        return "Inited";
+    case ChatState::ChatStateStopping:
+        return "Stopping";
+    case ChatState::ChatStateStopped:
+        return "Stopped";
+    case ChatState::ChatStateStarting:
+        return "Starting";
+    case ChatState::ChatStateStarted:
+        return "Started";
+    case ChatState::ChatStateSleeping:
+        return "Sleeping";
+    case ChatState::ChatStateSlept:
+        return "Slept";
+    case ChatState::ChatStateWaking:
+        return "Waking";
+    case ChatState::ChatStateWaked:
+        return "Waked";
+    default:
+        return "Unknown";
+    }
+}
+
+std::string Agent::chatEventToString(const ChatEvent &event)
+{
+    switch (event) {
+    case ChatEvent::Deinit:
+        return "Deinit";
+    case ChatEvent::Init:
+        return "Init";
+    case ChatEvent::Stop:
+        return "Stop";
+    case ChatEvent::Start:
+        return "Start";
+    case ChatEvent::Sleep:
+        return "Sleep";
+    case ChatEvent::WakeUp:
+        return "WakeUp";
+    default:
+        return "Unknown";
+    }
+}
+
 bool Agent::isTimeSync()
 {
     time_t now;
@@ -271,22 +352,24 @@ bool Agent::processChatEvent(const ChatEvent &event)
 {
     ESP_UTILS_LOG_TRACE_GUARD_WITH_THIS();
 
-    ESP_UTILS_LOGD("Process chat event: %d", static_cast<int>(event));
+    ESP_UTILS_LOGD("Process chat event: %s", chatEventToString(event).c_str());
     ESP_UTILS_LOGD(
-        "Current chat state(%d), last chat event(%d)", static_cast<int>(_chat_state),
-        static_cast<int>(_last_chat_event)
+        "Current chat state(%s), last chat event(%s)", chatStateToString(_chat_state).c_str(),
+        chatEventToString(_last_chat_event).c_str()
     );
 
+    if (event == _last_chat_event) {
+        ESP_UTILS_LOGW("Chat event already processed");
+        return true;
+    }
+
     chat_event_process_start_signal(event, _last_chat_event);
 
     switch (event) {
     case ChatEvent::Deinit:
         break;
     case ChatEvent::Init: {
-        if (hasChatState(_ChatStateInit)) {
-            ESP_UTILS_LOGW("Chat already initing or inited");
-            return true;
-        }
+        ESP_UTILS_CHECK_FALSE_RETURN(isChatState(ChatStateDeinit), false, "Chat not deinit");
 
         {
             esp_utils::value_guard chat_state_guard(_chat_state);
@@ -315,19 +398,12 @@ bool Agent::processChatEvent(const ChatEvent &event)
         break;
     }
     case ChatEvent::Stop: {
-        if (hasChatState(_ChatStateStop)) {
-            ESP_UTILS_LOGW("Chat already stopping or stopped");
-            return true;
-        }
-        ESP_UTILS_CHECK_FALSE_RETURN(
-            hasChatState(_ChatStateStart), false, "Invalid chat state(%d)", static_cast<int>(_chat_state)
-        );
+        ESP_UTILS_CHECK_FALSE_RETURN(hasChatState(ChatStateStarted), false, "Invalid chat state");
 
         {
             esp_utils::value_guard chat_state_guard(_chat_state);
             chat_state_guard.set(ChatStateStopping);
 
-            coze_chat_app_pause();
             ESP_UTILS_CHECK_FALSE_RETURN(coze_chat_app_stop() == ESP_OK, false, "Stop chat failed");
 
             chat_state_guard.set(ChatStateStopped);
@@ -336,13 +412,11 @@ bool Agent::processChatEvent(const ChatEvent &event)
         break;
     }
     case ChatEvent::Start: {
-        if (hasChatState(_ChatStateStart)) {
-            ESP_UTILS_LOGW("Chat already starting or started");
+        if (hasChatState(ChatStateStarted)) {
+            ESP_UTILS_LOGW("Chat already started");
             return true;
         }
-        ESP_UTILS_CHECK_FALSE_RETURN(
-            hasChatState(ChatStateInited), false, "Invalid chat state(%d)", static_cast<int>(_chat_state)
-        );
+        ESP_UTILS_CHECK_FALSE_RETURN(hasChatState(ChatStateInited), false, "Invalid chat state");
 
         {
             esp_utils::value_guard chat_state_guard(_chat_state);
@@ -370,58 +444,38 @@ bool Agent::processChatEvent(const ChatEvent &event)
                 chat_event_process_special_signal(ChatEventSpecialSignalType::StartMaxRetry);
                 ESP_UTILS_CHECK_FALSE_RETURN(false, false, "Start chat failed after %d retries", max_retries);
             }
-            coze_chat_app_resume();
-            _flags.is_sleep = false;
-            _flags.is_paused = false;
 
             chat_state_guard.set(ChatStateStarted);
             chat_state_guard.release();
         }
         break;
     }
-    case ChatEvent::Pause: {
-        if (_flags.is_paused) {
-            ESP_UTILS_LOGW("Chat already paused");
-            return true;
-        }
-        ESP_UTILS_CHECK_FALSE_RETURN(hasChatState(_ChatStateStart), false, "Chat not started");
-
-        coze_chat_app_pause();
-        _flags.is_paused = true;
-        break;
-    }
-    case ChatEvent::Resume: {
-        if (!_flags.is_paused) {
-            ESP_UTILS_LOGW("Chat not paused");
-            return true;
-        }
-        ESP_UTILS_CHECK_FALSE_RETURN(hasChatState(_ChatStateStart), false, "Chat not started");
-
-        coze_chat_app_resume();
-        _flags.is_paused = false;
-        break;
-    }
     case ChatEvent::Sleep: {
-        if (_flags.is_sleep) {
-            ESP_UTILS_LOGW("Chat already sleep");
-            return true;
-        }
-        ESP_UTILS_CHECK_FALSE_RETURN(hasChatState(_ChatStateStart), false, "Chat not started");
+        ESP_UTILS_CHECK_FALSE_RETURN(hasChatState(ChatStateStarted), false, "Chat not started");
+
+        esp_utils::value_guard chat_state_guard(_chat_state);
+        chat_state_guard.set(ChatStateSleeping);
 
-        // Should be called before set chat state to sleep
         coze_chat_app_sleep();
-        _flags.is_sleep = true;
+
+        chat_state_guard.set(ChatStateSlept);
+        chat_state_guard.release();
         break;
     }
     case ChatEvent::WakeUp: {
-        if (!_flags.is_sleep) {
-            ESP_UTILS_LOGW("Chat not sleep");
+        if (isChatState(ChatStateStarted)) {
+            ESP_UTILS_LOGW("Chat already woke up");
             return true;
         }
-        ESP_UTILS_CHECK_FALSE_RETURN(hasChatState(_ChatStateStart), false, "Chat not started");
+        ESP_UTILS_CHECK_FALSE_RETURN(isChatState(ChatStateSlept), false, "Chat not slept");
+
+        esp_utils::value_guard chat_state_guard(_chat_state);
+        chat_state_guard.set(ChatStateWaking);
 
         coze_chat_app_wakeup();
-        _flags.is_sleep = false;
+
+        chat_state_guard.set(ChatStateWaked);
+        chat_state_guard.release();
         break;
     }
     default: