DarkFlippers/unleashed-firmware
1
1
Fork 0
mirror of https://github.com/DarkFlippers/unleashed-firmware.git synced 2025-01-02 10:17:10 +03:00
Code Issues Projects Releases Wiki Activity

Merge pull request #578 from DarkFlippers/desktop_favorite_port

Browse Source 
Desktop favorite port
This commit is contained in:
MMX 2023-08-20 01:32:36 +03:00 committed by GitHub
commit f17b941f7d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 384 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
applications/services/desktop/animations/views/one_shot_animation_view.c
View File

@ -65,8 +65,8 @@ static bool one_shot_view_input(InputEvent* event, void* context) {
if(!consumed) {
if(event->key == InputKeyRight) {
/* Right button reserved for animation activation, so consume */
consumed = true;
if(event->type == InputTypeShort) {
consumed = true;
if(view->interact_callback) {
view->interact_callback(view->interact_callback_context);
}

5
applications/services/desktop/desktop.c
View File

@ -131,8 +131,9 @@ static bool desktop_custom_event_callback(void* context, uint32_t event) {
DESKTOP_SETTINGS_LOAD(&desktop->settings);
desktop_clock_reconfigure(desktop);
desktop_auto_lock_arm(desktop);
if(!furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock)) {
desktop_auto_lock_arm(desktop);
}
return true;
case DesktopGlobalAutoLock:
if(!loader_is_locked(desktop->loader)) {

30
applications/services/desktop/desktop_settings.h
View File

@ -8,7 +8,7 @@
#include <toolbox/saved_struct.h>
#include <storage/storage.h>
#define DESKTOP_SETTINGS_VER (12)
#define DESKTOP_SETTINGS_VER (13)
#define DESKTOP_SETTINGS_PATH INT_PATH(DESKTOP_SETTINGS_FILE_NAME)
#define DESKTOP_SETTINGS_MAGIC (0x17)
@ -43,6 +43,29 @@
#define DISPLAY_BATTERY_RETRO_5 4
#define DISPLAY_BATTERY_BAR_PERCENT 5
typedef enum {
FavoriteAppLeftShort = 0,
FavoriteAppLeftLong,
FavoriteAppRightShort,
FavoriteAppRightLong,
FavoriteAppNumber,
} FavoriteAppShortcut;
typedef enum {
DummyAppLeft = 0,
DummyAppLeftLong,
DummyAppRight,
DummyAppRightLong,
DummyAppUpLong,
DummyAppDown,
DummyAppDownLong,
DummyAppOk,
DummyAppOkLong,
DummyAppNumber,
} DummyAppShortcut;
typedef struct {
InputKey data[MAX_PIN_SIZE];
uint8_t length;
@ -53,12 +76,11 @@ typedef struct {
} FavoriteApp;
typedef struct {
FavoriteApp favorite_primary;
FavoriteApp favorite_secondary;
FavoriteApp favorite_tertiary;
PinCode pin_code;
uint32_t auto_lock_delay_ms;
uint8_t displayBatteryPercentage;
uint8_t dummy_mode;
uint8_t display_clock;
FavoriteApp favorite_apps[FavoriteAppNumber];
FavoriteApp dummy_apps[DummyAppNumber];
} DesktopSettings;

4
applications/services/desktop/scenes/desktop_scene_locked.c
View File

@ -87,6 +87,10 @@ bool desktop_scene_locked_on_event(void* context, SceneManagerEvent event) {
desktop_unlock(desktop);
consumed = true;
break;
case DesktopLockedEventDoorsClosed:
notification_message(desktop->notification, &sequence_display_backlight_off);
consumed = true;
break;
case DesktopLockedEventUpdate:
if(desktop_view_locked_is_locked_hint_visible(desktop->locked_view)) {
notification_message(desktop->notification, &sequence_display_backlight_off);

136
applications/services/desktop/scenes/desktop_scene_main.c
View File

@ -61,17 +61,33 @@ static void
}
#endif
static void desktop_scene_main_open_app_or_profile(Desktop* desktop, const char* path) {
if(loader_start_with_gui_error(desktop->loader, path, NULL) != LoaderStatusOk) {
static inline bool desktop_scene_main_check_none(const char* str) {
return (str[1] == '\0' && str[0] == '?');
}
static void desktop_scene_main_open_app_or_profile(Desktop* desktop, FavoriteApp* application) {
bool load_ok = false;
if(strlen(application->name_or_path) > 0) {
if(desktop_scene_main_check_none(application->name_or_path)) {
// skip loading
load_ok = true;
} else if(
loader_start(desktop->loader, application->name_or_path, NULL, NULL) ==
LoaderStatusOk) {
load_ok = true;
}
}
if(!load_ok) {
loader_start(desktop->loader, "Passport", NULL, NULL);
}
}
static void desktop_scene_main_start_favorite(Desktop* desktop, FavoriteApp* application) {
if(strlen(application->name_or_path) > 2) {
loader_start_with_gui_error(desktop->loader, application->name_or_path, NULL);
} else if(
(strlen(application->name_or_path) < 2) && (strcmp(application->name_or_path, "d") != 0)) {
if(strlen(application->name_or_path) > 0) {
if(!desktop_scene_main_check_none(application->name_or_path)) {
loader_start_with_gui_error(desktop->loader, application->name_or_path, NULL);
}
} else {
loader_start(desktop->loader, LOADER_APPLICATIONS_NAME, NULL, NULL);
}
}
@ -112,6 +128,12 @@ bool desktop_scene_main_on_event(void* context, SceneManagerEvent event) {
consumed = true;
} break;
case DesktopMainEventLock:
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
desktop_lock(desktop);
consumed = true;
break;
case DesktopMainEventOpenLockMenu:
scene_manager_next_scene(desktop->scene_manager, DesktopSceneLockMenu);
consumed = true;
@ -122,12 +144,6 @@ bool desktop_scene_main_on_event(void* context, SceneManagerEvent event) {
consumed = true;
break;
case DesktopMainEventLock:
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
desktop_lock(desktop);
consumed = true;
break;
case DesktopMainEventOpenArchive:
#ifdef APP_ARCHIVE
desktop_switch_to_app(desktop, &FLIPPER_ARCHIVE);
@ -141,21 +157,31 @@ bool desktop_scene_main_on_event(void* context, SceneManagerEvent event) {
break;
}
case DesktopMainEventOpenFavoritePrimary:
case DesktopMainEventOpenFavoriteLeftShort:
DESKTOP_SETTINGS_LOAD(&desktop->settings);
desktop_scene_main_start_favorite(desktop, &desktop->settings.favorite_primary);
desktop_scene_main_start_favorite(
desktop, &desktop->settings.favorite_apps[FavoriteAppLeftShort]);
consumed = true;
break;
case DesktopMainEventOpenFavoriteSecondary:
case DesktopMainEventOpenFavoriteLeftLong:
DESKTOP_SETTINGS_LOAD(&desktop->settings);
desktop_scene_main_start_favorite(desktop, &desktop->settings.favorite_secondary);
desktop_scene_main_start_favorite(
desktop, &desktop->settings.favorite_apps[FavoriteAppLeftLong]);
consumed = true;
break;
case DesktopMainEventOpenFavoriteTertiary:
case DesktopMainEventOpenFavoriteRightShort:
DESKTOP_SETTINGS_LOAD(&desktop->settings);
desktop_scene_main_start_favorite(desktop, &desktop->settings.favorite_tertiary);
desktop_scene_main_start_favorite(
desktop, &desktop->settings.favorite_apps[FavoriteAppRightShort]);
consumed = true;
break;
case DesktopMainEventOpenFavoriteRightLong:
DESKTOP_SETTINGS_LOAD(&desktop->settings);
desktop_scene_main_start_favorite(
desktop, &desktop->settings.favorite_apps[FavoriteAppRightLong]);
consumed = true;
break;
case DesktopAnimationEventCheckAnimation:
animation_manager_check_blocking_process(desktop->animation_manager);
consumed = true;
@ -166,39 +192,57 @@ bool desktop_scene_main_on_event(void* context, SceneManagerEvent event) {
break;
case DesktopAnimationEventInteractAnimation:
if(!animation_manager_interact_process(desktop->animation_manager)) {
loader_start(desktop->loader, "Passport", NULL, NULL);
DESKTOP_SETTINGS_LOAD(&desktop->settings);
if(!desktop->settings.dummy_mode) {
desktop_scene_main_open_app_or_profile(
desktop, &desktop->settings.favorite_apps[FavoriteAppRightShort]);
} else {
desktop_scene_main_open_app_or_profile(
desktop, &desktop->settings.dummy_apps[DummyAppRight]);
}
}
consumed = true;
break;
case DesktopMainEventOpenPassport: {
loader_start(desktop->loader, "Passport", NULL, NULL);
break;
}
case DesktopMainEventOpenGameMenu: {
desktop_scene_main_open_app_or_profile(desktop, EXT_PATH("/apps/Games/snake.fap"));
break;
}
case DesktopMainEventOpenTetris: {
desktop_scene_main_open_app_or_profile(desktop, EXT_PATH("/apps/Games/tetris.fap"));
break;
}
case DesktopMainEventOpenArkanoid: {
desktop_scene_main_open_app_or_profile(desktop, EXT_PATH("/apps/Games/arkanoid.fap"));
break;
}
case DesktopMainEventOpenDOOM: {
desktop_scene_main_open_app_or_profile(desktop, EXT_PATH("/apps/Games/doom.fap"));
break;
}
case DesktopMainEventOpenZombiez: {
desktop_scene_main_open_app_or_profile(desktop, EXT_PATH("/apps/Games/zombiez.fap"));
break;
}
case DesktopMainEventOpenHeap: {
case DesktopDummyEventOpenLeft:
desktop_scene_main_open_app_or_profile(
desktop, EXT_PATH("/apps/Games/heap_defence.fap"));
desktop, &desktop->settings.dummy_apps[DummyAppLeft]);
break;
}
case DesktopDummyEventOpenDown:
desktop_scene_main_open_app_or_profile(
desktop, &desktop->settings.dummy_apps[DummyAppDown]);
break;
case DesktopDummyEventOpenOk:
desktop_scene_main_open_app_or_profile(
desktop, &desktop->settings.dummy_apps[DummyAppOk]);
break;
case DesktopDummyEventOpenUpLong:
if(!desktop_scene_main_check_none(
desktop->settings.dummy_apps[DummyAppUpLong].name_or_path)) {
desktop_scene_main_open_app_or_profile(
desktop, &desktop->settings.dummy_apps[DummyAppUpLong]);
} else {
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
desktop_lock(desktop);
}
break;
case DesktopDummyEventOpenDownLong:
desktop_scene_main_open_app_or_profile(
desktop, &desktop->settings.dummy_apps[DummyAppDownLong]);
break;
case DesktopDummyEventOpenLeftLong:
desktop_scene_main_open_app_or_profile(
desktop, &desktop->settings.dummy_apps[DummyAppLeftLong]);
break;
case DesktopDummyEventOpenRightLong:
desktop_scene_main_open_app_or_profile(
desktop, &desktop->settings.dummy_apps[DummyAppRightLong]);
break;
case DesktopDummyEventOpenOkLong:
desktop_scene_main_open_app_or_profile(
desktop, &desktop->settings.dummy_apps[DummyAppOkLong]);
break;
case DesktopLockedEventUpdate:
desktop_view_locked_update(desktop->locked_view);
consumed = true;

25
applications/services/desktop/views/desktop_events.h
View File

@ -1,27 +1,30 @@
#pragma once
typedef enum {
DesktopMainEventLock,
DesktopMainEventOpenLockMenu,
DesktopMainEventOpenArchive,
DesktopMainEventOpenFavoritePrimary,
DesktopMainEventOpenFavoriteSecondary,
DesktopMainEventOpenFavoriteTertiary,
DesktopMainEventOpenFavoriteLeftShort,
DesktopMainEventOpenFavoriteLeftLong,
DesktopMainEventOpenFavoriteRightShort,
DesktopMainEventOpenFavoriteRightLong,
DesktopMainEventOpenMenu,
DesktopMainEventOpenDebug,
DesktopMainEventOpenPassport,
DesktopMainEventOpenPowerOff,
DesktopMainEventLock,
DesktopMainEventOpenGameMenu,
DesktopMainEventOpenTetris,
DesktopMainEventOpenArkanoid,
DesktopMainEventOpenDOOM,
DesktopMainEventOpenZombiez,
DesktopMainEventOpenHeap,
DesktopDummyEventOpenLeft,
DesktopDummyEventOpenDown,
DesktopDummyEventOpenOk,
DesktopDummyEventOpenUpLong,
DesktopDummyEventOpenDownLong,
DesktopDummyEventOpenLeftLong,
DesktopDummyEventOpenRightLong,
DesktopDummyEventOpenOkLong,
DesktopLockedEventUnlocked,
DesktopLockedEventUpdate,
DesktopLockedEventShowPinInput,
DesktopLockedEventDoorsClosed,
DesktopPinInputEventResetWrongPinLabel,
DesktopPinInputEventUnlocked,

4
applications/services/desktop/views/desktop_view_locked.c
View File

@ -99,6 +99,7 @@ void desktop_view_locked_update(DesktopViewLocked* locked_view) {
if(view_state == DesktopViewLockedStateDoorsClosing &&
!desktop_view_locked_doors_move(model)) {
locked_view->callback(DesktopLockedEventDoorsClosed, locked_view->context);
model->view_state = DesktopViewLockedStateLocked;
} else if(view_state == DesktopViewLockedStateLockedHintShown) {
model->view_state = DesktopViewLockedStateLocked;
@ -223,8 +224,7 @@ void desktop_view_locked_close_doors(DesktopViewLocked* locked_view) {
void desktop_view_locked_lock(DesktopViewLocked* locked_view, bool pin_locked) {
DesktopViewLockedModel* model = view_get_model(locked_view->view);
// TODO: Fix!!!!!!!!!!!
//furi_assert(model->view_state == DesktopViewLockedStateUnlocked);
furi_assert(model->view_state == DesktopViewLockedStateUnlocked);
model->view_state = DesktopViewLockedStateLocked;
model->pin_locked = pin_locked;
view_commit_model(locked_view->view, true);

43
applications/services/desktop/views/desktop_view_main.c
View File

@ -59,18 +59,18 @@ bool desktop_main_input_callback(InputEvent* event, void* context) {
} else if(event->key == InputKeyDown) {
main_view->callback(DesktopMainEventOpenArchive, main_view->context);
} else if(event->key == InputKeyLeft) {
main_view->callback(DesktopMainEventOpenFavoritePrimary, main_view->context);
main_view->callback(DesktopMainEventOpenFavoriteLeftShort, main_view->context);
}
// Right key is handled by animation manager
// Right key short is handled by animation manager
} else if(event->type == InputTypeLong) {
if(event->key == InputKeyDown) {
if(event->key == InputKeyUp) {
main_view->callback(DesktopMainEventLock, main_view->context);
} else if(event->key == InputKeyDown) {
main_view->callback(DesktopMainEventOpenDebug, main_view->context);
} else if(event->key == InputKeyLeft) {
main_view->callback(DesktopMainEventOpenFavoriteSecondary, main_view->context);
main_view->callback(DesktopMainEventOpenFavoriteLeftLong, main_view->context);
} else if(event->key == InputKeyRight) {
main_view->callback(DesktopMainEventOpenFavoriteTertiary, main_view->context);
} else if(event->key == InputKeyUp) {
main_view->callback(DesktopMainEventLock, main_view->context);
main_view->callback(DesktopMainEventOpenFavoriteRightLong, main_view->context);
} else if(event->key == InputKeyOk) {
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
main_view->callback(DesktopAnimationEventNewIdleAnimation, main_view->context);
@ -80,31 +80,30 @@ bool desktop_main_input_callback(InputEvent* event, void* context) {
} else {
if(event->type == InputTypeShort) {
if(event->key == InputKeyOk) {
main_view->callback(
DesktopMainEventOpenGameMenu, main_view->context); // OPENS Snake
main_view->callback(DesktopDummyEventOpenOk, main_view->context);
} else if(event->key == InputKeyUp) {
main_view->callback(DesktopMainEventOpenLockMenu, main_view->context);
} else if(event->key == InputKeyDown) {
main_view->callback(
DesktopMainEventOpenTetris, main_view->context); // OPENS Tetris
main_view->callback(DesktopDummyEventOpenDown, main_view->context);
} else if(event->key == InputKeyLeft) {
main_view->callback(
DesktopMainEventOpenArkanoid, main_view->context); // OPENS Arkanoid
main_view->callback(DesktopDummyEventOpenLeft, main_view->context);
}
// Right key is handled by animation manager
// Right key short is handled by animation manager
} else if(event->type == InputTypeLong) {
if(event->key == InputKeyOk) {
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
main_view->callback(DesktopAnimationEventNewIdleAnimation, main_view->context);
}
// Not working in DummyMode
// if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
// main_view->callback(DesktopAnimationEventNewIdleAnimation, main_view->context);
// }
main_view->callback(DesktopDummyEventOpenOkLong, main_view->context);
} else if(event->key == InputKeyUp) {
main_view->callback(DesktopMainEventOpenDOOM, main_view->context); // OPENS DOOM
main_view->callback(DesktopDummyEventOpenUpLong, main_view->context);
} else if(event->key == InputKeyDown) {
main_view->callback(
DesktopMainEventOpenZombiez, main_view->context); // OPENS Zombiez
main_view->callback(DesktopDummyEventOpenDownLong, main_view->context);
} else if(event->key == InputKeyLeft) {
main_view->callback(
DesktopMainEventOpenHeap, main_view->context); // OPENS Heap Defence
main_view->callback(DesktopDummyEventOpenLeftLong, main_view->context);
} else if(event->key == InputKeyRight) {
main_view->callback(DesktopDummyEventOpenRightLong, main_view->context);
}
}
}

139
applications/settings/desktop_settings/scenes/desktop_settings_scene_favorite.c
View File

@ -1,19 +1,25 @@
#include "../desktop_settings_app.h"
#include "applications.h"
#include "desktop_settings_scene.h"
#include "desktop_settings_scene_i.h"
#include <flipper_application/flipper_application.h>
#include <storage/storage.h>
#include <dialogs/dialogs.h>
#define APPS_COUNT (FLIPPER_APPS_COUNT + FLIPPER_EXTERNAL_APPS_COUNT)
#define EXTERNAL_BROWSER_NAME ("Apps")
#define EXTERNAL_BROWSER_INDEX (APPS_COUNT + 1)
#define DEFAULT_INDEX (0)
#define EXTERNAL_BROWSER_NAME ("Apps Menu (Default)")
#define PASSPORT_NAME ("Passport (Default)")
#define NONE_APPLICATION_INDEX (1)
#define NONE_APPLICATION_NAME "None (disable)"
#define LOCK_APPLICATION_NAME "Lock Flipper"
#define EXTERNAL_APPLICATION_INDEX (2)
#define EXTERNAL_APPLICATION_NAME ("[Select App]")
#define EXTERNAL_APPLICATION_INDEX (APPS_COUNT + 2)
#define NONE_APPLICATION_INDEX (APPS_COUNT + 3)
#define MAIN_LIST_APPLICATION_OFFSET (3)
#define PRESELECTED_SPECIAL 0xffffffff
@ -57,40 +63,44 @@ void desktop_settings_scene_favorite_on_enter(void* context) {
Submenu* submenu = app->submenu;
submenu_reset(submenu);
uint32_t primary_favorite =
uint32_t favorite_id =
scene_manager_get_scene_state(app->scene_manager, DesktopSettingsAppSceneFavorite);
uint32_t pre_select_item = PRESELECTED_SPECIAL;
FavoriteApp* curr_favorite_app = NULL;
if(primary_favorite == 0) {
curr_favorite_app = &app->settings.favorite_primary;
} else if(primary_favorite == 1) {
curr_favorite_app = &app->settings.favorite_secondary;
} else if(primary_favorite == 2) {
curr_favorite_app = &app->settings.favorite_tertiary;
bool is_dummy_app = false;
bool default_passport = false;
bool lock_if_none = false;
if((favorite_id & SCENE_STATE_SET_DUMMY_APP) == 0) {
furi_assert(favorite_id < FavoriteAppNumber);
curr_favorite_app = &app->settings.favorite_apps[favorite_id];
if(favorite_id == FavoriteAppRightShort) {
default_passport = true;
}
} else {
curr_favorite_app = &app->settings.favorite_primary;
}
if(curr_favorite_app == NULL) {
// This should not happen!
return;
}
for(size_t i = 0; i < APPS_COUNT; i++) {
const char* name = favorite_fap_get_app_name(i);
submenu_add_item(submenu, name, i, desktop_settings_scene_favorite_submenu_callback, app);
// Select favorite item in submenu
if(!strcmp(name, curr_favorite_app->name_or_path)) {
pre_select_item = i;
favorite_id &= ~(SCENE_STATE_SET_DUMMY_APP);
furi_assert(favorite_id < DummyAppNumber);
curr_favorite_app = &app->settings.dummy_apps[favorite_id];
is_dummy_app = true;
default_passport = true;
if(favorite_id == DummyAppUpLong) {
lock_if_none = true;
}
}
// Special case: Application browser
submenu_add_item(
submenu,
EXTERNAL_BROWSER_NAME,
EXTERNAL_BROWSER_INDEX,
default_passport ? (PASSPORT_NAME) : (EXTERNAL_BROWSER_NAME),
DEFAULT_INDEX,
desktop_settings_scene_favorite_submenu_callback,
app);
// Special case: None (disable) or Lock Flipper
submenu_add_item(
submenu,
lock_if_none ? (LOCK_APPLICATION_NAME) : (NONE_APPLICATION_NAME),
NONE_APPLICATION_INDEX,
desktop_settings_scene_favorite_submenu_callback,
app);
@ -102,28 +112,37 @@ void desktop_settings_scene_favorite_on_enter(void* context) {
desktop_settings_scene_favorite_submenu_callback,
app);
if(!is_dummy_app) {
for(size_t i = 0; i < APPS_COUNT; i++) {
const char* name = favorite_fap_get_app_name(i);
submenu_add_item(
submenu,
name,
i + MAIN_LIST_APPLICATION_OFFSET,
desktop_settings_scene_favorite_submenu_callback,
app);
// Select favorite item in submenu
if(!strcmp(name, curr_favorite_app->name_or_path)) {
pre_select_item = i + MAIN_LIST_APPLICATION_OFFSET;
}
}
}
if(pre_select_item == PRESELECTED_SPECIAL) {
if(curr_favorite_app->name_or_path[0] == '\0') {
pre_select_item = EXTERNAL_BROWSER_INDEX;
pre_select_item = DEFAULT_INDEX;
} else if(
(curr_favorite_app->name_or_path[1] == '\0') &&
(curr_favorite_app->name_or_path[0] == '?')) {
pre_select_item = NONE_APPLICATION_INDEX;
} else {
pre_select_item = EXTERNAL_APPLICATION_INDEX;
}
}
submenu_add_item(
submenu,
"None (disable)",
NONE_APPLICATION_INDEX,
desktop_settings_scene_favorite_submenu_callback,
app);
if(primary_favorite == 0) {
submenu_set_header(submenu, "Primary favorite app:");
} else if(primary_favorite == 1) {
submenu_set_header(submenu, "Secondary favorite app:");
} else if(primary_favorite == 2) {
submenu_set_header(submenu, "Tertiary favorite app:");
}
submenu_set_header(submenu, is_dummy_app ? ("Dummy Mode app:") : ("Favorite app:"));
submenu_set_selected_item(submenu, pre_select_item); // If set during loop, visual glitch.
view_dispatcher_switch_to_view(app->view_dispatcher, DesktopSettingsAppViewMenu);
@ -134,28 +153,26 @@ bool desktop_settings_scene_favorite_on_event(void* context, SceneManagerEvent e
bool consumed = false;
FuriString* temp_path = furi_string_alloc_set_str(EXT_PATH("apps"));
uint32_t primary_favorite =
uint32_t favorite_id =
scene_manager_get_scene_state(app->scene_manager, DesktopSettingsAppSceneFavorite);
FavoriteApp* curr_favorite_app = NULL;
if(primary_favorite == 0) {
curr_favorite_app = &app->settings.favorite_primary;
} else if(primary_favorite == 1) {
curr_favorite_app = &app->settings.favorite_secondary;
} else if(primary_favorite == 2) {
curr_favorite_app = &app->settings.favorite_tertiary;
if((favorite_id & SCENE_STATE_SET_DUMMY_APP) == 0) {
furi_assert(favorite_id < FavoriteAppNumber);
curr_favorite_app = &app->settings.favorite_apps[favorite_id];
} else {
curr_favorite_app = &app->settings.favorite_primary;
}
if(curr_favorite_app == NULL) {
// This should not happen!
furi_string_free(temp_path);
return consumed;
favorite_id &= ~(SCENE_STATE_SET_DUMMY_APP);
furi_assert(favorite_id < DummyAppNumber);
curr_favorite_app = &app->settings.dummy_apps[favorite_id];
}
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == EXTERNAL_BROWSER_INDEX) {
if(event.event == DEFAULT_INDEX) {
curr_favorite_app->name_or_path[0] = '\0';
consumed = true;
} else if(event.event == NONE_APPLICATION_INDEX) {
curr_favorite_app->name_or_path[0] = '?';
curr_favorite_app->name_or_path[1] = '\0';
consumed = true;
} else if(event.event == EXTERNAL_APPLICATION_INDEX) {
const DialogsFileBrowserOptions browser_options = {
.extension = ".fap",
@ -180,13 +197,9 @@ bool desktop_settings_scene_favorite_on_event(void* context, SceneManagerEvent e
MAX_APP_LENGTH);
consumed = true;
}
} else if(event.event == NONE_APPLICATION_INDEX) {
// Clear favorite app path and set it to "d" (disabled)
memset(curr_favorite_app->name_or_path, 0, strlen(curr_favorite_app->name_or_path));
strncpy(curr_favorite_app->name_or_path, "d", MAX_APP_LENGTH);
consumed = true;
} else {
const char* name = favorite_fap_get_app_name(event.event);
size_t app_index = event.event - MAIN_LIST_APPLICATION_OFFSET;
const char* name = favorite_fap_get_app_name(app_index);
if(name) strncpy(curr_favorite_app->name_or_path, name, MAX_APP_LENGTH);
consumed = true;
}

3
applications/settings/desktop_settings/scenes/desktop_settings_scene_i.h
View File

@ -5,3 +5,6 @@
#define SCENE_STATE_PIN_ERROR_MISMATCH (0)
#define SCENE_STATE_PIN_ERROR_WRONG (1)
#define SCENE_STATE_SET_FAVORITE_APP (0)
#define SCENE_STATE_SET_DUMMY_APP (1 << 8)

184
applications/settings/desktop_settings/scenes/desktop_settings_scene_start.c
View File

@ -3,16 +3,29 @@
#include "../desktop_settings_app.h"
#include "desktop_settings_scene.h"
#include "desktop_settings_scene_i.h"
#include <power/power_service/power.h>
#define SCENE_EVENT_SELECT_FAVORITE_PRIMARY 0
#define SCENE_EVENT_SELECT_FAVORITE_SECONDARY 1
#define SCENE_EVENT_SELECT_FAVORITE_TERTIARY 2
#define SCENE_EVENT_SELECT_PIN_SETUP 3
#define SCENE_EVENT_SELECT_AUTO_LOCK_DELAY 4
#define SCENE_EVENT_SELECT_BATTERY_DISPLAY 5
#define SCENE_EVENT_SELECT_CLOCK_DISPLAY 6
#define SCENE_EVENT_SELECT_CHANGE_NAME 7
typedef enum {
DesktopSettingsPinSetup = 0,
DesktopSettingsAutoLockDelay,
DesktopSettingsBatteryDisplay,
DesktopSettingsClockDisplay,
DesktopSettingsChangeName,
DesktopSettingsFavoriteLeftShort,
DesktopSettingsFavoriteLeftLong,
DesktopSettingsFavoriteRightShort,
DesktopSettingsFavoriteRightLong,
DesktopSettingsDummyLeft,
DesktopSettingsDummyLeftLong,
DesktopSettingsDummyRight,
DesktopSettingsDummyRightLong,
DesktopSettingsDummyUpLong,
DesktopSettingsDummyDown,
DesktopSettingsDummyDownLong,
DesktopSettingsDummyOk,
DesktopSettingsDummyOkLong,
} DesktopSettingsEntry;
#define AUTO_LOCK_DELAY_COUNT 9
const char* const auto_lock_delay_text[AUTO_LOCK_DELAY_COUNT] = {
@ -87,12 +100,6 @@ void desktop_settings_scene_start_on_enter(void* context) {
VariableItem* item;
uint8_t value_index;
variable_item_list_add(variable_item_list, "Primary Favorite App", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "Secondary Favorite App", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "Tertiary Favorite App", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "PIN Setup", 1, NULL, NULL);
item = variable_item_list_add(
@ -102,8 +109,6 @@ void desktop_settings_scene_start_on_enter(void* context) {
desktop_settings_scene_start_auto_lock_delay_changed,
app);
variable_item_list_set_enter_callback(
variable_item_list, desktop_settings_scene_start_var_list_enter_callback, app);
value_index = value_index_uint32(
app->settings.auto_lock_delay_ms, auto_lock_delay_value, AUTO_LOCK_DELAY_COUNT);
variable_item_set_current_value_index(item, value_index);
@ -137,6 +142,24 @@ void desktop_settings_scene_start_on_enter(void* context) {
variable_item_list_add(variable_item_list, "Change Flipper Name", 0, NULL, app);
variable_item_list_add(variable_item_list, "Favorite App - Left Short", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "Favorite App - Left Long", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "Favorite App - Right Short", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "Favorite App - Right Long", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "DummyMode App - Left", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "DummyMode App - Left Long", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "DummyMode App - Right", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "DummyMode App - Right Long", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "DummyMode App - Up Long", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "DummyMode App - Down", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "DummyMode App - Down Long", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "DummyMode App - Ok", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "DummyMode App - Ok Long", 1, NULL, NULL);
variable_item_list_set_enter_callback(
variable_item_list, desktop_settings_scene_start_var_list_enter_callback, app);
view_dispatcher_switch_to_view(app->view_dispatcher, DesktopSettingsAppViewVarItemList);
}
@ -146,35 +169,116 @@ bool desktop_settings_scene_start_on_event(void* context, SceneManagerEvent even
if(event.type == SceneManagerEventTypeCustom) {
switch(event.event) {
case SCENE_EVENT_SELECT_FAVORITE_PRIMARY:
scene_manager_set_scene_state(app->scene_manager, DesktopSettingsAppSceneFavorite, 0);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
consumed = true;
break;
case SCENE_EVENT_SELECT_FAVORITE_SECONDARY:
scene_manager_set_scene_state(app->scene_manager, DesktopSettingsAppSceneFavorite, 1);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
consumed = true;
break;
case SCENE_EVENT_SELECT_FAVORITE_TERTIARY:
scene_manager_set_scene_state(app->scene_manager, DesktopSettingsAppSceneFavorite, 2);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
consumed = true;
break;
case SCENE_EVENT_SELECT_PIN_SETUP:
case DesktopSettingsPinSetup:
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppScenePinMenu);
consumed = true;
break;
case SCENE_EVENT_SELECT_AUTO_LOCK_DELAY:
case SCENE_EVENT_SELECT_CLOCK_DISPLAY:
case SCENE_EVENT_SELECT_BATTERY_DISPLAY:
consumed = true;
break;
case SCENE_EVENT_SELECT_CHANGE_NAME:
// case DesktopSettingsAutoLockDelay:
// case DesktopSettingsBatteryDisplay:
// case DesktopSettingsClockDisplay:
// Proces in default
case DesktopSettingsChangeName:
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneChangeName);
consumed = true;
break;
case DesktopSettingsFavoriteLeftShort:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_FAVORITE_APP | FavoriteAppLeftShort);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsFavoriteLeftLong:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_FAVORITE_APP | FavoriteAppLeftLong);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsFavoriteRightShort:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_FAVORITE_APP | FavoriteAppRightShort);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsFavoriteRightLong:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_FAVORITE_APP | FavoriteAppRightLong);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsDummyLeft:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_DUMMY_APP | DummyAppLeft);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsDummyLeftLong:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_DUMMY_APP | DummyAppLeftLong);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsDummyRight:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_DUMMY_APP | DummyAppRight);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsDummyRightLong:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_DUMMY_APP | DummyAppRightLong);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsDummyUpLong:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_DUMMY_APP | DummyAppUpLong);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsDummyDown:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_DUMMY_APP | DummyAppDown);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsDummyDownLong:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_DUMMY_APP | DummyAppDownLong);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsDummyOk:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_DUMMY_APP | DummyAppOk);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
case DesktopSettingsDummyOkLong:
scene_manager_set_scene_state(
app->scene_manager,
DesktopSettingsAppSceneFavorite,
SCENE_STATE_SET_DUMMY_APP | DummyAppOkLong);
scene_manager_next_scene(app->scene_manager, DesktopSettingsAppSceneFavorite);
break;
default:
break;
}
consumed = true;
}
return consumed;
}