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/gui/canvas.c

@@ -0,0 +1,79 @@
+#include "canvas.h"
+#include "canvas_i.h"
+
+#include <assert.h>
+#include <flipper.h>
+#include <u8g2.h>
+
+struct Canvas {
+    FuriRecordSubscriber* fb_record;
+    u8g2_t* fb;
+    uint8_t offset_x;
+    uint8_t offset_y;
+    uint8_t width;
+    uint8_t height;
+};
+
+Canvas* canvas_alloc() {
+    Canvas* canvas = furi_alloc(sizeof(Canvas));
+    canvas->fb_record = furi_open_deprecated("u8g2_fb", false, false, NULL, NULL, NULL);
+    assert(canvas->fb_record);
+    return canvas;
+}
+
+void canvas_free(Canvas* canvas) {
+    assert(canvas);
+    free(canvas);
+}
+
+void canvas_commit(Canvas* canvas) {
+    assert(canvas);
+    if(canvas->fb) {
+        furi_commit(canvas->fb_record);
+        canvas->fb = NULL;
+    }
+}
+
+void canvas_frame_set(
+    Canvas* canvas,
+    uint8_t offset_x,
+    uint8_t offset_y,
+    uint8_t width,
+    uint8_t height) {
+    assert(canvas);
+    canvas->offset_x = offset_x;
+    canvas->offset_y = offset_y;
+    canvas->width = width;
+    canvas->height = height;
+}
+
+u8g2_t* canvas_fb(Canvas* canvas) {
+    if(!canvas->fb) {
+        canvas->fb = furi_take(canvas->fb_record);
+        assert(canvas->fb);
+    }
+    return canvas->fb;
+}
+
+void canvas_clear(Canvas* canvas) {
+    u8g2_t* fb = canvas_fb(canvas);
+    u8g2_ClearBuffer(fb);
+}
+
+void canvas_color_set(Canvas* canvas, uint8_t color) {
+    u8g2_t* fb = canvas_fb(canvas);
+    u8g2_SetDrawColor(fb, 1);
+}
+
+void canvas_font_set(Canvas* canvas, font_t font) {
+    u8g2_t* fb = canvas_fb(canvas);
+    u8g2_SetFontMode(fb, 1);
+    u8g2_SetFont(fb, font);
+}
+
+void canvas_str_draw(Canvas* canvas, uint8_t x, uint8_t y, const char* str) {
+    x += canvas->offset_x;
+    y += canvas->offset_y;
+    u8g2_t* fb = canvas_fb(canvas);
+    u8g2_DrawStr(fb, x, y, str);
+}

applications/gui/canvas.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <stdint.h>
+#include <u8g2.h>
+
+#define COLOR_WHITE 0x00
+#define COLOR_BLACK 0x01
+
+#define CANVAS_FONT_PRIMARY u8g2_font_Born2bSportyV2_tr
+#define CANVAS_FONT_SECONDARY u8g2_font_HelvetiPixel_tr
+
+typedef struct Canvas Canvas;
+typedef const uint8_t* font_t;
+
+uint8_t canvas_width(Canvas* canvas);
+uint8_t canvas_height(Canvas* canvas);
+
+void canvas_clear(Canvas* canvas);
+
+void canvas_color_set(Canvas* canvas, uint8_t color);
+
+void canvas_font_set(Canvas* canvas, font_t font);
+
+void canvas_str_draw(Canvas* canvas, uint8_t x, uint8_t y, const char* str);

applications/gui/canvas_i.h

@@ -0,0 +1,14 @@
+#pragma once
+
+Canvas* canvas_alloc();
+
+void canvas_free(Canvas* canvas);
+
+void canvas_commit(Canvas* canvas);
+
+void canvas_frame_set(
+    Canvas* canvas,
+    uint8_t offset_x,
+    uint8_t offset_y,
+    uint8_t width,
+    uint8_t height);

applications/gui/gui.c

@@ -0,0 +1,176 @@
+#include "gui.h"
+#include "gui_i.h"
+
+#include <flipper.h>
+#include <stdio.h>
+#include <m-array.h>
+
+#include "gui_event.h"
+#include "canvas.h"
+#include "canvas_i.h"
+#include "widget.h"
+#include "widget_i.h"
+
+ARRAY_DEF(WidgetArray, Widget*, M_PTR_OPLIST);
+
+struct GUI {
+    GUIEvent* event;
+    Canvas* canvas;
+    WidgetArray_t widgets_status_bar;
+    WidgetArray_t widgets;
+    WidgetArray_t widgets_fs;
+    WidgetArray_t widgets_dialog;
+};
+
+void gui_widget_status_bar_add(GUI* gui, Widget* widget) {
+    assert(gui);
+    assert(widget);
+
+    gui_event_lock(gui->event);
+    WidgetArray_push_back(gui->widgets_status_bar, widget);
+    widget_gui_set(widget, gui);
+    gui_event_unlock(gui->event);
+
+    gui_update(gui);
+}
+
+void gui_widget_add(GUI* gui, Widget* widget) {
+    assert(gui);
+    assert(widget);
+
+    gui_event_lock(gui->event);
+    WidgetArray_push_back(gui->widgets, widget);
+    widget_gui_set(widget, gui);
+    gui_event_unlock(gui->event);
+
+    gui_update(gui);
+}
+
+void gui_widget_fs_add(GUI* gui, Widget* widget) {
+    assert(gui);
+    assert(widget);
+
+    gui_event_lock(gui->event);
+    WidgetArray_push_back(gui->widgets_fs, widget);
+    widget_gui_set(widget, gui);
+    gui_event_unlock(gui->event);
+
+    gui_update(gui);
+}
+
+void gui_widget_dialog_add(GUI* gui, Widget* widget) {
+    assert(gui);
+    assert(widget);
+
+    gui_event_lock(gui->event);
+    WidgetArray_push_back(gui->widgets_dialog, widget);
+    widget_gui_set(widget, gui);
+    gui_event_unlock(gui->event);
+
+    gui_update(gui);
+}
+
+void gui_update(GUI* gui) {
+    assert(gui);
+    GUIMessage message;
+    message.type = GUIMessageTypeRedraw;
+    gui_event_messsage_send(gui->event, &message);
+}
+
+Widget* gui_widget_find_enabled(WidgetArray_t array) {
+    size_t widgets_count = WidgetArray_size(array);
+    for(size_t i = 0; i < widgets_count; i++) {
+        Widget* widget = *WidgetArray_get(array, widgets_count - i - 1);
+        if(widget_is_enabled(widget)) {
+            return widget;
+        }
+    }
+    return NULL;
+}
+
+bool gui_redraw_fs(GUI* gui) {
+    canvas_frame_set(gui->canvas, 0, 0, 128, 64);
+    Widget* widget = gui_widget_find_enabled(gui->widgets_fs);
+    if(widget) {
+        widget_draw(widget, gui->canvas);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+void gui_redraw_status_bar(GUI* gui) {
+    canvas_frame_set(gui->canvas, 0, 0, 128, 64);
+    Widget* widget = gui_widget_find_enabled(gui->widgets_status_bar);
+    if(widget) widget_draw(widget, gui->canvas);
+}
+
+void gui_redraw_normal(GUI* gui) {
+    canvas_frame_set(gui->canvas, 0, 9, 128, 55);
+    Widget* widget = gui_widget_find_enabled(gui->widgets);
+    if(widget) widget_draw(widget, gui->canvas);
+}
+
+void gui_redraw_dialogs(GUI* gui) {
+    canvas_frame_set(gui->canvas, 10, 20, 118, 44);
+    Widget* widget = gui_widget_find_enabled(gui->widgets_dialog);
+    if(widget) widget_draw(widget, gui->canvas);
+}
+
+void gui_redraw(GUI* gui) {
+    assert(gui);
+
+    if(!gui_redraw_fs(gui)) {
+        gui_redraw_status_bar(gui);
+        gui_redraw_normal(gui);
+    }
+    gui_redraw_dialogs(gui);
+
+    canvas_commit(gui->canvas);
+}
+
+void gui_input(GUI* gui, InputEvent* input_event) {
+    assert(gui);
+
+    Widget* widget = gui_widget_find_enabled(gui->widgets_dialog);
+    if(!widget) widget = gui_widget_find_enabled(gui->widgets_fs);
+    if(!widget) widget = gui_widget_find_enabled(gui->widgets);
+
+    if(widget) {
+        widget_input(widget, input_event);
+    }
+}
+
+GUI* gui_alloc() {
+    GUI* gui = furi_alloc(sizeof(GUI));
+    // Initialize widget arrays
+    WidgetArray_init(gui->widgets_status_bar);
+    WidgetArray_init(gui->widgets);
+    WidgetArray_init(gui->widgets_fs);
+    WidgetArray_init(gui->widgets_dialog);
+    // Event dispatcher
+    gui->event = gui_event_alloc();
+    // Drawing canvas
+    gui->canvas = canvas_alloc();
+
+    return gui;
+}
+
+void gui_task(void* p) {
+    GUI* gui = gui_alloc();
+    // Create FURI record
+    if(!furi_create_deprecated("gui", gui, sizeof(gui))) {
+        printf("[gui_task] cannot create the gui record\n");
+        furiac_exit(NULL);
+    }
+    furiac_ready();
+    // Forever dispatch
+    while(1) {
+        GUIMessage message = gui_event_message_next(gui->event);
+        if(message.type == GUIMessageTypeRedraw) {
+            gui_redraw(gui);
+        } else if(message.type == GUIMessageTypeInput) {
+            gui_input(gui, &message.input);
+        }
+    }
+}

applications/gui/gui.h

@@ -0,0 +1,12 @@
+#pragma once
+
+typedef struct Widget Widget;
+typedef struct GUI GUI;
+
+void gui_widget_status_bar_add(GUI* gui, Widget* widget);
+
+void gui_widget_add(GUI* gui, Widget* widget);
+
+void gui_widget_fs_add(GUI* gui, Widget* widget);
+
+void gui_widget_dialog_add(GUI* gui, Widget* widget);

applications/gui/gui_event.c

@@ -0,0 +1,73 @@
+#include "gui_event.h"
+
+#include <flipper.h>
+#include <assert.h>
+
+#define GUI_EVENT_MQUEUE_SIZE 8
+
+struct GUIEvent {
+    FuriRecordSubscriber* input_event_record;
+    osMessageQueueId_t mqueue;
+    osMutexId_t lock_mutex;
+};
+
+void gui_event_input_events_callback(const void* value, size_t size, void* ctx) {
+    assert(ctx);
+    GUIEvent* gui_event = ctx;
+
+    GUIMessage message;
+    message.type = GUIMessageTypeInput;
+    message.input = *(InputEvent*)value;
+
+    osMessageQueuePut(gui_event->mqueue, &message, 0, 0);
+}
+
+GUIEvent* gui_event_alloc() {
+    GUIEvent* gui_event = furi_alloc(sizeof(GUIEvent));
+    // Allocate message que
+    gui_event->mqueue = osMessageQueueNew(GUI_EVENT_MQUEUE_SIZE, sizeof(GUIMessage), NULL);
+    assert(gui_event->mqueue);
+
+    // Input
+    gui_event->input_event_record =
+        furi_open_deprecated("input_events", false, false, gui_event_input_events_callback, NULL, gui_event);
+    assert(gui_event->input_event_record != NULL);
+    // Lock mutex
+    gui_event->lock_mutex = osMutexNew(NULL);
+    assert(gui_event->lock_mutex);
+    gui_event_lock(gui_event);
+
+    return gui_event;
+}
+
+void gui_event_free(GUIEvent* gui_event) {
+    assert(gui_event);
+    gui_event_unlock(gui_event);
+    assert(osMessageQueueDelete(gui_event->mqueue) == osOK);
+    free(gui_event);
+}
+
+void gui_event_lock(GUIEvent* gui_event) {
+    assert(gui_event);
+    assert(osMutexAcquire(gui_event->lock_mutex, osWaitForever) == osOK);
+}
+
+void gui_event_unlock(GUIEvent* gui_event) {
+    assert(gui_event);
+    assert(osMutexRelease(gui_event->lock_mutex) == osOK);
+}
+
+void gui_event_messsage_send(GUIEvent* gui_event, GUIMessage* message) {
+    assert(gui_event); assert(message);
+    osMessageQueuePut(gui_event->mqueue, message, 0, 0);
+}
+
+GUIMessage gui_event_message_next(GUIEvent* gui_event) {
+    assert(gui_event);
+    GUIMessage message;
+    gui_event_unlock(gui_event);
+    while(osMessageQueueGet(gui_event->mqueue, &message, NULL, osWaitForever) != osOK) {
+    };
+    gui_event_lock(gui_event);
+    return message;
+}

applications/gui/gui_event.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <stdint.h>
+#include <input/input.h>
+
+typedef enum {
+    GUIMessageTypeRedraw = 0x00,
+    GUIMessageTypeInput = 0x01,
+} GUIMessageType;
+
+typedef struct {
+    GUIMessageType type;
+    InputEvent input;
+    void* data;
+} GUIMessage;
+
+typedef struct GUIEvent GUIEvent;
+
+GUIEvent* gui_event_alloc();
+
+void gui_event_free(GUIEvent* gui_event);
+
+void gui_event_lock(GUIEvent* gui_event);
+
+void gui_event_unlock(GUIEvent* gui_event);
+
+void gui_event_messsage_send(GUIEvent* gui_event, GUIMessage* message);
+
+GUIMessage gui_event_message_next(GUIEvent* gui_event);

applications/gui/gui_i.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void gui_update(GUI* gui);

applications/gui/widget.c

@@ -0,0 +1,79 @@
+#include "widget.h"
+#include "widget_i.h"
+
+#include <cmsis_os.h>
+#include <flipper.h>
+
+#include "gui.h"
+#include "gui_i.h"
+
+struct Widget {
+    void* gui;
+    bool is_enabled;
+    WidgetDrawCallback draw_callback;
+    void* draw_callback_context;
+    WidgetInputCallback input_callback;
+    void* input_callback_context;
+};
+
+Widget* widget_alloc(WidgetDrawCallback callback, void* callback_context) {
+    Widget* widget = furi_alloc(sizeof(Widget));
+    widget->is_enabled = true;
+    return widget;
+}
+
+void widget_free(Widget* widget) {
+    assert(widget);
+    assert(widget->gui == NULL);
+    free(widget);
+}
+
+void widget_enabled_set(Widget* widget, bool enabled) {
+    assert(widget);
+    widget->is_enabled = enabled;
+    widget_update(widget);
+}
+
+bool widget_is_enabled(Widget* widget) {
+    assert(widget);
+    return widget->is_enabled;
+}
+
+void widget_draw_callback_set(Widget* widget, WidgetDrawCallback callback, void* context) {
+    assert(widget);
+    widget->draw_callback = callback;
+    widget->draw_callback_context = context;
+}
+
+void widget_input_callback_set(Widget* widget, WidgetInputCallback callback, void* context) {
+    assert(widget);
+    widget->input_callback = callback;
+    widget->input_callback_context = context;
+}
+
+void widget_update(Widget* widget) {
+    assert(widget);
+    if(widget->gui) gui_update(widget->gui);
+}
+
+void widget_gui_set(Widget* widget, GUI* gui) {
+    assert(widget);
+    assert(gui);
+    widget->gui = gui;
+}
+
+void widget_draw(Widget* widget, Canvas* canvas) {
+    assert(widget);
+    assert(canvas);
+    assert(widget->gui);
+
+    if(widget->draw_callback) widget->draw_callback(canvas, widget->draw_callback_context);
+}
+
+void widget_input(Widget* widget, InputEvent* event) {
+    assert(widget);
+    assert(event);
+    assert(widget->gui);
+
+    if(widget->input_callback) widget->input_callback(event, widget->input_callback_context);
+}

applications/gui/widget.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <input/input.h>
+
+typedef struct GUI GUI;
+typedef struct Canvas Canvas;
+typedef struct Widget Widget;
+
+typedef void (*WidgetDrawCallback)(Canvas* canvas, void* context);
+typedef void (*WidgetInputCallback)(InputEvent* event, void* context);
+
+Widget* widget_alloc();
+void widget_free(Widget* widget);
+
+void widget_enabled_set(Widget* widget, bool enabled);
+bool widget_is_enabled(Widget* widget);
+
+void widget_draw_callback_set(Widget* widget, WidgetDrawCallback callback, void* context);
+void widget_input_callback_set(Widget* widget, WidgetInputCallback callback, void* context);
+
+// emit update signal
+void widget_update(Widget* widget);

applications/gui/widget_i.h

@@ -0,0 +1,7 @@
+#pragma once
+
+void widget_gui_set(Widget* widget, GUI* gui);
+
+void widget_draw(Widget* widget, Canvas* canvas);
+
+void widget_input(Widget* widget, InputEvent* event);