[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/debug/display_test/application.fam

@@ -0,0 +1,11 @@
+App(
+    appid="display_test",
+    name="Display Test",
+    apptype=FlipperAppType.DEBUG,
+    entry_point="display_test_app",
+    cdefines=["APP_DISPLAY_TEST"],
+    requires=["gui"],
+    stack_size=1 * 1024,
+    order=120,
+    fap_category="Debug",
+)

applications/debug/display_test/display_test.c

@@ -0,0 +1,232 @@
+#include "display_test.h"
+
+#include <furi_hal.h>
+#include <furi.h>
+
+// Need access to u8g2
+#include <gui/gui_i.h>
+#include <gui/canvas_i.h>
+#include <u8g2_glue.h>
+
+#include <gui/view_dispatcher.h>
+#include <gui/modules/submenu.h>
+#include <gui/modules/variable_item_list.h>
+
+#include "view_display_test.h"
+
+#define TAG "DisplayTest"
+
+typedef struct {
+    Gui* gui;
+    ViewDispatcher* view_dispatcher;
+    ViewDisplayTest* view_display_test;
+    VariableItemList* variable_item_list;
+    Submenu* submenu;
+
+    bool config_bias;
+    uint8_t config_contrast;
+    uint8_t config_regulation_ratio;
+} DisplayTest;
+
+typedef enum {
+    DisplayTestViewSubmenu,
+    DisplayTestViewConfigure,
+    DisplayTestViewDisplayTest,
+} DisplayTestView;
+
+const bool config_bias_value[] = {
+    true,
+    false,
+};
+const char* const config_bias_text[] = {
+    "1/7",
+    "1/9",
+};
+
+const uint8_t config_regulation_ratio_value[] = {
+    0b000,
+    0b001,
+    0b010,
+    0b011,
+    0b100,
+    0b101,
+    0b110,
+    0b111,
+};
+const char* const config_regulation_ratio_text[] = {
+    "3.0",
+    "3.5",
+    "4.0",
+    "4.5",
+    "5.0",
+    "5.5",
+    "6.0",
+    "6.5",
+};
+
+static void display_test_submenu_callback(void* context, uint32_t index) {
+    DisplayTest* instance = (DisplayTest*)context;
+    view_dispatcher_switch_to_view(instance->view_dispatcher, index);
+}
+
+static uint32_t display_test_previous_callback(void* context) {
+    UNUSED(context);
+    return DisplayTestViewSubmenu;
+}
+
+static uint32_t display_test_exit_callback(void* context) {
+    UNUSED(context);
+    return VIEW_NONE;
+}
+
+static void display_test_reload_config(DisplayTest* instance) {
+    FURI_LOG_I(
+        TAG,
+        "contrast: %d, regulation_ratio: %d, bias: %d",
+        instance->config_contrast,
+        instance->config_regulation_ratio,
+        instance->config_bias);
+    u8x8_d_st756x_init(
+        &instance->gui->canvas->fb.u8x8,
+        instance->config_contrast,
+        instance->config_regulation_ratio,
+        instance->config_bias);
+    gui_update(instance->gui);
+}
+
+static void display_config_set_bias(VariableItem* item) {
+    DisplayTest* instance = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, config_bias_text[index]);
+    instance->config_bias = config_bias_value[index];
+    display_test_reload_config(instance);
+}
+
+static void display_config_set_regulation_ratio(VariableItem* item) {
+    DisplayTest* instance = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    variable_item_set_current_value_text(item, config_regulation_ratio_text[index]);
+    instance->config_regulation_ratio = config_regulation_ratio_value[index];
+    display_test_reload_config(instance);
+}
+
+static void display_config_set_contrast(VariableItem* item) {
+    DisplayTest* instance = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+    string_t temp;
+    string_init(temp);
+    string_cat_printf(temp, "%d", index);
+    variable_item_set_current_value_text(item, string_get_cstr(temp));
+    string_clear(temp);
+    instance->config_contrast = index;
+    display_test_reload_config(instance);
+}
+
+DisplayTest* display_test_alloc() {
+    DisplayTest* instance = malloc(sizeof(DisplayTest));
+
+    View* view = NULL;
+
+    instance->gui = furi_record_open(RECORD_GUI);
+    instance->view_dispatcher = view_dispatcher_alloc();
+    view_dispatcher_enable_queue(instance->view_dispatcher);
+    view_dispatcher_attach_to_gui(
+        instance->view_dispatcher, instance->gui, ViewDispatcherTypeFullscreen);
+
+    // Test
+    instance->view_display_test = view_display_test_alloc();
+    view = view_display_test_get_view(instance->view_display_test);
+    view_set_previous_callback(view, display_test_previous_callback);
+    view_dispatcher_add_view(instance->view_dispatcher, DisplayTestViewDisplayTest, view);
+
+    // Configure
+    instance->variable_item_list = variable_item_list_alloc();
+    view = variable_item_list_get_view(instance->variable_item_list);
+    view_set_previous_callback(view, display_test_previous_callback);
+    view_dispatcher_add_view(instance->view_dispatcher, DisplayTestViewConfigure, view);
+
+    // Configurtion items
+    VariableItem* item;
+    instance->config_bias = false;
+    instance->config_contrast = 32;
+    instance->config_regulation_ratio = 0b101;
+    // Bias
+    item = variable_item_list_add(
+        instance->variable_item_list,
+        "Bias:",
+        COUNT_OF(config_bias_value),
+        display_config_set_bias,
+        instance);
+    variable_item_set_current_value_index(item, 1);
+    variable_item_set_current_value_text(item, config_bias_text[1]);
+    // Regulation Ratio
+    item = variable_item_list_add(
+        instance->variable_item_list,
+        "Reg Ratio:",
+        COUNT_OF(config_regulation_ratio_value),
+        display_config_set_regulation_ratio,
+        instance);
+    variable_item_set_current_value_index(item, 5);
+    variable_item_set_current_value_text(item, config_regulation_ratio_text[5]);
+    // Contrast
+    item = variable_item_list_add(
+        instance->variable_item_list, "Contrast:", 64, display_config_set_contrast, instance);
+    variable_item_set_current_value_index(item, 32);
+    variable_item_set_current_value_text(item, "32");
+
+    // Menu
+    instance->submenu = submenu_alloc();
+    view = submenu_get_view(instance->submenu);
+    view_set_previous_callback(view, display_test_exit_callback);
+    view_dispatcher_add_view(instance->view_dispatcher, DisplayTestViewSubmenu, view);
+    submenu_add_item(
+        instance->submenu,
+        "Test",
+        DisplayTestViewDisplayTest,
+        display_test_submenu_callback,
+        instance);
+    submenu_add_item(
+        instance->submenu,
+        "Configure",
+        DisplayTestViewConfigure,
+        display_test_submenu_callback,
+        instance);
+
+    return instance;
+}
+
+void display_test_free(DisplayTest* instance) {
+    view_dispatcher_remove_view(instance->view_dispatcher, DisplayTestViewSubmenu);
+    submenu_free(instance->submenu);
+
+    view_dispatcher_remove_view(instance->view_dispatcher, DisplayTestViewConfigure);
+    variable_item_list_free(instance->variable_item_list);
+
+    view_dispatcher_remove_view(instance->view_dispatcher, DisplayTestViewDisplayTest);
+    view_display_test_free(instance->view_display_test);
+
+    view_dispatcher_free(instance->view_dispatcher);
+    furi_record_close(RECORD_GUI);
+
+    free(instance);
+}
+
+int32_t display_test_run(DisplayTest* instance) {
+    UNUSED(instance);
+    view_dispatcher_switch_to_view(instance->view_dispatcher, DisplayTestViewSubmenu);
+    view_dispatcher_run(instance->view_dispatcher);
+
+    return 0;
+}
+
+int32_t display_test_app(void* p) {
+    UNUSED(p);
+
+    DisplayTest* instance = display_test_alloc();
+
+    int32_t ret = display_test_run(instance);
+
+    display_test_free(instance);
+
+    return ret;
+}

applications/debug/display_test/display_test.h

@@ -0,0 +1 @@
+#pragma once

applications/debug/display_test/view_display_test.c

@@ -0,0 +1,186 @@
+#include "view_display_test.h"
+
+typedef struct {
+    uint32_t test;
+    uint32_t size;
+    uint32_t counter;
+    bool flip_flop;
+} ViewDisplayTestModel;
+
+struct ViewDisplayTest {
+    View* view;
+    FuriTimer* timer;
+};
+
+static void view_display_test_draw_callback_intro(Canvas* canvas, void* _model) {
+    UNUSED(_model);
+    canvas_draw_str(canvas, 12, 24, "Use < and > to switch tests");
+    canvas_draw_str(canvas, 12, 36, "Use ^ and v to switch size");
+    canvas_draw_str(canvas, 32, 48, "Use (o) to flip");
+}
+
+static void view_display_test_draw_callback_fill(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    if(model->flip_flop) {
+        uint8_t width = canvas_width(canvas);
+        uint8_t height = canvas_height(canvas);
+        canvas_draw_box(canvas, 0, 0, width, height);
+    }
+}
+
+static void view_display_test_draw_callback_hstripe(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    uint8_t block = 1 + model->size;
+    uint8_t width = canvas_width(canvas);
+    uint8_t height = canvas_height(canvas);
+
+    for(uint8_t y = model->flip_flop * block; y < height; y += 2 * block) {
+        canvas_draw_box(canvas, 0, y, width, block);
+    }
+}
+
+static void view_display_test_draw_callback_vstripe(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    uint8_t block = 1 + model->size;
+    uint8_t width = canvas_width(canvas);
+    uint8_t height = canvas_height(canvas);
+
+    for(uint8_t x = model->flip_flop * block; x < width; x += 2 * block) {
+        canvas_draw_box(canvas, x, 0, block, height);
+    }
+}
+
+static void view_display_test_draw_callback_check(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    uint8_t block = 1 + model->size;
+    uint8_t width = canvas_width(canvas);
+    uint8_t height = canvas_height(canvas);
+
+    bool flip_flop = model->flip_flop;
+    for(uint8_t x = 0; x < width; x += block) {
+        bool last_flip_flop = flip_flop;
+        for(uint8_t y = 0; y < height; y += block) {
+            if(flip_flop) {
+                canvas_draw_box(canvas, x, y, block, block);
+            }
+            flip_flop = !flip_flop;
+        }
+        if(last_flip_flop == flip_flop) {
+            flip_flop = !flip_flop;
+        }
+    }
+}
+
+static void view_display_test_draw_callback_move(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    uint8_t block = 1 + model->size;
+    uint8_t width = canvas_width(canvas) - block;
+    uint8_t height = canvas_height(canvas) - block;
+
+    uint8_t x = model->counter % width;
+    if((model->counter / width) % 2) {
+        x = width - x;
+    }
+
+    uint8_t y = model->counter % height;
+    if((model->counter / height) % 2) {
+        y = height - y;
+    }
+
+    canvas_draw_box(canvas, x, y, block, block);
+}
+
+const ViewDrawCallback view_display_test_tests[] = {
+    view_display_test_draw_callback_intro,
+    view_display_test_draw_callback_fill,
+    view_display_test_draw_callback_hstripe,
+    view_display_test_draw_callback_vstripe,
+    view_display_test_draw_callback_check,
+    view_display_test_draw_callback_move,
+};
+
+static void view_display_test_draw_callback(Canvas* canvas, void* _model) {
+    ViewDisplayTestModel* model = _model;
+    view_display_test_tests[model->test](canvas, _model);
+}
+
+static bool view_display_test_input_callback(InputEvent* event, void* context) {
+    ViewDisplayTest* instance = context;
+
+    bool consumed = false;
+    if(event->type == InputTypeShort || event->type == InputTypeRepeat) {
+        with_view_model(
+            instance->view, (ViewDisplayTestModel * model) {
+                if(event->key == InputKeyLeft && model->test > 0) {
+                    model->test--;
+                    consumed = true;
+                } else if(
+                    event->key == InputKeyRight &&
+                    model->test < (COUNT_OF(view_display_test_tests) - 1)) {
+                    model->test++;
+                    consumed = true;
+                } else if(event->key == InputKeyDown && model->size > 0) {
+                    model->size--;
+                    consumed = true;
+                } else if(event->key == InputKeyUp && model->size < 24) {
+                    model->size++;
+                    consumed = true;
+                } else if(event->key == InputKeyOk) {
+                    model->flip_flop = !model->flip_flop;
+                    consumed = true;
+                }
+                return consumed;
+            });
+    }
+
+    return consumed;
+}
+
+static void view_display_test_enter(void* context) {
+    ViewDisplayTest* instance = context;
+    furi_timer_start(instance->timer, furi_kernel_get_tick_frequency() / 32);
+}
+
+static void view_display_test_exit(void* context) {
+    ViewDisplayTest* instance = context;
+    furi_timer_stop(instance->timer);
+}
+
+static void view_display_test_timer_callback(void* context) {
+    ViewDisplayTest* instance = context;
+    with_view_model(
+        instance->view, (ViewDisplayTestModel * model) {
+            model->counter++;
+            return true;
+        });
+}
+
+ViewDisplayTest* view_display_test_alloc() {
+    ViewDisplayTest* instance = malloc(sizeof(ViewDisplayTest));
+
+    instance->view = view_alloc();
+    view_set_context(instance->view, instance);
+    view_allocate_model(instance->view, ViewModelTypeLockFree, sizeof(ViewDisplayTestModel));
+    view_set_draw_callback(instance->view, view_display_test_draw_callback);
+    view_set_input_callback(instance->view, view_display_test_input_callback);
+    view_set_enter_callback(instance->view, view_display_test_enter);
+    view_set_exit_callback(instance->view, view_display_test_exit);
+
+    instance->timer =
+        furi_timer_alloc(view_display_test_timer_callback, FuriTimerTypePeriodic, instance);
+
+    return instance;
+}
+
+void view_display_test_free(ViewDisplayTest* instance) {
+    furi_assert(instance);
+
+    furi_timer_free(instance->timer);
+    view_free(instance->view);
+    free(instance);
+}
+
+View* view_display_test_get_view(ViewDisplayTest* instance) {
+    furi_assert(instance);
+    return instance->view;
+}

applications/debug/display_test/view_display_test.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <stdint.h>
+#include <gui/view.h>
+
+typedef struct ViewDisplayTest ViewDisplayTest;
+
+ViewDisplayTest* view_display_test_alloc();
+
+void view_display_test_free(ViewDisplayTest* instance);
+
+View* view_display_test_get_view(ViewDisplayTest* instance);