[FL-1217] Menu refactoring (#726)

* menu: remove dead code
* loader: change views from modules instead of menu service
* dolphin: start main menu with loader API
* applications: don't start menu service
* loader: add debug tools menu
* gui modules: introduce menu model
* loader: remove calls to menu service API
* gui modules: implement menu module
* loader: add menu view
* gui menu: add animation
* applications: remove menu service
* gui modules: rename icon_menu -> menu
* loader: clean up code
* menu module: add documentation, format code
* menu: remove unused parameter
* desktop: use loader to launch primary menu
* Applications: cleaner makefile app declaration. Loader: application autostart
* Gui: cleanup menu and submenu API.

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

applications/gui/modules/menu.c

@@ -0,0 +1,199 @@
+#include "menu.h"
+
+#include <m-array.h>
+#include <gui/elements.h>
+#include <furi.h>
+
+struct Menu {
+    View* view;
+};
+
+typedef struct {
+    const char* label;
+    IconAnimation* icon;
+    uint32_t index;
+    MenuItemCallback callback;
+    void* callback_context;
+} MenuItem;
+
+ARRAY_DEF(MenuItemArray, MenuItem, M_POD_OPLIST);
+
+typedef struct {
+    MenuItemArray_t items;
+    uint8_t position;
+} MenuModel;
+
+static void menu_process_up(Menu* menu);
+static void menu_process_down(Menu* menu);
+static void menu_process_ok(Menu* menu);
+
+static void menu_draw_callback(Canvas* canvas, void* _model) {
+    MenuModel* model = _model;
+
+    canvas_clear(canvas);
+
+    uint8_t position = model->position;
+    size_t items_count = MenuItemArray_size(model->items);
+    if(items_count) {
+        MenuItem* item;
+        size_t shift_position;
+        // First line
+        canvas_set_font(canvas, FontSecondary);
+        shift_position = (0 + position + items_count - 1) % items_count;
+        item = MenuItemArray_get(model->items, shift_position);
+        if(item->icon) {
+            canvas_draw_icon_animation(canvas, 4, 3, item->icon);
+            icon_animation_stop(item->icon);
+        }
+        canvas_draw_str(canvas, 22, 14, item->label);
+        // Second line main
+        canvas_set_font(canvas, FontPrimary);
+        shift_position = (1 + position + items_count - 1) % items_count;
+        item = MenuItemArray_get(model->items, shift_position);
+        if(item->icon) {
+            canvas_draw_icon_animation(canvas, 4, 25, item->icon);
+            icon_animation_start(item->icon);
+        }
+        canvas_draw_str(canvas, 22, 36, item->label);
+        // Third line
+        canvas_set_font(canvas, FontSecondary);
+        shift_position = (2 + position + items_count - 1) % items_count;
+        item = MenuItemArray_get(model->items, shift_position);
+        if(item->icon) {
+            canvas_draw_icon_animation(canvas, 4, 47, item->icon);
+            icon_animation_stop(item->icon);
+        }
+        canvas_draw_str(canvas, 22, 58, item->label);
+        // Frame and scrollbar
+        elements_frame(canvas, 0, 21, 128 - 5, 21);
+        elements_scrollbar(canvas, position, items_count);
+    } else {
+        canvas_draw_str(canvas, 2, 32, "Empty");
+        elements_scrollbar(canvas, 0, 0);
+    }
+}
+
+static bool menu_input_callback(InputEvent* event, void* context) {
+    Menu* menu = context;
+    bool consumed = false;
+
+    if(event->type == InputTypeShort) {
+        if(event->key == InputKeyUp) {
+            consumed = true;
+            menu_process_up(menu);
+        } else if(event->key == InputKeyDown) {
+            consumed = true;
+            menu_process_down(menu);
+        } else if(event->key == InputKeyOk) {
+            consumed = true;
+            menu_process_ok(menu);
+        }
+    }
+
+    return consumed;
+}
+
+Menu* menu_alloc() {
+    Menu* menu = furi_alloc(sizeof(Menu));
+    menu->view = view_alloc(menu->view);
+    view_set_context(menu->view, menu);
+    view_allocate_model(menu->view, ViewModelTypeLocking, sizeof(MenuModel));
+    view_set_draw_callback(menu->view, menu_draw_callback);
+    view_set_input_callback(menu->view, menu_input_callback);
+
+    with_view_model(
+        menu->view, (MenuModel * model) {
+            MenuItemArray_init(model->items);
+            model->position = 0;
+            return true;
+        });
+
+    return menu;
+}
+
+void menu_free(Menu* menu) {
+    furi_assert(menu);
+    with_view_model(
+        menu->view, (MenuModel * model) {
+            MenuItemArray_clear(model->items);
+            return true;
+        });
+    view_free(menu->view);
+    free(menu);
+}
+
+View* menu_get_view(Menu* menu) {
+    furi_assert(menu);
+    return (menu->view);
+}
+
+void menu_add_item(
+    Menu* menu,
+    const char* label,
+    IconAnimation* icon,
+    uint32_t index,
+    MenuItemCallback callback,
+    void* context) {
+    furi_assert(menu);
+    furi_assert(label);
+
+    MenuItem* item = NULL;
+    with_view_model(
+        menu->view, (MenuModel * model) {
+            item = MenuItemArray_push_new(model->items);
+            item->label = label;
+            item->icon = icon;
+            item->index = index;
+            item->callback = callback;
+            item->callback_context = context;
+            return true;
+        });
+}
+
+void menu_clean(Menu* menu) {
+    furi_assert(menu);
+    with_view_model(
+        menu->view, (MenuModel * model) {
+            MenuItemArray_clean(model->items);
+            model->position = 0;
+            return true;
+        });
+}
+
+static void menu_process_up(Menu* menu) {
+    with_view_model(
+        menu->view, (MenuModel * model) {
+            if(model->position > 0) {
+                model->position--;
+            } else {
+                model->position = MenuItemArray_size(model->items) - 1;
+            }
+            return true;
+        });
+}
+
+static void menu_process_down(Menu* menu) {
+    with_view_model(
+        menu->view, (MenuModel * model) {
+            if(model->position < MenuItemArray_size(model->items) - 1) {
+                model->position++;
+            } else {
+                model->position = 0;
+            }
+            return true;
+        });
+}
+
+static void menu_process_ok(Menu* menu) {
+    MenuItem* item = NULL;
+    with_view_model(
+        menu->view, (MenuModel * model) {
+            if(model->position < MenuItemArray_size(model->items)) {
+                item = MenuItemArray_get(model->items, model->position);
+            }
+            return true;
+        });
+    if(item && item->callback) {
+        item->callback(item->callback_context, item->index);
+    }
+}

applications/gui/modules/menu.h

@@ -0,0 +1,52 @@
+#pragma once
+#include <gui/view.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Menu anonymous structure */
+typedef struct Menu Menu;
+typedef void (*MenuItemCallback)(void* context, uint32_t index);
+
+/** Menu allocation and initialization
+ * @return Menu instance
+ */
+Menu* menu_alloc();
+
+/** Free menu
+ * @param menu - Menu instance
+ */
+void menu_free(Menu* menu);
+
+/** Get Menu view
+ * @param menu - Menu instance
+ * @return View instance
+ */
+View* menu_get_view(Menu* menu);
+
+/** Add item to menu
+ * @param menu - Menu instance
+ * @param label - menu item string label
+ * @param icon - IconAnimation instance
+ * @param index - menu item index
+ * @param callback - MenuItemCallback instance
+ * @param context - pointer to context
+ */
+void menu_add_item(
+    Menu* menu,
+    const char* label,
+    IconAnimation* icon,
+    uint32_t index,
+    MenuItemCallback callback,
+    void* context);
+
+/** Clean menu
+ * Note: this function does not free menu instance
+ * @param menu - Menu instance
+ */
+void menu_clean(Menu* menu);
+
+#ifdef __cplusplus
+}
+#endif

applications/gui/modules/submenu.c

@@ -1,23 +1,22 @@
 #include "submenu.h"
-#include "gui/canvas.h"
+
 #include <m-array.h>
-#include <furi.h>
 #include <gui/elements.h>
-#include <stdint.h>
-
-struct SubmenuItem {
-    const char* label;
-    uint32_t index;
-    SubmenuItemCallback callback;
-    void* callback_context;
-};
-
-ARRAY_DEF(SubmenuItemArray, SubmenuItem, M_POD_OPLIST);
+#include <furi.h>
 
 struct Submenu {
     View* view;
 };
 
+typedef struct {
+    const char* label;
+    uint32_t index;
+    SubmenuItemCallback callback;
+    void* callback_context;
+} SubmenuItem;
+
+ARRAY_DEF(SubmenuItemArray, SubmenuItem, M_POD_OPLIST);
+
 typedef struct {
     SubmenuItemArray_t items;
     const char* header;
@@ -149,7 +148,7 @@ View* submenu_get_view(Submenu* submenu) {
     return submenu->view;
 }
 
-SubmenuItem* submenu_add_item(
+void submenu_add_item(
     Submenu* submenu,
     const char* label,
     uint32_t index,
@@ -168,8 +167,6 @@ SubmenuItem* submenu_add_item(
             item->callback_context = callback_context;
             return true;
         });
-
-    return item;
 }
 
 void submenu_clean(Submenu* submenu) {

applications/gui/modules/submenu.h

@@ -7,7 +7,6 @@ extern "C" {
 
 /* Submenu anonymous structure */
 typedef struct Submenu Submenu;
-typedef struct SubmenuItem SubmenuItem;
 typedef void (*SubmenuItemCallback)(void* context, uint32_t index);
 
 /**
@@ -36,9 +35,8 @@ View* submenu_get_view(Submenu* submenu);
  * @param index - menu item index, used for callback, may be the same with other items
  * @param callback - menu item callback
  * @param callback_context - menu item callback context
- * @return SubmenuItem instance that can be used to modify or delete that item
  */
-SubmenuItem* submenu_add_item(
+void submenu_add_item(
     Submenu* submenu,
     const char* label,
     uint32_t index,