Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-04-24 03:29:57 -07:00
Code Issues Packages Projects Releases Wiki Activity

Fix battery style setting + move to xfw app

Browse Source
This commit is contained in:
Willy-JL
2023-01-19 23:38:36 +00:00
parent 8bd17394e3
commit f373bfa52d
7 changed files with 199 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
applications/services/desktop/desktop_settings.h
View File

@@ -36,14 +36,6 @@
#define MIN_PIN_SIZE 4
#define MAX_APP_LENGTH 128
#define DISPLAY_BATTERY_NO 0
#define DISPLAY_BATTERY_BAR 1
#define DISPLAY_BATTERY_PERCENT 2
#define DISPLAY_BATTERY_INVERTED_PERCENT 3
#define DISPLAY_BATTERY_RETRO_3 4
#define DISPLAY_BATTERY_RETRO_5 5
#define DISPLAY_BATTERY_BAR_PERCENT 6
#define FAP_LOADER_APP_NAME "Applications"
typedef struct {
@@ -62,5 +54,4 @@ typedef struct {
PinCode pin_code;
uint8_t is_locked;
uint32_t auto_lock_delay_ms;
uint8_t displayBatteryPercentage;
} DesktopSettings;

333
applications/services/power/power_service/power.c
View File

@@ -1,193 +1,187 @@
#include "power_i.h"
#include "desktop/desktop_settings.h"
#include <furi.h>
#include <furi_hal.h>
#include "../../../settings/xtreme_settings/xtreme_settings.h"
#define POWER_OFF_TIMEOUT 90
void power_draw_battery_callback(Canvas* canvas, void* context) {
furi_assert(context);
Power* power = context;
if(power->displayBatteryPercentage == DISPLAY_BATTERY_NO) {
// no draw
} else {
BatteryStyle battery_style = XTREME_SETTINGS()->battery_style;
if(battery_style == BatteryStyleOff) return;
canvas_draw_icon(canvas, 0, 0, &I_Battery_25x8);
canvas_set_color(canvas, ColorWhite);
canvas_draw_box(canvas, -1, 0, 1, 8);
canvas_draw_box(canvas, 0, -1, 24, 1);
canvas_draw_box(canvas, 0, 8, 24, 1);
canvas_draw_box(canvas, 25, 1, 2, 6);
canvas_set_color(canvas, ColorBlack);
canvas_draw_box(canvas, 25, 2, 1, 4);
canvas_draw_icon(canvas, 0, 0, &I_Battery_25x8);
canvas_set_color(canvas, ColorWhite);
canvas_draw_box(canvas, -1, 0, 1, 8);
canvas_draw_box(canvas, 0, -1, 24, 1);
canvas_draw_box(canvas, 0, 8, 24, 1);
canvas_draw_box(canvas, 25, 1, 2, 6);
canvas_set_color(canvas, ColorBlack);
canvas_draw_box(canvas, 25, 2, 1, 4);
if(power->info.gauge_is_ok) {
char batteryPercentile[4];
snprintf(batteryPercentile, sizeof(batteryPercentile), "%d", power->info.charge);
if((power->displayBatteryPercentage == DISPLAY_BATTERY_PERCENT) &&
if(power->info.gauge_is_ok) {
char batteryPercentile[4];
snprintf(batteryPercentile, sizeof(batteryPercentile), "%d", power->info.charge);
if((battery_style == BatteryStylePercent) &&
(power->state !=
PowerStateCharging)) { //if display battery percentage, black background white text
canvas_set_font(canvas, FontBatteryPercent);
canvas_set_color(canvas, ColorBlack);
canvas_draw_box(canvas, 1, 1, 22, 6);
canvas_set_color(canvas, ColorWhite);
canvas_draw_str_aligned(canvas, 11, 4, AlignCenter, AlignCenter, batteryPercentile);
} else if(
(battery_style == BatteryStyleInvertedPercent) &&
(power->state !=
PowerStateCharging)) { //if display battery percentage, black background white text
canvas_set_font(canvas, FontBatteryPercent);
PowerStateCharging)) { //if display inverted percentage, white background black text
canvas_set_font(canvas, FontBatteryPercent);
canvas_set_color(canvas, ColorBlack);
canvas_draw_str_aligned(canvas, 11, 4, AlignCenter, AlignCenter, batteryPercentile);
} else if(
(battery_style == BatteryStyleRetro3) &&
(power->state != PowerStateCharging)) { //Retro style segmented display, 3 parts
if(power->info.charge > 25) {
canvas_draw_box(canvas, 2, 2, 6, 4);
}
if(power->info.charge > 50) {
canvas_draw_box(canvas, 9, 2, 6, 4);
}
if(power->info.charge > 75) {
canvas_draw_box(canvas, 16, 2, 6, 4);
}
} else if(
(battery_style == BatteryStyleRetro5) &&
(power->state != PowerStateCharging)) { //Retro style segmented display, 5 parts
if(power->info.charge > 10) {
canvas_draw_box(canvas, 2, 2, 3, 4);
}
if(power->info.charge > 30) {
canvas_draw_box(canvas, 6, 2, 3, 4);
}
if(power->info.charge > 50) {
canvas_draw_box(canvas, 10, 2, 3, 4);
}
if(power->info.charge > 70) {
canvas_draw_box(canvas, 14, 2, 3, 4);
}
if(power->info.charge > 90) {
canvas_draw_box(canvas, 18, 2, 3, 4);
}
} else if(
(battery_style == BatteryStyleBarPercent) &&
(power->state != PowerStateCharging) && // Default bar display with percentage
(power->info.voltage_battery_charging >=
4.2)) { // not looking nice with low voltage indicator
canvas_set_font(canvas, FontBatteryPercent);
// align charge dispaly value with digits to draw
uint8_t bar_charge = power->info.charge;
if(bar_charge > 23 && bar_charge < 38) {
bar_charge = 23;
} else if(bar_charge >= 38 && bar_charge < 62) {
bar_charge = 50;
} else if(bar_charge >= 62 && bar_charge < 74) {
bar_charge = 74;
}
canvas_set_color(canvas, ColorBlack);
canvas_draw_box(canvas, 1, 1, (bar_charge * 22) / 100, 6);
// drawing digits
if(bar_charge < 38) { // both digits are black
canvas_set_color(canvas, ColorBlack);
canvas_draw_str_aligned(
canvas, 11, 4, AlignCenter, AlignCenter, batteryPercentile);
} else if(bar_charge >= 38 && bar_charge < 74) { // first digit is white
canvas_set_color(canvas, ColorWhite);
// first
char batteryPercentileFirstDigit[2];
snprintf(
batteryPercentileFirstDigit,
sizeof(batteryPercentileFirstDigit),
"%c",
batteryPercentile[0]);
canvas_draw_str_aligned(
canvas, 9, 4, AlignCenter, AlignCenter, batteryPercentileFirstDigit);
// second
char batteryPercentileSecondDigit[2];
snprintf(
batteryPercentileSecondDigit,
sizeof(batteryPercentileSecondDigit),
"%c",
batteryPercentile[1]);
canvas_set_color(canvas, ColorBlack);
canvas_draw_str_aligned(
canvas, 15, 4, AlignCenter, AlignCenter, batteryPercentileSecondDigit);
} else { // charge >= 62, both digits are white
canvas_set_color(canvas, ColorWhite);
canvas_draw_str_aligned(
canvas, 11, 4, AlignCenter, AlignCenter, batteryPercentile);
}
} else { //default bar display, added here to serve as fallback/default behaviour.
canvas_draw_box(canvas, 2, 2, (power->info.charge + 4) / 5, 4);
}
// TODO: Verify if it displays correctly with custom battery skins !!!
if(power->info.voltage_battery_charging < 4.2) {
// Battery charging voltage is modified, indicate with cross pattern
canvas_invert_color(canvas);
uint8_t battery_bar_width = (power->info.charge + 4) / 5;
bool cross_odd = false;
// Start 1 further in from the battery bar's x position
for(uint8_t x = 3; x <= battery_bar_width; x++) {
// Cross pattern is from the center of the battery bar
// y = 2 + 1 (inset) + 1 (for every other)
canvas_draw_dot(canvas, x, 3 + (uint8_t)cross_odd);
cross_odd = !cross_odd;
}
canvas_invert_color(canvas);
}
if(power->state == PowerStateCharging) {
canvas_set_bitmap_mode(canvas, 1);
// TODO: replace -1 magic for uint8_t with re-framing
if(battery_style == BatteryStylePercent ||
battery_style == BatteryStyleBarPercent) {
canvas_set_color(canvas, ColorBlack);
canvas_draw_box(canvas, 1, 1, 22, 6);
canvas_draw_icon(canvas, 2, -1, &I_Charging_lightning_9x10);
canvas_set_color(canvas, ColorWhite);
canvas_draw_str_aligned(canvas, 11, 4, AlignCenter, AlignCenter, batteryPercentile);
} else if(
(power->displayBatteryPercentage == DISPLAY_BATTERY_INVERTED_PERCENT) &&
(power->state !=
PowerStateCharging)) { //if display inverted percentage, white background black text
canvas_draw_icon(canvas, 2, -1, &I_Charging_lightning_mask_9x10);
canvas_set_font(canvas, FontBatteryPercent);
canvas_draw_str_aligned(
canvas, 16, 4, AlignCenter, AlignCenter, batteryPercentile);
} else if(battery_style == BatteryStyleInvertedPercent) {
canvas_set_color(canvas, ColorWhite);
canvas_draw_box(canvas, 1, 1, 22, 6);
canvas_draw_icon(canvas, 2, -1, &I_Charging_lightning_9x10);
canvas_set_color(canvas, ColorBlack);
canvas_draw_str_aligned(canvas, 11, 4, AlignCenter, AlignCenter, batteryPercentile);
} else if(
(power->displayBatteryPercentage == DISPLAY_BATTERY_RETRO_3) &&
(power->state != PowerStateCharging)) { //Retro style segmented display, 3 parts
if(power->info.charge > 25) {
canvas_draw_box(canvas, 2, 2, 6, 4);
}
if(power->info.charge > 50) {
canvas_draw_box(canvas, 9, 2, 6, 4);
}
if(power->info.charge > 75) {
canvas_draw_box(canvas, 16, 2, 6, 4);
}
} else if(
(power->displayBatteryPercentage == DISPLAY_BATTERY_RETRO_5) &&
(power->state != PowerStateCharging)) { //Retro style segmented display, 5 parts
if(power->info.charge > 10) {
canvas_draw_box(canvas, 2, 2, 3, 4);
}
if(power->info.charge > 30) {
canvas_draw_box(canvas, 6, 2, 3, 4);
}
if(power->info.charge > 50) {
canvas_draw_box(canvas, 10, 2, 3, 4);
}
if(power->info.charge > 70) {
canvas_draw_box(canvas, 14, 2, 3, 4);
}
if(power->info.charge > 90) {
canvas_draw_box(canvas, 18, 2, 3, 4);
}
} else if(
(power->displayBatteryPercentage == DISPLAY_BATTERY_BAR_PERCENT) &&
(power->state != PowerStateCharging) && // Default bar display with percentage
(power->info.voltage_battery_charging >=
4.2)) { // not looking nice with low voltage indicator
canvas_draw_icon(canvas, 2, -1, &I_Charging_lightning_mask_9x10);
canvas_set_font(canvas, FontBatteryPercent);
// align charge dispaly value with digits to draw
uint8_t bar_charge = power->info.charge;
if(bar_charge > 23 && bar_charge < 38) {
bar_charge = 23;
} else if(bar_charge >= 38 && bar_charge < 62) {
bar_charge = 50;
} else if(bar_charge >= 62 && bar_charge < 74) {
bar_charge = 74;
}
canvas_draw_str_aligned(
canvas, 16, 4, AlignCenter, AlignCenter, batteryPercentile);
} else {
canvas_set_color(canvas, ColorWhite);
canvas_draw_icon(canvas, 8, -1, &I_Charging_lightning_mask_9x10);
canvas_set_color(canvas, ColorBlack);
canvas_draw_box(canvas, 1, 1, (bar_charge * 22) / 100, 6);
// drawing digits
if(bar_charge < 38) { // both digits are black
canvas_set_color(canvas, ColorBlack);
canvas_draw_str_aligned(
canvas, 11, 4, AlignCenter, AlignCenter, batteryPercentile);
} else if(bar_charge >= 38 && bar_charge < 74) { // first digit is white
canvas_set_color(canvas, ColorWhite);
// first
char batteryPercentileFirstDigit[2];
snprintf(
batteryPercentileFirstDigit,
sizeof(batteryPercentileFirstDigit),
"%c",
batteryPercentile[0]);
canvas_draw_str_aligned(
canvas, 9, 4, AlignCenter, AlignCenter, batteryPercentileFirstDigit);
// second
char batteryPercentileSecondDigit[2];
snprintf(
batteryPercentileSecondDigit,
sizeof(batteryPercentileSecondDigit),
"%c",
batteryPercentile[1]);
canvas_set_color(canvas, ColorBlack);
canvas_draw_str_aligned(
canvas, 15, 4, AlignCenter, AlignCenter, batteryPercentileSecondDigit);
} else { // charge >= 62, both digits are white
canvas_set_color(canvas, ColorWhite);
canvas_draw_str_aligned(
canvas, 11, 4, AlignCenter, AlignCenter, batteryPercentile);
}
} else { //default bar display, added here to serve as fallback/default behaviour.
canvas_draw_box(canvas, 2, 2, (power->info.charge + 4) / 5, 4);
canvas_draw_icon(canvas, 8, -1, &I_Charging_lightning_9x10);
}
// TODO: Verify if it displays correctly with custom battery skins !!!
if(power->info.voltage_battery_charging < 4.2) {
// Battery charging voltage is modified, indicate with cross pattern
canvas_invert_color(canvas);
uint8_t battery_bar_width = (power->info.charge + 4) / 5;
bool cross_odd = false;
// Start 1 further in from the battery bar's x position
for(uint8_t x = 3; x <= battery_bar_width; x++) {
// Cross pattern is from the center of the battery bar
// y = 2 + 1 (inset) + 1 (for every other)
canvas_draw_dot(canvas, x, 3 + (uint8_t)cross_odd);
cross_odd = !cross_odd;
}
canvas_invert_color(canvas);
}
if(power->state == PowerStateCharging) {
canvas_set_bitmap_mode(canvas, 1);
// TODO: replace -1 magic for uint8_t with re-framing
if(power->displayBatteryPercentage == DISPLAY_BATTERY_PERCENT ||
power->displayBatteryPercentage == DISPLAY_BATTERY_BAR_PERCENT) {
canvas_set_color(canvas, ColorBlack);
canvas_draw_box(canvas, 1, 1, 22, 6);
canvas_draw_icon(canvas, 2, -1, &I_Charging_lightning_9x10);
canvas_set_color(canvas, ColorWhite);
canvas_draw_icon(canvas, 2, -1, &I_Charging_lightning_mask_9x10);
canvas_set_font(canvas, FontBatteryPercent);
canvas_draw_str_aligned(
canvas, 16, 4, AlignCenter, AlignCenter, batteryPercentile);
} else if(power->displayBatteryPercentage == DISPLAY_BATTERY_INVERTED_PERCENT) {
canvas_set_color(canvas, ColorWhite);
canvas_draw_box(canvas, 1, 1, 22, 6);
canvas_draw_icon(canvas, 2, -1, &I_Charging_lightning_9x10);
canvas_set_color(canvas, ColorBlack);
canvas_draw_icon(canvas, 2, -1, &I_Charging_lightning_mask_9x10);
canvas_set_font(canvas, FontBatteryPercent);
canvas_draw_str_aligned(
canvas, 16, 4, AlignCenter, AlignCenter, batteryPercentile);
} else {
canvas_set_color(canvas, ColorWhite);
canvas_draw_icon(canvas, 8, -1, &I_Charging_lightning_mask_9x10);
canvas_set_color(canvas, ColorBlack);
canvas_draw_icon(canvas, 8, -1, &I_Charging_lightning_9x10);
}
canvas_set_bitmap_mode(canvas, 0);
}
} else {
canvas_draw_box(canvas, 8, 3, 8, 2);
canvas_set_bitmap_mode(canvas, 0);
}
} else {
canvas_draw_box(canvas, 8, 3, 8, 2);
}
}
static ViewPort* power_battery_view_port_alloc(Power* power) {
ViewPort* battery_view_port = view_port_alloc();
if(power->displayBatteryPercentage == DISPLAY_BATTERY_NO) {
// no draw
} else {
view_port_set_width(battery_view_port, icon_get_width(&I_Battery_25x8));
view_port_draw_callback_set(battery_view_port, power_draw_battery_callback, power);
gui_add_view_port(power->gui, battery_view_port, GuiLayerStatusBarRight);
}
view_port_set_width(battery_view_port, icon_get_width(&I_Battery_25x8));
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;
}
@@ -470,11 +464,6 @@ int32_t power_srv(void* p) {
power_update_info(power);
furi_record_create(RECORD_POWER, power);
DesktopSettings* settings = malloc(sizeof(DesktopSettings));
DESKTOP_SETTINGS_LOAD(settings);
power->displayBatteryPercentage = settings->displayBatteryPercentage;
free(settings);
while(1) {
// Update data from gauge and charger
bool need_refresh = power_update_info(power);
@@ -489,13 +478,7 @@ int32_t power_srv(void* p) {
power_check_battery_level_change(power);
// Update battery view port
if(need_refresh) {
DesktopSettings* settings = malloc(sizeof(DesktopSettings));
DESKTOP_SETTINGS_LOAD(settings);
power->displayBatteryPercentage = settings->displayBatteryPercentage;
free(settings);
view_port_update(power->battery_view_port);
}
if(need_refresh) view_port_update(power->battery_view_port);
// Check OTG status and disable it in case of fault
if(furi_hal_power_is_otg_enabled()) {

10
applications/services/power/power_service/power.h
View File

@@ -25,6 +25,16 @@ typedef enum {
PowerEventTypeBatteryLevelChanged,
} PowerEventType;
typedef enum {
BatteryStyleOff,
BatteryStyleBar,
BatteryStylePercent,
BatteryStyleInvertedPercent,
BatteryStyleRetro3,
BatteryStyleRetro5,
BatteryStyleBarPercent,
} BatteryStyle;
typedef union {
uint8_t battery_level;
} PowerEventData;

1
applications/services/power/power_service/power_i.h
View File

@@ -44,7 +44,6 @@ struct Power {
bool battery_low;
bool show_low_bat_level_message;
uint8_t displayBatteryPercentage;
uint8_t battery_level;
uint8_t power_off_timeout;

41
applications/settings/desktop_settings/scenes/desktop_settings_scene_start.c
View File

@@ -26,20 +26,6 @@ const char* const auto_lock_delay_text[AUTO_LOCK_DELAY_COUNT] = {
const uint32_t auto_lock_delay_value[AUTO_LOCK_DELAY_COUNT] =
{0, 10000, 15000, 30000, 60000, 90000, 120000, 300000, 600000};
#define BATTERY_VIEW_COUNT 7
const char* const battery_view_count_text[BATTERY_VIEW_COUNT] =
{"Off", "Bar", "%", "Inv. %", "Retro 3", "Retro 5", "Bar %"};
const uint32_t displayBatteryPercentage_value[BATTERY_VIEW_COUNT] = {
DISPLAY_BATTERY_NO,
DISPLAY_BATTERY_BAR,
DISPLAY_BATTERY_PERCENT,
DISPLAY_BATTERY_INVERTED_PERCENT,
DISPLAY_BATTERY_RETRO_3,
DISPLAY_BATTERY_RETRO_5,
DISPLAY_BATTERY_BAR_PERCENT};
uint8_t origBattDisp_value = 0;
static void desktop_settings_scene_start_var_list_enter_callback(void* context, uint32_t index) {
DesktopSettingsApp* app = context;
view_dispatcher_send_custom_event(app->view_dispatcher, index);
@@ -53,18 +39,9 @@ static void desktop_settings_scene_start_auto_lock_delay_changed(VariableItem* i
app->settings.auto_lock_delay_ms = auto_lock_delay_value[index];
}
static void desktop_settings_scene_start_battery_view_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, battery_view_count_text[index]);
app->settings.displayBatteryPercentage = index;
}
void desktop_settings_scene_start_on_enter(void* context) {
DesktopSettingsApp* app = context;
VariableItemList* variable_item_list = app->variable_item_list;
origBattDisp_value = app->settings.displayBatteryPercentage;
VariableItem* item;
uint8_t value_index;
@@ -89,20 +66,6 @@ void desktop_settings_scene_start_on_enter(void* context) {
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, auto_lock_delay_text[value_index]);
item = variable_item_list_add(
variable_item_list,
"Battery View",
BATTERY_VIEW_COUNT,
desktop_settings_scene_start_battery_view_changed,
app);
value_index = value_index_uint32(
app->settings.displayBatteryPercentage,
displayBatteryPercentage_value,
BATTERY_VIEW_COUNT);
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, battery_view_count_text[value_index]);
variable_item_list_set_enter_callback(
variable_item_list, desktop_settings_scene_start_var_list_enter_callback, app);
view_dispatcher_switch_to_view(app->view_dispatcher, DesktopSettingsAppViewVarItemList);
@@ -148,8 +111,4 @@ void desktop_settings_scene_start_on_exit(void* context) {
DesktopSettingsApp* app = context;
variable_item_list_reset(app->variable_item_list);
DESKTOP_SETTINGS_SAVE(&app->settings);
if(app->settings.displayBatteryPercentage != origBattDisp_value) {
furi_hal_power_reset();
}
}

31
applications/settings/xtreme_settings/scenes/xtreme_settings_scene_start.c
View File

@@ -31,10 +31,8 @@ const char* const cycle_anims_names[CYCLE_ANIMS_COUNT] = {
"12 H",
"24 H",
};
const int32_t cycle_anims_values[CYCLE_ANIMS_COUNT] =
{-1, 0, 30, 60, 300, 600, 900, 1800, 3600, 7200, 21600, 43200, 86400};
static void xtreme_settings_scene_start_cycle_anims_changed(VariableItem* item) {
uint8_t index = variable_item_get_current_value_index(item);
variable_item_set_current_value_text(item, cycle_anims_names[index]);
@@ -47,6 +45,24 @@ static void xtreme_settings_scene_start_unlock_anims_changed(VariableItem* item)
XTREME_SETTINGS()->unlock_anims = value;
}
#define BATTERY_STYLE_COUNT 7
const char* const battery_style_names[BATTERY_STYLE_COUNT] =
{"OFF", "Bar", "%", "Inv. %", "Retro 3", "Retro 5", "Bar %"};
const uint32_t battery_style_values[BATTERY_STYLE_COUNT] = {
BatteryStyleOff,
BatteryStyleBar,
BatteryStylePercent,
BatteryStyleInvertedPercent,
BatteryStyleRetro3,
BatteryStyleRetro5,
BatteryStyleBarPercent
};
static void xtreme_settings_scene_start_battery_style_changed(VariableItem* item) {
uint8_t index = variable_item_get_current_value_index(item);
variable_item_set_current_value_text(item, battery_style_names[index]);
XTREME_SETTINGS()->battery_style = battery_style_values[index];
}
static void xtreme_settings_scene_start_xp_level_changed(VariableItem* item) {
XtremeSettingsApp* app = variable_item_get_context(item);
app->dolphin_level = variable_item_get_current_value_index(item) + 1;
@@ -164,6 +180,17 @@ void xtreme_settings_scene_start_on_enter(void* context) {
variable_item_set_current_value_index(item, xtreme_settings->unlock_anims);
variable_item_set_current_value_text(item, xtreme_settings->unlock_anims ? "ON" : "OFF");
item = variable_item_list_add(
var_item_list,
"Battery Style",
BATTERY_STYLE_COUNT,
xtreme_settings_scene_start_battery_style_changed,
app);
value_index = value_index_uint32(
xtreme_settings->battery_style, battery_style_values, BATTERY_STYLE_COUNT);
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, battery_style_names[value_index]);
char level_str[4];
snprintf(level_str, 4, "%i", app->dolphin_level);
item = variable_item_list_add(

2
applications/settings/xtreme_settings/xtreme_settings.h
View File

@@ -7,6 +7,7 @@
#include <stdbool.h>
#include <toolbox/saved_struct.h>
#include <storage/storage.h>
#include <power/power_service/power.h>
#define MAX_PACK_NAME_LEN 32
@@ -19,6 +20,7 @@ typedef struct {
bool unlock_anims;
bool sfw_mode;
char asset_pack[MAX_PACK_NAME_LEN];
BatteryStyle battery_style;
} XtremeSettings;
XtremeSettings* XTREME_SETTINGS();