[FL-3479] Desktop: more favorites, configurable dummy mode (#2972)

* Desktop: more favorite app shortcuts
* Making PVS happy
* Desktop settings submenu fix

Co-authored-by: あく <alleteam@gmail.com>

applications/services/desktop/animations/views/bubble_animation_view.c

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

applications/services/desktop/animations/views/one_shot_animation_view.c

@@ -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);
                 }

applications/services/desktop/desktop.c

@@ -223,7 +223,6 @@ void desktop_lock(Desktop* desktop) {
     scene_manager_set_scene_state(
         desktop->scene_manager, DesktopSceneLocked, SCENE_LOCKED_FIRST_ENTER);
     scene_manager_next_scene(desktop->scene_manager, DesktopSceneLocked);
-    notification_message(desktop->notification, &sequence_display_backlight_off_delay_1000);
 
     DesktopStatus status = {.locked = true};
     furi_pubsub_publish(desktop->status_pubsub, &status);

applications/services/desktop/desktop_settings.h

@@ -8,7 +8,7 @@
 #include <toolbox/saved_struct.h>
 #include <storage/storage.h>
 
-#define DESKTOP_SETTINGS_VER (9)
+#define DESKTOP_SETTINGS_VER (10)
 
 #define DESKTOP_SETTINGS_PATH INT_PATH(DESKTOP_SETTINGS_FILE_NAME)
 #define DESKTOP_SETTINGS_MAGIC (0x17)
@@ -36,6 +36,22 @@
 #define MIN_PIN_SIZE 4
 #define MAX_APP_LENGTH 128
 
+typedef enum {
+    FavoriteAppLeftShort = 0,
+    FavoriteAppLeftLong,
+    FavoriteAppRightShort,
+    FavoriteAppRightLong,
+    FavoriteAppNumber,
+} FavoriteAppShortcut;
+
+typedef enum {
+    DummyAppLeft = 0,
+    DummyAppRight,
+    DummyAppDown,
+    DummyAppOk,
+    DummyAppNumber,
+} DummyAppShortcut;
+
 typedef struct {
     InputKey data[MAX_PIN_SIZE];
     uint8_t length;
@@ -46,10 +62,10 @@ typedef struct {
 } FavoriteApp;
 
 typedef struct {
-    FavoriteApp favorite_primary;
-    FavoriteApp favorite_secondary;
     PinCode pin_code;
     uint32_t auto_lock_delay_ms;
     uint8_t dummy_mode;
     uint8_t display_clock;
+    FavoriteApp favorite_apps[FavoriteAppNumber];
+    FavoriteApp dummy_apps[DummyAppNumber];
 } DesktopSettings;

applications/services/desktop/scenes/desktop_scene_locked.c

@@ -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);

applications/services/desktop/scenes/desktop_scene_main.c

@@ -12,10 +12,6 @@
 
 #define TAG "DesktopSrv"
 
-#define MUSIC_PLAYER_APP EXT_PATH("/apps/Media/music_player.fap")
-#define SNAKE_GAME_APP EXT_PATH("/apps/Games/snake_game.fap")
-#define CLOCK_APP EXT_PATH("/apps/Tools/clock.fap")
-
 static void desktop_scene_main_new_idle_animation_callback(void* context) {
     furi_assert(context);
     Desktop* desktop = context;
@@ -65,8 +61,15 @@ static void
 }
 #endif
 
-static void desktop_scene_main_open_app_or_profile(Desktop* desktop, const char* path) {
+static void desktop_scene_main_open_app_or_profile(Desktop* desktop, FavoriteApp* application) {
-    if(loader_start_with_gui_error(desktop->loader, path, NULL) != LoaderStatusOk) {
+    bool load_ok = false;
+    if(strlen(application->name_or_path) > 0) {
+        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);
     }
 }
@@ -115,6 +118,11 @@ bool desktop_scene_main_on_event(void* context, SceneManagerEvent event) {
             consumed = true;
         } break;
 
+        case DesktopMainEventLock:
+            desktop_lock(desktop);
+            consumed = true;
+            break;
+
         case DesktopMainEventOpenLockMenu:
             scene_manager_next_scene(desktop->scene_manager, DesktopSceneLockMenu);
             consumed = true;
@@ -138,16 +146,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 DesktopMainEventOpenFavoriteRightShort:
+            DESKTOP_SETTINGS_LOAD(&desktop->settings);
+            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;
@@ -158,26 +181,31 @@ 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);
+        case DesktopDummyEventOpenLeft:
+            desktop_scene_main_open_app_or_profile(
+                desktop, &desktop->settings.dummy_apps[DummyAppLeft]);
             break;
-        }
+        case DesktopDummyEventOpenDown:
-        case DesktopMainEventOpenGame: {
+            desktop_scene_main_open_app_or_profile(
-            desktop_scene_main_open_app_or_profile(desktop, SNAKE_GAME_APP);
+                desktop, &desktop->settings.dummy_apps[DummyAppDown]);
             break;
-        }
+        case DesktopDummyEventOpenOk:
-        case DesktopMainEventOpenClock: {
+            desktop_scene_main_open_app_or_profile(
-            desktop_scene_main_open_app_or_profile(desktop, CLOCK_APP);
+                desktop, &desktop->settings.dummy_apps[DummyAppOk]);
             break;
-        }
+
-        case DesktopMainEventOpenMusicPlayer: {
-            desktop_scene_main_open_app_or_profile(desktop, MUSIC_PLAYER_APP);
-            break;
-        }
         case DesktopLockedEventUpdate:
             desktop_view_locked_update(desktop->locked_view);
             consumed = true;

applications/services/desktop/views/desktop_events.h

@@ -1,22 +1,25 @@
 #pragma once
 
 typedef enum {
+    DesktopMainEventLock,
     DesktopMainEventOpenLockMenu,
     DesktopMainEventOpenArchive,
-    DesktopMainEventOpenFavoritePrimary,
+    DesktopMainEventOpenFavoriteLeftShort,
-    DesktopMainEventOpenFavoriteSecondary,
+    DesktopMainEventOpenFavoriteLeftLong,
+    DesktopMainEventOpenFavoriteRightShort,
+    DesktopMainEventOpenFavoriteRightLong,
     DesktopMainEventOpenMenu,
     DesktopMainEventOpenDebug,
-    DesktopMainEventOpenPassport,
     DesktopMainEventOpenPowerOff,
 
-    DesktopMainEventOpenGame,
+    DesktopDummyEventOpenLeft,
-    DesktopMainEventOpenClock,
+    DesktopDummyEventOpenDown,
-    DesktopMainEventOpenMusicPlayer,
+    DesktopDummyEventOpenOk,
 
     DesktopLockedEventUnlocked,
     DesktopLockedEventUpdate,
     DesktopLockedEventShowPinInput,
+    DesktopLockedEventDoorsClosed,
 
     DesktopPinInputEventResetWrongPinLabel,
     DesktopPinInputEventUnlocked,

applications/services/desktop/views/desktop_view_locked.c

@@ -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;

applications/services/desktop/views/desktop_view_main.c

@@ -59,28 +59,32 @@ 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(DesktopMainEventOpenFavoriteRightLong, main_view->context);
             }
         }
     } else {
         if(event->type == InputTypeShort) {
             if(event->key == InputKeyOk) {
-                main_view->callback(DesktopMainEventOpenGame, main_view->context);
+                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(DesktopMainEventOpenMusicPlayer, main_view->context);
+                main_view->callback(DesktopDummyEventOpenDown, main_view->context);
             } else if(event->key == InputKeyLeft) {
-                main_view->callback(DesktopMainEventOpenClock, main_view->context);
+                main_view->callback(DesktopDummyEventOpenLeft, main_view->context);
             }
-            // Right key is handled by animation manager
+            // Right key short is handled by animation manager
         }
     }
 

applications/settings/desktop_settings/scenes/desktop_settings_scene_favorite.c

@@ -1,17 +1,19 @@
 #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 DEFAULT_INDEX (0)
-#define EXTERNAL_BROWSER_INDEX (APPS_COUNT + 1)
+#define EXTERNAL_BROWSER_NAME ("Apps Menu (Default)")
+#define PASSPORT_NAME ("Passport (Default)")
 
+#define EXTERNAL_APPLICATION_INDEX (1)
 #define EXTERNAL_APPLICATION_NAME ("[Select App]")
-#define EXTERNAL_APPLICATION_INDEX (APPS_COUNT + 2)
 
 #define PRESELECTED_SPECIAL 0xffffffff
 
@@ -55,28 +57,32 @@ 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 = primary_favorite ? &app->settings.favorite_primary :
+    FavoriteApp* curr_favorite_app = NULL;
-                                                        &app->settings.favorite_secondary;
+    bool is_dummy_app = false;
+    bool default_passport = false;
 
-    for(size_t i = 0; i < APPS_COUNT; i++) {
+    if((favorite_id & SCENE_STATE_SET_DUMMY_APP) == 0) {
-        const char* name = favorite_fap_get_app_name(i);
+        furi_assert(favorite_id < FavoriteAppNumber);
-
+        curr_favorite_app = &app->settings.favorite_apps[favorite_id];
-        submenu_add_item(submenu, name, i, desktop_settings_scene_favorite_submenu_callback, app);
+        if(favorite_id == FavoriteAppRightShort) {
-
+            default_passport = true;
-        // Select favorite item in submenu
-        if(!strcmp(name, curr_favorite_app->name_or_path)) {
-            pre_select_item = i;
         }
+    } else {
+        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;
     }
 
     // Special case: Application browser
     submenu_add_item(
         submenu,
-        EXTERNAL_BROWSER_NAME,
+        default_passport ? (PASSPORT_NAME) : (EXTERNAL_BROWSER_NAME),
-        EXTERNAL_BROWSER_INDEX,
+        DEFAULT_INDEX,
         desktop_settings_scene_favorite_submenu_callback,
         app);
 
@@ -88,16 +94,29 @@ 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 + 2, 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 + 2;
+            }
+        }
+    }
+
     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 {
             pre_select_item = EXTERNAL_APPLICATION_INDEX;
         }
     }
 
-    submenu_set_header(
+    submenu_set_header(submenu, is_dummy_app ? ("Dummy Mode app:") : ("Favorite app:"));
-        submenu, primary_favorite ? "Primary favorite app:" : "Secondary 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);
@@ -108,13 +127,20 @@ 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 = primary_favorite ? &app->settings.favorite_primary :
+    FavoriteApp* curr_favorite_app = NULL;
-                                                        &app->settings.favorite_secondary;
+    if((favorite_id & SCENE_STATE_SET_DUMMY_APP) == 0) {
+        furi_assert(favorite_id < FavoriteAppNumber);
+        curr_favorite_app = &app->settings.favorite_apps[favorite_id];
+    } else {
+        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 == EXTERNAL_APPLICATION_INDEX) {
@@ -142,7 +168,8 @@ bool desktop_settings_scene_favorite_on_event(void* context, SceneManagerEvent e
                 consumed = true;
             }
         } else {
-            const char* name = favorite_fap_get_app_name(event.event);
+            size_t app_index = event.event - 2;
+            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;
         }

applications/settings/desktop_settings/scenes/desktop_settings_scene_i.h

@@ -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)

applications/settings/desktop_settings/scenes/desktop_settings_scene_start.c

@@ -3,15 +3,24 @@
 
 #include "../desktop_settings_app.h"
 #include "desktop_settings_scene.h"
+#include "desktop_settings_scene_i.h"
 
-#define SCENE_EVENT_SELECT_FAVORITE_PRIMARY 0
+typedef enum {
-#define SCENE_EVENT_SELECT_FAVORITE_SECONDARY 1
+    DesktopSettingsPinSetup = 0,
-#define SCENE_EVENT_SELECT_PIN_SETUP 2
+    DesktopSettingsAutoLockDelay,
-#define SCENE_EVENT_SELECT_AUTO_LOCK_DELAY 3
+    DesktopSettingsClockDisplay,
-#define SCENE_EVENT_SELECT_CLOCK_DISPLAY 4
+    DesktopSettingsFavoriteLeftShort,
+    DesktopSettingsFavoriteLeftLong,
+    DesktopSettingsFavoriteRightShort,
+    DesktopSettingsFavoriteRightLong,
+    DesktopSettingsDummyLeft,
+    DesktopSettingsDummyRight,
+    DesktopSettingsDummyDown,
+    DesktopSettingsDummyOk,
+} DesktopSettingsEntry;
 
 #define AUTO_LOCK_DELAY_COUNT 6
-const char* const auto_lock_delay_text[AUTO_LOCK_DELAY_COUNT] = {
+static const char* const auto_lock_delay_text[AUTO_LOCK_DELAY_COUNT] = {
     "OFF",
     "30s",
     "60s",
@@ -19,8 +28,7 @@ const char* const auto_lock_delay_text[AUTO_LOCK_DELAY_COUNT] = {
     "5min",
     "10min",
 };
-
+static const uint32_t auto_lock_delay_value[AUTO_LOCK_DELAY_COUNT] =
-const uint32_t auto_lock_delay_value[AUTO_LOCK_DELAY_COUNT] =
     {0, 30000, 60000, 120000, 300000, 600000};
 
 #define CLOCK_ENABLE_COUNT 2
@@ -59,10 +67,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, "PIN Setup", 1, NULL, NULL);
 
     item = variable_item_list_add(
@@ -72,8 +76,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);
@@ -91,6 +93,19 @@ void desktop_settings_scene_start_on_enter(void* context) {
     variable_item_set_current_value_index(item, value_index);
     variable_item_set_current_value_text(item, clock_enable_text[value_index]);
 
+    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, "Dummy Mode App - Left", 1, NULL, NULL);
+    variable_item_list_add(variable_item_list, "Dummy Mode App - Right", 1, NULL, NULL);
+    variable_item_list_add(variable_item_list, "Dummy Mode App - Down", 1, NULL, NULL);
+    variable_item_list_add(variable_item_list, "Dummy Mode App - Ok", 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);
 }
 
@@ -100,25 +115,72 @@ bool desktop_settings_scene_start_on_event(void* context, SceneManagerEvent even
 
     if(event.type == SceneManagerEventTypeCustom) {
         switch(event.event) {
-        case SCENE_EVENT_SELECT_FAVORITE_PRIMARY:
+        case DesktopSettingsPinSetup:
-            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_SECONDARY:
-            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_PIN_SETUP:
             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 DesktopSettingsFavoriteLeftShort:
-            consumed = true;
+            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 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 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 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;
+
+        default:
             break;
         }
+        consumed = true;
     }
     return consumed;
 }