FL-528 GUI: View, ViewDispather. Dolphin: first start. (#276)

* GUI: view. Flooper-blooper fix compilation error.
* GUI: view and viewdispatcher bones
* GUI: view implementation, view models, view dispatcher
* GUI: view navigation, model refinement. Power: use view, view dispatcher.
* HAL Flash: proper page write. Dolphin: views. Power: views
* Dolphin: transition idle scree to Views
* Dolphin: input events on stats view. Format sources.
* HAL: flash erase. Dolphin: permanent state storage.
* Dolphin: first start welcome. HAL: flash operation status, errata 2.2.9 crutch.

3 files changed, 120 insertions, 85 deletions

diff --git a/applications/power/power.c b/applications/power/power.c
index 740c30c3..acb46c8c 100644
--- a/applications/power/power.c
+++ b/applications/power/power.c
@@ -1,38 +1,33 @@
 #include "power.h"
+#include "power_views.h"
 
 #include <flipper_v2.h>
 
 #include <menu/menu.h>
 #include <menu/menu_item.h>
+
 #include <gui/gui.h>
 #include <gui/widget.h>
+#include <gui/view.h>
+#include <gui/view_dispatcher.h>
+
 #include <assets_icons.h>
 #include <api-hal-power.h>
 #include <cli/cli.h>
 
 struct Power {
+    ViewDispatcher* view_dispatcher;
+    View* info_view;
+
     Icon* usb_icon;
     Widget* usb_widget;
 
     Icon* battery_icon;
     Widget* battery_widget;
 
-    Widget* widget;
-
     ValueMutex* menu_vm;
     Cli* cli;
     MenuItem* menu;
-
-    float current_charger;
-    float current_gauge;
-    float voltage_charger;
-    float voltage_gauge;
-    uint32_t capacity_remaining;
-    uint32_t capacity_full;
-    float temperature_charger;
-    float temperature_gauge;
-
-    uint8_t charge;
 };
 
 void power_draw_usb_callback(Canvas* canvas, void* context) {
@@ -46,70 +41,31 @@ void power_draw_battery_callback(Canvas* canvas, void* context) {
     Power* power = context;
 
     canvas_draw_icon(canvas, 0, 0, power->battery_icon);
-    canvas_draw_box(canvas, 2, 2, (float)power->charge / 100 * 14, 4);
+    with_view_model(
+        power->info_view, (PowerInfoModel * model) {
+            canvas_draw_box(canvas, 2, 2, (float)model->charge / 100 * 14, 4);
+        });
 }
 
-void power_off_callback(void* context) {
+void power_menu_off_callback(void* context) {
     api_hal_power_off();
 }
 
-void power_enable_otg_callback(void* context) {
-    api_hal_power_enable_otg();
+void power_menu_reset_callback(void* context) {
+    NVIC_SystemReset();
 }
 
-void power_disable_otg_callback(void* context) {
-    api_hal_power_disable_otg();
+void power_menu_enable_otg_callback(void* context) {
+    api_hal_power_enable_otg();
 }
 
-void power_info_callback(void* context) {
-    Power* power = context;
-    widget_enabled_set(power->widget, true);
+void power_menu_disable_otg_callback(void* context) {
+    api_hal_power_disable_otg();
 }
 
-void power_draw_callback(Canvas* canvas, void* context) {
+void power_menu_info_callback(void* context) {
     Power* power = context;
-
-    canvas_clear(canvas);
-    canvas_set_color(canvas, ColorBlack);
-    canvas_set_font(canvas, FontPrimary);
-    canvas_draw_str(canvas, 2, 10, "Power state:");
-
-    char buffer[64];
-    canvas_set_font(canvas, FontSecondary);
-    snprintf(
-        buffer,
-        64,
-        "Current: %ld/%ldmA",
-        (int32_t)(power->current_gauge * 1000),
-        (int32_t)(power->current_charger * 1000));
-    canvas_draw_str(canvas, 5, 22, buffer);
-    snprintf(
-        buffer,
-        64,
-        "Voltage: %ld/%ldmV",
-        (uint32_t)(power->voltage_gauge * 1000),
-        (uint32_t)(power->voltage_charger * 1000));
-    canvas_draw_str(canvas, 5, 32, buffer);
-    snprintf(buffer, 64, "Charge: %ld%%", (uint32_t)(power->charge));
-    canvas_draw_str(canvas, 5, 42, buffer);
-    snprintf(
-        buffer, 64, "Capacity: %ld of %ldmAh", power->capacity_remaining, power->capacity_full);
-    canvas_draw_str(canvas, 5, 52, buffer);
-    snprintf(
-        buffer,
-        64,
-        "Temperature: %ld/%ldC",
-        (uint32_t)(power->temperature_gauge),
-        (uint32_t)(power->temperature_charger));
-    canvas_draw_str(canvas, 5, 62, buffer);
-}
-
-void power_input_callback(InputEvent* event, void* context) {
-    Power* power = context;
-
-    if(!event->state || event->input != InputBack) return;
-
-    widget_enabled_set(power->widget, false);
+    view_dispatcher_switch_to_view(power->view_dispatcher, PowerViewInfo);
 }
 
 Power* power_alloc() {
@@ -122,26 +78,30 @@ Power* power_alloc() {
 
     power->menu = menu_item_alloc_menu("Power", NULL);
     menu_item_subitem_add(
-        power->menu, menu_item_alloc_function("Poweroff", NULL, power_off_callback, power));
+        power->menu, menu_item_alloc_function("Off", NULL, power_menu_off_callback, power));
+    menu_item_subitem_add(
+        power->menu, menu_item_alloc_function("Reset", NULL, power_menu_reset_callback, power));
     menu_item_subitem_add(
         power->menu,
-        menu_item_alloc_function("Enable OTG", NULL, power_enable_otg_callback, power));
+        menu_item_alloc_function("Enable OTG", NULL, power_menu_enable_otg_callback, power));
     menu_item_subitem_add(
         power->menu,
-        menu_item_alloc_function("Disable OTG", NULL, power_disable_otg_callback, power));
+        menu_item_alloc_function("Disable OTG", NULL, power_menu_disable_otg_callback, power));
     menu_item_subitem_add(
-        power->menu, menu_item_alloc_function("Info", NULL, power_info_callback, power));
+        power->menu, menu_item_alloc_function("Info", NULL, power_menu_info_callback, power));
+
+    power->view_dispatcher = view_dispatcher_alloc();
+    power->info_view = view_alloc();
+    view_allocate_model(power->info_view, ViewModelTypeLockFree, sizeof(PowerInfoModel));
+    view_set_draw_callback(power->info_view, power_info_draw_callback);
+    view_set_previous_callback(power->info_view, power_info_back_callback);
+    view_dispatcher_add_view(power->view_dispatcher, PowerViewInfo, power->info_view);
 
     power->usb_icon = assets_icons_get(I_USBConnected_15x8);
     power->usb_widget = widget_alloc();
     widget_set_width(power->usb_widget, icon_get_width(power->usb_icon));
     widget_draw_callback_set(power->usb_widget, power_draw_usb_callback, power);
 
-    power->widget = widget_alloc();
-    widget_draw_callback_set(power->widget, power_draw_callback, power);
-    widget_input_callback_set(power->widget, power_input_callback, power);
-    widget_enabled_set(power->widget, false);
-
     power->battery_icon = assets_icons_get(I_Battery_19x8);
     power->battery_widget = widget_alloc();
     widget_set_width(power->battery_widget, icon_get_width(power->battery_icon));
@@ -204,9 +164,9 @@ void power_task(void* p) {
     }
 
     Gui* gui = furi_open("gui");
-    gui_add_widget(gui, power->widget, GuiLayerFullscreen);
     gui_add_widget(gui, power->usb_widget, GuiLayerStatusBarLeft);
     gui_add_widget(gui, power->battery_widget, GuiLayerStatusBarRight);
+    view_dispatcher_attach_to_gui(power->view_dispatcher, gui, ViewDispatcherTypeFullscreen);
 
     with_value_mutex(
         power->menu_vm, (Menu * menu) { menu_item_add(menu, power->menu); });
@@ -221,16 +181,22 @@ void power_task(void* p) {
     furiac_ready();
 
     while(1) {
-        power->charge = api_hal_power_get_pct();
-        power->capacity_remaining = api_hal_power_get_battery_remaining_capacity();
-        power->capacity_full = api_hal_power_get_battery_full_capacity();
-        power->current_charger = api_hal_power_get_battery_current(ApiHalPowerICCharger);
-        power->current_gauge = api_hal_power_get_battery_current(ApiHalPowerICFuelGauge);
-        power->voltage_charger = api_hal_power_get_battery_voltage(ApiHalPowerICCharger);
-        power->voltage_gauge = api_hal_power_get_battery_voltage(ApiHalPowerICFuelGauge);
-        power->temperature_charger = api_hal_power_get_battery_temperature(ApiHalPowerICCharger);
-        power->temperature_gauge = api_hal_power_get_battery_temperature(ApiHalPowerICFuelGauge);
-        widget_update(power->widget);
+        with_view_model(
+            power->info_view, (PowerInfoModel * model) {
+                model->charge = api_hal_power_get_pct();
+                model->capacity_remaining = api_hal_power_get_battery_remaining_capacity();
+                model->capacity_full = api_hal_power_get_battery_full_capacity();
+                model->current_charger = api_hal_power_get_battery_current(ApiHalPowerICCharger);
+                model->current_gauge = api_hal_power_get_battery_current(ApiHalPowerICFuelGauge);
+                model->voltage_charger = api_hal_power_get_battery_voltage(ApiHalPowerICCharger);
+                model->voltage_gauge = api_hal_power_get_battery_voltage(ApiHalPowerICFuelGauge);
+                model->temperature_charger =
+                    api_hal_power_get_battery_temperature(ApiHalPowerICCharger);
+                model->temperature_gauge =
+                    api_hal_power_get_battery_temperature(ApiHalPowerICFuelGauge);
+            });
+
+        widget_update(power->battery_widget);
         widget_enabled_set(power->usb_widget, api_hal_power_is_charging());
         osDelay(1000);
     }
diff --git a/applications/power/power_views.c b/applications/power/power_views.c
new file mode 100644
index 00000000..1f0dfeb2
--- /dev/null
+++ b/applications/power/power_views.c
@@ -0,0 +1,38 @@
+#include "power_views.h"
+
+void power_info_draw_callback(Canvas* canvas, void* context) {
+    PowerInfoModel* data = context;
+
+    canvas_clear(canvas);
+    canvas_set_color(canvas, ColorBlack);
+    canvas_set_font(canvas, FontPrimary);
+    canvas_draw_str(canvas, 2, 10, "Power state:");
+
+    char buffer[64];
+    canvas_set_font(canvas, FontSecondary);
+    snprintf(
+        buffer,
+        64,
+        "Current: %ld/%ldmA",
+        (int32_t)(data->current_gauge * 1000),
+        (int32_t)(data->current_charger * 1000));
+    canvas_draw_str(canvas, 5, 22, buffer);
+    snprintf(
+        buffer,
+        64,
+        "Voltage: %ld/%ldmV",
+        (uint32_t)(data->voltage_gauge * 1000),
+        (uint32_t)(data->voltage_charger * 1000));
+    canvas_draw_str(canvas, 5, 32, buffer);
+    snprintf(buffer, 64, "Charge: %ld%%", (uint32_t)(data->charge));
+    canvas_draw_str(canvas, 5, 42, buffer);
+    snprintf(buffer, 64, "Capacity: %ld of %ldmAh", data->capacity_remaining, data->capacity_full);
+    canvas_draw_str(canvas, 5, 52, buffer);
+    snprintf(
+        buffer,
+        64,
+        "Temperature: %ld/%ldC",
+        (uint32_t)(data->temperature_gauge),
+        (uint32_t)(data->temperature_charger));
+    canvas_draw_str(canvas, 5, 62, buffer);
+}
diff --git a/applications/power/power_views.h b/applications/power/power_views.h
new file mode 100644
index 00000000..97931601
--- /dev/null
+++ b/applications/power/power_views.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <gui/canvas.h>
+#include <flipper_v2.h>
+#include <gui/view.h>
+
+typedef enum { PowerViewInfo } PowerView;
+
+typedef struct {
+    float current_charger;
+    float current_gauge;
+
+    float voltage_charger;
+    float voltage_gauge;
+
+    uint32_t capacity_remaining;
+    uint32_t capacity_full;
+
+    float temperature_charger;
+    float temperature_gauge;
+
+    uint8_t charge;
+} PowerInfoModel;
+
+static uint32_t power_info_back_callback(void* context) {
+    return VIEW_NONE;
+}
+
+void power_info_draw_callback(Canvas* canvas, void* context);