Merge branch 'ofw-dev' into dev

:(

applications/services/desktop/desktop.c

@@ -6,6 +6,8 @@
 #include <notification/notification_messages.h>
 #include <furi.h>
 #include <furi_hal.h>
+#include <cli/cli.h>
+#include <cli/cli_vcp.h>
 
 #include "animations/animation_manager.h"
 #include "desktop/scenes/desktop_scene.h"
@@ -14,7 +16,7 @@
 #include "desktop/views/desktop_view_pin_input.h"
 #include "desktop/views/desktop_view_pin_timeout.h"
 #include "desktop_i.h"
-#include "helpers/pin_lock.h"
+#include "helpers/pin.h"
 #include "helpers/slideshow_filename.h"
 
 #define TAG "Desktop"
@@ -70,9 +72,6 @@ static bool desktop_custom_event_callback(void* context, uint32_t event) {
         return true;
     case DesktopGlobalAutoLock:
         if(!loader_is_locked(desktop->loader)) {
-            if(desktop->settings.auto_lock_with_pin && desktop->settings.pin_code.length > 0) {
-                desktop_pin_lock(&desktop->settings);
-            }
             desktop_lock(desktop);
         }
         return true;
@@ -135,6 +134,15 @@ static void desktop_auto_lock_inhibit(Desktop* desktop) {
 }
 
 void desktop_lock(Desktop* desktop) {
+    furi_hal_rtc_set_flag(FuriHalRtcFlagLock);
+    furi_hal_rtc_set_pin_fails(0);
+
+    if(desktop->settings.pin_code.length) {
+        Cli* cli = furi_record_open(RECORD_CLI);
+        cli_session_close(cli);
+        furi_record_close(RECORD_CLI);
+    }
+
     desktop_auto_lock_inhibit(desktop);
     scene_manager_set_scene_state(
         desktop->scene_manager, DesktopSceneLocked, SCENE_LOCKED_FIRST_ENTER);
@@ -150,6 +158,13 @@ void desktop_unlock(Desktop* desktop) {
     desktop_view_locked_unlock(desktop->locked_view);
     scene_manager_search_and_switch_to_previous_scene(desktop->scene_manager, DesktopSceneMain);
     desktop_auto_lock_arm(desktop);
+    furi_hal_rtc_reset_flag(FuriHalRtcFlagLock);
+
+    if(desktop->settings.pin_code.length) {
+        Cli* cli = furi_record_open(RECORD_CLI);
+        cli_session_open(cli, &cli_vcp);
+        furi_record_close(RECORD_CLI);
+    }
 }
 
 void desktop_set_dummy_mode_state(Desktop* desktop, bool enabled) {
@@ -293,11 +308,14 @@ Desktop* desktop_alloc() {
     desktop->auto_lock_timer =
         furi_timer_alloc(desktop_auto_lock_timer_callback, FuriTimerTypeOnce, desktop);
 
+    furi_record_create(RECORD_DESKTOP, desktop);
+
     return desktop;
 }
 
 void desktop_free(Desktop* desktop) {
     furi_assert(desktop);
+    furi_check(furi_record_destroy(RECORD_DESKTOP));
 
     furi_pubsub_unsubscribe(
         loader_get_pubsub(desktop->loader), desktop->app_start_stop_subscription);
@@ -355,6 +373,16 @@ static bool desktop_check_file_flag(const char* flag_path) {
     return exists;
 }
 
+bool desktop_api_is_locked(Desktop* instance) {
+    furi_assert(instance);
+    return furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock);
+}
+
+void desktop_api_unlock(Desktop* instance) {
+    furi_assert(instance);
+    view_dispatcher_send_custom_event(instance->view_dispatcher, DesktopLockedEventUnlocked);
+}
+
 int32_t desktop_srv(void* p) {
     UNUSED(p);
 
@@ -378,14 +406,12 @@ int32_t desktop_srv(void* p) {
 
     scene_manager_next_scene(desktop->scene_manager, DesktopSceneMain);
 
-    desktop_pin_lock_init(&desktop->settings);
+    if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock)) {
-
+        desktop_lock(desktop);
-    if(!desktop_pin_lock_is_locked()) {
+    } else {
         if(!loader_is_locked(desktop->loader)) {
             desktop_auto_lock_arm(desktop);
         }
-    } else {
-        desktop_lock(desktop);
     }
 
     if(desktop_check_file_flag(SLIDESHOW_FS_PATH)) {

applications/services/desktop/desktop.h

@@ -1,3 +1,9 @@
 #pragma once
 
 typedef struct Desktop Desktop;
+
+#define RECORD_DESKTOP "desktop"
+
+bool desktop_api_is_locked(Desktop* instance);
+
+void desktop_api_unlock(Desktop* instance);

applications/services/desktop/desktop_settings.h

@@ -8,7 +8,7 @@
 #include <toolbox/saved_struct.h>
 #include <storage/storage.h>
 
-#define DESKTOP_SETTINGS_VER (8)
+#define DESKTOP_SETTINGS_VER (9)
 
 #define DESKTOP_SETTINGS_PATH INT_PATH(DESKTOP_SETTINGS_FILE_NAME)
 #define DESKTOP_SETTINGS_MAGIC (0x17)
@@ -60,9 +60,7 @@ typedef struct {
     FavoriteApp favorite_secondary;
     FavoriteApp favorite_tertiary;
     PinCode pin_code;
-    uint8_t is_locked;
     uint32_t auto_lock_delay_ms;
     uint8_t displayBatteryPercentage;
     uint8_t dummy_mode;
-    bool auto_lock_with_pin;
 } DesktopSettings;

applications/services/desktop/helpers/pin.c

@@ -0,0 +1,74 @@
+#include "pin.h"
+
+#include <notification/notification.h>
+#include <notification/notification_messages.h>
+#include <stddef.h>
+#include <furi.h>
+#include <furi_hal.h>
+#include <gui/gui.h>
+
+#include "../desktop_i.h"
+
+static const NotificationSequence sequence_pin_fail = {
+    &message_display_backlight_on,
+
+    &message_red_255,
+    &message_vibro_on,
+    &message_delay_100,
+    &message_vibro_off,
+    &message_red_0,
+
+    &message_delay_250,
+
+    &message_red_255,
+    &message_vibro_on,
+    &message_delay_100,
+    &message_vibro_off,
+    &message_red_0,
+    NULL,
+};
+
+static const uint8_t desktop_helpers_fails_timeout[] = {
+    0,
+    0,
+    0,
+    0,
+    30,
+    60,
+    90,
+    120,
+    150,
+    180,
+    /* +60 for every next fail */
+};
+
+void desktop_pin_lock_error_notify() {
+    NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
+    notification_message(notification, &sequence_pin_fail);
+    furi_record_close(RECORD_NOTIFICATION);
+}
+
+uint32_t desktop_pin_lock_get_fail_timeout() {
+    uint32_t pin_fails = furi_hal_rtc_get_pin_fails();
+    uint32_t pin_timeout = 0;
+    uint32_t max_index = COUNT_OF(desktop_helpers_fails_timeout) - 1;
+    if(pin_fails <= max_index) {
+        pin_timeout = desktop_helpers_fails_timeout[pin_fails];
+    } else {
+        pin_timeout = desktop_helpers_fails_timeout[max_index] + (pin_fails - max_index) * 60;
+    }
+
+    return pin_timeout;
+}
+
+bool desktop_pin_compare(const PinCode* pin_code1, const PinCode* pin_code2) {
+    furi_assert(pin_code1);
+    furi_assert(pin_code2);
+    bool result = false;
+
+    if(pin_code1->length == pin_code2->length) {
+        result = !memcmp(pin_code1->data, pin_code2->data, pin_code1->length);
+    }
+
+    return result;
+}

applications/services/desktop/helpers/pin.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <stdbool.h>
+#include <stdint.h>
+#include "../desktop.h"
+#include <desktop/desktop_settings.h>
+
+void desktop_pin_lock_error_notify();
+
+uint32_t desktop_pin_lock_get_fail_timeout();
+
+bool desktop_pin_compare(const PinCode* pin_code1, const PinCode* pin_code2);

applications/services/desktop/helpers/pin_lock.c

@@ -1,140 +0,0 @@
-
-#include <notification/notification.h>
-#include <notification/notification_messages.h>
-#include <stddef.h>
-#include <furi.h>
-#include <furi_hal.h>
-#include <gui/gui.h>
-
-#include "../helpers/pin_lock.h"
-#include "../desktop_i.h"
-#include <cli/cli.h>
-#include <cli/cli_vcp.h>
-
-static const NotificationSequence sequence_pin_fail = {
-    &message_display_backlight_on,
-
-    &message_red_255,
-    &message_vibro_on,
-    &message_delay_100,
-    &message_vibro_off,
-    &message_red_0,
-
-    &message_delay_250,
-
-    &message_red_255,
-    &message_vibro_on,
-    &message_delay_100,
-    &message_vibro_off,
-    &message_red_0,
-    NULL,
-};
-
-static const uint8_t desktop_helpers_fails_timeout[] = {
-    0,
-    0,
-    0,
-    0,
-    30,
-    60,
-    90,
-    120,
-    150,
-    180,
-    /* +60 for every next fail */
-};
-
-void desktop_pin_lock_error_notify() {
-    NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
-    notification_message(notification, &sequence_pin_fail);
-    furi_record_close(RECORD_NOTIFICATION);
-}
-
-uint32_t desktop_pin_lock_get_fail_timeout() {
-    uint32_t pin_fails = furi_hal_rtc_get_pin_fails();
-    uint32_t pin_timeout = 0;
-    uint32_t max_index = COUNT_OF(desktop_helpers_fails_timeout) - 1;
-    if(pin_fails <= max_index) {
-        pin_timeout = desktop_helpers_fails_timeout[pin_fails];
-    } else {
-        pin_timeout = desktop_helpers_fails_timeout[max_index] + (pin_fails - max_index) * 60;
-    }
-
-    return pin_timeout;
-}
-
-void desktop_pin_lock(DesktopSettings* settings) {
-    furi_assert(settings);
-
-    furi_hal_rtc_set_pin_fails(0);
-    furi_hal_rtc_set_flag(FuriHalRtcFlagLock);
-    Cli* cli = furi_record_open(RECORD_CLI);
-    cli_session_close(cli);
-    furi_record_close(RECORD_CLI);
-    settings->is_locked = 1;
-    DESKTOP_SETTINGS_SAVE(settings);
-}
-
-void desktop_pin_unlock(DesktopSettings* settings) {
-    furi_assert(settings);
-
-    furi_hal_rtc_reset_flag(FuriHalRtcFlagLock);
-    Cli* cli = furi_record_open(RECORD_CLI);
-    cli_session_open(cli, &cli_vcp);
-    furi_record_close(RECORD_CLI);
-    settings->is_locked = 0;
-    DESKTOP_SETTINGS_SAVE(settings);
-}
-
-void desktop_pin_lock_init(DesktopSettings* settings) {
-    furi_assert(settings);
-
-    if(settings->pin_code.length > 0) {
-        if(settings->is_locked == 1) {
-            furi_hal_rtc_set_flag(FuriHalRtcFlagLock);
-        } else {
-            if(desktop_pin_lock_is_locked()) {
-                settings->is_locked = 1;
-                DESKTOP_SETTINGS_SAVE(settings);
-            }
-        }
-    } else {
-        furi_hal_rtc_set_pin_fails(0);
-        furi_hal_rtc_reset_flag(FuriHalRtcFlagLock);
-    }
-
-    if(desktop_pin_lock_is_locked()) {
-        Cli* cli = furi_record_open(RECORD_CLI);
-        cli_session_close(cli);
-        furi_record_close(RECORD_CLI);
-    }
-}
-
-bool desktop_pin_lock_verify(const PinCode* pin_set, const PinCode* pin_entered) {
-    bool result = false;
-    if(desktop_pins_are_equal(pin_set, pin_entered)) {
-        furi_hal_rtc_set_pin_fails(0);
-        result = true;
-    } else {
-        uint32_t pin_fails = furi_hal_rtc_get_pin_fails();
-        furi_hal_rtc_set_pin_fails(pin_fails + 1);
-        result = false;
-    }
-    return result;
-}
-
-bool desktop_pin_lock_is_locked() {
-    return furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock);
-}
-
-bool desktop_pins_are_equal(const PinCode* pin_code1, const PinCode* pin_code2) {
-    furi_assert(pin_code1);
-    furi_assert(pin_code2);
-    bool result = false;
-
-    if(pin_code1->length == pin_code2->length) {
-        result = !memcmp(pin_code1->data, pin_code2->data, pin_code1->length);
-    }
-
-    return result;
-}

applications/services/desktop/helpers/pin_lock.h

@@ -1,21 +0,0 @@
-#pragma once
-#include <stdbool.h>
-#include <stdint.h>
-#include "../desktop.h"
-#include <desktop/desktop_settings.h>
-
-void desktop_pin_lock_error_notify();
-
-uint32_t desktop_pin_lock_get_fail_timeout();
-
-void desktop_pin_lock(DesktopSettings* settings);
-
-void desktop_pin_unlock(DesktopSettings* settings);
-
-bool desktop_pin_lock_is_locked();
-
-void desktop_pin_lock_init(DesktopSettings* settings);
-
-bool desktop_pin_lock_verify(const PinCode* pin_set, const PinCode* pin_entered);
-
-bool desktop_pins_are_equal(const PinCode* pin_code1, const PinCode* pin_code2);

applications/services/desktop/scenes/desktop_scene_lock_menu.c

@@ -10,7 +10,7 @@
 #include "../views/desktop_view_lock_menu.h"
 #include "desktop_scene_i.h"
 #include "desktop_scene.h"
-#include "../helpers/pin_lock.h"
+#include "../helpers/pin.h"
 
 #define TAG "DesktopSceneLock"
 
@@ -25,7 +25,6 @@ void desktop_scene_lock_menu_on_enter(void* context) {
     DESKTOP_SETTINGS_LOAD(&desktop->settings);
     scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
     desktop_lock_menu_set_callback(desktop->lock_menu, desktop_scene_lock_menu_callback, desktop);
-    desktop_lock_menu_set_pin_state(desktop->lock_menu, desktop->settings.pin_code.length > 0);
     desktop_lock_menu_set_dummy_mode_state(desktop->lock_menu, desktop->settings.dummy_mode);
     desktop_lock_menu_set_stealth_mode_state(
         desktop->lock_menu, furi_hal_rtc_is_flag_set(FuriHalRtcFlagStealthMode));
@@ -44,7 +43,6 @@ bool desktop_scene_lock_menu_on_event(void* context, SceneManagerEvent event) {
         if(check_pin_changed) {
             DESKTOP_SETTINGS_LOAD(&desktop->settings);
             if(desktop->settings.pin_code.length > 0) {
-                desktop_lock_menu_set_pin_state(desktop->lock_menu, true);
                 scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
             }
         }
@@ -55,21 +53,6 @@ bool desktop_scene_lock_menu_on_event(void* context, SceneManagerEvent event) {
             desktop_lock(desktop);
             consumed = true;
             break;
-        case DesktopLockMenuEventPinLock:
-            if(desktop->settings.pin_code.length > 0) {
-                desktop_pin_lock(&desktop->settings);
-                desktop_lock(desktop);
-            } else {
-                LoaderStatus status =
-                    loader_start(desktop->loader, "Desktop", DESKTOP_SETTINGS_RUN_PIN_SETUP_ARG);
-                if(status == LoaderStatusOk) {
-                    scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 1);
-                } else {
-                    FURI_LOG_E(TAG, "Unable to start desktop settings");
-                }
-            }
-            consumed = true;
-            break;
         case DesktopLockMenuEventDummyModeOn:
             desktop_set_dummy_mode_state(desktop, true);
             scene_manager_search_and_switch_to_previous_scene(

applications/services/desktop/scenes/desktop_scene_locked.c

@@ -7,7 +7,7 @@
 
 #include "../desktop.h"
 #include "../desktop_i.h"
-#include "../helpers/pin_lock.h"
+#include "../helpers/pin.h"
 #include "../animations/animation_manager.h"
 #include "../views/desktop_events.h"
 #include "../views/desktop_view_pin_input.h"
@@ -45,7 +45,7 @@ void desktop_scene_locked_on_enter(void* context) {
     bool switch_to_timeout_scene = false;
     uint32_t state = scene_manager_get_scene_state(desktop->scene_manager, DesktopSceneLocked);
     if(state == SCENE_LOCKED_FIRST_ENTER) {
-        bool pin_locked = desktop_pin_lock_is_locked();
+        bool pin_locked = desktop->settings.pin_code.length > 0;
         view_port_enabled_set(desktop->lock_icon_viewport, true);
         Gui* gui = furi_record_open(RECORD_GUI);
         gui_set_lockdown(gui, true);

applications/services/desktop/scenes/desktop_scene_main.c

@@ -108,13 +108,8 @@ bool desktop_scene_main_on_event(void* context, SceneManagerEvent event) {
             break;
 
         case DesktopMainEventLock:
-            if(desktop->settings.pin_code.length > 0) {
-                desktop_pin_lock(&desktop->settings);
-                desktop_lock(desktop);
-            } else {
             scene_manager_set_scene_state(desktop->scene_manager, DesktopSceneLockMenu, 0);
             desktop_lock(desktop);
-            }
             consumed = true;
             break;
 

applications/services/desktop/scenes/desktop_scene_pin_input.c

@@ -12,7 +12,7 @@
 #include "../animations/animation_manager.h"
 #include "../views/desktop_events.h"
 #include "../views/desktop_view_pin_input.h"
-#include "../helpers/pin_lock.h"
+#include "../helpers/pin.h"
 #include "desktop_scene.h"
 #include "desktop_scene_i.h"
 
@@ -54,9 +54,12 @@ static void desktop_scene_pin_input_back_callback(void* context) {
 
 static void desktop_scene_pin_input_done_callback(const PinCode* pin_code, void* context) {
     Desktop* desktop = (Desktop*)context;
-    if(desktop_pin_lock_verify(&desktop->settings.pin_code, pin_code)) {
+    if(desktop_pin_compare(&desktop->settings.pin_code, pin_code)) {
+        furi_hal_rtc_set_pin_fails(0);
         view_dispatcher_send_custom_event(desktop->view_dispatcher, DesktopPinInputEventUnlocked);
     } else {
+        uint32_t pin_fails = furi_hal_rtc_get_pin_fails();
+        furi_hal_rtc_set_pin_fails(pin_fails + 1);
         view_dispatcher_send_custom_event(
             desktop->view_dispatcher, DesktopPinInputEventUnlockFailed);
     }
@@ -126,7 +129,6 @@ bool desktop_scene_pin_input_on_event(void* context, SceneManagerEvent event) {
             consumed = true;
             break;
         case DesktopPinInputEventUnlocked:
-            desktop_pin_unlock(&desktop->settings);
             desktop_unlock(desktop);
             consumed = true;
             break;

applications/services/desktop/views/desktop_events.h

@@ -36,7 +36,6 @@ typedef enum {
     DesktopDebugEventExit,
 
     DesktopLockMenuEventLock,
-    DesktopLockMenuEventPinLock,
     DesktopLockMenuEventDummyModeOn,
     DesktopLockMenuEventDummyModeOff,
     DesktopLockMenuEventStealthModeOn,

applications/services/desktop/views/desktop_view_lock_menu.c

@@ -23,14 +23,6 @@ void desktop_lock_menu_set_callback(
     lock_menu->context = context;
 }
 
-void desktop_lock_menu_set_pin_state(DesktopLockMenuView* lock_menu, bool pin_is_set) {
-    with_view_model(
-        lock_menu->view,
-        DesktopLockMenuViewModel * model,
-        { model->pin_is_set = pin_is_set; },
-        true);
-}
-
 void desktop_lock_menu_set_dummy_mode_state(DesktopLockMenuView* lock_menu, bool dummy_mode) {
     with_view_model(
         lock_menu->view,
@@ -102,7 +94,6 @@ bool desktop_lock_menu_input_callback(InputEvent* event, void* context) {
     bool consumed = false;
     bool dummy_mode = false;
     bool stealth_mode = false;
-    bool pin_is_set = false;
     bool update = false;
 
     with_view_model(
@@ -131,15 +122,12 @@ bool desktop_lock_menu_input_callback(InputEvent* event, void* context) {
             idx = model->idx;
             dummy_mode = model->dummy_mode;
             stealth_mode = model->stealth_mode;
-            pin_is_set = model->pin_is_set;
         },
         update);
 
     if(event->key == InputKeyOk) {
         if((idx == DesktopLockMenuIndexLock)) {
-            if((pin_is_set) && (event->type == InputTypeLong)) {
+            if(event->type == InputTypeShort) {
-                lock_menu->callback(DesktopLockMenuEventPinLock, lock_menu->context);
-            } else if(event->type == InputTypeShort) {
                 lock_menu->callback(DesktopLockMenuEventLock, lock_menu->context);
             }
         } else if(idx == DesktopLockMenuIndexStealth) {

applications/services/desktop/views/desktop_view_lock_menu.h

@@ -17,7 +17,6 @@ struct DesktopLockMenuView {
 
 typedef struct {
     uint8_t idx;
-    bool pin_is_set;
     bool dummy_mode;
     bool stealth_mode;
 } DesktopLockMenuViewModel;
@@ -28,7 +27,6 @@ void desktop_lock_menu_set_callback(
     void* context);
 
 View* desktop_lock_menu_get_view(DesktopLockMenuView* lock_menu);
-void desktop_lock_menu_set_pin_state(DesktopLockMenuView* lock_menu, bool pin_is_set);
 void desktop_lock_menu_set_dummy_mode_state(DesktopLockMenuView* lock_menu, bool dummy_mode);
 void desktop_lock_menu_set_stealth_mode_state(DesktopLockMenuView* lock_menu, bool stealth_mode);
 void desktop_lock_menu_set_idx(DesktopLockMenuView* lock_menu, uint8_t idx);

applications/services/desktop/views/desktop_view_pin_setup_done.c

@@ -1,79 +0,0 @@
-#include <furi.h>
-#include <furi_hal.h>
-#include <gui/elements.h>
-#include <gui/canvas.h>
-#include <toolbox/version.h>
-#include <assets_icons.h>
-#include <dolphin/helpers/dolphin_state.h>
-#include <dolphin/dolphin.h>
-
-#include "../desktop_i.h"
-#include "desktop_view_pin_setup_done.h"
-
-struct DesktopViewPinSetupDone {
-    View* view;
-    DesktopViewPinSetupDoneDoneCallback callback;
-    void* context;
-};
-
-static void desktop_view_pin_done_draw(Canvas* canvas, void* model) {
-    furi_assert(canvas);
-    UNUSED(model);
-
-    canvas_set_font(canvas, FontPrimary);
-    elements_multiline_text_aligned(
-        canvas, 64, 0, AlignCenter, AlignTop, "Prepare to use\narrows as\nPIN symbols");
-
-    canvas_set_font(canvas, FontSecondary);
-    elements_multiline_text(canvas, 58, 24, "Prepare to use\narrows as\nPIN symbols");
-
-    canvas_draw_icon(canvas, 16, 18, &I_Pin_attention_dpad_29x29);
-    elements_button_right(canvas, "Next");
-}
-
-static bool desktop_view_pin_done_input(InputEvent* event, void* context) {
-    furi_assert(event);
-    furi_assert(context);
-
-    DesktopViewPinSetupDone* instance = context;
-    bool consumed = false;
-
-    if((event->key == InputKeyRight) && (event->type == InputTypeShort)) {
-        instance->callback(instance->context);
-        consumed = true;
-    }
-
-    return consumed;
-}
-
-void desktop_view_pin_done_set_callback(
-    DesktopViewPinSetupDone* instance,
-    DesktopViewPinSetupDoneDoneCallback callback,
-    void* context) {
-    furi_assert(instance);
-    furi_assert(callback);
-    instance->callback = callback;
-    instance->context = context;
-}
-
-DesktopViewPinSetupDone* desktop_view_pin_done_alloc() {
-    DesktopViewPinSetupDone* view = malloc(sizeof(DesktopViewPinSetupDone));
-    view->view = view_alloc();
-    view_set_context(view->view, view);
-    view_set_draw_callback(view->view, desktop_view_pin_done_draw);
-    view_set_input_callback(view->view, desktop_view_pin_done_input);
-
-    return view;
-}
-
-void desktop_view_pin_done_free(DesktopViewPinSetupDone* instance) {
-    furi_assert(instance);
-
-    view_free(instance->view);
-    free(instance);
-}
-
-View* desktop_view_pin_done_get_view(DesktopViewPinSetupDone* instance) {
-    furi_assert(instance);
-    return instance->view;
-}

applications/services/desktop/views/desktop_view_pin_setup_done.h

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <gui/view.h>
-
-typedef struct DesktopViewPinSetupDone DesktopViewPinSetupDone;
-
-typedef void (*DesktopViewPinSetupDoneDoneCallback)(void*);
-
-void desktop_view_pin_done_set_callback(
-    DesktopViewPinSetupDone* instance,
-    DesktopViewPinSetupDoneDoneCallback callback,
-    void* context);
-DesktopViewPinSetupDone* desktop_view_pin_done_alloc();
-void desktop_view_pin_done_free(DesktopViewPinSetupDone* instance);
-View* desktop_view_pin_done_get_view(DesktopViewPinSetupDone* instance);

applications/services/rpc/rpc.c

@@ -57,6 +57,10 @@ static RpcSystemCallbacks rpc_systems[] = {
         .alloc = rpc_system_property_alloc,
         .free = NULL,
     },
+    {
+        .alloc = rpc_desktop_alloc,
+        .free = rpc_desktop_free,
+    },
 };
 
 struct RpcSession {

applications/services/rpc/rpc_desktop.c

@@ -0,0 +1,73 @@
+#include "flipper.pb.h"
+#include "rpc_i.h"
+#include <desktop/desktop.h>
+#include "desktop.pb.h"
+
+#define TAG "RpcDesktop"
+
+typedef struct {
+    RpcSession* session;
+    Desktop* desktop;
+} RpcDesktop;
+
+static void rpc_desktop_on_is_locked_request(const PB_Main* request, void* context) {
+    furi_assert(request);
+    furi_assert(context);
+    furi_assert(request->which_content == PB_Main_desktop_is_locked_request_tag);
+
+    FURI_LOG_D(TAG, "IsLockedRequest");
+    RpcDesktop* rpc_desktop = context;
+    RpcSession* session = rpc_desktop->session;
+
+    PB_CommandStatus ret = desktop_api_is_locked(rpc_desktop->desktop) ? PB_CommandStatus_OK :
+                                                                         PB_CommandStatus_ERROR;
+
+    rpc_send_and_release_empty(session, request->command_id, ret);
+}
+
+static void rpc_desktop_on_unlock_request(const PB_Main* request, void* context) {
+    furi_assert(request);
+    furi_assert(context);
+    furi_assert(request->which_content == PB_Main_desktop_unlock_request_tag);
+
+    FURI_LOG_D(TAG, "UnlockRequest");
+    RpcDesktop* rpc_desktop = context;
+    RpcSession* session = rpc_desktop->session;
+
+    desktop_api_unlock(rpc_desktop->desktop);
+
+    rpc_send_and_release_empty(session, request->command_id, PB_CommandStatus_OK);
+}
+
+void* rpc_desktop_alloc(RpcSession* session) {
+    furi_assert(session);
+
+    RpcDesktop* rpc_desktop = malloc(sizeof(RpcDesktop));
+    rpc_desktop->desktop = furi_record_open(RECORD_DESKTOP);
+    rpc_desktop->session = session;
+
+    RpcHandler rpc_handler = {
+        .message_handler = NULL,
+        .decode_submessage = NULL,
+        .context = rpc_desktop,
+    };
+
+    rpc_handler.message_handler = rpc_desktop_on_is_locked_request;
+    rpc_add_handler(session, PB_Main_desktop_is_locked_request_tag, &rpc_handler);
+
+    rpc_handler.message_handler = rpc_desktop_on_unlock_request;
+    rpc_add_handler(session, PB_Main_desktop_unlock_request_tag, &rpc_handler);
+
+    return rpc_desktop;
+}
+
+void rpc_desktop_free(void* context) {
+    furi_assert(context);
+    RpcDesktop* rpc_desktop = context;
+
+    furi_assert(rpc_desktop->desktop);
+    furi_record_close(RECORD_DESKTOP);
+
+    rpc_desktop->session = NULL;
+    free(rpc_desktop);
+}

applications/services/rpc/rpc_i.h

@@ -36,6 +36,9 @@ void* rpc_system_gpio_alloc(RpcSession* session);
 void rpc_system_gpio_free(void* ctx);
 void* rpc_system_property_alloc(RpcSession* session);
 
+void* rpc_desktop_alloc(RpcSession* session);
+void rpc_desktop_free(void* ctx);
+
 void rpc_debug_print_message(const PB_Main* message);
 void rpc_debug_print_data(const char* prefix, uint8_t* buffer, size_t size);
 

applications/settings/desktop_settings/scenes/desktop_settings_scene_pin_auth.c

@@ -1,7 +1,7 @@
 #include <stdint.h>
 #include <core/check.h>
 #include <gui/scene_manager.h>
-#include <desktop/helpers/pin_lock.h>
+#include <desktop/helpers/pin.h>
 #include "../desktop_settings_app.h"
 #include <desktop/desktop_settings.h>
 #include <desktop/views/desktop_view_pin_input.h>
@@ -18,7 +18,7 @@ static void pin_auth_done_callback(const PinCode* pin_code, void* context) {
     DesktopSettingsApp* app = context;
 
     app->pincode_buffer = *pin_code;
-    if(desktop_pins_are_equal(&app->settings.pin_code, pin_code)) {
+    if(desktop_pin_compare(&app->settings.pin_code, pin_code)) {
         view_dispatcher_send_custom_event(app->view_dispatcher, SCENE_EVENT_PINS_EQUAL);
     } else {
         view_dispatcher_send_custom_event(app->view_dispatcher, SCENE_EVENT_PINS_DIFFERENT);

applications/settings/desktop_settings/scenes/desktop_settings_scene_pin_error.c

@@ -6,7 +6,7 @@
 #include <desktop/views/desktop_view_pin_input.h>
 #include "desktop_settings_scene.h"
 #include "desktop_settings_scene_i.h"
-#include <desktop/helpers/pin_lock.h>
+#include <desktop/helpers/pin.h>
 #include "../desktop_settings_app.h"
 
 #define SCENE_EVENT_EXIT (0U)

applications/settings/desktop_settings/scenes/desktop_settings_scene_pin_setup.c

@@ -7,7 +7,7 @@
 #include <desktop/views/desktop_view_pin_input.h>
 #include "desktop_settings_scene.h"
 #include "desktop_settings_scene_i.h"
-#include <desktop/helpers/pin_lock.h>
+#include <desktop/helpers/pin.h>
 
 #define SCENE_EVENT_EXIT (0U)
 #define SCENE_EVENT_1ST_PIN_ENTERED (1U)
@@ -25,7 +25,7 @@ static void pin_setup_done_callback(const PinCode* pin_code, void* context) {
         view_dispatcher_send_custom_event(app->view_dispatcher, SCENE_EVENT_1ST_PIN_ENTERED);
     } else {
         app->pincode_buffer_filled = false;
-        if(desktop_pins_are_equal(&app->pincode_buffer, pin_code)) {
+        if(desktop_pin_compare(&app->pincode_buffer, pin_code)) {
             view_dispatcher_send_custom_event(app->view_dispatcher, SCENE_EVENT_PINS_EQUAL);
         } else {
             view_dispatcher_send_custom_event(app->view_dispatcher, SCENE_EVENT_PINS_DIFFERENT);

applications/settings/desktop_settings/scenes/desktop_settings_scene_start.c

@@ -10,8 +10,7 @@
 #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_AUTO_LOCK_PIN 5
+#define SCENE_EVENT_SELECT_BATTERY_DISPLAY 5
-#define SCENE_EVENT_SELECT_BATTERY_DISPLAY 6
 
 #define AUTO_LOCK_DELAY_COUNT 9
 const char* const auto_lock_delay_text[AUTO_LOCK_DELAY_COUNT] = {
@@ -63,14 +62,6 @@ static void desktop_settings_scene_start_auto_lock_delay_changed(VariableItem* i
     app->settings.auto_lock_delay_ms = auto_lock_delay_value[index];
 }
 
-static void desktop_settings_scene_start_auto_lock_pin_changed(VariableItem* item) {
-    DesktopSettingsApp* app = variable_item_get_context(item);
-    uint8_t value = variable_item_get_current_value_index(item);
-
-    variable_item_set_current_value_text(item, value ? "ON" : "OFF");
-    app->settings.auto_lock_with_pin = value;
-}
-
 void desktop_settings_scene_start_on_enter(void* context) {
     DesktopSettingsApp* app = context;
     VariableItemList* variable_item_list = app->variable_item_list;
@@ -100,16 +91,6 @@ 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, auto_lock_delay_text[value_index]);
 
-    item = variable_item_list_add(
-        variable_item_list,
-        "Auto Lock Pin",
-        2,
-        desktop_settings_scene_start_auto_lock_pin_changed,
-        app);
-
-    variable_item_set_current_value_index(item, app->settings.auto_lock_with_pin);
-    variable_item_set_current_value_text(item, app->settings.auto_lock_with_pin ? "ON" : "OFF");
-
     item = variable_item_list_add(
         variable_item_list,
         "Battery View",
@@ -155,9 +136,6 @@ bool desktop_settings_scene_start_on_event(void* context, SceneManagerEvent even
         case SCENE_EVENT_SELECT_AUTO_LOCK_DELAY:
             consumed = true;
             break;
-        case SCENE_EVENT_SELECT_AUTO_LOCK_PIN:
-            consumed = true;
-            break;
         case SCENE_EVENT_SELECT_BATTERY_DISPLAY:
             consumed = true;
             break;

assets/protobuf

@@ -1 +1 @@
-Subproject commit 1f6b4a08c5d05c2b17926a3ba79f60109638932f
+Subproject commit a13c5ddd0397511bd4c6de4afdd1031a5b6f5bca

firmware/targets/f7/ble_glue/ble_glue.c

@@ -2,6 +2,7 @@
 #include "app_common.h"
 #include "ble_app.h"
 #include <ble/ble.h>
+#include <hci_tl.h>
 
 #include <interface/patterns/ble_thread/tl/tl.h>
 #include <interface/patterns/ble_thread/shci/shci.h>
@@ -72,6 +73,20 @@ void shci_register_io_bus(tSHciIO* fops) {
     fops->Send = ble_glue_TL_SYS_SendCmd;
 }
 
+static int32_t ble_glue_TL_BLE_SendCmd(uint8_t* buffer, uint16_t size) {
+    if(furi_hal_bt_get_hardfault_info()) {
+        furi_crash("ST(R) Copro(R) HardFault");
+    }
+
+    return TL_BLE_SendCmd(buffer, size);
+}
+
+void hci_register_io_bus(tHciIO* fops) {
+    /* Register IO bus services */
+    fops->Init = TL_BLE_Init;
+    fops->Send = ble_glue_TL_BLE_SendCmd;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 void ble_glue_init() {

lib/stm32wb.scons

@@ -48,7 +48,10 @@ sources += Glob(
 )
 sources += Glob(
     "stm32wb_copro/wpan/interface/patterns/ble_thread/tl/*_tl*.c",
-    exclude="stm32wb_copro/wpan/interface/patterns/ble_thread/tl/shci_tl_if.c",
+    exclude=[
+        "stm32wb_copro/wpan/interface/patterns/ble_thread/tl/hci_tl_if.c",
+        "stm32wb_copro/wpan/interface/patterns/ble_thread/tl/shci_tl_if.c",
+    ],
     source=True,
 )
 sources += [