Merge remote-tracking branch 'upstream/dev' into custom

derskythe · derskythe · commit f0949c964cda · 2024-08-21T09:04:59.000+04:00
# Conflicts:
#	applications/main/subghz/scenes/subghz_scene_rpc.c
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -13,7 +13,13 @@
 * OFW: iButton ID writing (Enable ID writing for ds1971 and ds1996)
 * Apps: **Check out more Apps updates and fixes by following** [this link](https://github.com/xMasterX/all-the-plugins/commits/dev)
 ## Other changes
+* Archive: Fix BadUSB favourite path check
+* Settings: Show free flash amount in internal storage info (by @Willy-JL)
 * Misc: Fix typo in comment in QueueTools.py (by @eltociear | PR #785)
+* OFW PR 3840: GUI: NumberInput small improvements (by @Willy-JL)
+* OFW PR 3838: SubGhz: Fix RPC status for ButtonRelease event (by @Skorpionm)
+* OFW: scripts: improved size validator for updater image
+* OFW: Desktop: seaprate callbacks for dolphin and storage subscriptions
 * OFW: Make file extensions case-insensitive
 * OFW: Remove internal storage folder if corresponding flag set
 * OFW: **Added a text input that only accepts full numbers (int)**
diff --git a/applications/main/archive/helpers/archive_files.c b/applications/main/archive/helpers/archive_files.c
@@ -17,8 +17,8 @@ void archive_set_file_type(ArchiveFile_t* file, const char* path, bool is_folder
             if((known_ext[i][0] == '?') || (known_ext[i][0] == '*')) continue;
             if(furi_string_end_withi(file->path, known_ext[i])) {
                 if((i == ArchiveFileTypeBadUsb) || (i == ArchiveFileTypeSubGhzRemote)) {
-                    if(furi_string_search(
-                           file->path, archive_get_default_path(ArchiveTabBadUsb)) == 0) {
+                    if((furi_string_search(file->path, EXT_PATH("badusb")) == 0) ||
+                       (furi_string_search(file->path, ANY_PATH("badusb")) == 0)) {
                         file->type = ArchiveFileTypeBadUsb;
                         return; // *.txt file is a BadUSB script only if it is in BadUSB folder
                     }
diff --git a/applications/main/subghz/scenes/subghz_scene_rpc.c b/applications/main/subghz/scenes/subghz_scene_rpc.c
@@ -59,6 +59,8 @@ bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {
                 default: //if(SubGhzTxRxStartTxStateOk)
                     result = true;
                     subghz_blink_start(subghz);
+                    scene_manager_set_scene_state(
+                        subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateTx);
                     break;
                 }
             }
@@ -70,6 +72,8 @@ bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {
                 subghz_blink_stop(subghz);
                 result = true;
             }
+            scene_manager_set_scene_state(
+                subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateIdle);
             rpc_system_app_confirm(subghz->rpc_ctx, result);
         } else if(event.event == SubGhzCustomEventSceneRpcLoad) {
             bool result = false;
diff --git a/applications/services/desktop/animations/animation_manager.c b/applications/services/desktop/animations/animation_manager.c
@@ -104,7 +104,7 @@ void animation_manager_set_dummy_mode_state(AnimationManager* animation_manager,
     }
 }
 
-static void animation_manager_check_blocking_callback(const void* message, void* context) {
+static void animation_manager_storage_callback(const void* message, void* context) {
     const StorageEvent* storage_event = message;
 
     switch(storage_event->type) {
@@ -123,6 +123,22 @@ static void animation_manager_check_blocking_callback(const void* message, void*
     }
 }
 
+static void animation_manager_dolphin_callback(const void* message, void* context) {
+    const DolphinPubsubEvent* dolphin_event = message;
+
+    switch(*dolphin_event) {
+    case DolphinPubsubEventUpdate:
+        furi_assert(context);
+        AnimationManager* animation_manager = context;
+        if(animation_manager->check_blocking_callback) {
+            animation_manager->check_blocking_callback(animation_manager->context);
+        }
+        break;
+    default:
+        break;
+    }
+}
+
 static void animation_manager_timer_callback(void* context) {
     furi_assert(context);
     AnimationManager* animation_manager = context;
@@ -300,12 +316,12 @@ AnimationManager* animation_manager_alloc(void) {
 
     Storage* storage = furi_record_open(RECORD_STORAGE);
     animation_manager->pubsub_subscription_storage = furi_pubsub_subscribe(
-        storage_get_pubsub(storage), animation_manager_check_blocking_callback, animation_manager);
+        storage_get_pubsub(storage), animation_manager_storage_callback, animation_manager);
     furi_record_close(RECORD_STORAGE);
 
     Dolphin* dolphin = furi_record_open(RECORD_DOLPHIN);
     animation_manager->pubsub_subscription_dolphin = furi_pubsub_subscribe(
-        dolphin_get_pubsub(dolphin), animation_manager_check_blocking_callback, animation_manager);
+        dolphin_get_pubsub(dolphin), animation_manager_dolphin_callback, animation_manager);
     furi_record_close(RECORD_DOLPHIN);
 
     animation_manager->blocking_shown_sd_ok = true;
diff --git a/applications/services/dolphin/dolphin.c b/applications/services/dolphin/dolphin.c
@@ -204,8 +204,8 @@ static bool dolphin_process_event(FuriEventLoopObject* object, void* context) {
     if(event.type == DolphinEventTypeDeed) {
         dolphin_state_on_deed(dolphin->state, event.deed);
 
-        DolphinPubsubEvent event = DolphinPubsubEventUpdate;
-        furi_pubsub_publish(dolphin->pubsub, &event);
+        DolphinPubsubEvent pubsub_event = DolphinPubsubEventUpdate;
+        furi_pubsub_publish(dolphin->pubsub, &pubsub_event);
         furi_event_loop_timer_start(dolphin->butthurt_timer, BUTTHURT_INCREASE_PERIOD_TICKS);
         furi_event_loop_timer_start(dolphin->flush_timer, FLUSH_TIMEOUT_TICKS);
 
diff --git a/applications/services/gui/modules/number_input.c b/applications/services/gui/modules/number_input.c
@@ -93,7 +93,7 @@ static void number_input_draw_input(Canvas* canvas, NumberInputModel* model) {
     const size_t text_x = 8;
     const size_t text_y = 25;
 
-    elements_slightly_rounded_frame(canvas, 6, 14, 116, 15);
+    elements_slightly_rounded_frame(canvas, 4, 14, 120, 15);
 
     canvas_draw_str(canvas, text_x, text_y, furi_string_get_cstr(model->text_buffer));
 }
@@ -206,7 +206,7 @@ static void number_input_add_digit(NumberInputModel* model, char* newChar) {
     }
     model->current_number = strtol(furi_string_get_cstr(model->text_buffer), NULL, 10);
     if(model->current_number == 0) {
-        furi_string_reset(model->text_buffer);
+        furi_string_set(model->text_buffer, "0");
     }
 }
 
@@ -417,7 +417,9 @@ void number_input_set_result_callback(
     int32_t max_value) {
     furi_check(number_input);
 
-    current_number = CLAMP(current_number, max_value, min_value);
+    if(current_number != 0) {
+        current_number = CLAMP(current_number, max_value, min_value);
+    }
 
     with_view_model(
         number_input->view,
@@ -426,7 +428,11 @@ void number_input_set_result_callback(
             model->callback = callback;
             model->callback_context = callback_context;
             model->current_number = current_number;
-            furi_string_printf(model->text_buffer, "%ld", current_number);
+            if(current_number != 0) {
+                furi_string_printf(model->text_buffer, "%ld", current_number);
+            } else {
+                furi_string_set(model->text_buffer, "");
+            }
             model->min_value = min_value;
             model->max_value = max_value;
         },
diff --git a/applications/settings/storage_settings/scenes/storage_settings_scene_internal_info.c b/applications/settings/storage_settings/scenes/storage_settings_scene_internal_info.c
@@ -1,5 +1,6 @@
 #include "../storage_settings.h"
 #include <furi_hal_version.h>
+#include <furi_hal_flash.h>
 
 static void
     storage_settings_scene_internal_info_dialog_callback(DialogExResult result, void* context) {
@@ -27,10 +28,20 @@ void storage_settings_scene_internal_info_on_enter(void* context) {
     } else {
         furi_string_printf(
             app->text_string,
-            "Name: %s\nType: Virtual\nTotal: %lu KiB\nFree: %lu KiB",
+            "Name: %s\nType: Virtual (/.int on SD)\nTotal: %lu KiB\nFree: %lu KiB\n",
             furi_hal_version_get_name_ptr() ? furi_hal_version_get_name_ptr() : "Unknown",
             (uint32_t)(total_space / 1024),
             (uint32_t)(free_space / 1024));
+
+        uint32_t free_flash =
+            furi_hal_flash_get_free_end_address() - furi_hal_flash_get_free_start_address();
+        if(free_flash < 1024) {
+            furi_string_cat_printf(app->text_string, "Flash: %lu B free", free_flash);
+        } else {
+            furi_string_cat_printf(
+                app->text_string, "Flash: %.2f KiB free", (double)free_flash / 1024);
+        }
+
         dialog_ex_set_text(
             dialog_ex, furi_string_get_cstr(app->text_string), 4, 4, AlignLeft, AlignTop);
     }
diff --git a/scripts/imglint.py b/scripts/imglint.py
@@ -4,7 +4,7 @@
 from pathlib import Path
 
 from flipper.app import App
-from PIL import Image, ImageOps
+from PIL import Image
 
 _logger = logging.getLogger(__name__)
 
diff --git a/scripts/update.py b/scripts/update.py
@@ -1,14 +1,12 @@
 #!/usr/bin/env python3
 
-import io
 import math
 import os
 import shutil
 import tarfile
 import zlib
 from os.path import exists, join
 
-import heatshrink2
 from flipper.app import App
 from flipper.assets.coprobin import CoproBinary, get_stack_type
 from flipper.assets.heatshrink_stream import HeatshrinkDataStreamHeader
@@ -35,7 +33,12 @@ class Main(App):
     )
 
     FLASH_BASE = 0x8000000
-    MIN_LFS_PAGES = 6
+    FLASH_PAGE_SIZE = 4 * 1024
+    MIN_GAP_PAGES = 2
+
+    # Update stage file larger than that is not loadable without fix
+    # https://github.com/flipperdevices/flipperzero-firmware/pull/3676
+    UPDATER_SIZE_THRESHOLD = 128 * 1024
 
     HEATSHRINK_WINDOW_SIZE = 13
     HEATSHRINK_LOOKAHEAD_SIZE = 6
@@ -117,7 +120,7 @@ def generate(self):
                 self.logger.error(
                     f"You are trying to bundle a non-standard stack type '{self.args.radiotype}'."
                 )
-                self.disclaimer()
+                self.show_disclaimer()
                 return 1
 
             if radio_addr == 0:
@@ -130,7 +133,9 @@ def generate(self):
         if not exists(self.args.directory):
             os.makedirs(self.args.directory)
 
+        updater_stage_size = os.stat(self.args.stage).st_size
         shutil.copyfile(self.args.stage, join(self.args.directory, stage_basename))
+
         dfu_size = 0
         if self.args.dfu:
             dfu_size = os.stat(self.args.dfu).st_size
@@ -146,10 +151,10 @@ def generate(self):
             ):
                 return 3
 
-        if not self.layout_check(dfu_size, radio_addr):
+        if not self.layout_check(updater_stage_size, dfu_size, radio_addr):
             self.logger.warn("Memory layout looks suspicious")
-            if not self.args.disclaimer == "yes":
-                self.disclaimer()
+            if self.args.disclaimer != "yes":
+                self.show_disclaimer()
                 return 2
 
         if self.args.splash:
@@ -198,22 +203,33 @@ def generate(self):
 
         return 0
 
-    def layout_check(self, fw_size, radio_addr):
+    def layout_check(self, stage_size, fw_size, radio_addr):
+        if stage_size > self.UPDATER_SIZE_THRESHOLD:
+            self.logger.warn(
+                f"Updater size {stage_size}b > {self.UPDATER_SIZE_THRESHOLD}b and is not loadable on older firmwares!"
+            )
+
         if fw_size == 0 or radio_addr == 0:
             self.logger.info("Cannot validate layout for partial package")
             return True
 
-        lfs_span = radio_addr - self.FLASH_BASE - fw_size
-        self.logger.debug(f"Expected LFS size: {lfs_span}")
-        lfs_span_pages = lfs_span / (4 * 1024)
-        if lfs_span_pages < self.MIN_LFS_PAGES:
+        fw2stack_gap = radio_addr - self.FLASH_BASE - fw_size
+        self.logger.debug(f"Expected reserved space size: {fw2stack_gap}")
+        fw2stack_gap_pages = fw2stack_gap / self.FLASH_PAGE_SIZE
+        if fw2stack_gap_pages < 0:
+            self.logger.warn(
+                f"Firmware image overlaps C2 region and is not programmable!"
+            )
+            return False
+
+        elif fw2stack_gap_pages < self.MIN_GAP_PAGES:
             self.logger.warn(
-                f"Expected LFS size is too small (~{int(lfs_span_pages)} pages)"
+                f"Expected reserved flash size is too small (~{int(fw2stack_gap_pages)} page(s), need >={self.MIN_GAP_PAGES} page(s))"
             )
             return False
         return True
 
-    def disclaimer(self):
+    def show_disclaimer(self):
         self.logger.error(
             "You might brick your device into a state in which you'd need an SWD programmer to fix it."
         )

Original file line number	Diff line number	Diff line change
`@@ -59,6 +59,8 @@ bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {`
`59`	`59`	`default: //if(SubGhzTxRxStartTxStateOk)`
`60`	`60`	`result = true;`
`61`	`61`	`subghz_blink_start(subghz);`
	`62`	`+ scene_manager_set_scene_state(`
	`63`	`+ subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateTx);`
`62`	`64`	`break;`
`63`	`65`	`}`
`64`	`66`	`}`
`@@ -70,6 +72,8 @@ bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {`
`70`	`72`	`subghz_blink_stop(subghz);`
`71`	`73`	`result = true;`
`72`	`74`	`}`
	`75`	`+ scene_manager_set_scene_state(`
	`76`	`+ subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateIdle);`
`73`	`77`	`rpc_system_app_confirm(subghz->rpc_ctx, result);`
`74`	`78`	`} else if(event.event == SubGhzCustomEventSceneRpcLoad) {`
`75`	`79`	`bool result = false;`