Auto_poweroff option moved from desktop to power.

Add settings for power service (load|save).

applications/services/power/power_service/power.c

@@ -7,6 +7,8 @@
 #include <update_util/update_operation.h>
 #include <notification/notification_messages.h>
 
+#include <loader/loader.h>
+
 #define TAG "Power"
 
 #define POWER_OFF_TIMEOUT_S  (90U)
@@ -379,7 +381,120 @@ static void power_handle_reboot(PowerBootMode mode) {
 
     furi_hal_power_reset();
 }
+// get settings from service to settings_app by send message to power queue
+void power_api_get_settings(Power* power, PowerSettings* settings) {
+    furi_assert(power);
+    furi_assert(settings);
 
+    PowerMessage msg = {
+        .type = PowerMessageTypeGetSettings,
+        .settings = settings,
+        .lock = api_lock_alloc_locked(),
+    };
+
+    furi_check(
+        furi_message_queue_put(power->message_queue, &msg, FuriWaitForever) == FuriStatusOk);
+    api_lock_wait_unlock_and_free(msg.lock);
+}
+
+// set settings from settings_app to service by send message to power queue
+void power_api_set_settings(Power* power, const PowerSettings* settings) {
+    furi_assert(power);
+    furi_assert(settings);
+
+    PowerMessage msg = {
+        .type = PowerMessageTypeSetSettings,
+        .csettings = settings,
+        .lock = api_lock_alloc_locked(),
+    };
+
+    furi_check(
+        furi_message_queue_put(power->message_queue, &msg, FuriWaitForever) == FuriStatusOk);
+    api_lock_wait_unlock_and_free(msg.lock);
+}
+
+//start furi timer for autopoweroff
+static void power_start_auto_poweroff_timer(Power* power) {
+    furi_timer_start(
+        power->p_auto_poweroff_timer, furi_ms_to_ticks(power->settings.p_auto_poweroff_delay_ms));
+}
+
+//stop furi timer for autopoweroff
+static void power_stop_auto_poweroff_timer(Power* power) {
+    furi_timer_stop(power->p_auto_poweroff_timer);
+}
+
+static uint32_t power_is_running_auto_poweroff_timer(Power* power) {
+    return furi_timer_is_running(power->p_auto_poweroff_timer);
+}
+
+// start|restart poweroff timer
+static void power_auto_poweroff_callback(const void* value, void* context) {
+    furi_assert(value);
+    furi_assert(context);
+    Power* power = context;
+    power_start_auto_poweroff_timer(power);
+}
+
+// callback for poweroff timer (what we do when timer end)
+static void power_auto_poweroff_timer_callback(void* context) {
+    furi_assert(context);
+    Power* power = context;
+    power_off(power);
+}
+
+//start|restart timer and events subscription and callbacks for input events (we restart timer when user press keys)
+static void power_auto_poweroff_arm(Power* power) {
+    if(power->settings.p_auto_poweroff_delay_ms) {
+        if(power->input_events_subscription == NULL) {
+            power->input_events_subscription = furi_pubsub_subscribe(
+                power->input_events_pubsub, power_auto_poweroff_callback, power);
+        }
+        power_start_auto_poweroff_timer(power);
+    }
+}
+
+// stop timer and event subscription 
+static void power_auto_poweroff_disarm(Power* power) {
+    power_stop_auto_poweroff_timer(power);
+    if(power->input_events_subscription) {
+        furi_pubsub_unsubscribe(power->input_events_pubsub, power->input_events_subscription);
+        power->input_events_subscription = NULL;
+    }
+}
+
+//check message queue from Loader - is some app started or not (if started we dont do auto poweroff)
+static void power_loader_callback(const void* message, void* context) {
+    furi_assert(context);
+    Power* power = context;
+    const LoaderEvent* event = message;
+
+    // disarm timer if some apps started
+    if(event->type == LoaderEventTypeApplicationBeforeLoad) {
+        power->app_running = true;
+        power_auto_poweroff_disarm(power);
+    // arm timer if some apps was not loaded or was stoped
+    } else if(
+        event->type == LoaderEventTypeApplicationLoadFailed ||
+        event->type == LoaderEventTypeApplicationStopped) {
+        power->app_running = false;
+        power_auto_poweroff_arm(power);
+    }
+}
+
+// apply power settings
+static void power_settings_apply(Power* power) {
+    //apply auto_poweroff settings
+    if(power->settings.p_auto_poweroff_delay_ms && !power->app_running) {
+        return;
+        power_auto_poweroff_arm(power);
+    } else if (power_is_running_auto_poweroff_timer(power)) {
+        power_auto_poweroff_disarm(power);
+    }
+    return;
+}
+
+// do something depend from power queue message
 static void power_message_callback(FuriEventLoopObject* object, void* context) {
     furi_assert(context);
     Power* power = context;
@@ -405,6 +520,20 @@ static void power_message_callback(FuriEventLoopObject* object, void* context) {
     case PowerMessageTypeShowBatteryLowWarning:
         power->show_battery_low_warning = *msg.bool_param;
         break;
+    case PowerMessageTypeGetSettings:
+        furi_assert(msg.lock);
+        *msg.settings = power->settings;
+        break;
+    case PowerMessageTypeSetSettings:
+        furi_assert(msg.lock);
+        power->settings = *msg.csettings;
+        power_settings_apply(power);
+        power_settings_save(&power->settings);
+        break;
+    case PowerMessageTypeReloadSettings:
+        power_settings_load(&power->settings);
+        power_settings_apply(power);
+        break;
     default:
         furi_crash();
     }
@@ -436,6 +565,36 @@ static void power_tick_callback(void* context) {
     }
 }
 
+static void power_storage_callback(const void* message, void* context) {
+    furi_assert(context);
+    Power* power = context;
+    const StorageEvent* event = message;
+
+    if(event->type == StorageEventTypeCardMount) {
+        PowerMessage msg = {
+            .type = PowerMessageTypeReloadSettings,
+        };
+
+        furi_check(
+            furi_message_queue_put(power->message_queue, &msg, FuriWaitForever) == FuriStatusOk);
+    }
+}
+
+// load inital settings from file for power service
+static void power_init_settings(Power* power) {
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    furi_pubsub_subscribe(storage_get_pubsub(storage), power_storage_callback, power);
+
+    if(storage_sd_status(storage) != FSE_OK) {
+        FURI_LOG_D(TAG, "SD Card not ready, skipping settings");
+        return;
+    }
+
+    power_settings_load(&power->settings);
+    power_settings_apply(power);
+    furi_record_close(RECORD_STORAGE);
+}
+
 static Power* power_alloc(void) {
     Power* power = malloc(sizeof(Power));
     // Pubsub
@@ -449,6 +608,16 @@ static Power* power_alloc(void) {
     desktop_settings_load(settings);
     power->displayBatteryPercentage = settings->displayBatteryPercentage;
     free(settings);
+
+    // auto_poweroff
+    //---define subscription to loader events message (info about started apps) and defina callback for this
+    Loader* loader = furi_record_open(RECORD_LOADER);
+    furi_pubsub_subscribe(loader_get_pubsub(loader), power_loader_callback, power);
+    power->input_events_pubsub = furi_record_open(RECORD_INPUT_EVENTS);
+    //define autopoweroff timer and they callback 
+    power->p_auto_poweroff_timer =
+        furi_timer_alloc(power_auto_poweroff_timer_callback, FuriTimerTypeOnce, power);
+
     // Gui
     Gui* gui = furi_record_open(RECORD_GUI);
 
@@ -489,6 +658,15 @@ int32_t power_srv(void* p) {
     power_update_info(power);
 
     furi_record_create(RECORD_POWER, power);
+
+// Can't be done in alloc, other things in startup need power service and it would deadlock by waiting for loader
+    Loader* loader = furi_record_open(RECORD_LOADER);
+    power->app_running = loader_is_locked(loader);
+    furi_record_close(RECORD_LOADER);
+
+    // load inital settings for power service
+    power_init_settings(power);
+
     furi_event_loop_run(power->event_loop);
 
     return 0;

applications/services/power/power_service/power.h

@@ -2,7 +2,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
-
+#include <power/power_service/power_settings.h>
 #include <core/pubsub.h>
 
 #ifdef __cplusplus
@@ -102,6 +102,12 @@ void power_enable_low_battery_level_notification(Power* power, bool enable);
  */
 void power_trigger_ui_update(Power* power);
 
+// get settings from service to app
+void power_api_get_settings(Power* instance, PowerSettings* settings);
+
+// set settings from app to service
+void power_api_set_settings(Power* instance, const PowerSettings* settings);
+
 #ifdef __cplusplus
 }
 #endif

applications/services/power/power_service/power_i.h

@@ -36,6 +36,11 @@ struct Power {
     uint8_t displayBatteryPercentage;
     uint8_t battery_level;
     uint8_t power_off_timeout;
+    PowerSettings settings;
+    FuriTimer* p_auto_poweroff_timer;
+    bool app_running;
+    FuriPubSub* input_events_pubsub;
+    FuriPubSubSubscription* input_events_subscription;
 };
 
 typedef enum {
@@ -49,6 +54,9 @@ typedef enum {
     PowerMessageTypeGetInfo,
     PowerMessageTypeIsBatteryHealthy,
     PowerMessageTypeShowBatteryLowWarning,
+    PowerMessageTypeGetSettings,
+    PowerMessageTypeSetSettings,
+    PowerMessageTypeReloadSettings,
 } PowerMessageType;
 
 typedef struct {
@@ -57,6 +65,8 @@ typedef struct {
         PowerBootMode boot_mode;
         PowerInfo* power_info;
         bool* bool_param;
+        PowerSettings* settings;
+        const PowerSettings* csettings;
     };
     FuriApiLock lock;
 } PowerMessage;

applications/services/power/power_service/power_settings.c

@@ -0,0 +1,75 @@
+#include "power_settings.h"
+#include "power_settings_filename.h"
+
+#include <saved_struct.h>
+#include <storage/storage.h>
+
+#define TAG "PowerSettings"
+
+#define POWER_SETTINGS_VER_0 (0) // OLD version number
+#define POWER_SETTINGS_VER   (1) // NEW actual version nnumber
+
+#define POWER_SETTINGS_PATH  INT_PATH(POWER_SETTINGS_FILE_NAME)
+#define POWER_SETTINGS_MAGIC (0x18)
+
+typedef struct {
+//inital set - empty
+} PowerSettingsV0;
+
+void power_settings_load(PowerSettings* settings) {
+    furi_assert(settings);
+
+    bool success = false;
+
+    do {
+        uint8_t version;
+        if(!saved_struct_get_metadata(POWER_SETTINGS_PATH, NULL, &version, NULL)) break;
+
+        if(version == POWER_SETTINGS_VER) { // if config actual version - load it directly
+            success = saved_struct_load(
+                POWER_SETTINGS_PATH,
+                settings,
+                sizeof(PowerSettings),
+                POWER_SETTINGS_MAGIC,
+                POWER_SETTINGS_VER);
+
+        } else if(version == POWER_SETTINGS_VER_0) { // if config previous version - load it and manual set new settings to inital value
+            PowerSettingsV0* settings_v0 = malloc(sizeof(PowerSettingsV0));
+
+            success = saved_struct_load(
+                POWER_SETTINGS_PATH,
+                settings_v0,
+                sizeof(PowerSettingsV0),
+                POWER_SETTINGS_MAGIC,
+                POWER_SETTINGS_VER_0);
+
+            if(success) {
+                settings->p_auto_poweroff_delay_ms = 0;
+            }
+
+            free(settings_v0);
+        }
+
+    } while(false);
+
+    if(!success) {
+        FURI_LOG_W(TAG, "Failed to load file, using defaults");
+        memset(settings, 0, sizeof(PowerSettings));
+        power_settings_save(settings);
+    }
+}
+
+void power_settings_save(const PowerSettings* settings) {
+    furi_assert(settings);
+
+    const bool success = saved_struct_save(
+        POWER_SETTINGS_PATH,
+        settings,
+        sizeof(PowerSettings),
+        POWER_SETTINGS_MAGIC,
+        POWER_SETTINGS_VER);
+
+    if(!success) {
+        FURI_LOG_E(TAG, "Failed to save file");
+    }
+}

applications/services/power/power_service/power_settings.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <stdint.h>
+
+typedef struct {
+    uint32_t p_auto_poweroff_delay_ms;
+} PowerSettings;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void power_settings_load(PowerSettings* settings);
+void power_settings_save(const PowerSettings* settings);
+#ifdef __cplusplus
+}
+#endif

applications/services/power/power_service/power_settings_filename.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#define POWER_SETTINGS_FILE_NAME ".power.settings"