From f9857e31ae5c71df2b5c392aa59068c883d0c344 Mon Sep 17 00:00:00 2001 From: Liu Zhong Wei Date: Mon, 2 Sep 2024 14:28:57 +0800 Subject: [PATCH] fix(app_examples): fix the incorrect version in the 'complex_conf' yml file --- CHANGELOG.md | 11 +- ... => esp_ui_phone_wallpaper_image_dark.svg} | 0 .../phone/complex_conf/idf_component.yml | 2 +- src/core/esp_ui_core_app.cpp | 139 ++++++++++++------ src/core/esp_ui_core_app.hpp | 35 +++-- src/core/esp_ui_core_home.cpp | 35 +++++ src/core/esp_ui_core_home.hpp | 5 +- src/core/esp_ui_core_manager.cpp | 13 +- src/core/esp_ui_template.hpp | 139 +++++++----------- src/systems/phone/esp_ui_phone.cpp | 3 +- src/systems/phone/esp_ui_phone_home.cpp | 53 ++++--- src/systems/phone/esp_ui_phone_home.hpp | 3 +- src/systems/phone/stylesheet/dark/core_data.h | 5 +- .../phone/stylesheet/dark/gesture_data.h | 10 +- src/widgets/status_bar/esp_ui_status_bar.cpp | 2 +- 15 files changed, 274 insertions(+), 181 deletions(-) rename docs/_static/phone/{esp_ui_phone_wallpaper_image_drak.svg => esp_ui_phone_wallpaper_image_dark.svg} (100%) diff --git a/CHANGELOG.md b/CHANGELOG.md index 77a56db..5c8244a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,11 +1,20 @@ # ChangeLog -## v0.2.1 - 2024-08-26 +## v0.2.1 - 2024-09-02 + +### Enhancements: + +* feat(core): add support for getting app visual area post-installation +* feat(core): improve app resource clean operations ### Bugfixes: * fix(docs): fix the video that cannot be previewed * fix(version): fix the macro definitions that are out of sync with the version +* fix(app_examples): fix the incorrect version in the 'complex_conf' yml file by @isthaison (#8) +* fix(phone): set default app launcher icon when no custom icon is provided +* fix(status_bar): use correct state when set battery charging flag +* fix(phone): correct the typo from 'drak' to 'dark' ## v0.2.0 - 2024-08-20 diff --git a/docs/_static/phone/esp_ui_phone_wallpaper_image_drak.svg b/docs/_static/phone/esp_ui_phone_wallpaper_image_dark.svg similarity index 100% rename from docs/_static/phone/esp_ui_phone_wallpaper_image_drak.svg rename to docs/_static/phone/esp_ui_phone_wallpaper_image_dark.svg diff --git a/src/app_examples/phone/complex_conf/idf_component.yml b/src/app_examples/phone/complex_conf/idf_component.yml index ad8b1ae..fb232a1 100644 --- a/src/app_examples/phone/complex_conf/idf_component.yml +++ b/src/app_examples/phone/complex_conf/idf_component.yml @@ -5,5 +5,5 @@ dependencies: version: ">=8.3,<9" public: true esp-ui: - version: "0.1.*" + version: "0.2.*" public: true diff --git a/src/core/esp_ui_core_app.cpp b/src/core/esp_ui_core_app.cpp index ad86aff..cf50f55 100644 --- a/src/core/esp_ui_core_app.cpp +++ b/src/core/esp_ui_core_app.cpp @@ -36,6 +36,7 @@ ESP_UI_CoreApp::ESP_UI_CoreApp(const ESP_UI_CoreAppData_t &data): _resource_anim_count(0), _resource_head_screen_index(0), _resource_screen_count(0), + _last_screen(nullptr), _active_screen(nullptr), _resource_head_timer(nullptr), _resource_head_anim(nullptr) @@ -54,6 +55,7 @@ ESP_UI_CoreApp::ESP_UI_CoreApp(const char *name, const void *launcher_icon, bool _resource_anim_count(0), _resource_head_screen_index(0), _resource_screen_count(0), + _last_screen(nullptr), _active_screen(nullptr), _resource_head_timer(nullptr), _resource_head_anim(nullptr) @@ -97,7 +99,7 @@ void ESP_UI_CoreApp::setLauncherIconImage(const ESP_UI_StyleImage_t &icon_image) bool ESP_UI_CoreApp::startRecordResource(void) { lv_disp_t *disp = nullptr; - lv_area_t &visual_area = _app_style.visual_area; + lv_area_t &visual_area = _app_style.calibrate_visual_area; ESP_UI_CHECK_FALSE_RETURN(checkInitialized(), false, "Not initialized"); ESP_UI_LOGD("App(%s: %d) start record resource", getName(), _id); @@ -134,7 +136,7 @@ bool ESP_UI_CoreApp::endRecordResource(void) lv_obj_t *screen = nullptr; lv_timer_t *timer_node = nullptr; lv_anim_t *anim_node = nullptr; - const lv_area_t &visual_area = _app_style.visual_area; + const lv_area_t &visual_area = _app_style.calibrate_visual_area; ESP_UI_CHECK_FALSE_RETURN(checkInitialized(), false, "Not initialized"); ESP_UI_LOGD("App(%s: %d) end record resource", getName(), _id); @@ -245,36 +247,57 @@ bool ESP_UI_CoreApp::cleanRecordResource(void) ESP_UI_LOGD("App(%s: %d) clean resource", getName(), _id); bool ret = true; - uint32_t resource_loop_count = 0; - std::list resource_screens = _resource_screens; + bool do_clean = false; + int resource_loop_count = 0; + int resource_clean_count = 0; + lv_disp_t *disp = nullptr; + lv_obj_t *screen_node = nullptr; lv_timer_t *timer_node = nullptr; lv_anim_t *anim_node = nullptr; + disp = _core->getDisplayDevice(); + ESP_UI_CHECK_NULL_RETURN(disp, false, "Invalid display"); + // Screen - for (auto screen : resource_screens) { - auto screen_map_it = _resource_screens_class_parent_map.find(screen); - if (screen_map_it == _resource_screens_class_parent_map.end()) { - ESP_UI_LOGE("Screen class parent map not found"); - } else { - if ((screen->class_p == screen_map_it->second.first) && - (screen->parent == screen_map_it->second.second)) { - if (lv_obj_is_valid(screen)) { - lv_obj_del(screen); - _resource_screens.erase(find(_resource_screens.begin(), _resource_screens.end(), screen)); - } + resource_loop_count = 0; + resource_clean_count = 0; + for (int i = 0; (i < (int)disp->screen_cnt) && (resource_loop_count++ < RESOURCE_LOOP_COUNT_MAX);) { + do_clean = false; + screen_node = (lv_obj_t *)disp->screens[i]; + auto screen_it = find(_resource_screens.begin(), _resource_screens.end(), screen_node); + if (screen_it != _resource_screens.end()) { + auto screen_map_it = _resource_screens_class_parent_map.find(screen_node); + if (screen_map_it == _resource_screens_class_parent_map.end()) { + ESP_UI_LOGE("Screen class parent map not found"); } else { - ESP_UI_LOGD("Screen(@0x%p) information is not matched, skip", screen); + if ((screen_node->class_p == screen_map_it->second.first) && + (screen_node->parent == screen_map_it->second.second)) { + lv_obj_del(screen_node); + do_clean = true; + resource_clean_count++; + } else { + ESP_UI_LOGD("Screen(@0x%p) information is not matched, skip", screen_node); + } + _resource_screens.erase(screen_it); + _resource_screens_class_parent_map.erase(screen_map_it); } } + i = do_clean ? 0 : i + 1; + } + if (resource_loop_count >= RESOURCE_LOOP_COUNT_MAX) { + ret = false; + ESP_UI_LOGE("Clean screen loop count exceed max"); + } else { + ESP_UI_LOGD("Clean screen(%d), miss(%d): ", resource_clean_count, (int)(_resource_screen_count - resource_clean_count)); } - ESP_UI_LOGD("Clean screen(%d), miss(%d): ", _resource_screen_count - (int)_resource_screens.size(), - (int)_resource_screens.size()); // Timer resource_loop_count = 0; + resource_clean_count = 0; timer_node = lv_timer_get_next(nullptr); while ((timer_node != nullptr) && (_resource_timers.size() > 0) && (resource_loop_count++ < RESOURCE_LOOP_COUNT_MAX)) { + do_clean = false; auto timer_it = find(_resource_timers.begin(), _resource_timers.end(), timer_node); if (timer_it != _resource_timers.end()) { auto timer_map_it = _resource_timers_cb_usr_map.find(timer_node); @@ -284,30 +307,31 @@ bool ESP_UI_CoreApp::cleanRecordResource(void) if ((timer_map_it->second.first == timer_node->timer_cb) && (timer_map_it->second.second == timer_node->user_data)) { lv_timer_del(timer_node); - _resource_timers.erase(timer_it); - timer_node = lv_timer_get_next(nullptr); - break; + do_clean = true; + resource_clean_count++; } else { ESP_UI_LOGD("Timer(@0x%p) information is not matched, skip", timer_node); } _resource_timers.erase(timer_it); + _resource_timers_cb_usr_map.erase(timer_map_it); } } - timer_node = lv_timer_get_next(timer_node); + timer_node = do_clean ? lv_timer_get_next(nullptr) : lv_timer_get_next(timer_node); } if (resource_loop_count >= RESOURCE_LOOP_COUNT_MAX) { ret = false; ESP_UI_LOGE("Clean timer loop count exceed max"); } else { - ESP_UI_LOGD("Clean timer(%d), miss(%d): ", _resource_timer_count - (int)_resource_timers.size(), - (int)_resource_timers.size()); + ESP_UI_LOGD("Clean timer(%d), miss(%d): ", resource_clean_count, _resource_timer_count - resource_clean_count); } // Animation resource_loop_count = 0; + resource_clean_count = 0; anim_node = (lv_anim_t *)_lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll)); while ((anim_node != nullptr) && (_resource_anims.size() > 0) && (resource_loop_count++ < RESOURCE_LOOP_COUNT_MAX)) { + do_clean = false; auto anim_it = find(_resource_anims.begin(), _resource_anims.end(), anim_node); if (anim_it != _resource_anims.end()) { auto anim_map_it = _resource_anims_var_exec_map.find(anim_node); @@ -317,26 +341,26 @@ bool ESP_UI_CoreApp::cleanRecordResource(void) if ((anim_map_it->second.first == anim_node->var) && (anim_map_it->second.second == anim_node->exec_cb)) { if (lv_anim_del(anim_node->var, anim_node->exec_cb)) { - _resource_anims.erase(anim_it); - anim_node = (lv_anim_t *)_lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll)); - continue; + do_clean = true; + resource_clean_count++; } else { ESP_UI_LOGE("Delete animation failed"); } - _resource_anims.erase(anim_it); } else { ESP_UI_LOGD("Anim(@0x%p) information is not matched, skip", anim_node); } + _resource_anims.erase(anim_it); + _resource_anims_var_exec_map.erase(anim_map_it); } } - anim_node = (lv_anim_t *)_lv_ll_get_next(&LV_GC_ROOT(_lv_anim_ll), anim_node); + anim_node = do_clean ? (lv_anim_t *)_lv_ll_get_head(&LV_GC_ROOT(_lv_anim_ll)) : + (lv_anim_t *)_lv_ll_get_next(&LV_GC_ROOT(_lv_anim_ll), anim_node); } if (resource_loop_count >= RESOURCE_LOOP_COUNT_MAX) { ret = false; ESP_UI_LOGE("Clean timer loop count exceed max"); } else { - ESP_UI_LOGD("Clean anim(%d), miss(%d): ", _resource_anim_count - (int)_resource_anims.size(), - (int)_resource_anims.size()); + ESP_UI_LOGD("Clean anim(%d), miss(%d): ", resource_clean_count, _resource_anim_count - resource_clean_count); } ESP_UI_CHECK_FALSE_RETURN(resetRecordResource(), false, "Reset record resource failed"); @@ -407,28 +431,35 @@ bool ESP_UI_CoreApp::processUninstall(void) return true; } -bool ESP_UI_CoreApp::processRun(lv_area_t area) +bool ESP_UI_CoreApp::processRun() { bool ret = true; ESP_UI_CHECK_FALSE_RETURN(checkInitialized(), false, "Not initialized"); ESP_UI_LOGD("App(%s: %d) run", getName(), _id); - ESP_UI_CHECK_FALSE_RETURN(setVisualArea(area), false, "Set app visual area failed"); // TODO // if (_flags.is_screen_small) { // // Create a temp screen to recolor the background // ESP_UI_CHECK_FALSE_RETURN(createAndloadTempScreen(), false, "Create temp screen failed"); // } + ESP_UI_CHECK_FALSE_RETURN(saveRecentScreen(false), false, "Save recent screen before run failed"); ESP_UI_CHECK_FALSE_RETURN(resetRecordResource(), false, "Reset record resource failed"); ESP_UI_CHECK_FALSE_RETURN(startRecordResource(), false, "Start record resource failed"); if (_core_active_data.flags.enable_default_screen) { ESP_UI_CHECK_FALSE_RETURN(initDefaultScreen(), false, "Create active screen failed"); } ESP_UI_CHECK_FALSE_RETURN(saveDisplayTheme(), false, "Save display theme failed"); - ret = run(); - ESP_UI_CHECK_FALSE_RETURN(saveRecentScreen(), false, "Save recent screen failed"); + ESP_UI_LOGD("Do run"); + if (!run()) { + ESP_UI_LOGE("Run app failed"); + ret = false; + } ESP_UI_CHECK_FALSE_RETURN(endRecordResource(), false, "Start record resource failed"); + if (!saveRecentScreen(true)) { + ESP_UI_LOGE("Save recent screen after run failed"); + ret = false; + } ESP_UI_CHECK_FALSE_GOTO(ret, err, "App run failed"); _status = ESP_UI_CORE_APP_STATUS_RUNNING; @@ -479,7 +510,7 @@ bool ESP_UI_CoreApp::processPause(void) ESP_UI_LOGE("Pause failed"); } ESP_UI_CHECK_FALSE_GOTO(saveAppTheme(), err, "Save app theme failed"); - ESP_UI_CHECK_FALSE_GOTO(saveRecentScreen(), err, "Save recent screen failed"); + ESP_UI_CHECK_FALSE_GOTO(saveRecentScreen(false), err, "Save recent screen failed"); ESP_UI_CHECK_FALSE_GOTO(loadDisplayTheme(), err, "Load display theme failed"); _status = ESP_UI_CORE_APP_STATUS_PAUSED; @@ -506,7 +537,7 @@ bool ESP_UI_CoreApp::processClose(bool is_app_active) // Otherwise, clean the resource when the screen is unloaded if (is_app_active) { // Save the last screen - ESP_UI_CHECK_FALSE_GOTO(saveRecentScreen(), err, "Save recent screen failed"); + ESP_UI_CHECK_FALSE_GOTO(saveRecentScreen(false), err, "Save recent screen failed"); // This is to prevent the screen from being cleaned before the screen is unloaded ESP_UI_CHECK_FALSE_GOTO(enableAutoClean(), err, "Enable auto clean failed"); } else { @@ -534,17 +565,29 @@ bool ESP_UI_CoreApp::processClose(bool is_app_active) } bool ESP_UI_CoreApp::setVisualArea(const lv_area_t &area) +{ + ESP_UI_CHECK_FALSE_RETURN(checkInitialized(), false, "Not initialized"); + ESP_UI_LOGD("App(%s: %d) set origin visual area[(%d,%d)-(%d,%d)]", getName(), + _id, area.x1, area.y1, area.x2, area.y2); + + _app_style.origin_visual_area = area; + + return true; +} + +bool ESP_UI_CoreApp::calibrateVisualArea(void) { uint16_t visual_area_x = 0; uint16_t visual_area_y = 0; uint16_t visual_area_w = 0; uint16_t visual_area_h = 0; - lv_area_t visual_area = area; + lv_area_t visual_area = _app_style.origin_visual_area; const ESP_UI_StyleSize_t &screen_size = _core->getCoreData().screen_size; const ESP_UI_StyleSize_t &app_size = getCoreActiveData().screen_size; ESP_UI_CHECK_FALSE_RETURN(checkInitialized(), false, "Not initialized"); - ESP_UI_LOGD("App(%s: %d) set visual area(%d,%d-%d,%d)", getName(), _id, area.x1, area.y1, area.x2, area.y2); + ESP_UI_LOGD("App(%s: %d) calibrate visual area[origin: (%d,%d)-(%d,%d)]", getName(), + _id, visual_area.x1, visual_area.y1, visual_area.x2, visual_area.y2); visual_area_w = visual_area.x2 - visual_area.x1 + 1; visual_area_h = visual_area.y2 - visual_area.y1 + 1; @@ -562,18 +605,20 @@ bool ESP_UI_CoreApp::setVisualArea(const lv_area_t &area) visual_area.y1 = visual_area_y; visual_area.x2 = visual_area_x + visual_area_w - 1; visual_area.y2 = visual_area_y + visual_area_h - 1; - _app_style.visual_area = visual_area; + _app_style.calibrate_visual_area = visual_area; _flags.is_screen_small = ((lv_area_get_height(&visual_area) < screen_size.height) || (lv_area_get_width(&visual_area) < screen_size.width)); + ESP_UI_LOGD("Calibrate visual area(%d,%d-%d,%d)", visual_area.x1, visual_area.y1, visual_area.x2, visual_area.y2); + return true; } bool ESP_UI_CoreApp::initDefaultScreen(void) { ESP_UI_CHECK_FALSE_RETURN(checkInitialized(), false, "Not initialized"); - ESP_UI_LOGD("App(%s: %d) init active screen", getName(), _id); + ESP_UI_LOGD("App(%s: %d) init default screen", getName(), _id); _active_screen = lv_obj_create(nullptr); ESP_UI_CHECK_NULL_RETURN(_active_screen, false, "Create default screen failed"); @@ -603,13 +648,19 @@ bool ESP_UI_CoreApp::cleanDefaultScreen(void) return true; } -bool ESP_UI_CoreApp::saveRecentScreen(void) +bool ESP_UI_CoreApp::saveRecentScreen(bool check_valid) { ESP_UI_CHECK_FALSE_RETURN(checkInitialized(), false, "Not initialized"); ESP_UI_LOGD("App(%s: %d) save recent screen", getName(), _id); - _active_screen = lv_disp_get_scr_act(_core->getDisplayDevice()); - ESP_UI_CHECK_NULL_RETURN(_active_screen, false, "Invalid active screen"); + lv_obj_t *active_screen = lv_disp_get_scr_act(_core->getDisplayDevice()); + ESP_UI_CHECK_FALSE_RETURN(active_screen != nullptr, false, "Invalid active screen"); + + if (check_valid) { + ESP_UI_CHECK_FALSE_RETURN(active_screen != _last_screen, false, "No app screen"); + } + _active_screen = active_screen; + _last_screen = active_screen; return true; } diff --git a/src/core/esp_ui_core_app.hpp b/src/core/esp_ui_core_app.hpp index d0fce1d..823b181 100644 --- a/src/core/esp_ui_core_app.hpp +++ b/src/core/esp_ui_core_app.hpp @@ -98,9 +98,9 @@ class ESP_UI_CoreApp { * @return area: the visual area of the app * */ - const lv_area_t & getVisualArea(void) const + const lv_area_t &getVisualArea(void) const { - return _app_style.visual_area; + return _app_style.calibrate_visual_area; } /** @@ -125,6 +125,17 @@ class ESP_UI_CoreApp { return _core_active_data; } + /** + * @brief Get the core object. + * + * @return core: used to access the core functions + * + */ + ESP_UI_Core *getCore(void) const + { + return _core; + } + protected: /** * @brief Called when the app starts running. This is the entry point for the app, where all UI resources should be @@ -303,31 +314,21 @@ class ESP_UI_CoreApp { */ bool cleanRecordResource(void); - /** - * @brief Get the core object. - * - * @return core: used to access the core functions - * - */ - ESP_UI_Core *getCore(void) const - { - return _core; - } - private: virtual bool beginExtra(void) { return true; } virtual bool delExtra(void) { return true; } virtual bool processInstall(ESP_UI_Core *core, int id); virtual bool processUninstall(void); - virtual bool processRun(lv_area_t area); + virtual bool processRun(void); virtual bool processResume(void); virtual bool processPause(void); virtual bool processClose(bool is_app_active); bool setVisualArea(const lv_area_t &area); + bool calibrateVisualArea(void); bool initDefaultScreen(void); bool cleanDefaultScreen(void); - bool saveRecentScreen(void); + bool saveRecentScreen(bool check_valid); bool loadRecentScreen(void); bool resetRecordResource(void); bool enableAutoClean(void); @@ -360,7 +361,8 @@ class ESP_UI_CoreApp { lv_theme_t *theme; } _display_style; struct { - lv_area_t visual_area; + lv_area_t origin_visual_area; + lv_area_t calibrate_visual_area; lv_theme_t *theme; } _app_style; // Resources @@ -368,6 +370,7 @@ class ESP_UI_CoreApp { int _resource_anim_count; int _resource_head_screen_index; int _resource_screen_count; + lv_obj_t *_last_screen; lv_obj_t *_active_screen; // lv_obj_t *_temp_screen; lv_timer_t *_resource_head_timer; diff --git a/src/core/esp_ui_core_home.cpp b/src/core/esp_ui_core_home.cpp index 7253523..0082666 100644 --- a/src/core/esp_ui_core_home.cpp +++ b/src/core/esp_ui_core_home.cpp @@ -137,6 +137,40 @@ bool ESP_UI_CoreHome::calibrateCoreObjectSize(const ESP_UI_StyleSize_t &parent, return true; } +bool ESP_UI_CoreHome::calibrateCoreObjectSize(const ESP_UI_StyleSize_t &parent, ESP_UI_StyleSize_t &target, + bool check_width, bool check_height) const +{ + uint16_t parent_w = 0; + uint16_t parent_h = 0; + + parent_w = parent.width; + parent_h = parent.height; + + // Check width + if (target.flags.enable_width_percent) { + ESP_UI_CHECK_VALUE_RETURN(target.width_percent, 1, 100, false, "Invalid width percent"); + target.width = (parent_w * target.width_percent) / 100; + } else if (check_width) { + ESP_UI_CHECK_VALUE_RETURN(target.width, 1, parent_w, false, "Invalid width"); + } + + // Check height + if (target.flags.enable_height_percent) { + ESP_UI_CHECK_VALUE_RETURN(target.height_percent, 1, 100, false, "Invalid Height percent"); + target.height = (parent_h * target.height_percent) / 100; + } else if (check_height) { + ESP_UI_CHECK_VALUE_RETURN(target.height, 1, parent_h, false, "Invalid Height"); + } + + // Process square + if (target.flags.enable_square) { + target.width = min(target.width, target.height); + target.height = target.width; + } + + return true; +} + bool ESP_UI_CoreHome::calibrateCoreObjectSize(const ESP_UI_StyleSize_t &parent, ESP_UI_StyleSize_t &target, bool allow_zero) const { @@ -258,6 +292,7 @@ bool ESP_UI_CoreHome::beginCore(void) // Container styles for (auto &style : _container_styles) { lv_style_init(&style); + lv_style_set_size(&style, LV_SIZE_CONTENT); lv_style_set_radius(&style, 0); lv_style_set_border_width(&style, 0); lv_style_set_pad_all(&style, 0); diff --git a/src/core/esp_ui_core_home.hpp b/src/core/esp_ui_core_home.hpp index c535d7d..b7790a8 100644 --- a/src/core/esp_ui_core_home.hpp +++ b/src/core/esp_ui_core_home.hpp @@ -27,6 +27,8 @@ class ESP_UI_CoreHome { bool showContainerBorder(void); bool hideContainerBorder(void); bool calibrateCoreObjectSize(const ESP_UI_StyleSize_t &parent, ESP_UI_StyleSize_t &target) const; + bool calibrateCoreObjectSize(const ESP_UI_StyleSize_t &parent, ESP_UI_StyleSize_t &target, + bool check_width, bool check_height) const; bool calibrateCoreObjectSize(const ESP_UI_StyleSize_t &parent, ESP_UI_StyleSize_t &target, bool allow_zero) const; bool calibrateCoreFont(const ESP_UI_StyleSize_t *parent, ESP_UI_StyleFont_t &target) const; bool calibrateCoreIconImage(const ESP_UI_StyleImage_t &target) const; @@ -47,11 +49,12 @@ class ESP_UI_CoreHome { private: virtual bool processAppInstall(ESP_UI_CoreApp *app) = 0; virtual bool processAppUninstall(ESP_UI_CoreApp *app) = 0; - virtual bool processAppRun(ESP_UI_CoreApp *app, lv_area_t &app_visual_area) = 0; + virtual bool processAppRun(ESP_UI_CoreApp *app) = 0; virtual bool processAppResume(ESP_UI_CoreApp *app) { return true; } virtual bool processAppPause(ESP_UI_CoreApp *app) { return true; } virtual bool processAppClose(ESP_UI_CoreApp *app) { return true; } virtual bool processMainScreenLoad(void); + virtual bool getAppVisualArea(ESP_UI_CoreApp *app, lv_area_t &app_visual_area) const { return true; } bool beginCore(void); bool delCore(void); diff --git a/src/core/esp_ui_core_manager.cpp b/src/core/esp_ui_core_manager.cpp index 1fdf8a8..e5d563f 100644 --- a/src/core/esp_ui_core_manager.cpp +++ b/src/core/esp_ui_core_manager.cpp @@ -39,6 +39,7 @@ int ESP_UI_CoreManager::installApp(ESP_UI_CoreApp *app) { bool app_installed = false; bool home_process_app_installed = false; + lv_area_t app_visual_area = {}; ESP_UI_CoreHome &home = _core._core_home; ESP_UI_CHECK_NULL_RETURN(app, -1, "Invalid app"); @@ -51,7 +52,10 @@ int ESP_UI_CoreManager::installApp(ESP_UI_CoreApp *app) } // Initialize app - ESP_UI_CHECK_FALSE_GOTO(app_installed = app->processInstall(&_core, _app_free_id), err, "app install failed"); + ESP_UI_CHECK_FALSE_GOTO(app_installed = app->processInstall(&_core, _app_free_id), err, "App install failed"); + ESP_UI_CHECK_FALSE_GOTO(home.getAppVisualArea(app, app_visual_area), err, "Home get app visual area failed"); + ESP_UI_CHECK_FALSE_GOTO(app->setVisualArea(app_visual_area), err, "App set visual area failed"); + ESP_UI_CHECK_FALSE_GOTO(app->calibrateVisualArea(), err, "App calibrate visual area failed"); // Process home ESP_UI_CHECK_FALSE_GOTO(home_process_app_installed = home.processAppInstall(app), err, @@ -189,18 +193,16 @@ bool ESP_UI_CoreManager::processAppRun(ESP_UI_CoreApp *app) { bool is_home_run = false; bool is_app_run = false; - lv_area_t app_visual_area = {}; ESP_UI_CoreHome &home = _core._core_home; ESP_UI_CHECK_NULL_RETURN(app, false, "Invalid app"); ESP_UI_LOGD("Process app(%d) run", app->_id); // Process home, and get the visual area of the app - ESP_UI_CHECK_FALSE_RETURN(is_home_run = home.processAppRun(app, app_visual_area), false, - "Process home before app run failed"); + ESP_UI_CHECK_FALSE_RETURN(is_home_run = home.processAppRun(app), false, "Process home before app run failed"); // Process app - ESP_UI_CHECK_FALSE_GOTO(is_app_run = app->processRun(app_visual_area), err, "Process app run failed"); + ESP_UI_CHECK_FALSE_GOTO(is_app_run = app->processRun(), err, "Process app run failed"); // Process extra ESP_UI_CHECK_FALSE_GOTO(processAppRunExtra(app), err, "Process app run extra failed"); @@ -217,6 +219,7 @@ bool ESP_UI_CoreManager::processAppRun(ESP_UI_CoreApp *app) if (is_app_run && !app->processClose(true)) { ESP_UI_LOGE("App process close failed"); } + ESP_UI_CHECK_FALSE_RETURN(home.processMainScreenLoad(), false, "Home load main screen failed"); return false; } diff --git a/src/core/esp_ui_template.hpp b/src/core/esp_ui_template.hpp index d0da885..ff02375 100644 --- a/src/core/esp_ui_template.hpp +++ b/src/core/esp_ui_template.hpp @@ -23,13 +23,13 @@ using ESP_UI_ResolutionNameStylesheetMap_t = std::map class ESP_UI_Template: public ESP_UI_Core { public: - ESP_UI_Template(const ESP_UI_CoreData_t &data, ESP_UI_CoreHome &home, ESP_UI_CoreManager &manager, + ESP_UI_Template(const ESP_UI_CoreData_t &core_data, ESP_UI_CoreHome &home, ESP_UI_CoreManager &manager, lv_disp_t *display); - virtual ~ESP_UI_Template() = 0; + virtual ~ESP_UI_Template(); - virtual bool calibrateStylesheet(const ESP_UI_StyleSize_t &screen_size, T &data) = 0; + virtual bool calibrateStylesheet(const ESP_UI_StyleSize_t &screen_size, T &stylesheet) = 0; - bool addStylesheet(const char *name, const ESP_UI_StyleSize_t &screen_size, const T &data); + bool addStylesheet(const char *name, const ESP_UI_StyleSize_t &screen_size, const T &stylesheet); bool activateStylesheet(const char *name, const ESP_UI_StyleSize_t &screen_size); size_t getStylesheetCount(void) const; @@ -68,6 +68,7 @@ class ESP_UI_Template: public ESP_UI_Core { protected: T _stylesheet; + bool calibrateResolutionSize(uint32_t &resolution, ESP_UI_StyleSize_t size) const; bool delTemplate(void); private: @@ -76,9 +77,9 @@ class ESP_UI_Template: public ESP_UI_Core { // *INDENT-OFF* template -ESP_UI_Template::ESP_UI_Template(const ESP_UI_CoreData_t &data, ESP_UI_CoreHome &home, +ESP_UI_Template::ESP_UI_Template(const ESP_UI_CoreData_t &core_data, ESP_UI_CoreHome &home, ESP_UI_CoreManager &manager, lv_disp_t *display): - ESP_UI_Core(data, home, manager, display), + ESP_UI_Core(core_data, home, manager, display), _stylesheet{} { } @@ -93,12 +94,11 @@ ESP_UI_Template::~ESP_UI_Template() } template -bool ESP_UI_Template::addStylesheet(const char *name, const ESP_UI_StyleSize_t &screen_size, const T &data) +bool ESP_UI_Template::addStylesheet(const char *name, const ESP_UI_StyleSize_t &screen_size, const T &stylesheet) { uint32_t resolution = 0; ESP_UI_StyleSize_t calibrate_size = screen_size; - ESP_UI_StyleSize_t display_size = {}; - std::shared_ptr calibration_data = std::make_shared(data); + std::shared_ptr calibration_stylesheet = std::make_shared(stylesheet); ESP_UI_CHECK_NULL_RETURN(name, false, "Invalid name"); @@ -109,21 +109,16 @@ bool ESP_UI_Template::addStylesheet(const char *name, const ESP_UI_StyleSize_ ESP_UI_CHECK_NULL_RETURN(_display, false, "Display device is not initialized"); } - display_size.width = lv_disp_get_hor_res(_display); - display_size.height = lv_disp_get_ver_res(_display); - ESP_UI_CHECK_FALSE_RETURN(_core_home.calibrateCoreObjectSize(display_size, calibrate_size), false, - "Invalid screen size"); - - resolution = (((uint32_t)calibrate_size.width) << 16) | calibrate_size.height; - ESP_UI_LOGD("Add data(%s - %dx%d)", name, calibrate_size.width, calibrate_size.height); + ESP_UI_CHECK_FALSE_RETURN(calibrateResolutionSize(resolution, calibrate_size), false, "Invalid screen size"); + ESP_UI_LOGD("Add stylesheet(%s - %dx%d)", name, calibrate_size.width, calibrate_size.height); - ESP_UI_CHECK_FALSE_RETURN(calibrateStylesheet(calibrate_size, *calibration_data), false, "Invalid data"); + ESP_UI_CHECK_FALSE_RETURN(calibrateStylesheet(calibrate_size, *calibration_stylesheet), false, "Invalid stylesheet"); // Check if the resolution is already exist auto it_resolution_map = _resolution_name_stylesheet_map.find(resolution); // If not exist, create a new map which contains the name and data if (it_resolution_map == _resolution_name_stylesheet_map.end()) { - _resolution_name_stylesheet_map[resolution][std::string(name)] = calibration_data; + _resolution_name_stylesheet_map[resolution][std::string(name)] = calibration_stylesheet; return true; } @@ -131,10 +126,10 @@ bool ESP_UI_Template::addStylesheet(const char *name, const ESP_UI_StyleSize_ auto it_name_map = it_resolution_map->second.find(name); // If exist, overwrite it, else add it if (it_name_map != it_resolution_map->second.end()) { - ESP_UI_LOGW("Data(%s) already exist, overwrite it", it_name_map->first.c_str()); - it_name_map->second = calibration_data; + ESP_UI_LOGW("Stylesheet(%s) already exist, overwrite it", it_name_map->first.c_str()); + it_name_map->second = calibration_stylesheet; } else { - it_resolution_map->second[name] = calibration_data; + it_resolution_map->second[name] = calibration_stylesheet; } return true; @@ -145,31 +140,20 @@ bool ESP_UI_Template::activateStylesheet(const char *name, const ESP_UI_Style { uint32_t resolution = 0; ESP_UI_StyleSize_t calibrate_size = screen_size; - ESP_UI_StyleSize_t display_size = {}; + const T *stylesheet = nullptr; ESP_UI_CHECK_NULL_RETURN(name, false, "Invalid name"); - ESP_UI_CHECK_NULL_RETURN(_display, false, "Display device is not initialized"); - display_size.width = lv_disp_get_hor_res(_display); - display_size.height = lv_disp_get_ver_res(_display); - ESP_UI_CHECK_FALSE_RETURN(_core_home.calibrateCoreObjectSize(display_size, calibrate_size), false, - "Invalid screen size"); - - resolution = (((uint32_t)calibrate_size.width) << 16) | calibrate_size.height; - ESP_UI_LOGD("Activate data(%s - %dx%d)", name, calibrate_size.width, calibrate_size.height); + ESP_UI_CHECK_FALSE_RETURN(calibrateResolutionSize(resolution, calibrate_size), false, "Invalid screen size"); + ESP_UI_LOGD("Activate stylesheet(%s - %dx%d)", name, calibrate_size.width, calibrate_size.height); - // Check if the resolution is already exist - auto it_resolution_map = _resolution_name_stylesheet_map.find(resolution); - ESP_UI_CHECK_FALSE_RETURN(it_resolution_map != _resolution_name_stylesheet_map.end(), false, "Resolution is not exist"); + stylesheet = getStylesheet(name, screen_size); + ESP_UI_CHECK_NULL_RETURN(stylesheet, false, "Get stylesheet failed"); - // If exist, check if the name is already exist - auto it_name_map = it_resolution_map->second.find(name); - ESP_UI_CHECK_FALSE_RETURN(it_name_map != it_resolution_map->second.end(), false, "Name is not exist"); + ESP_UI_Template::_stylesheet = *stylesheet; - ESP_UI_Template::_stylesheet = *it_name_map->second; - - if (checkCoreInitialized()) { - ESP_UI_CHECK_FALSE_RETURN(sendDataUpdateEvent(), false, "Send update data event failed"); + if (checkCoreInitialized() && !sendDataUpdateEvent()) { + ESP_UI_LOGE("Send update data event failed"); } return true; @@ -192,15 +176,8 @@ typename ESP_UI_NameStylesheetMap_t::iterator ESP_UI_Template::findNameSty { uint32_t resolution = 0; ESP_UI_StyleSize_t calibrate_size = screen_size; - ESP_UI_StyleSize_t display_size = {}; - - display_size.width = lv_disp_get_hor_res(_display); - display_size.height = lv_disp_get_ver_res(_display); - ESP_UI_CHECK_FALSE_RETURN(_core_home.calibrateCoreObjectSize(display_size, calibrate_size), - _resolution_name_stylesheet_map.end(), "Invalid screen size"); - resolution = (((uint32_t)calibrate_size.width) << 16) | calibrate_size.height; - ESP_UI_LOGD("Get resolution(%dx%d) name map", calibrate_size.width, calibrate_size.height); + ESP_UI_CHECK_FALSE_RETURN(calibrateResolutionSize(resolution, calibrate_size), false, "Invalid screen size"); return _resolution_name_stylesheet_map.find(resolution); } @@ -210,15 +187,8 @@ typename ESP_UI_NameStylesheetMap_t::iterator ESP_UI_Template::getNameStyl { uint32_t resolution = 0; ESP_UI_StyleSize_t calibrate_size = screen_size; - ESP_UI_StyleSize_t display_size = {}; - display_size.width = lv_disp_get_hor_res(_display); - display_size.height = lv_disp_get_ver_res(_display); - ESP_UI_CHECK_FALSE_RETURN(_core_home.calibrateCoreObjectSize(display_size, calibrate_size), - _resolution_name_stylesheet_map.end(), "Invalid screen size"); - - resolution = (((uint32_t)calibrate_size.width) << 16) | calibrate_size.height; - ESP_UI_LOGD("Get name data map end with resolution(%dx%d)", calibrate_size.width, calibrate_size.height); + ESP_UI_CHECK_FALSE_RETURN(calibrateResolutionSize(resolution, calibrate_size), false, "Invalid screen size"); return _resolution_name_stylesheet_map[resolution].end(); } @@ -228,26 +198,22 @@ const T *ESP_UI_Template::getStylesheet(const char *name, const ESP_UI_StyleS { uint32_t resolution = 0; ESP_UI_StyleSize_t calibrate_size = screen_size; - ESP_UI_StyleSize_t display_size = {}; - - ESP_UI_CHECK_NULL_RETURN(name, _stylesheet, "Invalid name"); - ESP_UI_CHECK_NULL_RETURN(_display, _stylesheet, "Display device is not initialized"); - display_size.width = lv_disp_get_hor_res(_display); - display_size.height = lv_disp_get_ver_res(_display); - ESP_UI_CHECK_FALSE_RETURN(_core_home.calibrateCoreObjectSize(display_size, calibrate_size), _stylesheet, - "Invalid screen size"); + ESP_UI_CHECK_NULL_RETURN(name, nullptr, "Invalid name"); - resolution = (((uint32_t)calibrate_size.width) << 16) | calibrate_size.height; - ESP_UI_LOGD("Get data(%s - %dx%d)", name, calibrate_size.width, calibrate_size.height); + ESP_UI_CHECK_FALSE_RETURN(calibrateResolutionSize(resolution, calibrate_size), nullptr, "Invalid screen size"); // Check if the resolution is already exist auto it_resolution_map = _resolution_name_stylesheet_map.find(resolution); - ESP_UI_CHECK_FALSE_RETURN(it_resolution_map != _resolution_name_stylesheet_map.end(), _stylesheet, "Resolution is not exist"); + if (it_resolution_map == _resolution_name_stylesheet_map.end()) { + return nullptr; + } // If exist, check if the name is already exist auto it_name_map = it_resolution_map->second.find(name); - ESP_UI_CHECK_FALSE_RETURN(it_name_map != it_resolution_map.end(), &_stylesheet, "Name is not exist"); + if (it_name_map == it_resolution_map->second.end()) { + return nullptr; + } return it_name_map->second.get(); } @@ -257,31 +223,36 @@ const T *ESP_UI_Template::getStylesheet(const ESP_UI_StyleSize_t &screen_size { uint32_t resolution = 0; ESP_UI_StyleSize_t calibrate_size = screen_size; - ESP_UI_StyleSize_t display_size = {}; - ESP_UI_CHECK_NULL_RETURN(_display, nullptr, "Display device is not initialized"); - - display_size.width = lv_disp_get_hor_res(_display); - display_size.height = lv_disp_get_ver_res(_display); - ESP_UI_CHECK_FALSE_RETURN(_core_home.calibrateCoreObjectSize(display_size, calibrate_size), nullptr, - "Invalid screen size"); - - resolution = (((uint32_t)calibrate_size.width) << 16) | calibrate_size.height; - ESP_UI_LOGD("Get data with resolution(%dx%d)", calibrate_size.width, calibrate_size.height); + ESP_UI_CHECK_FALSE_RETURN(calibrateResolutionSize(resolution, calibrate_size), nullptr, "Invalid screen size"); + ESP_UI_LOGD("Get stylesheet with resolution(%dx%d)", calibrate_size.width, calibrate_size.height); // Check if the resolution is already exist auto it_resolution_map = _resolution_name_stylesheet_map.find(resolution); - ESP_UI_CHECK_FALSE_RETURN(it_resolution_map != _resolution_name_stylesheet_map.end(), nullptr, - "Resolution is not exist"); - auto name_map = it_resolution_map->second; - ESP_UI_CHECK_FALSE_RETURN(!name_map.empty(), nullptr, "No data is found"); - - ESP_UI_LOGD("Get data(%s)", name_map.begin()->first.c_str()); + if ((it_resolution_map == _resolution_name_stylesheet_map.end()) || name_map.empty()) { + return nullptr; + } return name_map.begin()->second.get(); } +template +bool ESP_UI_Template::calibrateResolutionSize(uint32_t &resolution, ESP_UI_StyleSize_t size) const +{ + ESP_UI_StyleSize_t display_size = {}; + + ESP_UI_CHECK_NULL_RETURN(_display, false, "Display device is not initialized"); + + display_size.width = lv_disp_get_hor_res(_display); + display_size.height = lv_disp_get_ver_res(_display); + ESP_UI_CHECK_FALSE_RETURN(_core_home.calibrateCoreObjectSize(display_size, size), false, "Invalid screen size"); + + resolution = (((uint32_t)size.width) << 16) | size.height; + + return true; +} + template bool ESP_UI_Template::delTemplate(void) { diff --git a/src/systems/phone/esp_ui_phone.cpp b/src/systems/phone/esp_ui_phone.cpp index ec0fb5a..353174f 100644 --- a/src/systems/phone/esp_ui_phone.cpp +++ b/src/systems/phone/esp_ui_phone.cpp @@ -16,7 +16,7 @@ using namespace std; ESP_UI_Phone::ESP_UI_Phone(lv_disp_t *display): - ESP_UI_Template(_stylesheet.core, _home, _manager, display), + ESP_UI_TemplatePhone(_stylesheet.core, _home, _manager, display), _home(*this, _stylesheet.home), _manager(*this, _home, _stylesheet.manager) { @@ -28,6 +28,7 @@ ESP_UI_Phone::~ESP_UI_Phone() if (!del()) { ESP_UI_LOGE("Delete failed"); } + ESP_UI_TemplatePhone::~ESP_UI_TemplatePhone(); } bool ESP_UI_Phone::calibrateStylesheet(const ESP_UI_StyleSize_t &screen_size, ESP_UI_PhoneStylesheet_t &stylesheet) diff --git a/src/systems/phone/esp_ui_phone_home.cpp b/src/systems/phone/esp_ui_phone_home.cpp index d4fec50..1fe7271 100644 --- a/src/systems/phone/esp_ui_phone_home.cpp +++ b/src/systems/phone/esp_ui_phone_home.cpp @@ -120,6 +120,7 @@ bool ESP_UI_PhoneHome::processAppInstall(ESP_UI_CoreApp *app) if (phone_app->getLauncherIcon().resource == nullptr) { ESP_UI_LOGW("No launcher icon provided, use default icon"); icon_info.image.resource = &esp_ui_phone_app_launcher_image_default; + phone_app->setLauncherIconImage(ESP_UI_STYLE_IMAGE(&esp_ui_phone_app_launcher_image_default)); } ESP_UI_CHECK_FALSE_RETURN(_app_launcher.addIcon(phone_app->getActiveData().app_launcher_page_index, icon_info), false, "Add launcher icon failed"); @@ -141,14 +142,8 @@ bool ESP_UI_PhoneHome::processAppUninstall(ESP_UI_CoreApp *app) return true; } -bool ESP_UI_PhoneHome::processAppRun(ESP_UI_CoreApp *app, lv_area_t &app_visual_area) +bool ESP_UI_PhoneHome::processAppRun(ESP_UI_CoreApp *app) { - lv_area_t visual_area = { - .x1 = 0, - .y1 = 0, - .x2 = (lv_coord_t)(_core.getCoreData().screen_size.width - 1), - .y2 = (lv_coord_t)(_core.getCoreData().screen_size.height - 1), - }; ESP_UI_PhoneApp *phone_app = static_cast(app); ESP_UI_CHECK_NULL_RETURN(phone_app, false, "Invalid phone app"); @@ -176,12 +171,8 @@ bool ESP_UI_PhoneHome::processAppRun(ESP_UI_CoreApp *app, lv_area_t &app_visual_ ); } // Change visibility - const ESP_UI_StatusBarVisualMode_t &status_bar_visual_mode = app_data.status_bar_visual_mode; - ESP_UI_CHECK_FALSE_RETURN(_status_bar->setVisualMode(status_bar_visual_mode), false, + ESP_UI_CHECK_FALSE_RETURN(_status_bar->setVisualMode(app_data.status_bar_visual_mode), false, "Status bar set visual mode failed"); - if (status_bar_visual_mode == ESP_UI_STATUS_BAR_VISUAL_MODE_SHOW_FIXED) { - visual_area.y1 = _data.status_bar.data.main.size.height; - } } // Process navigation bar @@ -189,12 +180,8 @@ bool ESP_UI_PhoneHome::processAppRun(ESP_UI_CoreApp *app, lv_area_t &app_visual_ ESP_UI_LOGD("No navigation_bar"); } else { // Change visibility - const ESP_UI_NavigationBarVisualMode_t &navigation_bar_visual_mode = app_data.navigation_bar_visual_mode; - ESP_UI_CHECK_FALSE_RETURN(_navigation_bar->setVisualMode(navigation_bar_visual_mode), false, + ESP_UI_CHECK_FALSE_RETURN(_navigation_bar->setVisualMode(app_data.navigation_bar_visual_mode), false, "Navigation bar set visual mode failed"); - if (navigation_bar_visual_mode == ESP_UI_NAVIGATION_BAR_VISUAL_MODE_SHOW_FIXED) { - visual_area.y2 -= _data.navigation_bar.data.main.size.height; - } } // Process recents_screen @@ -208,8 +195,6 @@ bool ESP_UI_PhoneHome::processAppRun(ESP_UI_CoreApp *app, lv_area_t &app_visual_ "RecentsScreen add snapshot failed"); } - app_visual_area = visual_area; - return true; } @@ -301,6 +286,36 @@ bool ESP_UI_PhoneHome::processMainScreenLoad(void) return true; } +bool ESP_UI_PhoneHome::getAppVisualArea(ESP_UI_CoreApp *app, lv_area_t &app_visual_area) const +{ + ESP_UI_PhoneApp *phone_app = static_cast(app); + + ESP_UI_CHECK_NULL_RETURN(phone_app, false, "Invalid phone app"); + + lv_area_t visual_area = { + .x1 = 0, + .y1 = 0, + .x2 = (lv_coord_t)(_core.getCoreData().screen_size.width - 1), + .y2 = (lv_coord_t)(_core.getCoreData().screen_size.height - 1), + }; + const ESP_UI_PhoneAppData_t &app_data = phone_app->getActiveData(); + + // Process status bar + if ((_status_bar != nullptr) && (app_data.status_bar_visual_mode == ESP_UI_STATUS_BAR_VISUAL_MODE_SHOW_FIXED)) { + visual_area.y1 = _data.status_bar.data.main.size.height; + } + + // Process navigation bar + if ((_navigation_bar != nullptr) && + (app_data.navigation_bar_visual_mode == ESP_UI_NAVIGATION_BAR_VISUAL_MODE_SHOW_FIXED)) { + visual_area.y2 -= _data.navigation_bar.data.main.size.height; + } + + app_visual_area = visual_area; + + return true; +} + bool ESP_UI_PhoneHome::processRecentsScreenShow(void) { ESP_UI_LOGD("Process when show recents_screen"); diff --git a/src/systems/phone/esp_ui_phone_home.hpp b/src/systems/phone/esp_ui_phone_home.hpp index 9e260b6..77f3e3a 100644 --- a/src/systems/phone/esp_ui_phone_home.hpp +++ b/src/systems/phone/esp_ui_phone_home.hpp @@ -36,10 +36,11 @@ class ESP_UI_PhoneHome: public ESP_UI_CoreHome { bool del(void); bool processAppInstall(ESP_UI_CoreApp *app) override; bool processAppUninstall(ESP_UI_CoreApp *app) override; - bool processAppRun(ESP_UI_CoreApp *app, lv_area_t &app_visual_area) override; + bool processAppRun(ESP_UI_CoreApp *app) override; bool processAppResume(ESP_UI_CoreApp *app) override; bool processAppClose(ESP_UI_CoreApp *app) override; bool processMainScreenLoad(void) override; + bool getAppVisualArea(ESP_UI_CoreApp *app, lv_area_t &app_visual_area) const override; bool processRecentsScreenShow(void); diff --git a/src/systems/phone/stylesheet/dark/core_data.h b/src/systems/phone/stylesheet/dark/core_data.h index 64299fa..352b338 100644 --- a/src/systems/phone/stylesheet/dark/core_data.h +++ b/src/systems/phone/stylesheet/dark/core_data.h @@ -13,10 +13,11 @@ extern "C" { #endif /* Home */ +#define ESP_UI_PHONE_DEFAULT_DARK_CORE_HOME_BG_COLOR (0x1A1A1A) #define ESP_UI_PHONE_DEFAULT_DARK_CORE_HOME_DATA() \ { \ .background = { \ - .color = ESP_UI_STYLE_COLOR(0x1A1A1A), \ + .color = ESP_UI_STYLE_COLOR(ESP_UI_PHONE_DEFAULT_DARK_CORE_HOME_BG_COLOR), \ .wallpaper_image_resource = NULL, \ }, \ .text = { \ @@ -69,7 +70,7 @@ extern "C" { } /* Core */ -#define ESP_UI_PHONE_DEFAULT_DARK_CORE_INFO_DATA_NAME "EUI-Phone Default Drak" +#define ESP_UI_PHONE_DEFAULT_DARK_CORE_INFO_DATA_NAME "EUI-Phone Default Dark" #define ESP_UI_PHONE_DEFAULT_DARK_CORE_DATA() \ { \ .name = ESP_UI_PHONE_DEFAULT_DARK_CORE_INFO_DATA_NAME, \ diff --git a/src/systems/phone/stylesheet/dark/gesture_data.h b/src/systems/phone/stylesheet/dark/gesture_data.h index 021d034..04935eb 100644 --- a/src/systems/phone/stylesheet/dark/gesture_data.h +++ b/src/systems/phone/stylesheet/dark/gesture_data.h @@ -11,7 +11,7 @@ extern "C" { #endif -#define ESP_UI_PHONE_DEFAULT_DRAK_GESTURE_LEFT_RIGHT_INDICATOR_BAR_DATA() \ +#define ESP_UI_PHONE_DEFAULT_DARK_GESTURE_LEFT_RIGHT_INDICATOR_BAR_DATA() \ { \ .main = { \ .size_min = ESP_UI_STYLE_SIZE_RECT(10, 4), \ @@ -31,7 +31,7 @@ extern "C" { }, \ } -#define ESP_UI_PHONE_DEFAULT_DRAK_GESTURE_BOTTOM_INDICATOR_BAR_DATA() \ +#define ESP_UI_PHONE_DEFAULT_DARK_GESTURE_BOTTOM_INDICATOR_BAR_DATA() \ { \ .main = { \ .size_min = ESP_UI_STYLE_SIZE_RECT(4, 10), \ @@ -67,11 +67,11 @@ extern "C" { }, \ .indicator_bars = { \ [ESP_UI_GESTURE_INDICATOR_BAR_TYPE_LEFT] = \ - ESP_UI_PHONE_DEFAULT_DRAK_GESTURE_LEFT_RIGHT_INDICATOR_BAR_DATA(), \ + ESP_UI_PHONE_DEFAULT_DARK_GESTURE_LEFT_RIGHT_INDICATOR_BAR_DATA(), \ [ESP_UI_GESTURE_INDICATOR_BAR_TYPE_RIGHT] = \ - ESP_UI_PHONE_DEFAULT_DRAK_GESTURE_LEFT_RIGHT_INDICATOR_BAR_DATA(), \ + ESP_UI_PHONE_DEFAULT_DARK_GESTURE_LEFT_RIGHT_INDICATOR_BAR_DATA(), \ [ESP_UI_GESTURE_INDICATOR_BAR_TYPE_BOTTOM] = \ - ESP_UI_PHONE_DEFAULT_DRAK_GESTURE_BOTTOM_INDICATOR_BAR_DATA(), \ + ESP_UI_PHONE_DEFAULT_DARK_GESTURE_BOTTOM_INDICATOR_BAR_DATA(), \ }, \ .flags = { \ .enable_indicator_bars = { \ diff --git a/src/widgets/status_bar/esp_ui_status_bar.cpp b/src/widgets/status_bar/esp_ui_status_bar.cpp index 854ec71..067ed8d 100644 --- a/src/widgets/status_bar/esp_ui_status_bar.cpp +++ b/src/widgets/status_bar/esp_ui_status_bar.cpp @@ -468,7 +468,7 @@ bool ESP_UI_StatusBar::setBatteryPercent(bool charge_flag, int percent) const if (_data.flags.enable_battery_icon) { if (charge_flag) { - _battery_state = 5; + _battery_state = 4; } else { _battery_state = (int)((percent - 1) / 25); }