[FL-1783] Power service refactoring (#718)

* settings power: introduce power settings app
* power: move power API to separate file
* settings power: implement reboot scene
* settings power: add power off scene
* assets: add crying dolphin, fix Subghz assets names
* settings power: fix power off scene GUI
* settings power: add battery info scene
* power: add cli to application on start hook
* power: remove power from main menu
* power: move to power service folder
* power service: rework power off logic
* power: add pubsub events
* bt: subscribe to battery level change, update characteristic
* application: change order of Settings applications
* gui: add bubble element
* power: gui improvements
* application: rename Notification -> LCD and notifications
* Applications: menu order according to documentation and add missing power cli init
* settings power: add disconnect USB scene
* power cli: notify user to disconnect USB after poweroff
* Power: update poweroff message in cli

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>

applications/power/power_service/power.c

@@ -0,0 +1,179 @@
+#include "power_i.h"
+#include "views/power_off.h"
+
+#include <furi.h>
+#include <furi-hal.h>
+#include <gui/view_port.h>
+#include <gui/view.h>
+
+#define POWER_OFF_TIMEOUT 90
+
+void power_draw_battery_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    Power* power = context;
+    canvas_draw_icon(canvas, 0, 0, &I_Battery_26x8);
+    canvas_draw_box(canvas, 2, 2, power->info.charge / 5, 4);
+}
+
+static ViewPort* power_battery_view_port_alloc(Power* power) {
+    ViewPort* battery_view_port = view_port_alloc();
+    view_port_set_width(battery_view_port, icon_get_width(&I_Battery_26x8));
+    view_port_draw_callback_set(battery_view_port, power_draw_battery_callback, power);
+    gui_add_view_port(power->gui, battery_view_port, GuiLayerStatusBarRight);
+    return battery_view_port;
+}
+
+Power* power_alloc() {
+    Power* power = furi_alloc(sizeof(Power));
+
+    // Records
+    power->notification = furi_record_open("notification");
+    power->gui = furi_record_open("gui");
+
+    // Pubsub
+    init_pubsub(&power->event_pubsub);
+
+    // State initialization
+    power->state = PowerStateNotCharging;
+    power->battery_low = false;
+    power->power_off_timeout = POWER_OFF_TIMEOUT;
+    power->info_mtx = osMutexNew(NULL);
+
+    // Gui
+    power->view_dispatcher = view_dispatcher_alloc();
+    power->power_off = power_off_alloc();
+    view_dispatcher_add_view(
+        power->view_dispatcher, PowerViewOff, power_off_get_view(power->power_off));
+    view_dispatcher_attach_to_gui(
+        power->view_dispatcher, power->gui, ViewDispatcherTypeFullscreen);
+
+    // Battery view port
+    power->battery_view_port = power_battery_view_port_alloc(power);
+
+    return power;
+}
+
+void power_free(Power* power) {
+    furi_assert(power);
+
+    // Records
+    furi_record_close("notification");
+    furi_record_close("gui");
+
+    // Gui
+    view_dispatcher_remove_view(power->view_dispatcher, PowerViewOff);
+    power_off_free(power->power_off);
+    view_port_free(power->battery_view_port);
+
+    // State
+    osMutexDelete(power->info_mtx);
+    free(power);
+}
+
+static void power_check_charging_state(Power* power) {
+    if(furi_hal_power_is_charging()) {
+        if(power->info.charge == 100) {
+            if(power->state != PowerStateCharged) {
+                notification_internal_message(power->notification, &sequence_charged);
+                power->state = PowerStateCharged;
+                power->event.type = PowerEventTypeFullyCharged;
+                notify_pubsub(&power->event_pubsub, &power->event);
+            }
+        } else {
+            if(power->state != PowerStateCharging) {
+                notification_internal_message(power->notification, &sequence_charging);
+                power->state = PowerStateCharging;
+                power->event.type = PowerEventTypeStartCharging;
+                notify_pubsub(&power->event_pubsub, &power->event);
+            }
+        }
+    } else {
+        if(power->state != PowerStateNotCharging) {
+            notification_internal_message(power->notification, &sequence_not_charging);
+            power->state = PowerStateNotCharging;
+            power->event.type = PowerEventTypeStopCharging;
+            notify_pubsub(&power->event_pubsub, &power->event);
+        }
+    }
+}
+
+static void power_update_info(Power* power) {
+    osMutexAcquire(power->info_mtx, osWaitForever);
+    PowerInfo* info = &power->info;
+
+    info->charge = furi_hal_power_get_pct();
+    info->health = furi_hal_power_get_bat_health_pct();
+    info->capacity_remaining = furi_hal_power_get_battery_remaining_capacity();
+    info->capacity_full = furi_hal_power_get_battery_full_capacity();
+    info->current_charger = furi_hal_power_get_battery_current(FuriHalPowerICCharger);
+    info->current_gauge = furi_hal_power_get_battery_current(FuriHalPowerICFuelGauge);
+    info->voltage_charger = furi_hal_power_get_battery_voltage(FuriHalPowerICCharger);
+    info->voltage_gauge = furi_hal_power_get_battery_voltage(FuriHalPowerICFuelGauge);
+    info->voltage_vbus = furi_hal_power_get_usb_voltage();
+    info->temperature_charger = furi_hal_power_get_battery_temperature(FuriHalPowerICCharger);
+    info->temperature_gauge = furi_hal_power_get_battery_temperature(FuriHalPowerICFuelGauge);
+
+    osMutexRelease(power->info_mtx);
+}
+
+static void power_check_low_battery(Power* power) {
+    // Check battery charge and vbus voltage
+    if((power->info.charge == 0) && (power->info.voltage_vbus < 4.0f)) {
+        if(!power->battery_low) {
+            view_dispatcher_switch_to_view(power->view_dispatcher, PowerViewOff);
+        }
+        power->battery_low = true;
+    } else {
+        if(power->battery_low) {
+            view_dispatcher_switch_to_view(power->view_dispatcher, VIEW_NONE);
+            power->power_off_timeout = POWER_OFF_TIMEOUT;
+        }
+        power->battery_low = false;
+    }
+    // If battery low, update view and switch off power after timeout
+    if(power->battery_low) {
+        if(power->power_off_timeout) {
+            power_off_set_time_left(power->power_off, power->power_off_timeout--);
+        } else {
+            power_off();
+        }
+    }
+}
+
+static void power_check_battery_level_change(Power* power) {
+    if(power->battery_level != power->info.charge) {
+        power->battery_level = power->info.charge;
+        power->event.type = PowerEventTypeBatteryLevelChanged;
+        power->event.data.battery_level = power->battery_level;
+        notify_pubsub(&power->event_pubsub, &power->event);
+    }
+}
+
+int32_t power_srv(void* p) {
+    (void)p;
+    Power* power = power_alloc();
+    furi_record_create("power", power);
+
+    while(1) {
+        // Update data from gauge and charger
+        power_update_info(power);
+
+        // Check low battery level
+        power_check_low_battery(power);
+
+        // Check and notify about charging state
+        power_check_charging_state(power);
+
+        // Check and notify about battery level change
+        power_check_battery_level_change(power);
+
+        // Update battery view port
+        view_port_update(power->battery_view_port);
+
+        osDelay(1000);
+    }
+
+    power_free(power);
+
+    return 0;
+}

applications/power/power_service/power.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <stdint.h>
+#include <furi/pubsub.h>
+
+typedef struct Power Power;
+
+typedef enum {
+    PowerBootModeNormal,
+    PowerBootModeDfu,
+} PowerBootMode;
+
+typedef enum {
+    PowerEventTypeStopCharging,
+    PowerEventTypeStartCharging,
+    PowerEventTypeFullyCharged,
+    PowerEventTypeBatteryLevelChanged,
+} PowerEventType;
+
+typedef union {
+    uint8_t battery_level;
+} PowerEventData;
+
+typedef struct {
+    PowerEventType type;
+    PowerEventData data;
+} PowerEvent;
+
+typedef struct {
+    float current_charger;
+    float current_gauge;
+
+    float voltage_charger;
+    float voltage_gauge;
+    float voltage_vbus;
+
+    uint32_t capacity_remaining;
+    uint32_t capacity_full;
+
+    float temperature_charger;
+    float temperature_gauge;
+
+    uint8_t charge;
+    uint8_t health;
+} PowerInfo;
+
+/** Power off device
+ */
+void power_off();
+
+/** Reboot device
+ * @param mode - PowerBootMode
+ */
+void power_reboot(PowerBootMode mode);
+
+/** Get power info
+ * @param power - Power instance
+ * @param info - PowerInfo instance
+ */
+void power_get_info(Power* power, PowerInfo* info);
+
+/** Get power event pubsub handler
+ * @param power - Power instance
+ */
+PubSub* power_get_pubsub(Power* power);

applications/power/power_service/power_api.c

@@ -0,0 +1,31 @@
+#include "power_i.h"
+#include <furi.h>
+#include "furi-hal-power.h"
+#include "furi-hal-boot.h"
+
+void power_off() {
+    furi_hal_power_off();
+}
+
+void power_reboot(PowerBootMode mode) {
+    if(mode == PowerBootModeNormal) {
+        furi_hal_boot_set_mode(FuriHalBootModeNormal);
+    } else if(mode == PowerBootModeDfu) {
+        furi_hal_boot_set_mode(FuriHalBootModeDFU);
+    }
+    furi_hal_power_reset();
+}
+
+void power_get_info(Power* power, PowerInfo* info) {
+    furi_assert(power);
+    furi_assert(info);
+
+    osMutexAcquire(power->info_mtx, osWaitForever);
+    memcpy(info, &power->info, sizeof(power->info));
+    osMutexRelease(power->info_mtx);
+}
+
+PubSub* power_get_pubsub(Power* power) {
+    furi_assert(power);
+    return &power->event_pubsub;
+}

applications/power/power_service/power_i.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "power.h"
+
+#include <stdint.h>
+#include <gui/view_dispatcher.h>
+#include <gui/gui.h>
+#include "views/power_off.h"
+
+#include <notification/notification-messages.h>
+
+typedef enum {
+    PowerStateNotCharging,
+    PowerStateCharging,
+    PowerStateCharged,
+} PowerState;
+
+struct Power {
+    ViewDispatcher* view_dispatcher;
+    PowerOff* power_off;
+
+    ViewPort* battery_view_port;
+    Gui* gui;
+    NotificationApp* notification;
+    PubSub event_pubsub;
+    PowerEvent event;
+
+    PowerState state;
+    PowerInfo info;
+    osMutexId_t info_mtx;
+
+    bool battery_low;
+    uint8_t battery_level;
+    uint8_t power_off_timeout;
+};
+
+typedef enum { PowerViewOff } PowerView;

applications/power/power_service/views/power_off.c

@@ -0,0 +1,57 @@
+#include "power_off.h"
+#include <furi.h>
+#include <gui/elements.h>
+
+struct PowerOff {
+    View* view;
+};
+
+typedef struct {
+    uint32_t time_left_sec;
+} PowerOffModel;
+
+static void power_off_draw_callback(Canvas* canvas, void* _model) {
+    furi_assert(_model);
+    PowerOffModel* model = _model;
+    char buff[32];
+
+    canvas_set_color(canvas, ColorBlack);
+    canvas_set_font(canvas, FontPrimary);
+    canvas_draw_str_aligned(canvas, 64, 1, AlignCenter, AlignTop, "Battery low!");
+    canvas_draw_icon(canvas, 0, 18, &I_BatteryBody_52x28);
+    canvas_draw_icon(canvas, 16, 25, &I_FaceNopower_29x14);
+    elements_bubble(canvas, 54, 17, 70, 30);
+    canvas_set_font(canvas, FontSecondary);
+    elements_multiline_text_aligned(
+        canvas, 70, 23, AlignLeft, AlignTop, "Connect me\n to charger.");
+    snprintf(buff, sizeof(buff), "Poweroff in %lds.", model->time_left_sec);
+    canvas_draw_str_aligned(canvas, 64, 60, AlignCenter, AlignBottom, buff);
+}
+
+PowerOff* power_off_alloc() {
+    PowerOff* power_off = furi_alloc(sizeof(PowerOff));
+    power_off->view = view_alloc();
+    view_allocate_model(power_off->view, ViewModelTypeLocking, sizeof(PowerOffModel));
+    view_set_draw_callback(power_off->view, power_off_draw_callback);
+    return power_off;
+}
+
+void power_off_free(PowerOff* power_off) {
+    furi_assert(power_off);
+    view_free(power_off->view);
+    free(power_off);
+}
+
+View* power_off_get_view(PowerOff* power_off) {
+    furi_assert(power_off);
+    return power_off->view;
+}
+
+void power_off_set_time_left(PowerOff* power_off, uint8_t time_left) {
+    furi_assert(power_off);
+    with_view_model(
+        power_off->view, (PowerOffModel * model) {
+            model->time_left_sec = time_left;
+            return true;
+        });
+}

applications/power/power_service/views/power_off.h

@@ -0,0 +1,13 @@
+#pragma once
+
+typedef struct PowerOff PowerOff;
+
+#include <gui/view.h>
+
+PowerOff* power_off_alloc();
+
+void power_off_free(PowerOff* power_off);
+
+View* power_off_get_view(PowerOff* power_off);
+
+void power_off_set_time_left(PowerOff* power_off, uint8_t time_left);