Display and UI implementation (#169)

* Menu app. Lib: add mlib submodule.

* Menu: new startup lib dependency definition

* Menu: hierarchy in menu. Cube: fix heap1/4 inconsistency, stack protection.

* GUI: rendering pipeline initial version.

* GUI: layered widget composing, FURI record. Menu: FURI record, api.

* GUI: input dispatching. Menu: switch to input from GUI.

* GUI, MENU: code style cleanup, fix type conversion warnings.

* GUI, Menu: syntax check.

* Makefile: check and reinit submodules, format.

* Menu: lock on event processing. Makefile: proper submodule initialization.

* Menu: fix stack corruption by queue.

* GUI: refactor.

* Makefile: format rule fix, st-util pid.

* GUI, Menu, FURI: format with clang-format.

* GUI, MENU: locks in critical sections, fix stack corruption, ready signaling.

* Makefile: clang format rule cleanup.

* GUI,MENU: migrate to new API.

* Applications: PRODUCTION_HW variable, skip drivers build on local target.

* refactor production build

* add git to dockerfile

* GUI: uncomment lock block

Co-authored-by: Aleksandr Kutuzov <aku@plooks.com>

applications/menu/menu.c

@@ -0,0 +1,214 @@
+#include "menu.h"
+#include <cmsis_os.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include <flipper.h>
+#include <gui/gui.h>
+#include <gui/canvas.h>
+#include <gui/widget.h>
+
+#include "menu_event.h"
+#include "menu_item.h"
+
+struct Menu {
+    MenuEvent* event;
+    // GUI
+    FuriRecordSubscriber* gui_record;
+    Widget* widget;
+    // State
+    MenuItem* root;
+    MenuItem* settings;
+    MenuItem* current;
+    uint32_t position;
+};
+
+void menu_widget_callback(Canvas* canvas, void* context);
+
+Menu* menu_alloc() {
+    Menu* menu = furi_alloc(sizeof(Menu));
+
+    // Event dispatcher
+    menu->event = menu_event_alloc();
+
+    // Allocate and configure widget
+    menu->widget = widget_alloc();
+    widget_draw_callback_set(menu->widget, menu_widget_callback, menu);
+    widget_input_callback_set(menu->widget, menu_event_input_callback, menu->event);
+
+    // Open GUI and register fullscreen widget
+    menu->gui_record = furi_open_deprecated("gui", false, false, NULL, NULL, NULL);
+    assert(menu->gui_record);
+
+    return menu;
+}
+
+void menu_build_main(Menu* menu) {
+    assert(menu);
+    // Root point
+    menu->root = menu_item_alloc_menu(NULL, NULL);
+
+    menu_item_add(menu, menu_item_alloc_function("Sub 1 gHz", NULL, NULL));
+    menu_item_add(menu, menu_item_alloc_function("125 kHz RFID", NULL, NULL));
+    menu_item_add(menu, menu_item_alloc_function("Infrared", NULL, NULL));
+    menu_item_add(menu, menu_item_alloc_function("I-Button", NULL, NULL));
+    menu_item_add(menu, menu_item_alloc_function("USB", NULL, NULL));
+    menu_item_add(menu, menu_item_alloc_function("Bluetooth", NULL, NULL));
+    menu_item_add(menu, menu_item_alloc_function("GPIO / HW", NULL, NULL));
+    menu_item_add(menu, menu_item_alloc_function("NFC", NULL, NULL));
+    menu_item_add(menu, menu_item_alloc_function("U2F", NULL, NULL));
+    menu_item_add(menu, menu_item_alloc_function("Tamagotchi", NULL, NULL));
+    menu_item_add(menu, menu_item_alloc_function("Plugins", NULL, NULL));
+
+    menu->settings = menu_item_alloc_menu("Setting", NULL);
+    menu_item_subitem_add(menu->settings, menu_item_alloc_function("one", NULL, NULL));
+    menu_item_subitem_add(menu->settings, menu_item_alloc_function("two", NULL, NULL));
+    menu_item_subitem_add(menu->settings, menu_item_alloc_function("three", NULL, NULL));
+
+    menu_item_add(menu, menu->settings);
+}
+
+void menu_item_add(Menu* menu, MenuItem* item) {
+    menu_item_subitem_add(menu->root, item);
+}
+
+void menu_settings_item_add(Menu* menu, MenuItem* item) {
+    menu_item_subitem_add(menu->settings, item);
+}
+
+void menu_widget_callback(Canvas* canvas, void* context) {
+    assert(canvas);
+    assert(context);
+
+    Menu* menu = context;
+
+    menu_event_lock(menu->event);
+
+    if(!menu->current) {
+        canvas_clear(canvas);
+        canvas_color_set(canvas, COLOR_BLACK);
+        canvas_font_set(canvas, CANVAS_FONT_PRIMARY);
+        canvas_str_draw(canvas, 2, 32, "Idle Screen");
+    } else {
+        MenuItemArray_t* items = menu_item_get_subitems(menu->current);
+        canvas_clear(canvas);
+        canvas_color_set(canvas, COLOR_BLACK);
+        canvas_font_set(canvas, CANVAS_FONT_SECONDARY);
+        for(size_t i = 0; i < 5; i++) {
+            size_t shift_position = i + menu->position + MenuItemArray_size(*items) - 2;
+            shift_position = shift_position % (MenuItemArray_size(*items));
+            MenuItem* item = *MenuItemArray_get(*items, shift_position);
+            canvas_str_draw(canvas, 2, 12 * (i + 1), menu_item_get_label(item));
+        }
+    }
+
+    menu_event_unlock(menu->event);
+}
+
+void menu_update(Menu* menu) {
+    assert(menu);
+
+    menu_event_activity_notify(menu->event);
+    widget_update(menu->widget);
+}
+
+void menu_up(Menu* menu) {
+    assert(menu);
+
+    MenuItemArray_t* items = menu_item_get_subitems(menu->current);
+    if(menu->position == 0) menu->position = MenuItemArray_size(*items);
+    menu->position--;
+    menu_update(menu);
+}
+
+void menu_down(Menu* menu) {
+    assert(menu);
+
+    MenuItemArray_t* items = menu_item_get_subitems(menu->current);
+    menu->position++;
+    menu->position = menu->position % MenuItemArray_size(*items);
+    menu_update(menu);
+}
+
+void menu_ok(Menu* menu) {
+    assert(menu);
+
+    if(!menu->current) {
+        menu->current = menu->root;
+        menu_update(menu);
+        return;
+    }
+
+    MenuItemArray_t* items = menu_item_get_subitems(menu->current);
+    MenuItem* item = *MenuItemArray_get(*items, menu->position);
+    MenuItemType type = menu_item_get_type(item);
+
+    if(type == MenuItemTypeMenu) {
+        menu->current = item;
+        menu->position = 0;
+        menu_update(menu);
+    } else if(type == MenuItemTypeFunction) {
+        MenuItemCallback function = menu_item_get_function(item);
+        if(function) function();
+    }
+}
+
+void menu_back(Menu* menu) {
+    assert(menu);
+    MenuItem* parent = menu_item_get_parent(menu->current);
+    if(parent) {
+        menu->current = parent;
+        menu->position = 0;
+        menu_update(menu);
+    } else {
+        menu_exit(menu);
+    }
+}
+
+void menu_exit(Menu* menu) {
+    assert(menu);
+    menu->position = 0;
+    menu->current = NULL;
+    menu_update(menu);
+}
+
+void menu_task(void* p) {
+    Menu* menu = menu_alloc();
+    menu_build_main(menu);
+
+    // Register widget
+    GUI* gui = furi_take(menu->gui_record);
+    assert(gui);
+    gui_widget_fs_add(gui, menu->widget);
+    furi_commit(menu->gui_record);
+
+    if(!furi_create_deprecated("menu", menu, sizeof(menu))) {
+        printf("[menu_task] cannot create the menu record\n");
+        furiac_exit(NULL);
+    }
+    furiac_ready();
+    
+    while(1) {
+        MenuMessage m = menu_event_next(menu->event);
+
+        if(!menu->current && m.type != MenuMessageTypeOk) {
+            continue;
+        } else if(m.type == MenuMessageTypeUp) {
+            menu_up(menu);
+        } else if(m.type == MenuMessageTypeDown) {
+            menu_down(menu);
+        } else if(m.type == MenuMessageTypeOk) {
+            menu_ok(menu);
+        } else if(m.type == MenuMessageTypeLeft) {
+            menu_back(menu);
+        } else if(m.type == MenuMessageTypeRight) {
+            menu_ok(menu);
+        } else if(m.type == MenuMessageTypeBack) {
+            menu_back(menu);
+        } else if(m.type == MenuMessageTypeIdle) {
+            menu_exit(menu);
+        } else {
+            // TODO: fail somehow?
+        }
+    }
+}

applications/menu/menu.h

@@ -0,0 +1,17 @@
+#pragma once
+
+typedef struct Menu Menu;
+typedef struct MenuItem MenuItem;
+
+// Add menu item to root menu
+void menu_item_add(Menu* menu, MenuItem* item);
+
+// Add menu item to settings menu
+void menu_settings_item_add(Menu* menu, MenuItem* item);
+
+// Menu controls
+void menu_up(Menu* menu);
+void menu_down(Menu* menu);
+void menu_ok(Menu* menu);
+void menu_back(Menu* menu);
+void menu_exit(Menu* menu);

applications/menu/menu_event.c

@@ -0,0 +1,96 @@
+#include "menu_event.h"
+
+#include <cmsis_os.h>
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <flipper.h>
+
+#define MENU_MESSAGE_MQUEUE_SIZE 8
+
+struct MenuEvent {
+    osMessageQueueId_t mqueue;
+    osTimerId_t timeout_timer;
+    osMutexId_t lock_mutex;
+};
+
+void MenuEventimeout_callback(void* arg) {
+    MenuEvent* menu_event = arg;
+    MenuMessage message;
+    message.type = MenuMessageTypeIdle;
+    osMessageQueuePut(menu_event->mqueue, &message, 0, 0);
+}
+
+MenuEvent* menu_event_alloc() {
+    MenuEvent* menu_event = furi_alloc(sizeof(MenuEvent));
+
+    menu_event->mqueue = osMessageQueueNew(MENU_MESSAGE_MQUEUE_SIZE, sizeof(MenuMessage), NULL);
+    assert(menu_event->mqueue);
+
+    menu_event->timeout_timer =
+        osTimerNew(MenuEventimeout_callback, osTimerOnce, menu_event, NULL);
+    assert(menu_event->timeout_timer);
+
+    menu_event->lock_mutex = osMutexNew(NULL);
+    assert(menu_event->lock_mutex);
+
+    menu_event_lock(menu_event);
+
+    return menu_event;
+}
+
+void menu_event_free(MenuEvent* menu_event) {
+    assert(menu_event);
+    menu_event_unlock(menu_event);
+    assert(osMessageQueueDelete(menu_event->mqueue) == osOK);
+    free(menu_event);
+}
+
+void menu_event_lock(MenuEvent* menu_event) {
+    assert(osMutexAcquire(menu_event->lock_mutex, osWaitForever) == osOK);
+}
+
+void menu_event_unlock(MenuEvent* menu_event) {
+    assert(osMutexRelease(menu_event->lock_mutex) == osOK);
+}
+
+void menu_event_activity_notify(MenuEvent* menu_event) {
+    assert(menu_event);
+    osTimerStart(menu_event->timeout_timer, 60000U); // 1m timeout, return to main
+}
+
+MenuMessage menu_event_next(MenuEvent* menu_event) {
+    assert(menu_event);
+    MenuMessage message;
+    menu_event_unlock(menu_event);
+    while(osMessageQueueGet(menu_event->mqueue, &message, NULL, osWaitForever) != osOK) {
+    };
+    menu_event_lock(menu_event);
+    return message;
+}
+
+void menu_event_input_callback(InputEvent* input_event, void* context) {
+    MenuEvent* menu_event = context;
+    MenuMessage message;
+
+    if(!input_event->state) return;
+
+    if(input_event->input == InputUp) {
+        message.type = MenuMessageTypeUp;
+    } else if(input_event->input == InputDown) {
+        message.type = MenuMessageTypeDown;
+    } else if(input_event->input == InputRight) {
+        message.type = MenuMessageTypeRight;
+    } else if(input_event->input == InputLeft) {
+        message.type = MenuMessageTypeLeft;
+    } else if(input_event->input == InputOk) {
+        message.type = MenuMessageTypeOk;
+    } else if(input_event->input == InputBack) {
+        message.type = MenuMessageTypeBack;
+    } else {
+        message.type = MenuMessageTypeUnknown;
+    }
+
+    osMessageQueuePut(menu_event->mqueue, &message, 0, 0);
+}

applications/menu/menu_event.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <stdint.h>
+#include <input/input.h>
+
+typedef enum {
+    MenuMessageTypeUp = 0x00,
+    MenuMessageTypeDown = 0x01,
+    MenuMessageTypeLeft = 0x02,
+    MenuMessageTypeRight = 0x03,
+    MenuMessageTypeOk = 0x04,
+    MenuMessageTypeBack = 0x05,
+    MenuMessageTypeIdle = 0x06,
+    MenuMessageTypeUnknown = 0xFF,
+} MenuMessageType;
+
+typedef struct {
+    MenuMessageType type;
+    void* data;
+} MenuMessage;
+
+typedef struct MenuEvent MenuEvent;
+
+MenuEvent* menu_event_alloc();
+
+void menu_event_free(MenuEvent* menu_event);
+
+void menu_event_lock(MenuEvent* menu_event);
+
+void menu_event_unlock(MenuEvent* menu_event);
+
+void menu_event_activity_notify(MenuEvent* menu_event);
+
+MenuMessage menu_event_next(MenuEvent* menu_event);
+
+void menu_event_input_callback(InputEvent* input_event, void* context);

applications/menu/menu_item.c

@@ -0,0 +1,89 @@
+#include "menu_item.h"
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include <flipper.h>
+
+struct MenuItem {
+    MenuItemType type;
+    const char* label;
+    void* icon;
+    MenuItem* parent;
+    void* data;
+};
+
+MenuItem* menu_item_alloc() {
+    MenuItem* menu_item = furi_alloc(sizeof(MenuItem));
+    return menu_item;
+}
+
+MenuItem* menu_item_alloc_menu(const char* label, void* icon) {
+    MenuItem* menu_item = menu_item_alloc();
+
+    menu_item->type = MenuItemTypeMenu;
+    menu_item->label = label;
+    menu_item->icon = icon;
+
+    MenuItemArray_t* items = furi_alloc(sizeof(MenuItemArray_t));
+    MenuItemArray_init(*items);
+    menu_item->data = items;
+
+    return menu_item;
+}
+
+MenuItem* menu_item_alloc_function(const char* label, void* icon, MenuItemCallback function) {
+    MenuItem* menu_item = menu_item_alloc();
+
+    menu_item->type = MenuItemTypeFunction;
+    menu_item->label = label;
+    menu_item->icon = icon;
+    menu_item->data = function;
+
+    return menu_item;
+}
+
+void menu_item_release(MenuItem* menu_item) {
+    if(menu_item->type == MenuItemTypeMenu) free(menu_item->data);
+    free(menu_item);
+}
+
+MenuItem* menu_item_get_parent(MenuItem* menu_item) {
+    return menu_item->parent;
+}
+
+void menu_item_subitem_add(MenuItem* menu_item, MenuItem* sub_item) {
+    assert(menu_item->type == MenuItemTypeMenu);
+    MenuItemArray_t* items = menu_item->data;
+    sub_item->parent = menu_item;
+    MenuItemArray_push_back(*items, sub_item);
+}
+
+uint8_t menu_item_get_type(MenuItem* menu_item) {
+    return menu_item->type;
+}
+
+void menu_item_set_label(MenuItem* menu_item, const char* label) {
+    menu_item->label = label;
+}
+
+const char* menu_item_get_label(MenuItem* menu_item) {
+    return menu_item->label;
+}
+
+void menu_item_set_icon(MenuItem* menu_item, void* icon) {
+    menu_item->icon = icon;
+}
+
+void* menu_item_get_icon(MenuItem* menu_item) {
+    return menu_item->icon;
+}
+
+MenuItemArray_t* menu_item_get_subitems(MenuItem* menu_item) {
+    assert(menu_item->type == MenuItemTypeMenu);
+    return menu_item->data;
+}
+
+MenuItemCallback menu_item_get_function(MenuItem* menu_item) {
+    assert(menu_item->type == MenuItemTypeFunction);
+    return menu_item->data;
+}

applications/menu/menu_item.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <stdint.h>
+#include <m-array.h>
+
+typedef enum {
+    MenuItemTypeMenu = 0x00,
+    MenuItemTypeFunction = 0x01,
+} MenuItemType;
+
+typedef struct MenuItem MenuItem;
+typedef void (*MenuItemCallback)();
+
+ARRAY_DEF(MenuItemArray, MenuItem*, M_PTR_OPLIST);
+
+MenuItem* menu_item_alloc_menu(const char* label, void* icon);
+
+MenuItem* menu_item_alloc_function(const char* label, void* icon, MenuItemCallback function);
+
+void menu_item_release(MenuItem* menu_item);
+
+MenuItem* menu_item_get_parent(MenuItem* menu_item);
+
+void menu_item_subitem_add(MenuItem* menu_item, MenuItem* sub_item);
+
+MenuItemType menu_item_get_type(MenuItem* menu_item);
+
+void menu_item_set_label(MenuItem* menu_item, const char* label);
+const char* menu_item_get_label(MenuItem* menu_item);
+
+void menu_item_set_icon(MenuItem* menu_item, void* icon);
+void* menu_item_get_icon(MenuItem* menu_item);
+
+MenuItemArray_t* menu_item_get_subitems(MenuItem* menu_item);
+
+MenuItemCallback menu_item_get_function(MenuItem* menu_item);