[FL-1547], [FL-1500] NFC app v1 (#593)

* nfc: remove mifare read debug view and scene
* nfc: change mifare ultralight data structure
* mifare_ultralight: add more commands
* nfc: add emulate mifare ul scene
* nfc: rework data structures, remove debug scenes and views
* nfc: add read emv scenes
* nfc: mifare emulation wip
* nfc cli: increase detecting time
* nfc: save nfc files with new format
* nfc: store Mifare Ultralight
* nfc: start loading mifare ultralight
* nfc: add delete scenes
* nfc: add edit UID and name
* nfc: finish parsing uid and mifare ul data
* nfc: delete success fix
* gui_widget: introduce GuiWidget
* gui_widget: add string element
* gui_widget: add button element
* gui_widget: move free elements into gui_widget
* nfc: rework info scene with GuiWidget
* nfc: rework device info scene
* nfc: rework delete scene gui
* nfc: add compatible script support
* nfc: rework emv reading scenes
* nfc: rework bank card save
* nfc: add bank card custom view
* gui_widget: add icon element
* nfc: add icon to bank card
* nfc: start worker after switching view

Co-authored-by: あく <alleteam@gmail.com>

applications/nfc/gui_widget/gui_element_button.c

@@ -0,0 +1,84 @@
+#include "gui_element_i.h"
+#include "gui_element_button.h"
+#include "gui_widget.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, GuiElement* 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, GuiElement* element) {
+    GuiButtonModel* model = element->model;
+    bool consumed = false;
+
+    if((event->type == InputTypeShort) && model->callback) {
+        if((model->button_type == GuiButtonTypeLeft) && (event->key == InputKeyLeft)) {
+            model->callback(model->button_type, model->context);
+            consumed = true;
+        } else if((model->button_type == GuiButtonTypeRight) && (event->key == InputKeyRight)) {
+            model->callback(model->button_type, model->context);
+            consumed = true;
+        } else if((model->button_type == GuiButtonTypeCenter) && (event->key == InputKeyOk)) {
+            model->callback(model->button_type, model->context);
+            consumed = true;
+        }
+    }
+
+    return consumed;
+}
+
+static void gui_button_free(GuiElement* gui_button) {
+    furi_assert(gui_button);
+
+    GuiButtonModel* model = gui_button->model;
+    if(gui_button->parent != NULL) {
+        // TODO deattach element
+    }
+    string_clear(model->text);
+    free(gui_button->model);
+    free(gui_button);
+}
+
+GuiElement* gui_button_create(
+    GuiButtonType button_type,
+    const char* text,
+    ButtonCallback callback,
+    void* context) {
+    // Allocate and init model
+    GuiButtonModel* model = furi_alloc(sizeof(GuiButtonModel));
+    model->button_type = button_type;
+    model->callback = callback;
+    model->context = context;
+    string_init_set_str(model->text, text);
+
+    // Allocate and init Element
+    GuiElement* gui_button = furi_alloc(sizeof(GuiElement));
+    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/nfc/gui_widget/gui_element_button.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <stdint.h>
+
+typedef struct GuiElement GuiElement;
+
+typedef enum {
+    GuiButtonTypeLeft,
+    GuiButtonTypeCenter,
+    GuiButtonTypeRight,
+} GuiButtonType;
+
+typedef void (*ButtonCallback)(GuiButtonType button, void* context);
+
+/** Allocate Button Element
+ * @param button_type GuiButtonType instance
+ * @param text text on allocated button
+ * @param callback ButtonCallback instance
+ * @param context pointer to context
+ */
+GuiElement* gui_button_create(
+    GuiButtonType button_type,
+    const char* text,
+    ButtonCallback callback,
+    void* context);

applications/nfc/gui_widget/gui_element_i.h

@@ -0,0 +1,21 @@
+#pragma once
+#include <furi.h>
+#include <gui/view.h>
+
+typedef struct GuiElement GuiElement;
+typedef struct GuiWidget GuiWidget;
+
+struct GuiElement {
+    // generic draw and input callbacks
+    void (*draw)(Canvas* canvas, GuiElement* element);
+    bool (*input)(InputEvent* event, GuiElement* element);
+
+    // free callback
+    void (*free)(GuiElement* element);
+
+    // generic model holder
+    void* model;
+
+    // pointer to widget that hold our element
+    GuiWidget* parent;
+};

applications/nfc/gui_widget/gui_element_icon.c

@@ -0,0 +1,51 @@
+#include "gui_element_i.h"
+#include "gui_element_icon.h"
+#include "gui_widget.h"
+
+#include <m-string.h>
+
+typedef struct {
+    uint8_t x;
+    uint8_t y;
+    const Icon* icon;
+} GuiIconModel;
+
+static void gui_icon_draw(Canvas* canvas, GuiElement* 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(GuiElement* gui_icon) {
+    furi_assert(gui_icon);
+
+    if(gui_icon->parent != NULL) {
+        // TODO deattach element
+    }
+    free(gui_icon->model);
+    free(gui_icon);
+}
+
+GuiElement* gui_icon_create(uint8_t x, uint8_t y, const Icon* icon) {
+    furi_assert(icon);
+
+    // Allocate and init model
+    GuiIconModel* model = furi_alloc(sizeof(GuiIconModel));
+    model->x = x;
+    model->y = y;
+    model->icon = icon;
+
+    // Allocate and init Element
+    GuiElement* gui_icon = furi_alloc(sizeof(GuiElement));
+    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/nfc/gui_widget/gui_element_icon.h

@@ -0,0 +1,13 @@
+#pragma once
+#include <stdint.h>
+#include <gui/canvas.h>
+
+typedef struct GuiElement GuiElement;
+
+/** Allocate GuiElement element
+ * @param x - x coordinate
+ * @param y - y coordinate
+ * @param icon Icon instance
+ * @return GuiElement instance
+ */
+GuiElement* gui_icon_create(uint8_t x, uint8_t y, const Icon* icon);

applications/nfc/gui_widget/gui_element_string.c

@@ -0,0 +1,72 @@
+#include "gui_element_i.h"
+#include "gui_element_string.h"
+#include "gui_widget.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, GuiElement* 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(GuiElement* gui_string) {
+    furi_assert(gui_string);
+
+    GuiStringModel* model = gui_string->model;
+    if(gui_string->parent != NULL) {
+        // TODO deattach element
+    }
+    string_clear(model->text);
+    free(gui_string->model);
+    free(gui_string);
+}
+
+GuiElement* gui_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 = furi_alloc(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
+    GuiElement* gui_string = furi_alloc(sizeof(GuiElement));
+    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/nfc/gui_widget/gui_element_string.h

@@ -0,0 +1,21 @@
+#pragma once
+#include <stdint.h>
+#include <gui/canvas.h>
+
+typedef struct GuiElement GuiElement;
+
+/** Allocate GuiElement element
+ * @param x - x coordinate
+ * @param y - y coordinate
+ * @param horizontal - Align instance
+ * @param vertical - Align instance
+ * @param font Font instance
+ * @return GuiElement instance
+ */
+GuiElement* gui_string_create(
+    uint8_t x,
+    uint8_t y,
+    Align horizontal,
+    Align vertical,
+    Font font,
+    const char* text);

applications/nfc/gui_widget/gui_widget.c

@@ -0,0 +1,141 @@
+#include <furi.h>
+#include "gui_element_i.h"
+#include "gui_widget.h"
+
+#define MAX_GUI_ELEMENTS 8
+
+struct GuiWidget {
+    View* view;
+    void* context;
+};
+
+// TODO rework with M-LIB container
+typedef struct {
+    GuiElement* element[MAX_GUI_ELEMENTS];
+} GuiWidgetModel;
+
+static void gui_widget_view_draw_callback(Canvas* canvas, void* _model) {
+    GuiWidgetModel* model = _model;
+    canvas_clear(canvas);
+
+    for(uint8_t i = 0; i < MAX_GUI_ELEMENTS; i++) {
+        if(model->element[i] != NULL) {
+            if(model->element[i]->draw != NULL) {
+                model->element[i]->draw(canvas, model->element[i]);
+            }
+        }
+    };
+}
+
+static bool gui_widget_view_input_callback(InputEvent* event, void* context) {
+    GuiWidget* gui_widget = context;
+    bool consumed = false;
+
+    with_view_model(
+        gui_widget->view, (GuiWidgetModel * model) {
+            for(uint8_t i = 0; i < MAX_GUI_ELEMENTS; i++) {
+                if(model->element[i] != NULL) {
+                    if(model->element[i]->input != NULL) {
+                        consumed = model->element[i]->input(event, model->element[i]);
+                    }
+                }
+            };
+            return true;
+        });
+
+    return consumed;
+}
+
+GuiWidget* gui_widget_alloc() {
+    GuiWidget* gui_widget = furi_alloc(sizeof(GuiWidget));
+    gui_widget->view = view_alloc();
+    view_set_context(gui_widget->view, gui_widget);
+    view_allocate_model(gui_widget->view, ViewModelTypeLocking, sizeof(GuiWidgetModel));
+    view_set_draw_callback(gui_widget->view, gui_widget_view_draw_callback);
+    view_set_input_callback(gui_widget->view, gui_widget_view_input_callback);
+
+    with_view_model(
+        gui_widget->view, (GuiWidgetModel * model) {
+            for(uint8_t i = 0; i < MAX_GUI_ELEMENTS; i++) {
+                model->element[i] = NULL;
+            };
+            return true;
+        });
+
+    return gui_widget;
+}
+
+void gui_widget_free(GuiWidget* gui_widget) {
+    furi_assert(gui_widget);
+    gui_widget_clear(gui_widget);
+    view_free(gui_widget->view);
+    free(gui_widget);
+}
+
+void gui_widget_clear(GuiWidget* gui_widget) {
+    furi_assert(gui_widget);
+
+    with_view_model(
+        gui_widget->view, (GuiWidgetModel * model) {
+            for(uint8_t i = 0; i < MAX_GUI_ELEMENTS; i++) {
+                if(model->element[i]) {
+                    furi_assert(model->element[i]->free);
+                    model->element[i]->free(model->element[i]);
+                    model->element[i] = NULL;
+                }
+            };
+            return true;
+        });
+}
+
+View* gui_widget_get_view(GuiWidget* gui_widget) {
+    furi_assert(gui_widget);
+    return gui_widget->view;
+}
+
+void gui_widget_add_element(GuiWidget* gui_widget, GuiElement* element) {
+    furi_assert(gui_widget);
+    with_view_model(
+        gui_widget->view, (GuiWidgetModel * model) {
+            // add element to first null position
+            for(uint8_t i = 0; i < MAX_GUI_ELEMENTS; i++) {
+                if(model->element[i] == NULL) {
+                    model->element[i] = element;
+                    element->parent = gui_widget;
+                    break;
+                }
+            };
+            return true;
+        });
+}
+
+void gui_widget_add_string_element(
+    GuiWidget* gui_widget,
+    uint8_t x,
+    uint8_t y,
+    Align horizontal,
+    Align vertical,
+    Font font,
+    const char* text) {
+    furi_assert(gui_widget);
+    GuiElement* string_element = gui_string_create(x, y, horizontal, vertical, font, text);
+    gui_widget_add_element(gui_widget, string_element);
+}
+
+void gui_widget_add_button_element(
+    GuiWidget* gui_widget,
+    GuiButtonType button_type,
+    const char* text,
+    ButtonCallback callback,
+    void* context) {
+    furi_assert(gui_widget);
+    GuiElement* button_element = gui_button_create(button_type, text, callback, context);
+    gui_widget_add_element(gui_widget, button_element);
+}
+
+void gui_widget_add_icon_element(GuiWidget* gui_widget, uint8_t x, uint8_t y, const Icon* icon) {
+    furi_assert(gui_widget);
+    furi_assert(icon);
+    GuiElement* icon_element = gui_icon_create(x, y, icon);
+    gui_widget_add_element(gui_widget, icon_element);
+}

applications/nfc/gui_widget/gui_widget.h

@@ -0,0 +1,76 @@
+#pragma once
+#include <gui/view.h>
+#include "gui_element_string.h"
+#include "gui_element_button.h"
+#include "gui_element_icon.h"
+
+typedef struct GuiWidget GuiWidget;
+typedef struct GuiElement GuiElement;
+
+/** Allocate Gui Widget that holds Gui Elements
+ * @return GuiWidget instance
+ */
+GuiWidget* gui_widget_alloc();
+
+/** Free Gui Widget
+ * @note this function free Gui Elements
+ * @param gui_widget GuiWidget instance
+ */
+void gui_widget_free(GuiWidget* gui_widget);
+
+/** Clear Gui Widget
+ * @param gui_widget GuiWidget instance
+ */
+void gui_widget_clear(GuiWidget* gui_widget);
+
+/** Get Gui Widget view
+ * @param gui_widget GuiWidget instance
+ * @return View instance
+ */
+View* gui_widget_get_view(GuiWidget* gui_widget);
+
+/** Add generic Gui Elements to Gui Widget
+ * @param gui_widget GuiWidget instance
+ * @param element GuiElement element
+ */
+void gui_widget_add_element(GuiWidget* gui_widget, GuiElement* element);
+
+/** Add String Element
+ * @param gui_widget GuiWidget instance
+ * @param x - x coordinate
+ * @param y - y coordinate
+ * @param horizontal - Align instance
+ * @param vertical - Align instance
+ * @param font Font instance
+ * @return GuiElement instance
+ */
+void gui_widget_add_string_element(
+    GuiWidget* gui_widget,
+    uint8_t x,
+    uint8_t y,
+    Align horizontal,
+    Align vertical,
+    Font font,
+    const char* text);
+
+/** Add Button Element
+ * @param gui_widget GuiWidget instance
+ * @param button_type GuiButtonType instance
+ * @param text text on allocated button
+ * @param callback ButtonCallback instance
+ * @param context pointer to context
+ */
+void gui_widget_add_button_element(
+    GuiWidget* gui_widget,
+    GuiButtonType button_type,
+    const char* text,
+    ButtonCallback callback,
+    void* context);
+
+/** Add Icon Element
+ * @param gui_widget GuiWidget instance
+ * @param x - x coordinate
+ * @param y - y coordinate
+ * @param icon Icon instance
+ */
+void gui_widget_add_icon_element(GuiWidget* gui_widget, uint8_t x, uint8_t y, const Icon* icon);