[FL-1448], [FL-1529] Introducing Scene Manager, NFC App refactoring and bug fixes (#575)

* gui: refactore ViewNavigator -> SceneManager
* view_dispatcher: remove scene controller, add custom and navigation cb
* scene_manager: rework scene controller, move AppScene from lib
* nfc: rework nfc scenes with new scene controller API
* view_dispatcher: crash on free if not all views were freed
* nfc: introduce scene declaration
* scene_manager: allocate and configure application scenes
* nfc: rework nfc with new Scene Manager API
* scene_manager: remove dublicated scene handlers allocation
* nfc: rework nfc app with new scene manager API
* view_dispatcher: add tick event
* scene_manager: add tick event type and handler
* nfc: rework notifications with tick event
* scene_manager: remove scene id from scene structure
* scene_manager: rename array -> stack, add documentation
* api-hal-nfc: remove listen activation processing
* nfc_scene_start: shorter submenu call
* nfc: fix nfc file name
* nfc: fix Retry in mifare ul success read
* nfc_cli: fix read timeout in nfc_detect CLI command

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

applications/gui/scene_manager.c

@@ -0,0 +1,139 @@
+#include "scene_manager_i.h"
+#include <furi.h>
+
+SceneManager* scene_manager_alloc(const SceneManagerHandlers* app_scene_handlers, void* context) {
+    furi_assert(context);
+
+    SceneManager* scene_manager = furi_alloc(sizeof(SceneManager));
+    // Set SceneManager context and scene handlers
+    scene_manager->context = context;
+    scene_manager->scene_handlers = app_scene_handlers;
+    // Allocate all scenes
+    scene_manager->scene = furi_alloc(sizeof(AppScene) * app_scene_handlers->scene_num);
+    // Initialize ScaneManager array for navigation
+    SceneManagerIdStack_init(scene_manager->scene_id_stack);
+
+    return scene_manager;
+}
+
+void scene_manager_free(SceneManager* scene_manager) {
+    furi_assert(scene_manager);
+
+    // Clear ScaneManager array
+    SceneManagerIdStack_clear(scene_manager->scene_id_stack);
+    // Clear allocated scenes
+    free(scene_manager->scene);
+    // Free SceneManager structure
+    free(scene_manager);
+}
+
+void scene_manager_set_scene_state(SceneManager* scene_manager, uint32_t scene_id, uint32_t state) {
+    furi_assert(scene_manager);
+    furi_assert(scene_id < scene_manager->scene_handlers->scene_num);
+
+    scene_manager->scene[scene_id].state = state;
+}
+
+uint32_t scene_manager_get_scene_state(SceneManager* scene_manager, uint32_t scene_id) {
+    furi_assert(scene_manager);
+    furi_assert(scene_id < scene_manager->scene_handlers->scene_num);
+
+    return scene_manager->scene[scene_id].state;
+}
+
+bool scene_manager_handle_custom_event(SceneManager* scene_manager, uint32_t custom_event) {
+    furi_assert(scene_manager);
+
+    SceneManagerEvent event = {
+        .type = SceneManagerEventTypeCustom,
+        .event = custom_event,
+    };
+    uint32_t scene_id = *SceneManagerIdStack_back(scene_manager->scene_id_stack);
+    return scene_manager->scene_handlers->on_event_handlers[scene_id](
+        scene_manager->context, event);
+}
+
+bool scene_manager_handle_navigation_event(SceneManager* scene_manager) {
+    furi_assert(scene_manager);
+
+    SceneManagerEvent event = {
+        .type = SceneManagerEventTypeNavigation,
+    };
+    uint32_t scene_id = *SceneManagerIdStack_back(scene_manager->scene_id_stack);
+    bool consumed =
+        scene_manager->scene_handlers->on_event_handlers[scene_id](scene_manager->context, event);
+    if(!consumed) {
+        consumed = scene_manager_previous_scene(scene_manager);
+    }
+    return consumed;
+}
+
+void scene_manager_handle_tick_event(SceneManager* scene_manager) {
+    furi_assert(scene_manager);
+
+    SceneManagerEvent event = {
+        .type = SceneManagerEventTypeTick,
+    };
+    uint32_t scene_id = *SceneManagerIdStack_back(scene_manager->scene_id_stack);
+    scene_manager->scene_handlers->on_event_handlers[scene_id](scene_manager->context, event);
+}
+
+void scene_manager_next_scene(SceneManager* scene_manager, uint32_t next_scene_id) {
+    furi_assert(scene_manager);
+    furi_assert(next_scene_id < scene_manager->scene_handlers->scene_num);
+
+    // Check if it is not the first scene
+    if(SceneManagerIdStack_size(scene_manager->scene_id_stack)) {
+        uint32_t cur_scene_id = *SceneManagerIdStack_back(scene_manager->scene_id_stack);
+        scene_manager->scene_handlers->on_exit_handlers[cur_scene_id](scene_manager->context);
+    }
+    // Add next scene and run on_enter
+    SceneManagerIdStack_push_back(scene_manager->scene_id_stack, next_scene_id);
+    scene_manager->scene_handlers->on_enter_handlers[next_scene_id](scene_manager->context);
+}
+
+bool scene_manager_previous_scene(SceneManager* scene_manager) {
+    furi_assert(scene_manager);
+
+    uint32_t cur_scene_id = 0;
+    SceneManagerIdStack_pop_back(&cur_scene_id, scene_manager->scene_id_stack);
+
+    // Handle exit from start scene separately
+    if(SceneManagerIdStack_size(scene_manager->scene_id_stack) == 0) {
+        scene_manager->scene_handlers->on_exit_handlers[cur_scene_id](scene_manager->context);
+        return false;
+    }
+    uint32_t prev_scene_id = *SceneManagerIdStack_back(scene_manager->scene_id_stack);
+    scene_manager->scene_handlers->on_exit_handlers[cur_scene_id](scene_manager->context);
+    scene_manager->scene_handlers->on_enter_handlers[prev_scene_id](scene_manager->context);
+    return true;
+}
+
+bool scene_manager_search_previous_scene(SceneManager* scene_manager, uint32_t scene_id) {
+    furi_assert(scene_manager);
+
+    uint32_t prev_scene_id = 0;
+    uint32_t cur_scene_id = *SceneManagerIdStack_back(scene_manager->scene_id_stack);
+    SceneManagerIdStack_it_t scene_it;
+    SceneManagerIdStack_it_last(scene_it, scene_manager->scene_id_stack);
+    // Search scene with given id in navigation stack
+    bool scene_found = false;
+    while(!scene_found) {
+        SceneManagerIdStack_previous(scene_it);
+        if(SceneManagerIdStack_end_p(scene_it)) {
+            return false;
+        }
+        prev_scene_id = *SceneManagerIdStack_ref(scene_it);
+        if(prev_scene_id == scene_id) {
+            scene_found = true;
+        }
+    }
+    // Remove all scene id from navigation stack
+    SceneManagerIdStack_next(scene_it);
+    SceneManagerIdStack_pop_until(scene_manager->scene_id_stack, scene_it);
+
+    scene_manager->scene_handlers->on_exit_handlers[cur_scene_id](scene_manager->context);
+    scene_manager->scene_handlers->on_enter_handlers[prev_scene_id](scene_manager->context);
+
+    return true;
+}

applications/gui/scene_manager.h

@@ -0,0 +1,116 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/** Scene Manager events type
+ */
+typedef enum {
+    SceneManagerEventTypeCustom,
+    SceneManagerEventTypeNavigation,
+    SceneManagerEventTypeTick,
+} SceneManagerEventType;
+
+/** Scene Manager event
+ */
+typedef struct {
+    SceneManagerEventType type;
+    uint32_t event;
+} SceneManagerEvent;
+
+/** Prototype for Scene on_enter handler */
+typedef void (*AppSceneOnEnterCallback)(void* context);
+
+/** Prototype for Scene on_event handler */
+typedef bool (*AppSceneOnEventCallback)(void* context, SceneManagerEvent event);
+
+/** Prototype for Scene on_exit handler */
+typedef void (*AppSceneOnExitCallback)(void* context);
+
+/** Scene Manager configuration structure
+ * Contains array of Scene handlers
+ */
+typedef struct {
+    const AppSceneOnEnterCallback* on_enter_handlers;
+    const AppSceneOnEventCallback* on_event_handlers;
+    const AppSceneOnExitCallback* on_exit_handlers;
+    const uint32_t scene_num;
+} SceneManagerHandlers;
+
+typedef struct SceneManager SceneManager;
+
+/** Set Scene state
+ * @param scene_manager SceneManager instance
+ * @param scene_id Scene ID
+ * @param state Scene new state
+ */
+void scene_manager_set_scene_state(SceneManager* scene_manager, uint32_t scene_id, uint32_t state);
+
+/** Get Scene state
+ * @param scene_manager SceneManager instance
+ * @param scene_id Scene ID
+ * @return Scene state
+ */
+uint32_t scene_manager_get_scene_state(SceneManager* scene_manager, uint32_t scene_id);
+
+/** Scene Manager allocation and configuration
+ * Scene Manager allocates all scenes internally
+ * @param app_scene_handlers SceneManagerHandlers instance
+ * @param context context to be set on Scene handlers calls
+ * @return SceneManager instance
+ */
+SceneManager* scene_manager_alloc(const SceneManagerHandlers* app_scene_handlers, void* context);
+
+/** Free Scene Manager with allocated Scenes
+ * @param scene_manager SceneManager instance
+ */
+void scene_manager_free(SceneManager* scene_manager);
+
+/** Custom event handler
+ * Calls Scene event handler with Custom event parameter
+ * @param scene_manager SceneManager instance
+ * @param custom_event Custom event code
+ * @return true if event was consumed, false otherwise
+ */
+bool scene_manager_handle_custom_event(SceneManager* scene_manager, uint32_t custom_event);
+
+/** Navigation event handler
+ * Calls Scene event handler with Navigation event parameter
+ * @param scene_manager SceneManager instance
+ * @return true if event was consumed, false otherwise
+ */
+bool scene_manager_handle_navigation_event(SceneManager* scene_manager);
+
+/** Tick event handler
+ * Calls Scene event handler with Tick event parameter
+ * @param scene_manager SceneManager instance
+ * @return true if event was consumed, false otherwise
+ */
+void scene_manager_handle_tick_event(SceneManager* scene_manager);
+
+/** Add and run next Scene
+ * @param scene_manager SceneManager instance
+ * @param next_scene_id next Scene ID
+ */
+void scene_manager_next_scene(SceneManager* scene_manager, uint32_t next_scene_id);
+
+/** Run previous Scene
+ * @param scene_manager SceneManager instance
+ * @return true if previous scene was found, false otherwise
+ */
+bool scene_manager_previous_scene(SceneManager* scene_manager);
+
+/** Search previous Scene by ID
+ * @param scene_manager SceneManager instance
+ * @param scene_id Scene ID
+ * @return true if previous scene was found, false otherwise
+ */
+bool scene_manager_search_previous_scene(SceneManager* scene_manager, uint32_t scene_id);
+
+#ifdef __cplusplus
+}
+#endif

applications/gui/scene_manager_i.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "scene_manager.h"
+#include <m-array.h>
+
+ARRAY_DEF(SceneManagerIdStack, uint32_t, M_DEFAULT_OPLIST);
+
+typedef struct {
+    uint32_t state;
+} AppScene;
+
+struct SceneManager {
+    SceneManagerIdStack_t scene_id_stack;
+    const SceneManagerHandlers* scene_handlers;
+    AppScene* scene;
+    void* context;
+};

applications/gui/view_dispatcher.c

@@ -20,15 +20,9 @@ void view_dispatcher_free(ViewDispatcher* view_dispatcher) {
     if(view_dispatcher->gui) {
         gui_remove_view_port(view_dispatcher->gui, view_dispatcher->view_port);
     }
-    // Free views
-    ViewDict_it_t it;
-    ViewDict_it(it, view_dispatcher->views);
-    while(!ViewDict_end_p(it)) {
-        ViewDict_itref_t* ref = ViewDict_ref(it);
-        // Crash if view wasn't freed
-        furi_check(ref->value);
-        ViewDict_next(it);
-    }
+    // Crash if not all views were freed
+    furi_assert(ViewDict_size(view_dispatcher->views) == 0);
+
     ViewDict_clear(view_dispatcher->views);
     // Free ViewPort
     view_port_free(view_dispatcher->view_port);
@@ -36,10 +30,6 @@ void view_dispatcher_free(ViewDispatcher* view_dispatcher) {
     if(view_dispatcher->queue) {
         osMessageQueueDelete(view_dispatcher->queue);
     }
-    // Free View Navigator
-    if(view_dispatcher->view_navigator) {
-        view_navigator_free(view_dispatcher->view_navigator);
-    }
     // Free dispatcher
     free(view_dispatcher);
 }
@@ -50,40 +40,55 @@ void view_dispatcher_enable_queue(ViewDispatcher* view_dispatcher) {
     view_dispatcher->queue = osMessageQueueNew(8, sizeof(ViewDispatcherMessage), NULL);
 }
 
-void view_dispatcher_enable_navigation(ViewDispatcher* view_dispatcher, void* context) {
+void view_dispatcher_set_event_callback_context(ViewDispatcher* view_dispatcher, void* context) {
     furi_assert(view_dispatcher);
-    view_dispatcher->view_navigator = view_navigator_alloc(context);
+    view_dispatcher->event_context = context;
 }
 
-void view_dispatcher_add_scene(ViewDispatcher* view_dispatcher, AppScene* scene) {
+void view_dispatcher_set_navigation_event_callback(
+    ViewDispatcher* view_dispatcher,
+    ViewDispatcherNavigationEventCallback callback) {
     furi_assert(view_dispatcher);
-    furi_assert(view_dispatcher->view_navigator);
-    furi_assert(scene);
-    view_navigator_add_next_scene(view_dispatcher->view_navigator, scene);
+    furi_assert(callback);
+    view_dispatcher->navigation_event_callback = callback;
+}
+
+void view_dispatcher_set_custom_event_callback(
+    ViewDispatcher* view_dispatcher,
+    ViewDispatcherCustomEventCallback callback) {
+    furi_assert(view_dispatcher);
+    furi_assert(callback);
+    view_dispatcher->custom_event_callback = callback;
+}
+
+void view_dispatcher_set_tick_event_callback(
+    ViewDispatcher* view_dispatcher,
+    ViewDispatcherTickEventCallback callback,
+    uint32_t tick_period) {
+    furi_assert(view_dispatcher);
+    furi_assert(callback);
+    view_dispatcher->tick_event_callback = callback;
+    view_dispatcher->tick_period = tick_period;
 }
 
 void view_dispatcher_run(ViewDispatcher* view_dispatcher) {
     furi_assert(view_dispatcher);
     furi_assert(view_dispatcher->queue);
 
-    if(view_dispatcher->view_navigator) {
-        view_navigator_start(view_dispatcher->view_navigator);
-    }
-
+    uint32_t tick_period = view_dispatcher->tick_period == 0 ? osWaitForever :
+                                                               view_dispatcher->tick_period;
     ViewDispatcherMessage message;
-    while(osMessageQueueGet(view_dispatcher->queue, &message, NULL, osWaitForever) == osOK) {
+    while(1) {
+        if(osMessageQueueGet(view_dispatcher->queue, &message, NULL, tick_period) != osOK) {
+            view_dispatcher_handle_tick_event(view_dispatcher);
+            continue;
+        }
         if(message.type == ViewDispatcherMessageTypeStop) {
             break;
         } else if(message.type == ViewDispatcherMessageTypeInput) {
             view_dispatcher_handle_input(view_dispatcher, &message.input);
         } else if(message.type == ViewDispatcherMessageTypeCustomEvent) {
             view_dispatcher_handle_custom_event(view_dispatcher, message.custom_event);
-        } else if(message.type == ViewDispatcherMessageTypeNavigationEvent) {
-            view_navigator_handle_navigation_event(
-                view_dispatcher->view_navigator, message.navigator_event);
-        } else if(message.type == ViewDispatcherMessageTypeBackSearchScene) {
-            view_navigator_handle_back_search_scene_event(
-                view_dispatcher->view_navigator, message.navigator_event);
         }
     }
 }
@@ -206,9 +211,9 @@ void view_dispatcher_handle_input(ViewDispatcher* view_dispatcher, InputEvent* e
         uint32_t view_id = VIEW_IGNORE;
         if(event->key == InputKeyBack) {
             view_id = view_previous(view_dispatcher->current_view);
-            if((view_id == VIEW_IGNORE) && (view_dispatcher->view_navigator)) {
-                is_consumed = view_navigator_handle_navigation_event(
-                    view_dispatcher->view_navigator, ViewNavigatorEventBack);
+            if((view_id == VIEW_IGNORE) && (view_dispatcher->navigation_event_callback)) {
+                is_consumed =
+                    view_dispatcher->navigation_event_callback(view_dispatcher->event_context);
                 if(!is_consumed) {
                     view_dispatcher_stop(view_dispatcher);
                     return;
@@ -223,14 +228,21 @@ void view_dispatcher_handle_input(ViewDispatcher* view_dispatcher, InputEvent* e
     }
 }
 
+void view_dispatcher_handle_tick_event(ViewDispatcher* view_dispatcher) {
+    if(view_dispatcher->tick_event_callback) {
+        view_dispatcher->tick_event_callback(view_dispatcher->event_context);
+    }
+}
+
 void view_dispatcher_handle_custom_event(ViewDispatcher* view_dispatcher, uint32_t event) {
     bool is_consumed = false;
     if(view_dispatcher->current_view) {
         is_consumed = view_custom(view_dispatcher->current_view, event);
     }
-    // If custom event is not consumed in View, handle it in Scene
-    if(!is_consumed) {
-        is_consumed = view_navigator_handle_custom_event(view_dispatcher->view_navigator, event);
+    // If custom event is not consumed in View, call callback
+    if(!is_consumed && view_dispatcher->custom_event_callback) {
+        is_consumed =
+            view_dispatcher->custom_event_callback(view_dispatcher->event_context, event);
     }
 }
 
@@ -245,30 +257,6 @@ void view_dispatcher_send_custom_event(ViewDispatcher* view_dispatcher, uint32_t
     furi_check(osMessageQueuePut(view_dispatcher->queue, &message, 0, osWaitForever) == osOK);
 }
 
-void view_dispatcher_send_navigation_event(ViewDispatcher* view_dispatcher, uint32_t event) {
-    furi_assert(view_dispatcher);
-    furi_assert(view_dispatcher->queue);
-    furi_assert(view_dispatcher->view_navigator);
-
-    ViewDispatcherMessage message;
-    message.type = ViewDispatcherMessageTypeNavigationEvent;
-    message.custom_event = event;
-
-    furi_check(osMessageQueuePut(view_dispatcher->queue, &message, 0, osWaitForever) == osOK);
-}
-
-void view_dispatcher_send_back_search_scene_event(ViewDispatcher* view_dispatcher, uint32_t event) {
-    furi_assert(view_dispatcher);
-    furi_assert(view_dispatcher->queue);
-    furi_assert(view_dispatcher->view_navigator);
-
-    ViewDispatcherMessage message;
-    message.type = ViewDispatcherMessageTypeBackSearchScene;
-    message.custom_event = event;
-
-    furi_check(osMessageQueuePut(view_dispatcher->queue, &message, 0, osWaitForever) == osOK);
-}
-
 void view_dispatcher_set_current_view(ViewDispatcher* view_dispatcher, View* view) {
     furi_assert(view_dispatcher);
     // Dispatch view exit event

applications/gui/view_dispatcher.h

@@ -2,7 +2,7 @@
 
 #include "view.h"
 #include "gui.h"
-#include "view_navigator.h"
+#include "scene_manager.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -18,6 +18,18 @@ typedef enum {
 
 typedef struct ViewDispatcher ViewDispatcher;
 
+/** Prototype for custom event callback
+ */
+typedef bool (*ViewDispatcherCustomEventCallback)(void* context, uint32_t event);
+
+/** Prototype for navigation event callback
+ */
+typedef bool (*ViewDispatcherNavigationEventCallback)(void* context);
+
+/** Prototype for tick event callback
+ */
+typedef void (*ViewDispatcherTickEventCallback)(void* context);
+
 /** Allocate ViewDispatcher instance
  * @return pointer to ViewDispatcher instance
  */
@@ -39,30 +51,39 @@ void view_dispatcher_enable_queue(ViewDispatcher* view_dispatcher);
  */
 void view_dispatcher_send_custom_event(ViewDispatcher* view_dispatcher, uint32_t event);
 
-/** Enable View Navigator to handle custom events and scene navigation
+/** Set custom event handler
+ * Called on Custom Event, if it is not consumed by view
  * @param view_dispatcher ViewDispatcher instance
- * @param context  context for all scenes
+ * @param callback ViewDispatcherCustomEventCallback instance
  */
-void view_dispatcher_enable_navigation(ViewDispatcher* view_dispatcher, void* context);
+void view_dispatcher_set_custom_event_callback(
+    ViewDispatcher* view_dispatcher,
+    ViewDispatcherCustomEventCallback callback);
 
-/** Add Scene to view navigator
- * Use only after navigation enabled
+/** Set navigation event handler
+ * Called on Input Short Back Event, if it is not consumed by view
  * @param view_dispatcher ViewDispatcher instance
- * @param scene AppScene instance
+ * @param callback ViewDispatcherNavigationEventCallback instance
  */
-void view_dispatcher_add_scene(ViewDispatcher* view_dispatcher, AppScene* scene);
+void view_dispatcher_set_navigation_event_callback(
+    ViewDispatcher* view_dispatcher,
+    ViewDispatcherNavigationEventCallback callback);
 
-/** Send navigation event
+/** Set tick event handler
  * @param view_dispatcher ViewDispatcher instance
- * @param event event
+ * @param callback ViewDispatcherTickEventCallback
+ * @param tick_period callback call period
  */
-void view_dispatcher_send_navigation_event(ViewDispatcher* view_dispatcher, uint32_t event);
+void view_dispatcher_set_tick_event_callback(
+    ViewDispatcher* view_dispatcher,
+    ViewDispatcherTickEventCallback callback,
+    uint32_t tick_period);
 
-/** Send search scene event
+/** Set event callback context
  * @param view_dispatcher ViewDispatcher instance
- * @param event event
+ * @param context pointer to context
  */
-void view_dispatcher_send_back_search_scene_event(ViewDispatcher* view_dispatcher, uint32_t event);
+void view_dispatcher_set_event_callback_context(ViewDispatcher* view_dispatcher, void* context);
 
 /** Run ViewDispatcher
  * Use only after queue enabled

applications/gui/view_dispatcher_i.h

@@ -15,14 +15,16 @@ struct ViewDispatcher {
     ViewPort* view_port;
     ViewDict_t views;
     View* current_view;
-    ViewNavigator* view_navigator;
+    ViewDispatcherCustomEventCallback custom_event_callback;
+    ViewDispatcherNavigationEventCallback navigation_event_callback;
+    ViewDispatcherTickEventCallback tick_event_callback;
+    uint32_t tick_period;
+    void* event_context;
 };
 
 typedef enum {
     ViewDispatcherMessageTypeInput,
     ViewDispatcherMessageTypeCustomEvent,
-    ViewDispatcherMessageTypeNavigationEvent,
-    ViewDispatcherMessageTypeBackSearchScene,
     ViewDispatcherMessageTypeStop,
 } ViewDispatcherMessageType;
 
@@ -31,8 +33,6 @@ typedef struct {
     union {
         InputEvent input;
         uint32_t custom_event;
-        ViewNavigatorEvent navigator_event;
-        uint32_t scene_id;
     };
 } ViewDispatcherMessage;
 
@@ -45,6 +45,9 @@ void view_dispatcher_input_callback(InputEvent* event, void* context);
 /* Input handler */
 void view_dispatcher_handle_input(ViewDispatcher* view_dispatcher, InputEvent* event);
 
+/* Tick handler */
+void view_dispatcher_handle_tick_event(ViewDispatcher* view_dispatcher);
+
 /* Custom event handler */
 void view_dispatcher_handle_custom_event(ViewDispatcher* view_dispatcher, uint32_t event);
 

applications/gui/view_navigator.c

@@ -1,109 +0,0 @@
-#include "view_navigator_i.h"
-
-ViewNavigator* view_navigator_alloc(void* context) {
-    furi_assert(context);
-
-    ViewNavigator* view_navigator = furi_alloc(sizeof(ViewNavigator));
-    view_navigator->context = context;
-    ViewNavSceneArray_init(view_navigator->scene_array);
-
-    return view_navigator;
-}
-
-void view_navigator_free(ViewNavigator* view_navigator) {
-    furi_assert(view_navigator);
-    ViewNavSceneArray_clear(view_navigator->scene_array);
-
-    free(view_navigator);
-}
-
-bool view_navigator_handle_custom_event(ViewNavigator* view_navigator, uint32_t event) {
-    AppScene* scene = *ViewNavSceneArray_back(view_navigator->scene_array);
-    return scene->on_event(view_navigator->context, event);
-}
-
-bool view_navigator_handle_navigation_event(ViewNavigator* view_navigator, uint32_t event) {
-    if(event == ViewNavigatorEventNext) {
-        return view_navigator_next_scene(view_navigator);
-    } else if(event == ViewNavigatorEventBack) {
-        AppScene* scene = *ViewNavSceneArray_back(view_navigator->scene_array);
-        if(scene->on_event(view_navigator->context, ViewNavigatorEventBack)) {
-            return true;
-        } else {
-            return view_navigator_previous_scene(view_navigator);
-        }
-    }
-    return false;
-}
-
-bool view_navigator_handle_back_search_scene_event(ViewNavigator* view_navigator, uint32_t event) {
-    return view_navigator_search_previous_scene(view_navigator, event);
-}
-
-void view_navigator_add_next_scene(ViewNavigator* view_navigator, AppScene* scene) {
-    furi_assert(view_navigator);
-    furi_assert(scene);
-
-    ViewNavSceneArray_push_back(view_navigator->scene_array, scene);
-}
-
-void view_navigator_start(ViewNavigator* view_navigator) {
-    furi_assert(view_navigator);
-    AppScene* scene = *ViewNavSceneArray_front(view_navigator->scene_array);
-    furi_assert(scene);
-    scene->on_enter(view_navigator->context);
-}
-
-bool view_navigator_next_scene(ViewNavigator* view_navigator) {
-    ViewNavSceneArray_it_t scene_it;
-    ViewNavSceneArray_it_last(scene_it, view_navigator->scene_array);
-    ViewNavSceneArray_previous(scene_it);
-    AppScene* current_scene = *ViewNavSceneArray_ref(scene_it);
-    AppScene* next_scene = *ViewNavSceneArray_back(view_navigator->scene_array);
-    if(current_scene && next_scene) {
-        current_scene->on_exit(view_navigator->context);
-        next_scene->on_enter(view_navigator->context);
-        return true;
-    }
-    return false;
-}
-
-bool view_navigator_previous_scene(ViewNavigator* view_navigator) {
-    AppScene* current_scene = NULL;
-    ViewNavSceneArray_pop_back(&current_scene, view_navigator->scene_array);
-    if(ViewNavSceneArray_size(view_navigator->scene_array) == 0) {
-        // Handle exit from start scene separately
-        current_scene->on_exit(view_navigator->context);
-        return false;
-    }
-    AppScene* previous_scene = *ViewNavSceneArray_back(view_navigator->scene_array);
-    if(current_scene && previous_scene) {
-        current_scene->on_exit(view_navigator->context);
-        previous_scene->on_enter(view_navigator->context);
-        return true;
-    }
-    return false;
-}
-
-bool view_navigator_search_previous_scene(ViewNavigator* view_navigator, uint32_t scene_id) {
-    AppScene* previous_scene = NULL;
-    AppScene* current_scene = *ViewNavSceneArray_back(view_navigator->scene_array);
-    ViewNavSceneArray_it_t scene_it;
-    ViewNavSceneArray_it_last(scene_it, view_navigator->scene_array);
-    bool scene_found = false;
-    while(!scene_found) {
-        ViewNavSceneArray_previous(scene_it);
-        previous_scene = *ViewNavSceneArray_ref(scene_it);
-        if(previous_scene == NULL) {
-            return false;
-        }
-        if(previous_scene->id == scene_id) {
-            scene_found = true;
-        }
-    }
-    ViewNavSceneArray_next(scene_it);
-    ViewNavSceneArray_pop_until(view_navigator->scene_array, scene_it);
-    current_scene->on_exit(view_navigator->context);
-    previous_scene->on_enter(view_navigator->context);
-    return true;
-}

applications/gui/view_navigator.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include "app_scene.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
-    ViewNavigatorEventNext = 0x00000000UL,
-    ViewNavigatorEventBack = 0xFFFFFFFFUL,
-} ViewNavigatorEvent;
-
-typedef struct ViewNavigator ViewNavigator;
-
-ViewNavigator* view_navigator_alloc(void* context);
-void view_navigator_free(ViewNavigator* view_navigator);
-
-bool view_navigator_handle_custom_event(ViewNavigator* view_navigator, uint32_t event);
-bool view_navigator_handle_navigation_event(ViewNavigator* view_navigator, uint32_t event);
-bool view_navigator_handle_back_search_scene_event(ViewNavigator* view_navigator, uint32_t event);
-
-void view_navigator_add_next_scene(ViewNavigator* view_navigator, AppScene* scene);
-void view_navigator_start(ViewNavigator* view_navigator);
-
-#ifdef __cplusplus
-}
-#endif

applications/gui/view_navigator_i.h

@@ -1,16 +0,0 @@
-#pragma once
-
-#include "view_navigator.h"
-#include <furi.h>
-#include <m-array.h>
-
-ARRAY_DEF(ViewNavSceneArray, AppScene*, M_PTR_OPLIST);
-
-struct ViewNavigator {
-    ViewNavSceneArray_t scene_array;
-    void* context;
-};
-
-bool view_navigator_next_scene(ViewNavigator* view_navigator);
-bool view_navigator_previous_scene(ViewNavigator* view_navigator);
-bool view_navigator_search_previous_scene(ViewNavigator* view_navigator, uint32_t scene_id);