Merge remote-tracking branch 'ul/dev' into mntm-dev

applications/services/desktop/desktop.c

@@ -137,6 +137,10 @@ static bool desktop_custom_event_callback(void* context, uint32_t event) {
 
     } else if(event == DesktopGlobalAutoLock) {
         if(!desktop->app_running && !desktop->locked) {
+            // Disable AutoLock if usb_inhibit_autolock option enabled and device have active USB session.
+            if((desktop->settings.usb_inhibit_auto_lock) && (furi_hal_usb_is_locked())) {
+                return true;
+            }
             desktop_lock(desktop, desktop->settings.auto_lock_with_pin);
         }
 

applications/services/desktop/desktop_settings.c

@@ -6,7 +6,7 @@
 
 #define TAG "DesktopSettings"
 
-#define DESKTOP_SETTINGS_VER   (11)
+#define DESKTOP_SETTINGS_VER   (12)
 #define DESKTOP_SETTINGS_MAGIC (0x13) // Different from OFW 0x17
 
 void desktop_settings_load(DesktopSettings* settings) {

applications/services/desktop/desktop_settings.h

@@ -5,6 +5,7 @@
 typedef struct {
     uint32_t auto_lock_delay_ms;
     uint8_t auto_lock_with_pin;
+    uint8_t usb_inhibit_auto_lock;
     uint8_t display_clock;
 } DesktopSettings;
 

applications/services/power/power_service/power.c

@@ -2,12 +2,13 @@
 
 #include <furi.h>
 #include <furi_hal.h>
-#include <loader/loader.h>
 #include <momentum/momentum.h>
 
 #include <update_util/update_operation.h>
 #include <notification/notification_messages.h>
 
+#include <loader/loader.h>
+
 #define TAG "Power"
 
 #define POWER_OFF_TIMEOUT_S  (90U)
@@ -252,106 +253,6 @@ static ViewPort* power_battery_view_port_alloc(Power* power) {
     return battery_view_port;
 }
 
-static void power_start_auto_shutdown_timer(Power* power) {
-    furi_timer_start(
-        power->auto_shutdown_timer, furi_ms_to_ticks(power->settings.shutdown_idle_delay_ms));
-}
-
-static void power_stop_auto_shutdown_timer(Power* power) {
-    furi_timer_stop(power->auto_shutdown_timer);
-}
-
-static uint32_t power_is_running_auto_shutdown_timer(Power* power) {
-    return furi_timer_is_running(power->auto_shutdown_timer);
-}
-
-static void power_auto_shutdown_callback(const void* value, void* context) {
-    furi_assert(value);
-    furi_assert(context);
-    UNUSED(value);
-    Power* power = context;
-    power_start_auto_shutdown_timer(power);
-}
-
-static void power_auto_shutdown_arm(Power* power) {
-    if(power->settings.shutdown_idle_delay_ms) {
-        if(power->input_events_subscription == NULL) {
-            power->input_events_subscription = furi_pubsub_subscribe(
-                power->input_events_pubsub, power_auto_shutdown_callback, power);
-        }
-        if(power->ascii_events_subscription == NULL) {
-            power->ascii_events_subscription = furi_pubsub_subscribe(
-                power->ascii_events_pubsub, power_auto_shutdown_callback, power);
-        }
-        power_start_auto_shutdown_timer(power);
-    }
-}
-
-static void power_auto_shutdown_inhibit(Power* power) {
-    power_stop_auto_shutdown_timer(power);
-    if(power->input_events_subscription) {
-        furi_pubsub_unsubscribe(power->input_events_pubsub, power->input_events_subscription);
-        power->input_events_subscription = NULL;
-    }
-    if(power->ascii_events_subscription) {
-        furi_pubsub_unsubscribe(power->ascii_events_pubsub, power->ascii_events_subscription);
-        power->ascii_events_subscription = NULL;
-    }
-}
-
-static void power_loader_callback(const void* message, void* context) {
-    furi_assert(context);
-    Power* power = context;
-    const LoaderEvent* event = message;
-
-    if(event->type == LoaderEventTypeApplicationBeforeLoad) {
-        power->app_running = true;
-        power_auto_shutdown_inhibit(power);
-    } else if(
-        event->type == LoaderEventTypeApplicationLoadFailed ||
-        event->type == LoaderEventTypeApplicationStopped) {
-        power->app_running = false;
-        power_auto_shutdown_arm(power);
-    }
-}
-
-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);
-    }
-}
-
-static void power_auto_shutdown_timer_callback(void* context) {
-    furi_assert(context);
-    Power* power = context;
-
-    // Suppress shutdown on idle while charging to avoid the battery from not charging fully. Then restart timer back to original timeout.
-    if(power->state != PowerStateNotCharging) {
-        FURI_LOG_D(TAG, "Plugged in, reset idle timer");
-        power_auto_shutdown_arm(power);
-    } else {
-        power_auto_shutdown_inhibit(power);
-        power_off(power);
-    }
-}
-
-static void power_apply_settings(Power* power) {
-    if(power->settings.shutdown_idle_delay_ms && !power->app_running) {
-        power_auto_shutdown_arm(power);
-    } else if(power_is_running_auto_shutdown_timer(power)) {
-        power_auto_shutdown_inhibit(power);
-    }
-}
-
 static bool power_update_info(Power* power) {
     const PowerInfo info = {
         .is_charging = furi_hal_power_is_charging(),
@@ -499,6 +400,101 @@ static void power_handle_reboot(PowerBootMode mode) {
     furi_hal_power_reset();
 }
 
+//start furi timer for autopoweroff
+static void power_start_auto_poweroff_timer(Power* power) {
+    furi_timer_start(
+        power->auto_poweroff_timer, furi_ms_to_ticks(power->settings.auto_poweroff_delay_ms));
+}
+
+//stop furi timer for autopoweroff
+static void power_stop_auto_poweroff_timer(Power* power) {
+    furi_timer_stop(power->auto_poweroff_timer);
+}
+
+static uint32_t power_is_running_auto_poweroff_timer(Power* power) {
+    return furi_timer_is_running(power->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;
+
+    //Dont poweroff device if charger connected
+    if(power->state != PowerStateNotCharging) {
+        FURI_LOG_D(TAG, "We dont auto_power_off until battery is charging");
+        power_start_auto_poweroff_timer(power);
+    } else {
+        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.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);
+        }
+        if(power->ascii_events_subscription == NULL) {
+            power->ascii_events_subscription = furi_pubsub_subscribe(
+                power->ascii_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;
+    }
+    if(power->ascii_events_subscription) {
+        furi_pubsub_unsubscribe(power->ascii_events_pubsub, power->ascii_events_subscription);
+        power->ascii_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.auto_poweroff_delay_ms && !power->app_running) {
+        power_auto_poweroff_arm(power);
+    } else if(power_is_running_auto_poweroff_timer(power)) {
+        power_auto_poweroff_disarm(power);
+    }
+}
+
+// do something depend from power queue message
 static void power_message_callback(FuriEventLoopObject* object, void* context) {
     furi_assert(context);
     Power* power = context;
@@ -531,12 +527,12 @@ static void power_message_callback(FuriEventLoopObject* object, void* context) {
     case PowerMessageTypeSetSettings:
         furi_assert(msg.lock);
         power->settings = *msg.csettings;
-        power_apply_settings(power);
+        power_settings_apply(power);
         power_settings_save(&power->settings);
         break;
     case PowerMessageTypeReloadSettings:
         power_settings_load(&power->settings);
-        power_apply_settings(power);
+        power_settings_apply(power);
         break;
     default:
         furi_crash();
@@ -573,6 +569,22 @@ 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);
@@ -583,7 +595,7 @@ static void power_init_settings(Power* power) {
     }
 
     power_settings_load(&power->settings);
-    power_apply_settings(power);
+    power_settings_apply(power);
     furi_record_close(RECORD_STORAGE);
 }
 
@@ -597,13 +609,15 @@ static Power* power_alloc(void) {
     // Gui
     Gui* gui = furi_record_open(RECORD_GUI);
 
-    // Auto shutdown on idle
+    // 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);
     power->ascii_events_pubsub = furi_record_open(RECORD_ASCII_EVENTS);
-    power->auto_shutdown_timer =
-        furi_timer_alloc(power_auto_shutdown_timer_callback, FuriTimerTypeOnce, power);
+    //define autopoweroff timer and they callback
+    power->auto_poweroff_timer =
+        furi_timer_alloc(power_auto_poweroff_timer_callback, FuriTimerTypeOnce, power);
 
     power->view_holder = view_holder_alloc();
     power->view_power_off = power_off_alloc();
@@ -639,6 +653,10 @@ int32_t power_srv(void* p) {
     }
 
     Power* power = power_alloc();
+
+    // load inital settings for power service
+    power_init_settings(power);
+
     power_update_info(power);
 
     furi_record_create(RECORD_POWER, power);
@@ -647,7 +665,6 @@ int32_t power_srv(void* p) {
     Loader* loader = furi_record_open(RECORD_LOADER);
     power->app_running = loader_is_locked(loader);
     furi_record_close(RECORD_LOADER);
-    power_init_settings(power);
 
     furi_event_loop_run(power->event_loop);
 

applications/services/power/power_service/power_api.c

@@ -75,7 +75,8 @@ void power_enable_low_battery_level_notification(Power* power, bool enable) {
  * Private API for the Settings app
  */
 
-void power_get_settings(Power* power, PowerSettings* settings) {
+// 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);
 
@@ -90,7 +91,8 @@ void power_get_settings(Power* power, PowerSettings* settings) {
     api_lock_wait_unlock_and_free(msg.lock);
 }
 
-void power_set_settings(Power* power, const PowerSettings* settings) {
+// 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);
 

applications/services/power/power_service/power_i.h

@@ -11,7 +11,7 @@
 #include "views/power_off.h"
 #include "views/power_unplug_usb.h"
 
-#include <power/power_settings.h>
+#include <power/power_service/power_settings.h>
 
 typedef enum {
     PowerStateNotCharging,
@@ -38,14 +38,14 @@ struct Power {
     uint8_t battery_level;
     uint8_t power_off_timeout;
 
+    PowerSettings settings;
+    FuriTimer* auto_poweroff_timer;
+    bool app_running;
+    bool is_charge_capped;
     FuriPubSub* input_events_pubsub;
     FuriPubSub* ascii_events_pubsub;
     FuriPubSubSubscription* input_events_subscription;
     FuriPubSubSubscription* ascii_events_subscription;
-    FuriTimer* auto_shutdown_timer;
-    PowerSettings settings;
-    bool is_charge_capped;
-    bool app_running;
 };
 
 typedef enum {

applications/services/power/power_service/power_settings.h

@@ -3,7 +3,7 @@
 #include <stdint.h>
 
 typedef struct {
-    uint32_t shutdown_idle_delay_ms;
+    uint32_t auto_poweroff_delay_ms;
 } PowerSettings;
 
 void power_settings_load(PowerSettings* settings);

applications/services/power/power_service/power_settings_api_i.h

@@ -1,8 +1,10 @@
 #pragma once
 
 #include "power.h"
-#include "../power_settings.h"
+#include "power_settings.h"
 
-void power_get_settings(Power* power, PowerSettings* settings);
+// get settings from service to app
+void power_api_get_settings(Power* instance, PowerSettings* settings);
 
-void power_set_settings(Power* power, const PowerSettings* settings);
+// set settings from app to service
+void power_api_set_settings(Power* instance, const PowerSettings* settings);

applications/settings/desktop_settings/scenes/desktop_settings_scene_start.c

@@ -10,11 +10,13 @@ typedef enum {
     DesktopSettingsResetKeybinds,
     DesktopSettingsAutoLockDelay,
     DesktopSettingsAutoLockPin,
+    DesktopSettingsAutoLockInhibit,
     DesktopSettingsClockDisplay,
     DesktopSettingsHappyMode,
 } DesktopSettingsEntry;
 
 #define AUTO_LOCK_DELAY_COUNT 9
+
 static const char* const auto_lock_delay_text[AUTO_LOCK_DELAY_COUNT] = {
     "OFF",
     "10s",
@@ -26,9 +28,19 @@ static const char* const auto_lock_delay_text[AUTO_LOCK_DELAY_COUNT] = {
     "5min",
     "10min",
 };
+
 static const uint32_t auto_lock_delay_value[AUTO_LOCK_DELAY_COUNT] =
     {0, 10000, 15000, 30000, 60000, 90000, 120000, 300000, 600000};
 
+#define USB_INHIBIT_AUTO_LOCK_DELAY_COUNT 2
+
+const char* const usb_inhibit_auto_lock_delay_text[USB_INHIBIT_AUTO_LOCK_DELAY_COUNT] = {
+    "OFF",
+    "ON",
+};
+
+const uint32_t usb_inhibit_auto_lock_delay_value[USB_INHIBIT_AUTO_LOCK_DELAY_COUNT] = {0, 1};
+
 #define CLOCK_ENABLE_COUNT 2
 const char* const clock_enable_text[CLOCK_ENABLE_COUNT] = {
     "OFF",
@@ -66,6 +78,14 @@ static void desktop_settings_scene_start_auto_lock_pin_changed(VariableItem* ite
     app->settings.auto_lock_with_pin = value;
 }
 
+static void desktop_settings_scene_start_usb_inhibit_auto_lock_delay_changed(VariableItem* item) {
+    DesktopSettingsApp* app = variable_item_get_context(item);
+    uint8_t index = variable_item_get_current_value_index(item);
+
+    variable_item_set_current_value_text(item, usb_inhibit_auto_lock_delay_text[index]);
+    app->settings.usb_inhibit_auto_lock = usb_inhibit_auto_lock_delay_value[index];
+}
+
 void desktop_settings_scene_start_on_enter(void* context) {
     DesktopSettingsApp* app = context;
     VariableItemList* variable_item_list = app->variable_item_list;
@@ -101,6 +121,21 @@ void desktop_settings_scene_start_on_enter(void* context) {
     variable_item_set_current_value_index(item, app->settings.auto_lock_with_pin);
     variable_item_set_current_value_text(item, app->settings.auto_lock_with_pin ? "ON" : "OFF");
 
+    // USB connection Inhibit autolock OFF|ON|with opened RPC session
+    item = variable_item_list_add(
+        variable_item_list,
+        "Auto Lock disarm by active USB session",
+        USB_INHIBIT_AUTO_LOCK_DELAY_COUNT,
+        desktop_settings_scene_start_usb_inhibit_auto_lock_delay_changed,
+        app);
+
+    value_index = value_index_uint32(
+        app->settings.usb_inhibit_auto_lock,
+        usb_inhibit_auto_lock_delay_value,
+        USB_INHIBIT_AUTO_LOCK_DELAY_COUNT);
+    variable_item_set_current_value_index(item, value_index);
+    variable_item_set_current_value_text(item, usb_inhibit_auto_lock_delay_text[value_index]);
+
     item = variable_item_list_add(
         variable_item_list,
         "Show Clock",

applications/settings/power_settings_app/mock_imports/mock_power_api.c

@@ -3,5 +3,5 @@
 // Instead of copying the file, can (ab)use the preprocessor to insert the source code here
 // Then, we still use the Header from original code as if nothing happened
 
-// power_get_settings(), power_set_settings()
+// power_api_get_settings(), power_api_set_settings()
 #include <applications/services/power/power_service/power_api.c>

applications/settings/power_settings_app/power_settings_app.c

@@ -50,18 +50,19 @@ PowerSettingsApp* power_settings_app_alloc(uint32_t first_scene, ViewDispatcherT
         PowerSettingsAppViewBatteryInfo,
         battery_info_get_view(app->battery_info));
     app->submenu = submenu_alloc();
-    app->variable_item_list = variable_item_list_alloc();
     view_dispatcher_add_view(
         app->view_dispatcher, PowerSettingsAppViewSubmenu, submenu_get_view(app->submenu));
-    app->dialog = dialog_ex_alloc();
-    view_dispatcher_add_view(
-        app->view_dispatcher, PowerSettingsAppViewDialog, dialog_ex_get_view(app->dialog));
+    app->variable_item_list = variable_item_list_alloc();
     view_dispatcher_add_view(
         app->view_dispatcher,
         PowerSettingsAppViewVariableItemList,
         variable_item_list_get_view(app->variable_item_list));
+    app->dialog = dialog_ex_alloc();
+    view_dispatcher_add_view(
+        app->view_dispatcher, PowerSettingsAppViewDialog, dialog_ex_get_view(app->dialog));
 
-    power_get_settings(app->power, &app->settings);
+    // get settings from service to app
+    power_api_get_settings(app->power, &app->settings);
 
     // Set first scene
     scene_manager_next_scene(app->scene_manager, first_scene);
@@ -70,7 +71,9 @@ PowerSettingsApp* power_settings_app_alloc(uint32_t first_scene, ViewDispatcherT
 
 void power_settings_app_free(PowerSettingsApp* app) {
     furi_assert(app);
-    power_set_settings(app->power, &app->settings);
+
+    // set settings from app to service
+    power_api_set_settings(app->power, &app->settings);
     // Views
     view_dispatcher_remove_view(app->view_dispatcher, PowerSettingsAppViewBatteryInfo);
     battery_info_free(app->battery_info);
@@ -78,12 +81,12 @@ void power_settings_app_free(PowerSettingsApp* app) {
     view_dispatcher_remove_view(app->view_dispatcher, PowerSettingsAppViewSubmenu);
     submenu_free(app->submenu);
 
-    view_dispatcher_remove_view(app->view_dispatcher, PowerSettingsAppViewDialog);
-    dialog_ex_free(app->dialog);
-
     view_dispatcher_remove_view(app->view_dispatcher, PowerSettingsAppViewVariableItemList);
     variable_item_list_free(app->variable_item_list);
 
+    view_dispatcher_remove_view(app->view_dispatcher, PowerSettingsAppViewDialog);
+    dialog_ex_free(app->dialog);
+
     // View dispatcher
     view_dispatcher_free(app->view_dispatcher);
     scene_manager_free(app->scene_manager);

applications/settings/power_settings_app/power_settings_app.h

@@ -11,23 +11,22 @@
 
 #include "views/battery_info.h"
 #include <gui/modules/submenu.h>
-#include <gui/modules/dialog_ex.h>
 #include <gui/modules/variable_item_list.h>
+#include <gui/modules/dialog_ex.h>
 
 #include "scenes/power_settings_scene.h"
 
 typedef struct {
     PowerSettings settings;
-
     Power* power;
     Gui* gui;
     SceneManager* scene_manager;
     ViewDispatcher* view_dispatcher;
     BatteryInfo* battery_info;
     Submenu* submenu;
-    VariableItemList* variable_item_list;
     DialogEx* dialog;
     PowerInfo info;
+    VariableItemList* variable_item_list;
 
     bool about_battery;
 } PowerSettingsApp;

applications/settings/power_settings_app/scenes/power_settings_scene_start.c

@@ -6,30 +6,47 @@ enum PowerSettingsSubmenuIndex {
     PowerSettingsSubmenuIndexBatteryInfo,
     PowerSettingsSubmenuIndexReboot,
     PowerSettingsSubmenuIndexOff,
-    PowerSettingsSubmenuShutdownIdle
+    PowerSettingsSubmenuIndexAutoPowerOff,
 };
 
-#define SHUTDOWN_IDLE_DELAY_COUNT 9
-const char* const shutdown_idle_delay_text[SHUTDOWN_IDLE_DELAY_COUNT] = {
+#define AUTO_POWEROFF_DELAY_COUNT 13
+const char* const auto_poweroff_delay_text[AUTO_POWEROFF_DELAY_COUNT] = {
     "OFF",
-    "15m",
-    "30m",
-    "1h",
+    "5min",
+    "10min",
+    "15min",
+    "30min",
+    "45min",
+    "60min",
+    "90min",
     "2h",
     "6h",
     "12h",
     "24h",
-    "48h",
-};
-const uint32_t shutdown_idle_delay_value[SHUTDOWN_IDLE_DELAY_COUNT] =
-    {0, 900000, 1800000, 3600000, 7200000, 21600000, 43200000, 86400000, 172800000};
+    "48h"};
 
-static void power_settings_scene_start_auto_lock_delay_changed(VariableItem* item) {
+const uint32_t auto_poweroff_delay_value[AUTO_POWEROFF_DELAY_COUNT] = {
+    0,
+    300000,
+    600000,
+    900000,
+    1800000,
+    2700000,
+    3600000,
+    5400000,
+    7200000,
+    21600000,
+    43200000,
+    86400000,
+    172800000};
+
+// change variable_item_list visible text and app_poweroff_delay_time_settings when user change item in variable_item_list
+static void power_settings_scene_start_auto_poweroff_delay_changed(VariableItem* item) {
     PowerSettingsApp* app = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
 
-    variable_item_set_current_value_text(item, shutdown_idle_delay_text[index]);
-    app->settings.shutdown_idle_delay_ms = shutdown_idle_delay_value[index];
+    variable_item_set_current_value_text(item, auto_poweroff_delay_text[index]);
+    app->settings.auto_poweroff_delay_ms = auto_poweroff_delay_value[index];
 }
 
 static void power_settings_scene_start_submenu_callback(void* context, uint32_t index) {
@@ -53,16 +70,17 @@ void power_settings_scene_start_on_enter(void* context) {
 
     item = variable_item_list_add(
         variable_item_list,
-        "Shutdown on Idle",
-        SHUTDOWN_IDLE_DELAY_COUNT,
-        power_settings_scene_start_auto_lock_delay_changed,
+        "Auto PowerOff",
+        AUTO_POWEROFF_DELAY_COUNT,
+        power_settings_scene_start_auto_poweroff_delay_changed, //function for change visible item list value and app settings
         app);
+
     value_index = value_index_uint32(
-        app->settings.shutdown_idle_delay_ms,
-        shutdown_idle_delay_value,
-        SHUTDOWN_IDLE_DELAY_COUNT);
+        app->settings.auto_poweroff_delay_ms,
+        auto_poweroff_delay_value,
+        AUTO_POWEROFF_DELAY_COUNT);
     variable_item_set_current_value_index(item, value_index);
-    variable_item_set_current_value_text(item, shutdown_idle_delay_text[value_index]);
+    variable_item_set_current_value_text(item, auto_poweroff_delay_text[value_index]);
 
     variable_item_list_set_selected_item(
         variable_item_list,
@@ -85,7 +103,6 @@ bool power_settings_scene_start_on_event(void* context, SceneManagerEvent event)
             scene_manager_next_scene(app->scene_manager, PowerSettingsAppSceneReboot);
         } else if(event.event == PowerSettingsSubmenuIndexOff) {
             scene_manager_next_scene(app->scene_manager, PowerSettingsAppScenePowerOff);
-        } else if(event.event == PowerSettingsSubmenuShutdownIdle) {
         }
         scene_manager_set_scene_state(app->scene_manager, PowerSettingsAppSceneStart, event.event);
         consumed = true;