make loading subghz file from favourites a bit faster

applications/main/subghz/scenes/subghz_scene_read_raw.c

@@ -134,12 +134,22 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneNeedSaving);
             } else {
                 //Restore default setting
+                if(subghz->raw_send_only) {
                     subghz_preset_init(
                         subghz,
-                    subghz_setting_get_preset_name(subghz->setting, subghz->last_settings->preset),
+                        "AM650",
+                        subghz_setting_get_default_frequency(subghz->setting),
+                        NULL,
+                        0);
+                } else {
+                    subghz_preset_init(
+                        subghz,
+                        subghz_setting_get_preset_name(
+                            subghz->setting, subghz->last_settings->preset),
                         subghz->last_settings->frequency,
                         NULL,
                         0);
+                }
                 if(!scene_manager_search_and_switch_to_previous_scene(
                        subghz->scene_manager, SubGhzSceneSaved)) {
                     if(!scene_manager_search_and_switch_to_previous_scene(

applications/main/subghz/subghz.c

@@ -61,7 +61,7 @@ void subghz_blink_stop(SubGhz* instance) {
     notification_message(instance->notifications, &sequence_blink_stop);
 }
 
-SubGhz* subghz_alloc() {
+SubGhz* subghz_alloc(bool alloc_for_tx_only) {
     SubGhz* subghz = malloc(sizeof(SubGhz));
 
     string_init(subghz->file_path);
@@ -88,6 +88,7 @@ SubGhz* subghz_alloc() {
     // Open Notification record
     subghz->notifications = furi_record_open(RECORD_NOTIFICATION);
 
+    if(!alloc_for_tx_only) {
         // SubMenu
         subghz->submenu = submenu_alloc();
         view_dispatcher_add_view(
@@ -99,27 +100,31 @@ SubGhz* subghz_alloc() {
             subghz->view_dispatcher,
             SubGhzViewIdReceiver,
             subghz_view_receiver_get_view(subghz->subghz_receiver));
-
+    }
     // Popup
     subghz->popup = popup_alloc();
     view_dispatcher_add_view(
         subghz->view_dispatcher, SubGhzViewIdPopup, popup_get_view(subghz->popup));
-
+    if(!alloc_for_tx_only) {
         // Text Input
         subghz->text_input = text_input_alloc();
         view_dispatcher_add_view(
-        subghz->view_dispatcher, SubGhzViewIdTextInput, text_input_get_view(subghz->text_input));
+            subghz->view_dispatcher,
+            SubGhzViewIdTextInput,
+            text_input_get_view(subghz->text_input));
 
         // Byte Input
         subghz->byte_input = byte_input_alloc();
         view_dispatcher_add_view(
-        subghz->view_dispatcher, SubGhzViewIdByteInput, byte_input_get_view(subghz->byte_input));
+            subghz->view_dispatcher,
+            SubGhzViewIdByteInput,
+            byte_input_get_view(subghz->byte_input));
 
         // Custom Widget
         subghz->widget = widget_alloc();
         view_dispatcher_add_view(
             subghz->view_dispatcher, SubGhzViewIdWidget, widget_get_view(subghz->widget));
-
+    }
     //Dialog
     subghz->dialogs = furi_record_open(RECORD_DIALOGS);
 
@@ -129,7 +134,7 @@ SubGhz* subghz_alloc() {
         subghz->view_dispatcher,
         SubGhzViewIdTransmitter,
         subghz_view_transmitter_get_view(subghz->subghz_transmitter));
-
+    if(!alloc_for_tx_only) {
         // Variable Item List
         subghz->variable_item_list = variable_item_list_alloc();
         view_dispatcher_add_view(
@@ -143,9 +148,9 @@ SubGhz* subghz_alloc() {
             subghz->view_dispatcher,
             SubGhzViewIdFrequencyAnalyzer,
             subghz_frequency_analyzer_get_view(subghz->subghz_frequency_analyzer));
-
+    }
     // Read RAW
-    subghz->subghz_read_raw = subghz_read_raw_alloc();
+    subghz->subghz_read_raw = subghz_read_raw_alloc(alloc_for_tx_only);
     view_dispatcher_add_view(
         subghz->view_dispatcher,
         SubGhzViewIdReadRAW,
@@ -176,9 +181,14 @@ SubGhz* subghz_alloc() {
 
     //init setting
     subghz->setting = subghz_setting_alloc();
-    subghz_setting_load(subghz->setting, EXT_PATH("subghz/assets/setting_user"));
+    if(alloc_for_tx_only) {
+        subghz_setting_load(subghz->setting, EXT_PATH("subghz/assets/setting_user"), false);
+    } else {
+        subghz_setting_load(subghz->setting, EXT_PATH("subghz/assets/setting_user"), true);
+    }
 
     // Load last used values for Read, Read RAW, etc. or default
+    if(!alloc_for_tx_only) {
         subghz->last_settings = subghz_last_settings_alloc();
         subghz_last_settings_load(
             subghz->last_settings, subghz_setting_get_preset_count(subghz->setting));
@@ -190,24 +200,32 @@ SubGhz* subghz_alloc() {
             subghz->last_settings->preset);
 #endif
         subghz_setting_set_default_frequency(subghz->setting, subghz->last_settings->frequency);
-
+    }
     //init Worker & Protocol & History & KeyBoard
     subghz->lock = SubGhzLockOff;
     subghz->txrx = malloc(sizeof(SubGhzTxRx));
     subghz->txrx->preset = malloc(sizeof(SubGhzPresetDefinition));
     string_init(subghz->txrx->preset->name);
+    if(!alloc_for_tx_only) {
         subghz_preset_init(
             subghz,
             subghz_setting_get_preset_name(subghz->setting, subghz->last_settings->preset),
             subghz->last_settings->frequency,
             NULL,
             0);
-
+    } else {
+        subghz_preset_init(
+            subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
+    }
     subghz->txrx->txrx_state = SubGhzTxRxStateSleep;
     subghz->txrx->hopper_state = SubGhzHopperStateOFF;
     subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
+    if(!alloc_for_tx_only) {
         subghz->txrx->history = subghz_history_alloc();
+    }
+    if(!alloc_for_tx_only) {
         subghz->txrx->worker = subghz_worker_alloc();
+    }
     subghz->txrx->fff_data = flipper_format_string_alloc();
     subghz->txrx->secure_data = malloc(sizeof(SecureData));
 
@@ -216,14 +234,17 @@ SubGhz* subghz_alloc() {
         subghz->txrx->environment, EXT_PATH("subghz/assets/came_atomo"));
     subghz_environment_set_nice_flor_s_rainbow_table_file_name(
         subghz->txrx->environment, EXT_PATH("subghz/assets/nice_flor_s"));
+
     subghz->txrx->receiver = subghz_receiver_alloc_init(subghz->txrx->environment);
     subghz_receiver_set_filter(subghz->txrx->receiver, SubGhzProtocolFlag_Decodable);
 
+    if(!alloc_for_tx_only) {
         subghz_worker_set_overrun_callback(
             subghz->txrx->worker, (SubGhzWorkerOverrunCallback)subghz_receiver_reset);
         subghz_worker_set_pair_callback(
             subghz->txrx->worker, (SubGhzWorkerPairCallback)subghz_receiver_decode);
         subghz_worker_set_context(subghz->txrx->worker, subghz->txrx->receiver);
+    }
 
     //Init Error_str
     string_init(subghz->error_str);
@@ -231,7 +252,7 @@ SubGhz* subghz_alloc() {
     return subghz;
 }
 
-void subghz_free(SubGhz* subghz) {
+void subghz_free(SubGhz* subghz, bool alloc_for_tx_only) {
     furi_assert(subghz);
 
     if(subghz->rpc_ctx) {
@@ -254,6 +275,8 @@ void subghz_free(SubGhz* subghz) {
     view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdStatic);
     subghz_test_static_free(subghz->subghz_test_static);
 #endif
+
+    if(!alloc_for_tx_only) {
         // Receiver
         view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdReceiver);
         subghz_view_receiver_free(subghz->subghz_receiver);
@@ -269,14 +292,14 @@ void subghz_free(SubGhz* subghz) {
         // Custom Widget
         view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdWidget);
         widget_free(subghz->widget);
-
+    }
     //Dialog
     furi_record_close(RECORD_DIALOGS);
 
     // Transmitter
     view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdTransmitter);
     subghz_view_transmitter_free(subghz->subghz_transmitter);
-
+    if(!alloc_for_tx_only) {
         // Variable Item List
         view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdVariableItemList);
         variable_item_list_free(subghz->variable_item_list);
@@ -284,15 +307,15 @@ void subghz_free(SubGhz* subghz) {
         // Frequency Analyzer
         view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdFrequencyAnalyzer);
         subghz_frequency_analyzer_free(subghz->subghz_frequency_analyzer);
-
+    }
     // Read RAW
     view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdReadRAW);
     subghz_read_raw_free(subghz->subghz_read_raw);
-
+    if(!alloc_for_tx_only) {
         // Submenu
         view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdMenu);
         submenu_free(subghz->submenu);
-
+    }
     // Popup
     view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdPopup);
     popup_free(subghz->popup);
@@ -309,14 +332,21 @@ void subghz_free(SubGhz* subghz) {
 
     //setting
     subghz_setting_free(subghz->setting);
+    if(!alloc_for_tx_only) {
         subghz_last_settings_free(subghz->last_settings);
-
+    }
     //Worker & Protocol & History
+
     subghz_receiver_free(subghz->txrx->receiver);
+
     subghz_environment_free(subghz->txrx->environment);
+    if(!alloc_for_tx_only) {
         subghz_worker_free(subghz->txrx->worker);
+    }
     flipper_format_free(subghz->txrx->fff_data);
+    if(!alloc_for_tx_only) {
         subghz_history_free(subghz->txrx->history);
+    }
     string_clear(subghz->txrx->preset->name);
     free(subghz->txrx->preset);
     free(subghz->txrx->secure_data);
@@ -338,7 +368,20 @@ void subghz_free(SubGhz* subghz) {
 }
 
 int32_t subghz_app(void* p) {
-    SubGhz* subghz = subghz_alloc();
+    bool alloc_for_tx;
+    if(p && strlen(p)) {
+        alloc_for_tx = true;
+    } else {
+        alloc_for_tx = false;
+    }
+
+    SubGhz* subghz = subghz_alloc(alloc_for_tx);
+
+    if(alloc_for_tx) {
+        subghz->raw_send_only = true;
+    } else {
+        subghz->raw_send_only = false;
+    }
 
     //Load database
     bool load_database = subghz_environment_load_keystore(
@@ -397,7 +440,7 @@ int32_t subghz_app(void* p) {
 
     furi_hal_power_suppress_charge_exit();
 
-    subghz_free(subghz);
+    subghz_free(subghz, alloc_for_tx);
 
     return 0;
 }

applications/main/subghz/subghz_i.h

@@ -97,6 +97,7 @@ struct SubGhz {
 
     SubGhzFrequencyAnalyzer* subghz_frequency_analyzer;
     SubGhzReadRAW* subghz_read_raw;
+    bool raw_send_only;
 #if FURI_DEBUG
     SubGhzTestStatic* subghz_test_static;
     SubGhzTestCarrier* subghz_test_carrier;

applications/main/subghz/subghz_setting.c

@@ -181,7 +181,7 @@ void subghz_setting_load_default(SubGhzSetting* instance) {
         instance, subghz_frequency_list, subghz_hopper_frequency_list);
 }
 
-void subghz_setting_load(SubGhzSetting* instance, const char* file_path) {
+void subghz_setting_load(SubGhzSetting* instance, const char* file_path, bool not_skip_frequencies) {
     furi_assert(instance);
 
     Storage* storage = furi_record_open(RECORD_STORAGE);
@@ -214,6 +214,7 @@ void subghz_setting_load(SubGhzSetting* instance, const char* file_path) {
             }
 
             // Standard frequencies (optional)
+            if(not_skip_frequencies) {
                 temp_bool = true;
                 flipper_format_read_bool(fff_data_file, "Add_standard_frequencies", &temp_bool, 1);
                 if(!temp_bool) {
@@ -259,9 +260,11 @@ void subghz_setting_load(SubGhzSetting* instance, const char* file_path) {
                     FURI_LOG_E(TAG, "Rewind error");
                     break;
                 }
-            if(flipper_format_read_uint32(fff_data_file, "Default_frequency", &temp_data32, 1)) {
+                if(flipper_format_read_uint32(
+                       fff_data_file, "Default_frequency", &temp_data32, 1)) {
                     subghz_setting_set_default_frequency(instance, temp_data32);
                 }
+            }
 
             // custom preset (optional)
             if(!flipper_format_rewind(fff_data_file)) {

applications/main/subghz/subghz_setting.h

@@ -14,7 +14,7 @@ SubGhzSetting* subghz_setting_alloc(void);
 
 void subghz_setting_free(SubGhzSetting* instance);
 
-void subghz_setting_load(SubGhzSetting* instance, const char* file_path);
+void subghz_setting_load(SubGhzSetting* instance, const char* file_path, bool not_skip_frequencies);
 
 size_t subghz_setting_get_frequency_count(SubGhzSetting* instance);
 

applications/main/subghz/views/subghz_read_raw.c

@@ -27,6 +27,7 @@ typedef struct {
     uint8_t ind_write;
     uint8_t ind_sin;
     SubGhzReadRAWStatus status;
+    bool raw_send_only;
 } SubGhzReadRAWModel;
 
 void subghz_read_raw_set_callback(
@@ -232,9 +233,11 @@ void subghz_read_raw_draw(Canvas* canvas, SubGhzReadRAWModel* model) {
         elements_button_right(canvas, "Save");
         break;
     case SubGhzReadRAWStatusLoadKeyIDLE:
+        if(!model->raw_send_only) {
             elements_button_left(canvas, "New");
-        elements_button_center(canvas, "Send");
             elements_button_right(canvas, "More");
+        }
+        elements_button_center(canvas, "Send");
         elements_text_box(
             canvas,
             4,
@@ -362,6 +365,7 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
     } else if(event->key == InputKeyLeft && event->type == InputTypeShort) {
         with_view_model(
             instance->view, (SubGhzReadRAWModel * model) {
+                if(!model->raw_send_only) {
                     if(model->status == SubGhzReadRAWStatusStart) {
                         //Config
                         instance->callback(SubGhzCustomEventViewReadRAWConfig, instance->context);
@@ -376,11 +380,13 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
                         string_reset(model->file_name);
                         instance->callback(SubGhzCustomEventViewReadRAWErase, instance->context);
                     }
+                }
                 return true;
             });
     } else if(event->key == InputKeyRight && event->type == InputTypeShort) {
         with_view_model(
             instance->view, (SubGhzReadRAWModel * model) {
+                if(!model->raw_send_only) {
                     if(model->status == SubGhzReadRAWStatusIDLE) {
                         //Save
                         instance->callback(SubGhzCustomEventViewReadRAWSave, instance->context);
@@ -388,6 +394,7 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
                         //More
                         instance->callback(SubGhzCustomEventViewReadRAWMore, instance->context);
                     }
+                }
                 return true;
             });
     } else if(event->key == InputKeyOk && event->type == InputTypeShort) {
@@ -487,7 +494,7 @@ void subghz_read_raw_exit(void* context) {
         });
 }
 
-SubGhzReadRAW* subghz_read_raw_alloc() {
+SubGhzReadRAW* subghz_read_raw_alloc(bool raw_send_only) {
     SubGhzReadRAW* instance = malloc(sizeof(SubGhzReadRAW));
 
     // View allocation and configuration
@@ -505,6 +512,7 @@ SubGhzReadRAW* subghz_read_raw_alloc() {
             string_init(model->preset_str);
             string_init(model->sample_write);
             string_init(model->file_name);
+            model->raw_send_only = raw_send_only;
             model->rssi_history = malloc(SUBGHZ_READ_RAW_RSSI_HISTORY_SIZE * sizeof(uint8_t));
             return true;
         });

applications/main/subghz/views/subghz_read_raw.h

@@ -25,7 +25,7 @@ void subghz_read_raw_set_callback(
     SubGhzReadRAWCallback callback,
     void* context);
 
-SubGhzReadRAW* subghz_read_raw_alloc();
+SubGhzReadRAW* subghz_read_raw_alloc(bool raw_send_only);
 
 void subghz_read_raw_free(SubGhzReadRAW* subghz_static);
 

applications/main/unirfremix/unirfremix_app.c

@@ -827,7 +827,7 @@ static void input_callback(InputEvent* input_event, void* ctx) {
 void unirfremix_subghz_alloc(UniRFRemix* app) {
     // load subghz presets
     app->setting = subghz_setting_alloc();
-    subghz_setting_load(app->setting, EXT_PATH("subghz/assets/setting_user"));
+    subghz_setting_load(app->setting, EXT_PATH("subghz/assets/setting_user"), false);
 
     // load mfcodes
     app->environment = subghz_environment_alloc();