[FL-2627] Flipper applications: SDK, build and debug system (#1387)

* Added support for running applications from SD card (FAPs - Flipper Application Packages)
* Added plugin_dist target for fbt to build FAPs
* All apps of type FlipperAppType.EXTERNAL and FlipperAppType.PLUGIN are built as FAPs by default
* Updated VSCode configuration for new fbt features - re-deploy stock configuration to use them
* Added debugging support for FAPs with fbt debug & VSCode
* Added public firmware API with automated versioning

Co-authored-by: hedger <hedger@users.noreply.github.com>
Co-authored-by: SG <who.just.the.doctor@gmail.com>
Co-authored-by: あく <alleteam@gmail.com>

applications/services/gui/modules/widget_elements/widget_element.h

@@ -0,0 +1,22 @@
+/**
+ * @file widget_element_i.h
+ * GUI: internal Widget Element API
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    GuiButtonTypeLeft,
+    GuiButtonTypeCenter,
+    GuiButtonTypeRight,
+} GuiButtonType;
+
+typedef void (*ButtonCallback)(GuiButtonType result, InputType type, void* context);
+
+#ifdef __cplusplus
+}
+#endif

applications/services/gui/modules/widget_elements/widget_element_button.c

@@ -0,0 +1,79 @@
+#include "widget_element_i.h"
+#include <gui/elements.h>
+#include <m-string.h>
+
+typedef struct {
+    GuiButtonType button_type;
+    string_t text;
+    ButtonCallback callback;
+    void* context;
+} GuiButtonModel;
+
+static void gui_button_draw(Canvas* canvas, WidgetElement* element) {
+    furi_assert(canvas);
+    furi_assert(element);
+    GuiButtonModel* model = element->model;
+
+    canvas_set_color(canvas, ColorBlack);
+    canvas_set_font(canvas, FontSecondary);
+
+    if(model->button_type == GuiButtonTypeLeft) {
+        elements_button_left(canvas, string_get_cstr(model->text));
+    } else if(model->button_type == GuiButtonTypeRight) {
+        elements_button_right(canvas, string_get_cstr(model->text));
+    } else if(model->button_type == GuiButtonTypeCenter) {
+        elements_button_center(canvas, string_get_cstr(model->text));
+    }
+}
+
+static bool gui_button_input(InputEvent* event, WidgetElement* element) {
+    GuiButtonModel* model = element->model;
+    bool consumed = false;
+
+    if(model->callback == NULL) return consumed;
+
+    if((model->button_type == GuiButtonTypeLeft) && (event->key == InputKeyLeft)) {
+        model->callback(model->button_type, event->type, model->context);
+        consumed = true;
+    } else if((model->button_type == GuiButtonTypeRight) && (event->key == InputKeyRight)) {
+        model->callback(model->button_type, event->type, model->context);
+        consumed = true;
+    } else if((model->button_type == GuiButtonTypeCenter) && (event->key == InputKeyOk)) {
+        model->callback(model->button_type, event->type, model->context);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+static void gui_button_free(WidgetElement* gui_button) {
+    furi_assert(gui_button);
+
+    GuiButtonModel* model = gui_button->model;
+    string_clear(model->text);
+    free(gui_button->model);
+    free(gui_button);
+}
+
+WidgetElement* widget_element_button_create(
+    GuiButtonType button_type,
+    const char* text,
+    ButtonCallback callback,
+    void* context) {
+    // Allocate and init model
+    GuiButtonModel* model = malloc(sizeof(GuiButtonModel));
+    model->button_type = button_type;
+    model->callback = callback;
+    model->context = context;
+    string_init_set_str(model->text, text);
+
+    // Allocate and init Element
+    WidgetElement* gui_button = malloc(sizeof(WidgetElement));
+    gui_button->parent = NULL;
+    gui_button->input = gui_button_input;
+    gui_button->draw = gui_button_draw;
+    gui_button->free = gui_button_free;
+    gui_button->model = model;
+
+    return gui_button;
+}

applications/services/gui/modules/widget_elements/widget_element_frame.c

@@ -0,0 +1,48 @@
+#include "widget_element_i.h"
+
+typedef struct {
+    uint8_t x;
+    uint8_t y;
+    uint8_t width;
+    uint8_t height;
+    uint8_t radius;
+} GuiFrameModel;
+
+static void gui_frame_draw(Canvas* canvas, WidgetElement* element) {
+    furi_assert(canvas);
+    furi_assert(element);
+    GuiFrameModel* model = element->model;
+    canvas_draw_rframe(canvas, model->x, model->y, model->width, model->height, model->radius);
+}
+
+static void gui_frame_free(WidgetElement* gui_frame) {
+    furi_assert(gui_frame);
+
+    free(gui_frame->model);
+    free(gui_frame);
+}
+
+WidgetElement* widget_element_frame_create(
+    uint8_t x,
+    uint8_t y,
+    uint8_t width,
+    uint8_t height,
+    uint8_t radius) {
+    // Allocate and init model
+    GuiFrameModel* model = malloc(sizeof(GuiFrameModel));
+    model->x = x;
+    model->y = y;
+    model->width = width;
+    model->height = height;
+    model->radius = radius;
+
+    // Allocate and init Element
+    WidgetElement* gui_frame = malloc(sizeof(WidgetElement));
+    gui_frame->parent = NULL;
+    gui_frame->input = NULL;
+    gui_frame->draw = gui_frame_draw;
+    gui_frame->free = gui_frame_free;
+    gui_frame->model = model;
+
+    return gui_frame;
+}

applications/services/gui/modules/widget_elements/widget_element_i.h

@@ -0,0 +1,91 @@
+/**
+ * @file widget_element_i.h
+ * GUI: internal Widget Element API
+ */
+
+#pragma once
+#include <furi.h>
+#include <gui/view.h>
+#include <input/input.h>
+#include "widget_element.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct WidgetElement WidgetElement;
+typedef struct Widget Widget;
+
+struct WidgetElement {
+    // generic draw and input callbacks
+    void (*draw)(Canvas* canvas, WidgetElement* element);
+    bool (*input)(InputEvent* event, WidgetElement* element);
+
+    // free callback
+    void (*free)(WidgetElement* element);
+
+    // generic model holder
+    void* model;
+    FuriMutex* model_mutex;
+
+    // pointer to widget that hold our element
+    Widget* parent;
+};
+
+/** Create multi string element */
+WidgetElement* widget_element_string_multiline_create(
+    uint8_t x,
+    uint8_t y,
+    Align horizontal,
+    Align vertical,
+    Font font,
+    const char* text);
+
+/** Create string element */
+WidgetElement* widget_element_string_create(
+    uint8_t x,
+    uint8_t y,
+    Align horizontal,
+    Align vertical,
+    Font font,
+    const char* text);
+
+/** Create text box element */
+WidgetElement* widget_element_text_box_create(
+    uint8_t x,
+    uint8_t y,
+    uint8_t width,
+    uint8_t height,
+    Align horizontal,
+    Align vertical,
+    const char* text,
+    bool strip_to_dots);
+
+/** Create button element */
+WidgetElement* widget_element_button_create(
+    GuiButtonType button_type,
+    const char* text,
+    ButtonCallback callback,
+    void* context);
+
+/** Create icon element */
+WidgetElement* widget_element_icon_create(uint8_t x, uint8_t y, const Icon* icon);
+
+/** Create frame element */
+WidgetElement* widget_element_frame_create(
+    uint8_t x,
+    uint8_t y,
+    uint8_t width,
+    uint8_t height,
+    uint8_t radius);
+
+WidgetElement* widget_element_text_scroll_create(
+    uint8_t x,
+    uint8_t y,
+    uint8_t width,
+    uint8_t height,
+    const char* text);
+
+#ifdef __cplusplus
+}
+#endif

applications/services/gui/modules/widget_elements/widget_element_icon.c

@@ -0,0 +1,44 @@
+#include "widget_element_i.h"
+
+typedef struct {
+    uint8_t x;
+    uint8_t y;
+    const Icon* icon;
+} GuiIconModel;
+
+static void gui_icon_draw(Canvas* canvas, WidgetElement* element) {
+    furi_assert(canvas);
+    furi_assert(element);
+    GuiIconModel* model = element->model;
+
+    if(model->icon) {
+        canvas_draw_icon(canvas, model->x, model->y, model->icon);
+    }
+}
+
+static void gui_icon_free(WidgetElement* gui_icon) {
+    furi_assert(gui_icon);
+
+    free(gui_icon->model);
+    free(gui_icon);
+}
+
+WidgetElement* widget_element_icon_create(uint8_t x, uint8_t y, const Icon* icon) {
+    furi_assert(icon);
+
+    // Allocate and init model
+    GuiIconModel* model = malloc(sizeof(GuiIconModel));
+    model->x = x;
+    model->y = y;
+    model->icon = icon;
+
+    // Allocate and init Element
+    WidgetElement* gui_icon = malloc(sizeof(WidgetElement));
+    gui_icon->parent = NULL;
+    gui_icon->input = NULL;
+    gui_icon->draw = gui_icon_draw;
+    gui_icon->free = gui_icon_free;
+    gui_icon->model = model;
+
+    return gui_icon;
+}

applications/services/gui/modules/widget_elements/widget_element_string.c

@@ -0,0 +1,66 @@
+#include "widget_element_i.h"
+#include <m-string.h>
+
+typedef struct {
+    uint8_t x;
+    uint8_t y;
+    Align horizontal;
+    Align vertical;
+    Font font;
+    string_t text;
+} GuiStringModel;
+
+static void gui_string_draw(Canvas* canvas, WidgetElement* element) {
+    furi_assert(canvas);
+    furi_assert(element);
+    GuiStringModel* model = element->model;
+
+    if(string_size(model->text)) {
+        canvas_set_font(canvas, model->font);
+        canvas_draw_str_aligned(
+            canvas,
+            model->x,
+            model->y,
+            model->horizontal,
+            model->vertical,
+            string_get_cstr(model->text));
+    }
+}
+
+static void gui_string_free(WidgetElement* gui_string) {
+    furi_assert(gui_string);
+
+    GuiStringModel* model = gui_string->model;
+    string_clear(model->text);
+    free(gui_string->model);
+    free(gui_string);
+}
+
+WidgetElement* widget_element_string_create(
+    uint8_t x,
+    uint8_t y,
+    Align horizontal,
+    Align vertical,
+    Font font,
+    const char* text) {
+    furi_assert(text);
+
+    // Allocate and init model
+    GuiStringModel* model = malloc(sizeof(GuiStringModel));
+    model->x = x;
+    model->y = y;
+    model->horizontal = horizontal;
+    model->vertical = vertical;
+    model->font = font;
+    string_init_set_str(model->text, text);
+
+    // Allocate and init Element
+    WidgetElement* gui_string = malloc(sizeof(WidgetElement));
+    gui_string->parent = NULL;
+    gui_string->input = NULL;
+    gui_string->draw = gui_string_draw;
+    gui_string->free = gui_string_free;
+    gui_string->model = model;
+
+    return gui_string;
+}

applications/services/gui/modules/widget_elements/widget_element_string_multiline.c

@@ -0,0 +1,67 @@
+#include "widget_element_i.h"
+#include <m-string.h>
+#include <gui/elements.h>
+
+typedef struct {
+    uint8_t x;
+    uint8_t y;
+    Align horizontal;
+    Align vertical;
+    Font font;
+    string_t text;
+} GuiStringMultiLineModel;
+
+static void gui_string_multiline_draw(Canvas* canvas, WidgetElement* element) {
+    furi_assert(canvas);
+    furi_assert(element);
+    GuiStringMultiLineModel* model = element->model;
+
+    if(string_size(model->text)) {
+        canvas_set_font(canvas, model->font);
+        elements_multiline_text_aligned(
+            canvas,
+            model->x,
+            model->y,
+            model->horizontal,
+            model->vertical,
+            string_get_cstr(model->text));
+    }
+}
+
+static void gui_string_multiline_free(WidgetElement* gui_string) {
+    furi_assert(gui_string);
+
+    GuiStringMultiLineModel* model = gui_string->model;
+    string_clear(model->text);
+    free(gui_string->model);
+    free(gui_string);
+}
+
+WidgetElement* widget_element_string_multiline_create(
+    uint8_t x,
+    uint8_t y,
+    Align horizontal,
+    Align vertical,
+    Font font,
+    const char* text) {
+    furi_assert(text);
+
+    // Allocate and init model
+    GuiStringMultiLineModel* model = malloc(sizeof(GuiStringMultiLineModel));
+    model->x = x;
+    model->y = y;
+    model->horizontal = horizontal;
+    model->vertical = vertical;
+    model->font = font;
+    string_init_set_str(model->text, text);
+
+    // Allocate and init Element
+    WidgetElement* gui_string = malloc(sizeof(WidgetElement));
+    gui_string->parent = NULL;
+    gui_string->input = NULL;
+    gui_string->draw = gui_string_multiline_draw;
+    gui_string->free = gui_string_multiline_free;
+    gui_string->model = model;
+
+    return gui_string;
+}

applications/services/gui/modules/widget_elements/widget_element_text_box.c

@@ -0,0 +1,75 @@
+#include "widget_element_i.h"
+#include <m-string.h>
+#include <gui/elements.h>
+
+typedef struct {
+    uint8_t x;
+    uint8_t y;
+    uint8_t width;
+    uint8_t height;
+    Align horizontal;
+    Align vertical;
+    string_t text;
+    bool strip_to_dots;
+} GuiTextBoxModel;
+
+static void gui_text_box_draw(Canvas* canvas, WidgetElement* element) {
+    furi_assert(canvas);
+    furi_assert(element);
+    GuiTextBoxModel* model = element->model;
+
+    if(string_size(model->text)) {
+        elements_text_box(
+            canvas,
+            model->x,
+            model->y,
+            model->width,
+            model->height,
+            model->horizontal,
+            model->vertical,
+            string_get_cstr(model->text),
+            model->strip_to_dots);
+    }
+}
+
+static void gui_text_box_free(WidgetElement* gui_string) {
+    furi_assert(gui_string);
+
+    GuiTextBoxModel* model = gui_string->model;
+    string_clear(model->text);
+    free(gui_string->model);
+    free(gui_string);
+}
+
+WidgetElement* widget_element_text_box_create(
+    uint8_t x,
+    uint8_t y,
+    uint8_t width,
+    uint8_t height,
+    Align horizontal,
+    Align vertical,
+    const char* text,
+    bool strip_to_dots) {
+    furi_assert(text);
+
+    // Allocate and init model
+    GuiTextBoxModel* model = malloc(sizeof(GuiTextBoxModel));
+    model->x = x;
+    model->y = y;
+    model->width = width;
+    model->height = height;
+    model->horizontal = horizontal;
+    model->vertical = vertical;
+    string_init_set_str(model->text, text);
+    model->strip_to_dots = strip_to_dots;
+
+    // Allocate and init Element
+    WidgetElement* gui_string = malloc(sizeof(WidgetElement));
+    gui_string->parent = NULL;
+    gui_string->input = NULL;
+    gui_string->draw = gui_text_box_draw;
+    gui_string->free = gui_text_box_free;
+    gui_string->model = model;
+
+    return gui_string;
+}

applications/services/gui/modules/widget_elements/widget_element_text_scroll.c

@@ -0,0 +1,245 @@
+#include "widget_element_i.h"
+#include <m-string.h>
+#include <gui/elements.h>
+#include <m-array.h>
+
+#define WIDGET_ELEMENT_TEXT_SCROLL_BAR_OFFSET (4)
+
+typedef struct {
+    Font font;
+    Align horizontal;
+    string_t text;
+} TextScrollLineArray;
+
+ARRAY_DEF(TextScrollLineArray, TextScrollLineArray, M_POD_OPLIST)
+
+typedef struct {
+    TextScrollLineArray_t line_array;
+    uint8_t x;
+    uint8_t y;
+    uint8_t width;
+    uint8_t height;
+    string_t text;
+    uint8_t scroll_pos_total;
+    uint8_t scroll_pos_current;
+    bool text_formatted;
+} WidgetElementTextScrollModel;
+
+static bool
+    widget_element_text_scroll_process_ctrl_symbols(TextScrollLineArray* line, string_t text) {
+    bool processed = false;
+
+    do {
+        if(string_get_char(text, 0) != '\e') break;
+        char ctrl_symbol = string_get_char(text, 1);
+        if(ctrl_symbol == 'c') {
+            line->horizontal = AlignCenter;
+        } else if(ctrl_symbol == 'r') {
+            line->horizontal = AlignRight;
+        } else if(ctrl_symbol == '#') {
+            line->font = FontPrimary;
+        }
+        string_right(text, 2);
+        processed = true;
+    } while(false);
+
+    return processed;
+}
+
+void widget_element_text_scroll_add_line(WidgetElement* element, TextScrollLineArray* line) {
+    WidgetElementTextScrollModel* model = element->model;
+    TextScrollLineArray new_line;
+    new_line.font = line->font;
+    new_line.horizontal = line->horizontal;
+    string_init_set(new_line.text, line->text);
+    TextScrollLineArray_push_back(model->line_array, new_line);
+}
+
+static void widget_element_text_scroll_fill_lines(Canvas* canvas, WidgetElement* element) {
+    WidgetElementTextScrollModel* model = element->model;
+    TextScrollLineArray line_tmp;
+    bool all_text_processed = false;
+    string_init(line_tmp.text);
+    bool reached_new_line = true;
+    uint16_t total_height = 0;
+
+    while(!all_text_processed) {
+        if(reached_new_line) {
+            // Set default line properties
+            line_tmp.font = FontSecondary;
+            line_tmp.horizontal = AlignLeft;
+            string_reset(line_tmp.text);
+            // Process control symbols
+            while(widget_element_text_scroll_process_ctrl_symbols(&line_tmp, model->text))
+                ;
+        }
+        // Set canvas font
+        canvas_set_font(canvas, line_tmp.font);
+        CanvasFontParameters* params = canvas_get_font_params(canvas, line_tmp.font);
+        total_height += params->height;
+        if(total_height > model->height) {
+            model->scroll_pos_total++;
+        }
+
+        uint8_t line_width = 0;
+        uint16_t char_i = 0;
+        while(true) {
+            char next_char = string_get_char(model->text, char_i++);
+            if(next_char == '\0') {
+                string_push_back(line_tmp.text, '\0');
+                widget_element_text_scroll_add_line(element, &line_tmp);
+                total_height += params->leading_default - params->height;
+                all_text_processed = true;
+                break;
+            } else if(next_char == '\n') {
+                string_push_back(line_tmp.text, '\0');
+                widget_element_text_scroll_add_line(element, &line_tmp);
+                string_right(model->text, char_i);
+                total_height += params->leading_default - params->height;
+                reached_new_line = true;
+                break;
+            } else {
+                line_width += canvas_glyph_width(canvas, next_char);
+                if(line_width > model->width) {
+                    string_push_back(line_tmp.text, '\0');
+                    widget_element_text_scroll_add_line(element, &line_tmp);
+                    string_right(model->text, char_i - 1);
+                    string_reset(line_tmp.text);
+                    total_height += params->leading_default - params->height;
+                    reached_new_line = false;
+                    break;
+                } else {
+                    string_push_back(line_tmp.text, next_char);
+                }
+            }
+        }
+    }
+
+    string_clear(line_tmp.text);
+}
+
+static void widget_element_text_scroll_draw(Canvas* canvas, WidgetElement* element) {
+    furi_assert(canvas);
+    furi_assert(element);
+
+    furi_mutex_acquire(element->model_mutex, FuriWaitForever);
+
+    WidgetElementTextScrollModel* model = element->model;
+    if(!model->text_formatted) {
+        widget_element_text_scroll_fill_lines(canvas, element);
+        model->text_formatted = true;
+    }
+
+    uint8_t y = model->y;
+    uint8_t x = model->x;
+    uint16_t curr_line = 0;
+    if(TextScrollLineArray_size(model->line_array)) {
+        TextScrollLineArray_it_t it;
+        for(TextScrollLineArray_it(it, model->line_array); !TextScrollLineArray_end_p(it);
+            TextScrollLineArray_next(it), curr_line++) {
+            if(curr_line < model->scroll_pos_current) continue;
+            TextScrollLineArray* line = TextScrollLineArray_ref(it);
+            CanvasFontParameters* params = canvas_get_font_params(canvas, line->font);
+            if(y + params->descender > model->y + model->height) break;
+            canvas_set_font(canvas, line->font);
+            if(line->horizontal == AlignLeft) {
+                x = model->x;
+            } else if(line->horizontal == AlignCenter) {
+                x = (model->x + model->width) / 2;
+            } else if(line->horizontal == AlignRight) {
+                x = model->x + model->width;
+            }
+            canvas_draw_str_aligned(
+                canvas, x, y, line->horizontal, AlignTop, string_get_cstr(line->text));
+            y += params->leading_default;
+        }
+        // Draw scroll bar
+        if(model->scroll_pos_total > 1) {
+            elements_scrollbar_pos(
+                canvas,
+                model->x + model->width + WIDGET_ELEMENT_TEXT_SCROLL_BAR_OFFSET,
+                model->y,
+                model->height,
+                model->scroll_pos_current,
+                model->scroll_pos_total);
+        }
+    }
+
+    furi_mutex_release(element->model_mutex);
+}
+
+static bool widget_element_text_scroll_input(InputEvent* event, WidgetElement* element) {
+    furi_assert(event);
+    furi_assert(element);
+
+    furi_mutex_acquire(element->model_mutex, FuriWaitForever);
+
+    WidgetElementTextScrollModel* model = element->model;
+    bool consumed = false;
+
+    if((event->type == InputTypeShort) || (event->type == InputTypeRepeat)) {
+        if(event->key == InputKeyUp) {
+            if(model->scroll_pos_current > 0) {
+                model->scroll_pos_current--;
+            }
+            consumed = true;
+        } else if(event->key == InputKeyDown) {
+            if((model->scroll_pos_total > 1) &&
+               (model->scroll_pos_current < model->scroll_pos_total - 1)) {
+                model->scroll_pos_current++;
+            }
+            consumed = true;
+        }
+    }
+
+    furi_mutex_release(element->model_mutex);
+
+    return consumed;
+}
+
+static void widget_element_text_scroll_free(WidgetElement* text_scroll) {
+    furi_assert(text_scroll);
+
+    WidgetElementTextScrollModel* model = text_scroll->model;
+    TextScrollLineArray_it_t it;
+    for(TextScrollLineArray_it(it, model->line_array); !TextScrollLineArray_end_p(it);
+        TextScrollLineArray_next(it)) {
+        TextScrollLineArray* line = TextScrollLineArray_ref(it);
+        string_clear(line->text);
+    }
+    TextScrollLineArray_clear(model->line_array);
+    string_clear(model->text);
+    free(text_scroll->model);
+    furi_mutex_free(text_scroll->model_mutex);
+    free(text_scroll);
+}
+
+WidgetElement* widget_element_text_scroll_create(
+    uint8_t x,
+    uint8_t y,
+    uint8_t width,
+    uint8_t height,
+    const char* text) {
+    furi_assert(text);
+
+    // Allocate and init model
+    WidgetElementTextScrollModel* model = malloc(sizeof(WidgetElementTextScrollModel));
+    model->x = x;
+    model->y = y;
+    model->width = width - WIDGET_ELEMENT_TEXT_SCROLL_BAR_OFFSET;
+    model->height = height;
+    model->scroll_pos_current = 0;
+    model->scroll_pos_total = 1;
+    TextScrollLineArray_init(model->line_array);
+    string_init_set_str(model->text, text);
+
+    WidgetElement* text_scroll = malloc(sizeof(WidgetElement));
+    text_scroll->parent = NULL;
+    text_scroll->draw = widget_element_text_scroll_draw;
+    text_scroll->input = widget_element_text_scroll_input;
+    text_scroll->free = widget_element_text_scroll_free;
+    text_scroll->model = model;
+    text_scroll->model_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+
+    return text_scroll;
+}