[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/view_stack.c

@@ -0,0 +1,172 @@
+#include "gui/view.h"
+#include <core/memmgr.h>
+#include "view_stack.h"
+#include "view_i.h"
+
+#define MAX_VIEWS 3
+
+typedef struct {
+    View* views[MAX_VIEWS];
+} ViewStackModel;
+
+struct ViewStack {
+    View* view;
+};
+
+static void view_stack_draw(Canvas* canvas, void* model);
+static bool view_stack_input(InputEvent* event, void* context);
+
+static void view_stack_update_callback(View* view_top_or_bottom, void* context) {
+    furi_assert(view_top_or_bottom);
+    furi_assert(context);
+
+    View* view_stack_view = context;
+    if(view_stack_view->update_callback) {
+        view_stack_view->update_callback(
+            view_stack_view, view_stack_view->update_callback_context);
+    }
+}
+
+static void view_stack_enter(void* context) {
+    furi_assert(context);
+
+    ViewStack* view_stack = context;
+    ViewStackModel* model = view_get_model(view_stack->view);
+
+    /* if more than 1 Stack View hold same view they have to reassign update_callback_context */
+    for(int i = 0; i < MAX_VIEWS; ++i) {
+        if(model->views[i]) {
+            view_set_update_callback_context(model->views[i], view_stack->view);
+            if(model->views[i]->enter_callback) {
+                model->views[i]->enter_callback(model->views[i]->context);
+            }
+        }
+    }
+
+    view_commit_model(view_stack->view, false);
+}
+
+static void view_stack_exit(void* context) {
+    furi_assert(context);
+
+    ViewStack* view_stack = context;
+    ViewStackModel* model = view_get_model(view_stack->view);
+
+    for(int i = 0; i < MAX_VIEWS; ++i) {
+        if(model->views[i] && model->views[i]->exit_callback) {
+            model->views[i]->exit_callback(model->views[i]->context);
+        }
+    }
+
+    view_commit_model(view_stack->view, false);
+}
+
+ViewStack* view_stack_alloc(void) {
+    ViewStack* view_stack = malloc(sizeof(ViewStack));
+    view_stack->view = view_alloc();
+
+    view_allocate_model(view_stack->view, ViewModelTypeLocking, sizeof(ViewStackModel));
+    view_set_draw_callback(view_stack->view, view_stack_draw);
+    view_set_input_callback(view_stack->view, view_stack_input);
+    view_set_context(view_stack->view, view_stack);
+    view_set_enter_callback(view_stack->view, view_stack_enter);
+    view_set_exit_callback(view_stack->view, view_stack_exit);
+    return view_stack;
+}
+
+void view_stack_free(ViewStack* view_stack) {
+    furi_assert(view_stack);
+
+    ViewStackModel* model = view_get_model(view_stack->view);
+    for(int i = 0; i < MAX_VIEWS; ++i) {
+        if(model->views[i]) {
+            view_set_update_callback(model->views[i], NULL);
+            view_set_update_callback_context(model->views[i], NULL);
+        }
+    }
+    view_commit_model(view_stack->view, false);
+
+    view_free(view_stack->view);
+    free(view_stack);
+}
+
+static void view_stack_draw(Canvas* canvas, void* _model) {
+    furi_assert(_model);
+
+    ViewStackModel* model = _model;
+    for(int i = 0; i < MAX_VIEWS; ++i) {
+        if(model->views[i]) {
+            view_draw(model->views[i], canvas);
+        }
+    }
+}
+
+static bool view_stack_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    furi_assert(context);
+
+    ViewStack* view_stack = context;
+
+    bool consumed = false;
+    ViewStackModel* model = view_get_model(view_stack->view);
+    for(int i = MAX_VIEWS - 1; i >= 0; i--) {
+        if(model->views[i] && view_input(model->views[i], event)) {
+            consumed = true;
+            break;
+        }
+    }
+    view_commit_model(view_stack->view, false);
+
+    return consumed;
+}
+
+void view_stack_add_view(ViewStack* view_stack, View* view) {
+    furi_assert(view_stack);
+    furi_assert(view);
+
+    bool result = false;
+    ViewStackModel* model = view_get_model(view_stack->view);
+    for(int i = 0; i < MAX_VIEWS; ++i) {
+        if(!model->views[i]) {
+            model->views[i] = view;
+            view_set_update_callback(model->views[i], view_stack_update_callback);
+            view_set_update_callback_context(model->views[i], view_stack->view);
+            if(view->enter_callback) {
+                view->enter_callback(view->context);
+            }
+            result = true;
+            break;
+        }
+    }
+    view_commit_model(view_stack->view, result);
+    furi_assert(result);
+}
+
+void view_stack_remove_view(ViewStack* view_stack, View* view) {
+    furi_assert(view_stack);
+    furi_assert(view);
+
+    /* Removing view on-the-go is dangerous, but it is protected with
+     * Locking model, so system is consistent at any time. */
+    bool result = false;
+    ViewStackModel* model = view_get_model(view_stack->view);
+    for(int i = 0; i < MAX_VIEWS; ++i) {
+        if(model->views[i] == view) {
+            if(view->exit_callback) {
+                view->exit_callback(view->context);
+            }
+            view_set_update_callback(model->views[i], NULL);
+            view_set_update_callback_context(model->views[i], NULL);
+            model->views[i] = NULL;
+            result = true;
+            break;
+        }
+    }
+    view_commit_model(view_stack->view, result);
+    furi_assert(result);
+}
+
+View* view_stack_get_view(ViewStack* view_stack) {
+    furi_assert(view_stack);
+    return view_stack->view;
+}