[FL-2152] New PIN lock (#989)

* [Fl-2152] New PIN Lock, part 1
* Fix errors & leaks, renaming
* Add support to f6
* Fix error, remove duplicate code
* Fix drawing corners of Lock Popup
* FuriHal: insomnia if usb connected
* Applications: cleanup timers use

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>

applications/desktop/views/desktop_events.h

@@ -6,24 +6,35 @@ typedef enum {
     DesktopMainEventOpenFavorite,
     DesktopMainEventOpenMenu,
     DesktopMainEventOpenDebug,
-    DesktopMainEventUpdate,
-    DesktopMainEventUnlocked,
     DesktopMainEventRightShort,
-    DesktopMainEventCheckAnimation,
-    DesktopMainEventNewIdleAnimation,
-    DesktopMainEventInteractAnimation,
     DesktopMainEventBeforeAppStarted,
     DesktopMainEventAfterAppFinished,
-    DesktopLockedEventUnlock,
-    DesktopLockedEventCheckAnimation,
-    DesktopLockedEventMax,
+
+    DesktopLockedEventUnlocked,
+    DesktopLockedEventUpdate,
+    DesktopLockedEventShowPinInput,
+
+    DesktopPinInputEventResetWrongPinLabel,
+    DesktopPinInputEventUnlocked,
+    DesktopPinInputEventUnlockFailed,
+    DesktopPinInputEventBack,
+
+    DesktopPinTimeoutExit,
+
     DesktopDebugEventDeed,
     DesktopDebugEventWrongDeed,
     DesktopDebugEventSaveState,
     DesktopDebugEventExit,
+
     DesktopFirstStartCompleted,
     DesktopFirstStartPoweroff,
+
     DesktopLockMenuEventLock,
     DesktopLockMenuEventPinLock,
     DesktopLockMenuEventExit,
+
+    DesktopAnimationEventCheckAnimation,
+    DesktopAnimationEventNewIdleAnimation,
+    DesktopAnimationEventInteractAnimation,
+
 } DesktopEvent;

applications/desktop/views/desktop_locked.c

@@ -1,247 +0,0 @@
-#include "desktop/desktop_settings/desktop_settings.h"
-#include "furi/check.h"
-#include "gui/view.h"
-#include "portmacro.h"
-#include <furi.h>
-#include <gui/gui_i.h>
-#include <gui/elements.h>
-#include "../desktop_i.h"
-#include "desktop_locked.h"
-#include <stdint.h>
-
-#define DOOR_MOVING_INTERVAL_MS (1000 / 16)
-#define UNLOCKED_HINT_TIMEOUT_MS (2000)
-
-struct DesktopLockedView {
-    View* view;
-    DesktopLockedViewCallback callback;
-    void* context;
-
-    TimerHandle_t timer;
-    uint8_t lock_count;
-    uint32_t lock_lastpress;
-
-    PinCode pincode;
-    PinCode pincode_input;
-};
-
-typedef struct {
-    uint32_t hint_icon_expire_at;
-    bool unlocked_hint;
-    bool locked;
-    bool pin_locked;
-
-    int8_t door_left_x;
-    int8_t door_right_x;
-    bool animation_seq_end;
-} DesktopLockedViewModel;
-
-static void desktop_locked_unlock(DesktopLockedView* locked_view);
-
-void desktop_locked_set_callback(
-    DesktopLockedView* locked_view,
-    DesktopLockedViewCallback callback,
-    void* context) {
-    furi_assert(locked_view);
-    furi_assert(callback);
-    locked_view->callback = callback;
-    locked_view->context = context;
-}
-
-void locked_view_timer_callback(TimerHandle_t timer) {
-    DesktopLockedView* locked_view = pvTimerGetTimerID(timer);
-    locked_view->callback(DesktopMainEventUpdate, locked_view->context);
-}
-
-static void desktop_locked_update_hint_icon_timeout(DesktopLockedView* locked_view) {
-    DesktopLockedViewModel* model = view_get_model(locked_view->view);
-    model->hint_icon_expire_at = osKernelGetTickCount() + osKernelGetTickFreq();
-    view_commit_model(locked_view->view, true);
-}
-
-static void desktop_locked_reset_door_pos(DesktopLockedView* locked_view) {
-    DesktopLockedViewModel* model = view_get_model(locked_view->view);
-    model->animation_seq_end = false;
-    model->door_left_x = DOOR_L_POS;
-    model->door_right_x = DOOR_R_POS;
-    view_commit_model(locked_view->view, true);
-}
-
-void desktop_locked_update(DesktopLockedView* locked_view) {
-    bool stop_timer = false;
-
-    DesktopLockedViewModel* model = view_get_model(locked_view->view);
-    if(model->locked) {
-        if(model->door_left_x != DOOR_L_POS_MAX) {
-            model->door_left_x = CLAMP(model->door_left_x + 5, DOOR_L_POS_MAX, DOOR_L_POS);
-            model->door_right_x = CLAMP(model->door_right_x - 5, DOOR_R_POS, DOOR_R_POS_MIN);
-        } else {
-            model->animation_seq_end = true;
-        }
-        stop_timer = model->animation_seq_end;
-    } else {
-        model->unlocked_hint = false;
-        stop_timer = true;
-    }
-    view_commit_model(locked_view->view, true);
-
-    if(stop_timer) {
-        xTimerStop(locked_view->timer, portMAX_DELAY);
-    }
-}
-
-void desktop_locked_draw(Canvas* canvas, void* model) {
-    DesktopLockedViewModel* m = model;
-    uint32_t now = osKernelGetTickCount();
-    canvas_set_color(canvas, ColorBlack);
-
-    if(m->locked) {
-        if(!m->animation_seq_end) {
-            canvas_draw_icon(canvas, m->door_left_x, 0 + STATUS_BAR_Y_SHIFT, &I_DoorLeft_70x55);
-            canvas_draw_icon(canvas, m->door_right_x, 0 + STATUS_BAR_Y_SHIFT, &I_DoorRight_70x55);
-            canvas_set_font(canvas, FontPrimary);
-            elements_multiline_text_framed(canvas, 42, 30 + STATUS_BAR_Y_SHIFT, "Locked");
-        } else if((now < m->hint_icon_expire_at) && !m->pin_locked) {
-            canvas_set_font(canvas, FontSecondary);
-            canvas_draw_icon(canvas, 13, 2 + STATUS_BAR_Y_SHIFT, &I_LockPopup_100x49);
-            elements_multiline_text(canvas, 65, 20 + STATUS_BAR_Y_SHIFT, "To unlock\npress:");
-        }
-    } else {
-        if(m->unlocked_hint) {
-            canvas_set_font(canvas, FontPrimary);
-            elements_multiline_text_framed(canvas, 42, 30 + STATUS_BAR_Y_SHIFT, "Unlocked");
-        }
-    }
-}
-
-View* desktop_locked_get_view(DesktopLockedView* locked_view) {
-    furi_assert(locked_view);
-    return locked_view->view;
-}
-
-bool desktop_locked_input(InputEvent* event, void* context) {
-    furi_assert(event);
-    furi_assert(context);
-    DesktopLockedView* locked_view = context;
-    bool locked = false;
-    bool locked_with_pin = false;
-    uint32_t press_time = xTaskGetTickCount();
-
-    {
-        DesktopLockedViewModel* model = view_get_model(locked_view->view);
-        bool changed = false;
-        locked = model->locked;
-        locked_with_pin = model->pin_locked;
-        if(!locked && model->unlocked_hint && event->type == InputTypePress) {
-            model->unlocked_hint = false;
-            changed = true;
-        }
-        view_commit_model(locked_view->view, changed);
-    }
-
-    if(!locked || (event->type != InputTypeShort)) {
-        return locked;
-    }
-
-    if(press_time - locked_view->lock_lastpress > UNLOCK_RST_TIMEOUT) {
-        locked_view->lock_lastpress = press_time;
-        locked_view->lock_count = 0;
-        locked_view->pincode_input.length = 0;
-    }
-
-    if(locked_with_pin) {
-        locked_view->pincode_input.length = code_input_push(
-            locked_view->pincode_input.data, locked_view->pincode_input.length, event->key);
-        bool match = code_input_compare(
-            locked_view->pincode_input.data,
-            locked_view->pincode_input.length,
-            locked_view->pincode.data,
-            locked_view->pincode.length);
-
-        if(match) {
-            desktop_locked_unlock(locked_view);
-        }
-    } else {
-        if(event->key == InputKeyBack) {
-            locked_view->lock_lastpress = press_time;
-            locked_view->lock_count++;
-            if(locked_view->lock_count == UNLOCK_CNT) {
-                desktop_locked_unlock(locked_view);
-            }
-        } else {
-            desktop_locked_update_hint_icon_timeout(locked_view);
-            locked_view->lock_count = 0;
-        }
-    }
-
-    locked_view->lock_lastpress = press_time;
-
-    return locked;
-}
-
-DesktopLockedView* desktop_locked_alloc() {
-    DesktopLockedView* locked_view = furi_alloc(sizeof(DesktopLockedView));
-    locked_view->view = view_alloc();
-    locked_view->timer =
-        xTimerCreate("Locked view", 1000 / 16, pdTRUE, locked_view, locked_view_timer_callback);
-
-    view_allocate_model(locked_view->view, ViewModelTypeLocking, sizeof(DesktopLockedViewModel));
-    view_set_context(locked_view->view, locked_view);
-    view_set_draw_callback(locked_view->view, (ViewDrawCallback)desktop_locked_draw);
-    view_set_input_callback(locked_view->view, desktop_locked_input);
-
-    return locked_view;
-}
-
-void desktop_locked_free(DesktopLockedView* locked_view) {
-    furi_assert(locked_view);
-    osTimerDelete(locked_view->timer);
-    view_free(locked_view->view);
-    free(locked_view);
-}
-
-void desktop_locked_lock(DesktopLockedView* locked_view) {
-    locked_view->pincode.length = 0;
-    DesktopLockedViewModel* model = view_get_model(locked_view->view);
-    model->locked = true;
-    model->pin_locked = false;
-    view_commit_model(locked_view->view, true);
-    desktop_locked_reset_door_pos(locked_view);
-    xTimerChangePeriod(locked_view->timer, DOOR_MOVING_INTERVAL_MS, portMAX_DELAY);
-
-    Gui* gui = furi_record_open("gui");
-    gui_set_lockdown(gui, true);
-    furi_record_close("gui");
-}
-
-void desktop_locked_lock_pincode(DesktopLockedView* locked_view, PinCode pincode) {
-    locked_view->pincode = pincode;
-    locked_view->pincode_input.length = 0;
-    DesktopLockedViewModel* model = view_get_model(locked_view->view);
-    model->locked = true;
-    model->pin_locked = true;
-    view_commit_model(locked_view->view, true);
-    desktop_locked_reset_door_pos(locked_view);
-    xTimerChangePeriod(locked_view->timer, DOOR_MOVING_INTERVAL_MS, portMAX_DELAY);
-
-    Gui* gui = furi_record_open("gui");
-    gui_set_lockdown(gui, true);
-    furi_record_close("gui");
-}
-
-static void desktop_locked_unlock(DesktopLockedView* locked_view) {
-    furi_assert(locked_view);
-
-    locked_view->lock_count = 0;
-    DesktopLockedViewModel* model = view_get_model(locked_view->view);
-    model->locked = false;
-    model->pin_locked = false;
-    model->unlocked_hint = true;
-    view_commit_model(locked_view->view, true);
-    locked_view->callback(DesktopMainEventUnlocked, locked_view->context);
-    xTimerChangePeriod(locked_view->timer, UNLOCKED_HINT_TIMEOUT_MS, portMAX_DELAY);
-
-    Gui* gui = furi_record_open("gui");
-    gui_set_lockdown(gui, false);
-    furi_record_close("gui");
-}

applications/desktop/views/desktop_locked.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <desktop/desktop_settings/desktop_settings.h>
-#include <gui/view.h>
-#include "desktop_events.h"
-
-#define UNLOCK_RST_TIMEOUT 300
-#define UNLOCK_CNT 3
-
-#define DOOR_L_POS -57
-#define DOOR_L_POS_MAX 0
-#define DOOR_R_POS 115
-#define DOOR_R_POS_MIN 60
-
-typedef enum {
-    DesktopLockedWithPin,
-    DesktopLockedNoPin,
-} DesktopLockedSceneState;
-
-typedef struct DesktopLockedView DesktopLockedView;
-
-typedef void (*DesktopLockedViewCallback)(DesktopEvent event, void* context);
-
-void desktop_locked_set_callback(
-    DesktopLockedView* locked_view,
-    DesktopLockedViewCallback callback,
-    void* context);
-
-void desktop_locked_update(DesktopLockedView* locked_view);
-
-View* desktop_locked_get_view(DesktopLockedView* locked_view);
-DesktopLockedView* desktop_locked_alloc();
-void desktop_locked_free(DesktopLockedView* locked_view);
-
-void desktop_locked_lock_pincode(DesktopLockedView* locked_view, PinCode pincode);
-void desktop_locked_lock(DesktopLockedView* locked_view);

applications/desktop/views/desktop_view_debug.c

@@ -1,11 +1,11 @@
 #include <toolbox/version.h>
 #include <furi.h>
 #include <furi_hal.h>
+#include <dolphin/helpers/dolphin_state.h>
+#include <dolphin/dolphin.h>
 
 #include "../desktop_i.h"
-#include "desktop_debug.h"
-#include "dolphin/helpers/dolphin_state.h"
-#include "dolphin/dolphin.h"
+#include "desktop_view_debug.h"
 
 void desktop_debug_set_callback(
     DesktopDebugView* debug_view,

applications/desktop/views/desktop_view_first_start.c

@@ -1,8 +1,9 @@
 #include <furi.h>
 #include <furi_hal.h>
 #include <gui/elements.h>
+
 #include "../desktop_i.h"
-#include "desktop_first_start.h"
+#include "desktop_view_first_start.h"
 
 #define DESKTOP_FIRST_START_POWEROFF_SHORT 5000
 #define DESKTOP_FIRST_START_POWEROFF_LONG (60 * 60 * 1000)

applications/desktop/views/desktop_view_lock_menu.c

@@ -2,7 +2,7 @@
 #include <gui/elements.h>
 
 #include "../desktop_i.h"
-#include "desktop_lock_menu.h"
+#include "desktop_view_lock_menu.h"
 
 #define LOCK_MENU_ITEMS_NB 3
 

applications/desktop/views/desktop_view_locked.c

@@ -0,0 +1,233 @@
+#include <projdefs.h>
+#include <stdint.h>
+#include <furi.h>
+#include <gui/elements.h>
+#include <gui/icon.h>
+#include <gui/view.h>
+#include <portmacro.h>
+
+#include "../desktop_settings/desktop_settings.h"
+#include "../desktop_i.h"
+#include "desktop_view_locked.h"
+
+#define DOOR_MOVING_INTERVAL_MS (1000 / 16)
+#define UNLOCKED_HINT_TIMEOUT_MS (2000)
+
+#define DOOR_OFFSET_START -55
+#define DOOR_OFFSET_END 0
+
+#define DOOR_L_FINAL_POS 0
+#define DOOR_R_FINAL_POS 60
+
+#define UNLOCK_CNT 3
+#define UNLOCK_RST_TIMEOUT 600
+
+struct DesktopViewLocked {
+    View* view;
+    DesktopViewLockedCallback callback;
+    void* context;
+
+    TimerHandle_t timer;
+    uint8_t lock_count;
+    uint32_t lock_lastpress;
+};
+
+typedef struct {
+    uint32_t hint_icon_expire_at;
+    bool unlocked_hint;
+    bool locked;
+    bool pin_locked;
+
+    int8_t door_offset;
+    bool doors_closing;
+} DesktopViewLockedModel;
+
+void desktop_view_locked_set_callback(
+    DesktopViewLocked* locked_view,
+    DesktopViewLockedCallback callback,
+    void* context) {
+    furi_assert(locked_view);
+    furi_assert(callback);
+    locked_view->callback = callback;
+    locked_view->context = context;
+}
+
+static void locked_view_timer_callback(TimerHandle_t timer) {
+    DesktopViewLocked* locked_view = pvTimerGetTimerID(timer);
+    locked_view->callback(DesktopLockedEventUpdate, locked_view->context);
+}
+
+static void desktop_view_locked_doors_draw(Canvas* canvas, DesktopViewLockedModel* model) {
+    int8_t offset = model->door_offset;
+    uint8_t door_left_x = DOOR_L_FINAL_POS + offset;
+    uint8_t door_right_x = DOOR_R_FINAL_POS - offset;
+    uint8_t height = icon_get_height(&I_DoorLeft_70x55);
+    canvas_draw_icon(canvas, door_left_x, canvas_height(canvas) - height, &I_DoorLeft_70x55);
+    canvas_draw_icon(canvas, door_right_x, canvas_height(canvas) - height, &I_DoorRight_70x55);
+}
+
+static bool desktop_view_locked_doors_move(DesktopViewLockedModel* model) {
+    bool stop = false;
+    if(model->door_offset < DOOR_OFFSET_END) {
+        model->door_offset = CLAMP(model->door_offset + 5, DOOR_OFFSET_END, DOOR_OFFSET_START);
+        stop = true;
+    }
+
+    return stop;
+}
+
+static void desktop_view_locked_update_hint_icon_timeout(DesktopViewLocked* locked_view) {
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    model->hint_icon_expire_at = osKernelGetTickCount() + osKernelGetTickFreq();
+    view_commit_model(locked_view->view, true);
+}
+
+void desktop_view_locked_update(DesktopViewLocked* locked_view) {
+    bool stop_timer = false;
+
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    if(model->locked) {
+        model->doors_closing = desktop_view_locked_doors_move(model);
+        stop_timer = !model->doors_closing;
+    } else {
+        model->unlocked_hint = false;
+        stop_timer = true;
+    }
+    view_commit_model(locked_view->view, true);
+
+    if(stop_timer) {
+        xTimerStop(locked_view->timer, portMAX_DELAY);
+    }
+}
+
+static void desktop_view_locked_draw(Canvas* canvas, void* model) {
+    DesktopViewLockedModel* m = model;
+    uint32_t now = osKernelGetTickCount();
+    canvas_set_color(canvas, ColorBlack);
+
+    if(m->locked) {
+        if(m->doors_closing) {
+            desktop_view_locked_doors_draw(canvas, m);
+            canvas_set_font(canvas, FontPrimary);
+            elements_multiline_text_framed(canvas, 42, 30 + STATUS_BAR_Y_SHIFT, "Locked");
+        } else if((now < m->hint_icon_expire_at) && !m->pin_locked) {
+            canvas_set_font(canvas, FontSecondary);
+            elements_bold_rounded_frame(canvas, 14, 2 + STATUS_BAR_Y_SHIFT, 99, 48);
+            elements_multiline_text(canvas, 65, 20 + STATUS_BAR_Y_SHIFT, "To unlock\npress:");
+            canvas_draw_icon(canvas, 65, 36 + STATUS_BAR_Y_SHIFT, &I_Back3_45x8);
+            canvas_draw_icon(canvas, 16, 7 + STATUS_BAR_Y_SHIFT, &I_WarningDolphin_45x42);
+            canvas_draw_dot(canvas, 17, 61);
+        }
+    } else {
+        if(m->unlocked_hint) {
+            canvas_set_font(canvas, FontPrimary);
+            elements_multiline_text_framed(canvas, 42, 30 + STATUS_BAR_Y_SHIFT, "Unlocked");
+        }
+    }
+}
+
+View* desktop_view_locked_get_view(DesktopViewLocked* locked_view) {
+    furi_assert(locked_view);
+    return locked_view->view;
+}
+
+static bool desktop_view_locked_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    furi_assert(context);
+    DesktopViewLocked* locked_view = context;
+    bool locked = false;
+    bool locked_with_pin = false;
+    bool doors_closing = false;
+    uint32_t press_time = xTaskGetTickCount();
+
+    {
+        DesktopViewLockedModel* model = view_get_model(locked_view->view);
+        bool changed = false;
+        locked = model->locked;
+        locked_with_pin = model->pin_locked;
+        doors_closing = model->doors_closing;
+        if(!locked && model->unlocked_hint && event->type == InputTypePress) {
+            model->unlocked_hint = false;
+            changed = true;
+        }
+        view_commit_model(locked_view->view, changed);
+    }
+
+    if(!locked || doors_closing || (event->type != InputTypeShort)) {
+        return locked;
+    }
+
+    if(locked_with_pin) {
+        locked_view->callback(DesktopLockedEventShowPinInput, locked_view->context);
+    } else {
+        if(press_time - locked_view->lock_lastpress > UNLOCK_RST_TIMEOUT) {
+            locked_view->lock_lastpress = press_time;
+            locked_view->lock_count = 0;
+        }
+
+        desktop_view_locked_update_hint_icon_timeout(locked_view);
+        if(event->key == InputKeyBack) {
+            locked_view->lock_lastpress = press_time;
+            locked_view->lock_count++;
+            if(locked_view->lock_count == UNLOCK_CNT) {
+                desktop_view_locked_unlock(locked_view);
+                locked_view->callback(DesktopLockedEventUnlocked, locked_view->context);
+            }
+        } else {
+            locked_view->lock_count = 0;
+        }
+
+        locked_view->lock_lastpress = press_time;
+    }
+
+    return locked;
+}
+
+DesktopViewLocked* desktop_view_locked_alloc() {
+    DesktopViewLocked* locked_view = furi_alloc(sizeof(DesktopViewLocked));
+    locked_view->view = view_alloc();
+    locked_view->timer =
+        xTimerCreate(NULL, 1000 / 16, pdTRUE, locked_view, locked_view_timer_callback);
+
+    locked_view->view = view_alloc();
+    view_allocate_model(locked_view->view, ViewModelTypeLocking, sizeof(DesktopViewLockedModel));
+    view_set_context(locked_view->view, locked_view);
+    view_set_draw_callback(locked_view->view, desktop_view_locked_draw);
+    view_set_input_callback(locked_view->view, desktop_view_locked_input);
+
+    return locked_view;
+}
+
+void desktop_view_locked_free(DesktopViewLocked* locked_view) {
+    furi_assert(locked_view);
+    osTimerDelete(locked_view->timer);
+    view_free(locked_view->view);
+    free(locked_view);
+}
+
+void desktop_view_locked_close_doors(DesktopViewLocked* locked_view) {
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    model->doors_closing = true;
+    model->door_offset = DOOR_OFFSET_START;
+    view_commit_model(locked_view->view, true);
+    xTimerChangePeriod(locked_view->timer, pdMS_TO_TICKS(DOOR_MOVING_INTERVAL_MS), portMAX_DELAY);
+}
+
+void desktop_view_locked_lock(DesktopViewLocked* locked_view, bool pin_locked) {
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    model->locked = true;
+    model->pin_locked = pin_locked;
+    view_commit_model(locked_view->view, true);
+}
+
+void desktop_view_locked_unlock(DesktopViewLocked* locked_view) {
+    furi_assert(locked_view);
+
+    locked_view->lock_count = 0;
+    DesktopViewLockedModel* model = view_get_model(locked_view->view);
+    model->locked = false;
+    model->pin_locked = false;
+    model->unlocked_hint = true;
+    view_commit_model(locked_view->view, true);
+    xTimerChangePeriod(locked_view->timer, pdMS_TO_TICKS(UNLOCKED_HINT_TIMEOUT_MS), portMAX_DELAY);
+}

applications/desktop/views/desktop_view_locked.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../desktop_settings/desktop_settings.h"
+#include "../views/desktop_events.h"
+#include <gui/view.h>
+
+typedef struct DesktopViewLocked DesktopViewLocked;
+
+typedef void (*DesktopViewLockedCallback)(DesktopEvent event, void* context);
+
+void desktop_view_locked_set_callback(
+    DesktopViewLocked* locked_view,
+    DesktopViewLockedCallback callback,
+    void* context);
+void desktop_view_locked_update(DesktopViewLocked* locked_view);
+View* desktop_view_locked_get_view(DesktopViewLocked* locked_view);
+DesktopViewLocked* desktop_view_locked_alloc();
+void desktop_view_locked_free(DesktopViewLocked* locked_view);
+void desktop_view_locked_lock(DesktopViewLocked* locked_view, bool pin_locked);
+void desktop_view_locked_unlock(DesktopViewLocked* locked_view);
+void desktop_view_locked_close_doors(DesktopViewLocked* locked_view);

applications/desktop/views/desktop_view_main.c

@@ -7,7 +7,7 @@
 #include <dolphin/dolphin.h>
 
 #include "../desktop_i.h"
-#include "desktop_main.h"
+#include "desktop_view_main.h"
 
 struct DesktopMainView {
     View* view;

applications/desktop/views/desktop_view_pin_input.c

@@ -0,0 +1,340 @@
+#include <gui/canvas.h>
+#include <furi.h>
+#include <gui/view.h>
+#include <gui/elements.h>
+#include <stdint.h>
+#include <portmacro.h>
+
+#include "desktop_view_pin_input.h"
+#include "../desktop_settings/desktop_settings.h"
+
+#define NO_ACTIVITY_TIMEOUT 15000
+
+#define PIN_CELL_WIDTH 13
+#define DEFAULT_PIN_X 64
+#define DEFAULT_PIN_Y 32
+
+struct DesktopViewPinInput {
+    View* view;
+    DesktopViewPinInputCallback back_callback;
+    DesktopViewPinInputCallback timeout_callback;
+    DesktopViewPinInputDoneCallback done_callback;
+    void* context;
+    TimerHandle_t timer;
+};
+
+typedef struct {
+    PinCode pin;
+    bool pin_hidden;
+    bool locked_input;
+    uint8_t pin_x;
+    uint8_t pin_y;
+    const char* primary_str;
+    uint8_t primary_str_x;
+    uint8_t primary_str_y;
+    const char* secondary_str;
+    uint8_t secondary_str_x;
+    uint8_t secondary_str_y;
+    const char* button_label;
+} DesktopViewPinInputModel;
+
+static bool desktop_view_pin_input_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    furi_assert(context);
+
+    DesktopViewPinInput* pin_input = context;
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+
+    bool call_back_callback = false;
+    bool call_done_callback = false;
+    PinCode pin_code = {0};
+
+    if(event->type == InputTypeShort) {
+        switch(event->key) {
+        case InputKeyRight:
+        case InputKeyLeft:
+        case InputKeyDown:
+        case InputKeyUp:
+            if(!model->locked_input) {
+                if(model->pin.length < MAX_PIN_SIZE) {
+                    model->pin.data[model->pin.length++] = event->key;
+                }
+            }
+            break;
+        case InputKeyOk:
+            if(model->pin.length >= MIN_PIN_SIZE) {
+                call_done_callback = true;
+                pin_code = model->pin;
+            }
+            break;
+        case InputKeyBack:
+            if(!model->locked_input) {
+                if(model->pin.length > 0) {
+                    model->pin.length = 0;
+                } else {
+                    call_back_callback = true;
+                }
+            }
+            break;
+        default:
+            furi_assert(0);
+            break;
+        }
+    }
+    view_commit_model(pin_input->view, true);
+
+    if(call_done_callback && pin_input->done_callback) {
+        pin_input->done_callback(&pin_code, pin_input->context);
+    } else if(call_back_callback && pin_input->back_callback) {
+        pin_input->back_callback(pin_input->context);
+    }
+
+    xTimerStart(pin_input->timer, 0);
+
+    return true;
+}
+
+static void desktop_view_pin_input_draw_cells(Canvas* canvas, DesktopViewPinInputModel* model) {
+    furi_assert(canvas);
+    furi_assert(model);
+
+    uint8_t draw_pin_size = MAX(4, model->pin.length + 1);
+    if(model->locked_input || (model->pin.length == MAX_PIN_SIZE)) {
+        draw_pin_size = model->pin.length;
+    }
+
+    uint8_t x = model->pin_x - (draw_pin_size * (PIN_CELL_WIDTH - 1)) / 2;
+    uint8_t y = model->pin_y - (PIN_CELL_WIDTH / 2);
+
+    for(int i = 0; i < draw_pin_size; ++i) {
+        canvas_draw_frame(canvas, x, y, PIN_CELL_WIDTH, PIN_CELL_WIDTH);
+        if(i < model->pin.length) {
+            if(model->pin_hidden) {
+                canvas_draw_icon(canvas, x + 3, y + 3, &I_Pin_star_7x7);
+            } else {
+                switch(model->pin.data[i]) {
+                case InputKeyDown:
+                    canvas_draw_icon(canvas, x + 3, y + 2, &I_Pin_arrow_down_7x9);
+                    break;
+                case InputKeyUp:
+                    canvas_draw_icon(canvas, x + 3, y + 2, &I_Pin_arrow_up7x9);
+                    break;
+                case InputKeyLeft:
+                    canvas_draw_icon(canvas, x + 2, y + 3, &I_Pin_arrow_left_9x7);
+                    break;
+                case InputKeyRight:
+                    canvas_draw_icon(canvas, x + 2, y + 3, &I_Pin_arrow_right_9x7);
+                    break;
+                default:
+                    furi_assert(0);
+                    break;
+                }
+            }
+        } else if(i == model->pin.length) {
+            canvas_draw_icon(canvas, x + 4, y + PIN_CELL_WIDTH + 1, &I_Pin_pointer_5x3);
+        }
+        x += PIN_CELL_WIDTH - 1;
+    }
+}
+
+static void desktop_view_pin_input_draw(Canvas* canvas, void* context) {
+    furi_assert(canvas);
+    furi_assert(context);
+
+    canvas_set_font(canvas, FontSecondary);
+    DesktopViewPinInputModel* model = context;
+    desktop_view_pin_input_draw_cells(canvas, model);
+
+    if((model->pin.length > 0) && !model->locked_input) {
+        canvas_draw_icon(canvas, 4, 53, &I_Pin_back_full_40x8);
+    }
+
+    if(model->button_label && ((model->pin.length >= MIN_PIN_SIZE) || model->locked_input)) {
+        elements_button_center(canvas, model->button_label);
+    }
+
+    if(model->primary_str) {
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str(canvas, model->primary_str_x, model->primary_str_y, model->primary_str);
+        canvas_set_font(canvas, FontSecondary);
+    }
+
+    if(model->secondary_str) {
+        canvas_set_font(canvas, FontSecondary);
+        canvas_draw_str(
+            canvas, model->secondary_str_x, model->secondary_str_y, model->secondary_str);
+    }
+}
+
+void desktop_view_pin_input_timer_callback(TimerHandle_t timer) {
+    DesktopViewPinInput* pin_input = pvTimerGetTimerID(timer);
+
+    if(pin_input->timeout_callback) {
+        pin_input->timeout_callback(pin_input->context);
+    }
+}
+
+static void desktop_view_pin_input_enter(void* context) {
+    DesktopViewPinInput* pin_input = context;
+    xTimerStart(pin_input->timer, portMAX_DELAY);
+}
+
+static void desktop_view_pin_input_exit(void* context) {
+    DesktopViewPinInput* pin_input = context;
+    xTimerStop(pin_input->timer, portMAX_DELAY);
+}
+
+DesktopViewPinInput* desktop_view_pin_input_alloc(void) {
+    DesktopViewPinInput* pin_input = furi_alloc(sizeof(DesktopViewPinInput));
+    pin_input->view = view_alloc();
+    view_allocate_model(pin_input->view, ViewModelTypeLocking, sizeof(DesktopViewPinInputModel));
+    view_set_context(pin_input->view, pin_input);
+    view_set_draw_callback(pin_input->view, desktop_view_pin_input_draw);
+    view_set_input_callback(pin_input->view, desktop_view_pin_input_input);
+    pin_input->timer = xTimerCreate(
+        NULL,
+        pdMS_TO_TICKS(NO_ACTIVITY_TIMEOUT),
+        pdFALSE,
+        pin_input,
+        desktop_view_pin_input_timer_callback);
+    view_set_enter_callback(pin_input->view, desktop_view_pin_input_enter);
+    view_set_exit_callback(pin_input->view, desktop_view_pin_input_exit);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->pin_x = DEFAULT_PIN_X;
+    model->pin_y = DEFAULT_PIN_Y;
+    model->pin.length = 0;
+    view_commit_model(pin_input->view, false);
+
+    return pin_input;
+}
+
+void desktop_view_pin_input_free(DesktopViewPinInput* pin_input) {
+    furi_assert(pin_input);
+
+    xTimerStop(pin_input->timer, portMAX_DELAY);
+    while(xTimerIsTimerActive(pin_input->timer)) {
+        delay(1);
+    }
+    xTimerDelete(pin_input->timer, portMAX_DELAY);
+
+    view_free(pin_input->view);
+    free(pin_input);
+}
+
+void desktop_view_pin_input_lock_input(DesktopViewPinInput* pin_input) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->locked_input = true;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_unlock_input(DesktopViewPinInput* pin_input) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->locked_input = false;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_pin(DesktopViewPinInput* pin_input, const PinCode* pin) {
+    furi_assert(pin_input);
+    furi_assert(pin);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->pin = *pin;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_reset_pin(DesktopViewPinInput* pin_input) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->pin.length = 0;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_hide_pin(DesktopViewPinInput* pin_input, bool pin_hidden) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->pin_hidden = pin_hidden;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_label_button(DesktopViewPinInput* pin_input, const char* label) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->button_label = label;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_label_primary(
+    DesktopViewPinInput* pin_input,
+    uint8_t x,
+    uint8_t y,
+    const char* label) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->primary_str = label;
+    model->primary_str_x = x;
+    model->primary_str_y = y;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_label_secondary(
+    DesktopViewPinInput* pin_input,
+    uint8_t x,
+    uint8_t y,
+    const char* label) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->secondary_str = label;
+    model->secondary_str_x = x;
+    model->secondary_str_y = y;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_pin_position(DesktopViewPinInput* pin_input, uint8_t x, uint8_t y) {
+    furi_assert(pin_input);
+
+    DesktopViewPinInputModel* model = view_get_model(pin_input->view);
+    model->pin_x = x;
+    model->pin_y = y;
+    view_commit_model(pin_input->view, true);
+}
+
+void desktop_view_pin_input_set_context(DesktopViewPinInput* pin_input, void* context) {
+    furi_assert(pin_input);
+    pin_input->context = context;
+}
+
+void desktop_view_pin_input_set_timeout_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputCallback callback) {
+    furi_assert(pin_input);
+    pin_input->timeout_callback = callback;
+}
+
+void desktop_view_pin_input_set_back_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputCallback callback) {
+    furi_assert(pin_input);
+    pin_input->back_callback = callback;
+}
+
+void desktop_view_pin_input_set_done_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputDoneCallback callback) {
+    furi_assert(pin_input);
+    pin_input->done_callback = callback;
+}
+
+View* desktop_view_pin_input_get_view(DesktopViewPinInput* pin_input) {
+    furi_assert(pin_input);
+    return pin_input->view;
+}

applications/desktop/views/desktop_view_pin_input.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <gui/view.h>
+#include "desktop/desktop_settings/desktop_settings.h"
+
+typedef void (*DesktopViewPinInputCallback)(void*);
+typedef void (*DesktopViewPinInputDoneCallback)(const PinCode* pin_code, void*);
+typedef struct DesktopViewPinInput DesktopViewPinInput;
+
+DesktopViewPinInput* desktop_view_pin_input_alloc(void);
+void desktop_view_pin_input_free(DesktopViewPinInput*);
+
+void desktop_view_pin_input_set_pin(DesktopViewPinInput* pin_input, const PinCode* pin);
+void desktop_view_pin_input_reset_pin(DesktopViewPinInput* pin_input);
+void desktop_view_pin_input_hide_pin(DesktopViewPinInput* pin_input, bool pin_hidden);
+void desktop_view_pin_input_set_label_button(DesktopViewPinInput* pin_input, const char* label);
+void desktop_view_pin_input_set_label_primary(
+    DesktopViewPinInput* pin_input,
+    uint8_t x,
+    uint8_t y,
+    const char* label);
+void desktop_view_pin_input_set_label_secondary(
+    DesktopViewPinInput* pin_input,
+    uint8_t x,
+    uint8_t y,
+    const char* label);
+void desktop_view_pin_input_set_pin_position(DesktopViewPinInput* pin_input, uint8_t x, uint8_t y);
+View* desktop_view_pin_input_get_view(DesktopViewPinInput*);
+void desktop_view_pin_input_set_done_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputDoneCallback callback);
+void desktop_view_pin_input_set_back_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputCallback callback);
+void desktop_view_pin_input_set_timeout_callback(
+    DesktopViewPinInput* pin_input,
+    DesktopViewPinInputCallback callback);
+void desktop_view_pin_input_set_context(DesktopViewPinInput* pin_input, void* context);
+void desktop_view_pin_input_lock_input(DesktopViewPinInput* pin_input);
+void desktop_view_pin_input_unlock_input(DesktopViewPinInput* pin_input);

applications/desktop/views/desktop_view_pin_setup_done.c

@@ -0,0 +1,80 @@
+#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);
+    furi_assert(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 = furi_alloc(sizeof(DesktopViewPinSetupDone));
+    view->view = view_alloc();
+    view_allocate_model(view->view, ViewModelTypeLockFree, 1);
+    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/desktop/views/desktop_view_pin_setup_done.h

@@ -0,0 +1,15 @@
+#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/desktop/views/desktop_view_pin_timeout.c

@@ -0,0 +1,109 @@
+
+#include <furi.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <FreeRTOS.h>
+#include <portmacro.h>
+#include <projdefs.h>
+#include <input/input.h>
+#include <gui/canvas.h>
+#include <gui/view.h>
+
+#include "desktop_view_pin_timeout.h"
+
+struct DesktopViewPinTimeout {
+    View* view;
+    TimerHandle_t timer;
+    DesktopViewPinTimeoutDoneCallback callback;
+    void* context;
+};
+
+typedef struct {
+    uint32_t time_left;
+} DesktopViewPinTimeoutModel;
+
+void desktop_view_pin_timeout_set_callback(
+    DesktopViewPinTimeout* instance,
+    DesktopViewPinTimeoutDoneCallback callback,
+    void* context) {
+    furi_assert(instance);
+
+    instance->callback = callback;
+    instance->context = context;
+}
+
+static void desktop_view_pin_timeout_timer_callback(TimerHandle_t timer) {
+    DesktopViewPinTimeout* instance = pvTimerGetTimerID(timer);
+    bool stop = false;
+
+    DesktopViewPinTimeoutModel* model = view_get_model(instance->view);
+    if(model->time_left > 0) {
+        --model->time_left;
+    } else {
+        stop = true;
+    }
+    view_commit_model(instance->view, true);
+
+    if(stop) {
+        xTimerStop(instance->timer, portMAX_DELAY);
+        instance->callback(instance->context);
+    }
+}
+
+static bool desktop_view_pin_timeout_input(InputEvent* event, void* context) {
+    return true;
+}
+
+static void desktop_view_pin_timeout_draw(Canvas* canvas, void* _model) {
+    furi_assert(canvas);
+    furi_assert(_model);
+
+    DesktopViewPinTimeoutModel* model = _model;
+
+    canvas_set_font(canvas, FontPrimary);
+    canvas_draw_str(canvas, 36, 31, "Wrong PIN!");
+
+    canvas_set_font(canvas, FontSecondary);
+    char str[30] = {0};
+    snprintf(str, sizeof(str), "Timeout: %lds", model->time_left);
+    canvas_draw_str_aligned(canvas, 64, 38, AlignCenter, AlignCenter, str);
+}
+
+void desktop_view_pin_timeout_free(DesktopViewPinTimeout* instance) {
+    view_free(instance->view);
+    xTimerDelete(instance->timer, portMAX_DELAY);
+
+    free(instance);
+}
+
+DesktopViewPinTimeout* desktop_view_pin_timeout_alloc(void) {
+    DesktopViewPinTimeout* instance = furi_alloc(sizeof(DesktopViewPinTimeout));
+    instance->timer = xTimerCreate(
+        NULL, pdMS_TO_TICKS(1000), pdTRUE, instance, desktop_view_pin_timeout_timer_callback);
+
+    instance->view = view_alloc();
+    view_allocate_model(instance->view, ViewModelTypeLockFree, sizeof(DesktopViewPinTimeoutModel));
+
+    view_set_context(instance->view, instance);
+    view_set_draw_callback(instance->view, desktop_view_pin_timeout_draw);
+    view_set_input_callback(instance->view, desktop_view_pin_timeout_input);
+
+    return instance;
+}
+
+void desktop_view_pin_timeout_start(DesktopViewPinTimeout* instance, uint32_t time_left) {
+    furi_assert(instance);
+
+    DesktopViewPinTimeoutModel* model = view_get_model(instance->view);
+    // no race - always called when timer is stopped
+    model->time_left = time_left;
+    view_commit_model(instance->view, true);
+
+    xTimerStart(instance->timer, portMAX_DELAY);
+}
+
+View* desktop_view_pin_timeout_get_view(DesktopViewPinTimeout* instance) {
+    furi_assert(instance);
+
+    return instance->view;
+}

applications/desktop/views/desktop_view_pin_timeout.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <stdint.h>
+#include <gui/view.h>
+
+typedef void (*DesktopViewPinTimeoutDoneCallback)(void*);
+typedef struct DesktopViewPinTimeout DesktopViewPinTimeout;
+
+void desktop_view_pin_timeout_set_callback(
+    DesktopViewPinTimeout* instance,
+    DesktopViewPinTimeoutDoneCallback callback,
+    void* context);
+DesktopViewPinTimeout* desktop_view_pin_timeout_alloc(void);
+void desktop_view_pin_timeout_free(DesktopViewPinTimeout*);
+void desktop_view_pin_timeout_start(DesktopViewPinTimeout* instance, uint32_t time_left);
+View* desktop_view_pin_timeout_get_view(DesktopViewPinTimeout* instance);