Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-12 10:38:36 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge desktop service changes, refactor some old code

Browse Source
This commit is contained in:
Willy-JL
2024-08-08 00:40:32 +02:00
parent b14944b029
commit 7905b829cf
6 changed files with 243 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
applications/services/desktop/application.fam
View File

@@ -14,5 +14,5 @@ App(
conflicts=["updater"],
stack_size=2 * 1024,
order=60,
sdk_headers=["desktop_settings.h"],
sdk_headers=["desktop.h"],
)

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

@@ -1,32 +1,26 @@
#include <storage/storage.h>
#include <assets_icons.h>
#include <gui/gui.h>
#include <gui/gui_i.h>
#include <gui/view_stack.h>
#include <notification/notification.h>
#include <notification/notification_messages.h>
#include <furi.h>
#include <furi_hal.h>
#include "desktop_i.h"
#include <cli/cli.h>
#include <cli/cli_vcp.h>
#include <locale/locale.h>
#include <applications/main/archive/helpers/archive_helpers_ext.h>
#include <momentum/momentum.h>
#include "animations/animation_manager.h"
#include "desktop/scenes/desktop_scene.h"
#include "desktop/scenes/desktop_scene_i.h"
#include "desktop/views/desktop_view_locked.h"
#include "desktop/views/desktop_view_pin_input.h"
#include "desktop/views/desktop_view_pin_timeout.h"
#include "desktop_i.h"
#include "helpers/pin.h"
#include <gui/gui_i.h>
#include <locale/locale.h>
#include <storage/storage.h>
#include <momentum/settings.h>
#include <applications/main/archive/helpers/archive_helpers_ext.h>
#include <assets_icons.h>
#include "scenes/desktop_scene.h"
#include "scenes/desktop_scene_locked.h"
#define TAG "Desktop"
static void desktop_auto_lock_arm(Desktop*);
static void desktop_auto_lock_inhibit(Desktop*);
static void desktop_start_auto_lock_timer(Desktop*);
static void desktop_apply_settings(Desktop*);
static void desktop_loader_callback(const void* message, void* context) {
furi_assert(context);
@@ -43,6 +37,16 @@ static void desktop_loader_callback(const void* message, void* context) {
}
}
static void desktop_storage_callback(const void* message, void* context) {
furi_assert(context);
Desktop* desktop = context;
const StorageEvent* event = message;
if(event->type == StorageEventTypeCardMount) {
view_dispatcher_send_custom_event(desktop->view_dispatcher, DesktopGlobalReloadSettings);
}
}
static void desktop_lock_icon_draw_callback(Canvas* canvas, void* context) {
UNUSED(context);
furi_assert(canvas);
@@ -117,27 +121,39 @@ static bool desktop_custom_event_callback(void* context, uint32_t event) {
furi_assert(context);
Desktop* desktop = (Desktop*)context;
switch(event) {
case DesktopGlobalBeforeAppStarted:
if(event == DesktopGlobalBeforeAppStarted) {
if(animation_manager_is_animation_loaded(desktop->animation_manager)) {
animation_manager_unload_and_stall_animation(desktop->animation_manager);
}
desktop_auto_lock_inhibit(desktop);
desktop->app_running = true;
furi_semaphore_release(desktop->animation_semaphore);
return true;
case DesktopGlobalAfterAppFinished:
} else if(event == DesktopGlobalAfterAppFinished) {
animation_manager_load_and_continue_animation(desktop->animation_manager);
desktop_clock_reconfigure(desktop);
desktop_auto_lock_arm(desktop);
return true;
case DesktopGlobalAutoLock:
if(!loader_is_locked(desktop->loader) && !desktop->locked) {
desktop->app_running = false;
} else if(event == DesktopGlobalAutoLock) {
if(!desktop->app_running && !desktop->locked) {
desktop_lock(desktop, desktop->settings.auto_lock_with_pin);
}
return true;
} else if(event == DesktopGlobalSaveSettings) {
desktop_settings_save(&desktop->settings);
desktop_apply_settings(desktop);
} else if(event == DesktopGlobalReloadSettings) {
desktop_settings_load(&desktop->settings);
desktop_apply_settings(desktop);
} else {
return scene_manager_handle_custom_event(desktop->scene_manager, event);
}
return scene_manager_handle_custom_event(desktop->scene_manager, event);
return true;
}
static bool desktop_back_event_callback(void* context) {
@@ -205,87 +221,42 @@ static void desktop_clock_timer_callback(void* context) {
furi_assert(context);
Desktop* desktop = context;
if(gui_active_view_port_count(desktop->gui, GuiLayerStatusBarLeft) < 6) {
const bool clock_enabled = gui_active_view_port_count(desktop->gui, GuiLayerStatusBarLeft) < 6;
if(clock_enabled) {
desktop_clock_update(desktop);
view_port_enabled_set(desktop->clock_viewport, true);
} else {
view_port_enabled_set(desktop->clock_viewport, false);
}
view_port_enabled_set(desktop->clock_viewport, clock_enabled);
}
void desktop_lock(Desktop* desktop, bool pin_lock) {
furi_assert(!desktop->locked);
pin_lock = pin_lock && desktop_pin_is_valid(&desktop->settings.pin_code);
if(!furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock)) {
furi_hal_rtc_set_pin_fails(0);
}
if(pin_lock) {
furi_hal_rtc_set_flag(FuriHalRtcFlagLock);
Cli* cli = furi_record_open(RECORD_CLI);
cli_session_close(cli);
furi_record_close(RECORD_CLI);
if(!momentum_settings.allow_locked_rpc_commands) {
Bt* bt = furi_record_open(RECORD_BT);
bt_close_rpc_connection(bt);
furi_record_close(RECORD_BT);
}
}
desktop_auto_lock_inhibit(desktop);
scene_manager_set_scene_state(
desktop->scene_manager, DesktopSceneLocked, SCENE_LOCKED_FIRST_ENTER);
scene_manager_next_scene(desktop->scene_manager, DesktopSceneLocked);
DesktopStatus status = {.locked = true};
furi_pubsub_publish(desktop->status_pubsub, &status);
desktop->locked = true;
}
void desktop_unlock(Desktop* desktop) {
furi_assert(desktop->locked);
view_port_enabled_set(desktop->lock_icon_viewport, false);
Gui* gui = furi_record_open(RECORD_GUI);
gui_set_lockdown(gui, false);
furi_record_close(RECORD_GUI);
desktop_view_locked_unlock(desktop->locked_view);
scene_manager_search_and_switch_to_previous_scene(desktop->scene_manager, DesktopSceneMain);
desktop_auto_lock_arm(desktop);
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock)) {
furi_hal_rtc_reset_flag(FuriHalRtcFlagLock);
furi_hal_rtc_set_pin_fails(0);
Cli* cli = furi_record_open(RECORD_CLI);
cli_session_open(cli, &cli_vcp);
furi_record_close(RECORD_CLI);
}
Bt* bt = furi_record_open(RECORD_BT);
bt_open_rpc_connection(bt);
furi_record_close(RECORD_BT);
DesktopStatus status = {.locked = false};
furi_pubsub_publish(desktop->status_pubsub, &status);
desktop->locked = false;
}
void desktop_set_stealth_mode_state(Desktop* desktop, bool enabled) {
static void desktop_apply_settings(Desktop* desktop) {
desktop->in_transition = true;
if(enabled) {
furi_hal_rtc_set_flag(FuriHalRtcFlagStealthMode);
} else {
furi_hal_rtc_reset_flag(FuriHalRtcFlagStealthMode);
desktop_clock_reconfigure(desktop);
view_port_enabled_set(desktop->dummy_mode_icon_viewport, desktop->settings.dummy_mode);
if(!desktop->app_running && !desktop->locked) {
desktop_auto_lock_arm(desktop);
}
desktop_lock_menu_set_stealth_mode_state(desktop->lock_menu, enabled);
view_port_enabled_set(desktop->stealth_mode_icon_viewport, enabled);
desktop->in_transition = false;
}
Desktop* desktop_alloc(void) {
static void desktop_init_settings(Desktop* desktop) {
furi_pubsub_subscribe(storage_get_pubsub(desktop->storage), desktop_storage_callback, desktop);
if(storage_sd_status(desktop->storage) != FSE_OK) {
FURI_LOG_D(TAG, "SD Card not ready, skipping settings");
return;
}
desktop_settings_load(&desktop->settings);
desktop_apply_settings(desktop);
}
static Desktop* desktop_alloc(void) {
Desktop* desktop = malloc(sizeof(Desktop));
desktop->animation_semaphore = furi_semaphore_alloc(1, 0);
@@ -383,16 +354,14 @@ Desktop* desktop_alloc(void) {
}
gui_add_view_port(desktop->gui, desktop->stealth_mode_icon_viewport, GuiLayerStatusBarLeft);
// Unload animations before starting an application
desktop->loader = furi_record_open(RECORD_LOADER);
furi_pubsub_subscribe(loader_get_pubsub(desktop->loader), desktop_loader_callback, desktop);
desktop->storage = furi_record_open(RECORD_STORAGE);
desktop->notification = furi_record_open(RECORD_NOTIFICATION);
desktop->app_start_stop_subscription = furi_pubsub_subscribe(
loader_get_pubsub(desktop->loader), desktop_loader_callback, desktop);
desktop->input_events_pubsub = furi_record_open(RECORD_INPUT_EVENTS);
desktop->input_events_subscription = NULL;
desktop->ascii_events_pubsub = furi_record_open(RECORD_ASCII_EVENTS);
desktop->ascii_events_subscription = NULL;
desktop->auto_lock_timer =
furi_timer_alloc(desktop_auto_lock_timer_callback, FuriTimerTypeOnce, desktop);
@@ -402,19 +371,95 @@ Desktop* desktop_alloc(void) {
desktop->update_clock_timer =
furi_timer_alloc(desktop_clock_timer_callback, FuriTimerTypePeriodic, desktop);
desktop->app_running = loader_is_locked(desktop->loader);
furi_record_create(RECORD_DESKTOP, desktop);
return desktop;
}
static bool desktop_check_file_flag(const char* flag_path) {
Storage* storage = furi_record_open(RECORD_STORAGE);
bool exists = storage_common_stat(storage, flag_path, NULL) == FSE_OK;
furi_record_close(RECORD_STORAGE);
/*
* Private API
*/
return exists;
void desktop_lock(Desktop* desktop, bool with_pin) {
furi_assert(!desktop->locked);
with_pin = with_pin && desktop_pin_code_is_set();
if(!furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock)) {
furi_hal_rtc_set_pin_fails(0);
}
if(with_pin) {
furi_hal_rtc_set_flag(FuriHalRtcFlagLock);
if(!momentum_settings.allow_locked_rpc_commands) {
Cli* cli = furi_record_open(RECORD_CLI);
cli_session_close(cli);
furi_record_close(RECORD_CLI);
Bt* bt = furi_record_open(RECORD_BT);
bt_close_rpc_connection(bt);
furi_record_close(RECORD_BT);
}
}
desktop_auto_lock_inhibit(desktop);
scene_manager_set_scene_state(
desktop->scene_manager, DesktopSceneLocked, DesktopSceneLockedStateFirstEnter);
scene_manager_next_scene(desktop->scene_manager, DesktopSceneLocked);
DesktopStatus status = {.locked = true};
furi_pubsub_publish(desktop->status_pubsub, &status);
desktop->locked = true;
}
void desktop_unlock(Desktop* desktop) {
furi_assert(desktop->locked);
view_port_enabled_set(desktop->lock_icon_viewport, false);
Gui* gui = furi_record_open(RECORD_GUI);
gui_set_lockdown(gui, false);
furi_record_close(RECORD_GUI);
desktop_view_locked_unlock(desktop->locked_view);
scene_manager_search_and_switch_to_previous_scene(desktop->scene_manager, DesktopSceneMain);
desktop_auto_lock_arm(desktop);
bool with_pin = furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock);
furi_hal_rtc_reset_flag(FuriHalRtcFlagLock);
furi_hal_rtc_set_pin_fails(0);
if(with_pin) {
Cli* cli = furi_record_open(RECORD_CLI);
cli_session_open(cli, &cli_vcp);
furi_record_close(RECORD_CLI);
Bt* bt = furi_record_open(RECORD_BT);
bt_open_rpc_connection(bt);
furi_record_close(RECORD_BT);
}
DesktopStatus status = {.locked = false};
furi_pubsub_publish(desktop->status_pubsub, &status);
desktop->locked = false;
}
void desktop_set_stealth_mode_state(Desktop* desktop, bool enabled) {
desktop->in_transition = true;
if(enabled) {
furi_hal_rtc_set_flag(FuriHalRtcFlagStealthMode);
} else {
furi_hal_rtc_reset_flag(FuriHalRtcFlagStealthMode);
}
view_port_enabled_set(desktop->stealth_mode_icon_viewport, enabled);
desktop->in_transition = false;
}
/*
* Public API
*/
bool desktop_api_is_locked(Desktop* instance) {
furi_assert(instance);
return furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock);
@@ -430,6 +475,26 @@ FuriPubSub* desktop_api_get_status_pubsub(Desktop* instance) {
return instance->status_pubsub;
}
void desktop_api_reload_settings(Desktop* instance) {
furi_assert(instance);
view_dispatcher_send_custom_event(instance->view_dispatcher, DesktopGlobalReloadSettings);
}
void desktop_api_get_settings(Desktop* instance, DesktopSettings* settings) {
furi_assert(instance);
furi_assert(settings);
*settings = instance->settings;
}
void desktop_api_set_settings(Desktop* instance, const DesktopSettings* settings) {
furi_assert(instance);
furi_assert(settings);
instance->settings = *settings;
view_dispatcher_send_custom_event(instance->view_dispatcher, DesktopGlobalSaveSettings);
}
static const KeybindType keybind_types[] = {
[InputTypeShort] = KeybindTypePress,
[InputTypeLong] = KeybindTypeHold,
@@ -479,6 +544,10 @@ void desktop_run_keybind(Desktop* instance, InputType _type, InputKey _key) {
}
}
/*
* Application thread
*/
int32_t desktop_srv(void* p) {
UNUSED(p);
@@ -491,31 +560,15 @@ int32_t desktop_srv(void* p) {
Desktop* desktop = desktop_alloc();
bool ok = DESKTOP_SETTINGS_LOAD(&desktop->settings);
if(ok && desktop->settings.pin_code.length) {
ok = desktop_pin_is_valid(&desktop->settings.pin_code);
}
if(!ok) {
memset(&desktop->settings, 0, sizeof(desktop->settings));
furi_hal_rtc_reset_flag(FuriHalRtcFlagLock);
furi_hal_rtc_set_pin_fails(0);
}
DESKTOP_KEYBINDS_LOAD(&desktop->keybinds, sizeof(desktop->keybinds));
desktop_clock_reconfigure(desktop);
desktop_init_settings(desktop);
scene_manager_next_scene(desktop->scene_manager, DesktopSceneMain);
if(momentum_settings.lock_on_boot || furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock)) {
desktop_lock(desktop, true);
} else {
if(!loader_is_locked(desktop->loader)) {
desktop_auto_lock_arm(desktop);
}
}
if(desktop_check_file_flag(SLIDESHOW_FS_PATH)) {
if(storage_file_exists(desktop->storage, SLIDESHOW_FS_PATH)) {
scene_manager_next_scene(desktop->scene_manager, DesktopSceneSlideshow);
}
@@ -539,14 +592,12 @@ int32_t desktop_srv(void* p) {
}
// Special case: autostart application is already running
if(loader_is_locked(desktop->loader) &&
animation_manager_is_animation_loaded(desktop->animation_manager)) {
if(desktop->app_running && animation_manager_is_animation_loaded(desktop->animation_manager)) {
animation_manager_unload_and_stall_animation(desktop->animation_manager);
}
view_dispatcher_run(desktop->view_dispatcher);
furi_crash("That was unexpected");
// Should never get here (a service thread will crash automatically if it returns)
return 0;
}

43
applications/services/desktop/scenes/desktop_scene_lock_menu.c
View File

@@ -10,10 +10,17 @@
#include <desktop/desktop_settings.h>
#include "../views/desktop_view_lock_menu.h"
#include "desktop_scene.h"
#include "../helpers/pin.h"
#include "../helpers/pin_code.h"
#include <power/power_service/power.h>
#define TAG "DesktopSceneLock"
typedef enum {
CheckPinNo,
CheckPinLock,
CheckPinLockOff,
} CheckPin;
void desktop_scene_lock_menu_callback(DesktopEvent event, void* context) {
Desktop* desktop = (Desktop*)context;
view_dispatcher_send_custom_event(desktop->view_dispatcher, event);
@@ -22,17 +29,14 @@ void desktop_scene_lock_menu_callback(DesktopEvent event, void* context) {
void desktop_scene_lock_menu_on_enter(void* context) {
Desktop* desktop = (Desktop*)context;
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, CheckPinNo);
desktop_lock_menu_set_callback(desktop->lock_menu, desktop_scene_lock_menu_callback, desktop);
desktop_lock_menu_set_pin_state(
desktop->lock_menu, desktop_pin_is_valid(&desktop->settings.pin_code));
desktop_lock_menu_set_pin_state(desktop->lock_menu, desktop_pin_code_is_set());
desktop_lock_menu_set_stealth_mode_state(
desktop->lock_menu, furi_hal_rtc_is_flag_set(FuriHalRtcFlagStealthMode));
desktop_lock_menu_set_idx(desktop->lock_menu, 3);
Gui* gui = furi_record_open(RECORD_GUI);
gui_set_hide_statusbar(gui, true);
furi_record_close(RECORD_GUI);
gui_set_hide_statusbar(desktop->gui, true);
view_dispatcher_switch_to_view(desktop->view_dispatcher, DesktopViewIdLockMenu);
}
@@ -57,13 +61,14 @@ bool desktop_scene_lock_menu_on_event(void* context, SceneManagerEvent event) {
bool consumed = false;
if(event.type == SceneManagerEventTypeTick) {
int check_pin_changed =
CheckPin check_pin_changed =
scene_manager_get_scene_state(desktop->scene_manager, DesktopSceneLockMenu);
if(check_pin_changed && desktop_pin_code_is_set()) {
if(check_pin_changed != CheckPinNo && desktop_pin_code_is_set()) {
desktop_lock_menu_set_pin_state(desktop->lock_menu, true);
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
scene_manager_set_scene_state(
desktop->scene_manager, DesktopSceneLockMenu, CheckPinNo);
desktop_lock(desktop, true);
if(check_pin_changed == 2) {
if(check_pin_changed == CheckPinLockOff) {
Power* power = furi_record_open(RECORD_POWER);
furi_delay_ms(500);
power_off(power);
@@ -85,18 +90,19 @@ bool desktop_scene_lock_menu_on_event(void* context, SceneManagerEvent event) {
break;
case DesktopLockMenuEventLockPinCode:
desktop_scene_lock_menu_save_settings(desktop);
if(desktop_pin_is_valid(&desktop->settings.pin_code)) {
if(desktop_pin_code_is_set()) {
desktop_lock(desktop, true);
} else {
loader_start_detached_with_gui_error(
desktop->loader, "Desktop", DESKTOP_SETTINGS_RUN_PIN_SETUP_ARG);
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 1);
scene_manager_set_scene_state(
desktop->scene_manager, DesktopSceneLockMenu, CheckPinLock);
}
consumed = true;
break;
case DesktopLockMenuEventLockPinOff:
desktop_scene_lock_menu_save_settings(desktop);
if(desktop_pin_is_valid(&desktop->settings.pin_code)) {
if(desktop_pin_code_is_set()) {
desktop_lock(desktop, true);
Power* power = furi_record_open(RECORD_POWER);
furi_delay_ms(500);
@@ -105,7 +111,8 @@ bool desktop_scene_lock_menu_on_event(void* context, SceneManagerEvent event) {
} else {
loader_start_detached_with_gui_error(
desktop->loader, "Desktop", DESKTOP_SETTINGS_RUN_PIN_SETUP_ARG);
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 2);
scene_manager_set_scene_state(
desktop->scene_manager, DesktopSceneLockMenu, CheckPinLockOff);
}
consumed = true;
break;
@@ -124,7 +131,7 @@ bool desktop_scene_lock_menu_on_event(void* context, SceneManagerEvent event) {
break;
}
} else if(event.type == SceneManagerEventTypeBack) {
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, CheckPinNo);
}
return consumed;
}
@@ -133,7 +140,5 @@ void desktop_scene_lock_menu_on_exit(void* context) {
Desktop* desktop = (Desktop*)context;
desktop_scene_lock_menu_save_settings(desktop);
Gui* gui = furi_record_open(RECORD_GUI);
gui_set_hide_statusbar(gui, false);
furi_record_close(RECORD_GUI);
gui_set_hide_statusbar(desktop->gui, false);
}

3
applications/services/desktop/scenes/desktop_scene_pin_input.c
View File

@@ -59,10 +59,9 @@ static void desktop_scene_pin_input_done_callback(const DesktopPinCode* pin_code
} else {
uint32_t pin_fails = furi_hal_rtc_get_pin_fails() + 1;
if(pin_fails >= 10 && momentum_settings.bad_pins_format) {
furi_hal_rtc_reset_registers();
furi_hal_rtc_set_flag(FuriHalRtcFlagStorageFormatInternal);
storage_sd_format(furi_record_open(RECORD_STORAGE));
furi_record_close(RECORD_STORAGE);
furi_hal_rtc_reset_registers();
power_reboot(PowerBootModeNormal);
}
furi_hal_rtc_set_pin_fails(pin_fails);

44
applications/services/desktop/views/desktop_view_lock_menu.c
View File

@@ -43,7 +43,7 @@ void desktop_lock_menu_set_pin_state(DesktopLockMenuView* lock_menu, bool pin_is
DesktopLockMenuViewModel * model,
{
model->pin_is_set = pin_is_set;
model->pin_lock = pin_is_set;
model->lock_popup_index = pin_is_set; // Select with PIN by default if set
},
true);
}
@@ -166,13 +166,13 @@ void desktop_lock_menu_draw_callback(Canvas* canvas, void* model) {
}
}
if(m->show_lock_menu) {
if(m->show_lock_popup) {
canvas_set_font(canvas, FontSecondary);
elements_bold_rounded_frame(canvas, 24, 4, 80, 56);
canvas_draw_str_aligned(canvas, 64, 16, AlignCenter, AlignCenter, "Keypad Lock");
canvas_draw_str_aligned(canvas, 64, 32, AlignCenter, AlignCenter, "PIN Code Lock");
canvas_draw_str_aligned(canvas, 64, 48, AlignCenter, AlignCenter, "PIN Lock + OFF");
elements_frame(canvas, 28, 8 + m->pin_lock * 16, 72, 15);
elements_frame(canvas, 28, 8 + m->lock_popup_index * 16, 72, 15);
}
}
@@ -187,8 +187,8 @@ bool desktop_lock_menu_input_callback(InputEvent* event, void* context) {
DesktopLockMenuView* lock_menu = context;
uint8_t idx = 0;
int pin_lock = 0;
bool show_lock_menu = false;
bool show_lock_popup = false;
DesktopLockMenuPopupIndex lock_popup_index = 0;
bool stealth_mode = false;
bool consumed = true;
@@ -196,26 +196,28 @@ bool desktop_lock_menu_input_callback(InputEvent* event, void* context) {
lock_menu->view,
DesktopLockMenuViewModel * model,
{
show_lock_menu = model->show_lock_menu;
show_lock_popup = model->show_lock_popup;
stealth_mode = model->stealth_mode;
if((event->type == InputTypeShort) || (event->type == InputTypeRepeat)) {
if(model->show_lock_menu) {
if(model->show_lock_popup) {
if(event->key == InputKeyUp) {
model->pin_lock--;
if(model->pin_lock < 0) {
model->pin_lock = 2;
if(model->lock_popup_index == 0) {
model->lock_popup_index = DesktopLockMenuPopupIndexMAX - 1;
} else {
model->lock_popup_index--;
}
} else if(event->key == InputKeyDown) {
model->pin_lock++;
if(model->pin_lock > 2) {
model->pin_lock = 0;
if(model->lock_popup_index == DesktopLockMenuPopupIndexMAX - 1) {
model->lock_popup_index = 0;
} else {
model->lock_popup_index++;
}
} else if(event->key == InputKeyBack || event->key == InputKeyOk) {
model->show_lock_menu = false;
model->show_lock_popup = false;
}
} else {
if(model->idx == DesktopLockMenuIndexLock && event->key == InputKeyOk) {
model->show_lock_menu = true;
model->show_lock_popup = true;
} else if(model->idx < 6) {
if(event->key == InputKeyUp || event->key == InputKeyDown) {
if(model->idx % 2) {
@@ -250,21 +252,21 @@ bool desktop_lock_menu_input_callback(InputEvent* event, void* context) {
}
}
idx = model->idx;
pin_lock = model->pin_lock;
lock_popup_index = model->lock_popup_index;
},
true);
DesktopEvent desktop_event = 0;
if(show_lock_menu) {
if(show_lock_popup) {
if(event->key == InputKeyOk && event->type == InputTypeShort) {
switch(pin_lock) {
case 0:
switch(lock_popup_index) {
case DesktopLockMenuPopupIndexKeypad:
desktop_event = DesktopLockMenuEventLockKeypad;
break;
case 1:
case DesktopLockMenuPopupIndexPinCode:
desktop_event = DesktopLockMenuEventLockPinCode;
break;
case 2:
case DesktopLockMenuPopupIndexPinOff:
desktop_event = DesktopLockMenuEventLockPinOff;
break;
default:

11
applications/services/desktop/views/desktop_view_lock_menu.h
View File

@@ -23,14 +23,21 @@ struct DesktopLockMenuView {
bool save_bt;
};
typedef enum {
DesktopLockMenuPopupIndexKeypad,
DesktopLockMenuPopupIndexPinCode,
DesktopLockMenuPopupIndexPinOff,
DesktopLockMenuPopupIndexMAX,
} DesktopLockMenuPopupIndex;
typedef struct {
uint8_t idx;
bool _dummy_mode; // Unused, kept for compatibility
bool stealth_mode;
bool pin_is_set;
int pin_lock;
bool show_lock_menu;
bool show_lock_popup;
DesktopLockMenuPopupIndex lock_popup_index;
DesktopLockMenuView* lock_menu;
} DesktopLockMenuViewModel;