[FL-3743] SubGhz: UI update (#3352)

* [FL-3743]SubGhz: screen refactoring
* SubGhz: fix syntax
* SubGhz: gui
* SubGhz: add animation icon ant in read_info scene
* SubGhz: up speed animation icon

Co-authored-by: あく <alleteam@gmail.com>

applications/main/subghz/helpers/subghz_custom_event.h

@@ -26,6 +26,7 @@ typedef enum {
     //SubGhzCustomEvent
     SubGhzCustomEventSceneDeleteSuccess = 100,
     SubGhzCustomEventSceneDelete,
+    SubGhzCustomEventSceneDeleteBack,
     SubGhzCustomEventSceneDeleteRAW,
     SubGhzCustomEventSceneDeleteRAWBack,
 
@@ -70,5 +71,6 @@ typedef enum {
     SubGhzCustomEventViewTransmitterBack,
     SubGhzCustomEventViewTransmitterSendStart,
     SubGhzCustomEventViewTransmitterSendStop,
+    SubGhzCustomEventViewTransmitterSendSave,
     SubGhzCustomEventViewTransmitterError,
 } SubGhzCustomEvent;

applications/main/subghz/scenes/subghz_scene_delete.c

@@ -6,47 +6,57 @@ void subghz_scene_delete_callback(GuiButtonType result, InputType type, void* co
     SubGhz* subghz = context;
     if((result == GuiButtonTypeRight) && (type == InputTypeShort)) {
         view_dispatcher_send_custom_event(subghz->view_dispatcher, SubGhzCustomEventSceneDelete);
+    } else if((result == GuiButtonTypeLeft) && (type == InputTypeShort)) {
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventSceneDeleteBack);
     }
 }
 
 void subghz_scene_delete_on_enter(void* context) {
     SubGhz* subghz = context;
+
     FuriString* frequency_str;
     FuriString* modulation_str;
+    FuriString* text_out;
     FuriString* text;
+    text_out = furi_string_alloc();
+    text = furi_string_alloc();
+
+    path_extract_filename(subghz->file_path, text, true);
+    furi_string_cat_printf(text_out, "\e#Delete %s?\e#\n", furi_string_get_cstr(text));
+
+    furi_string_reset(text);
+    subghz_protocol_decoder_base_get_string(subghz_txrx_get_decoder(subghz->txrx), text);
+
+    size_t dot = furi_string_search_char(text, '\r');
+    if(dot > 0) {
+        furi_string_left(text, dot);
+    }
+    furi_string_cat_printf(text_out, "%s\n", furi_string_get_cstr(text));
+
+    furi_string_free(text);
 
     frequency_str = furi_string_alloc();
     modulation_str = furi_string_alloc();
-    text = furi_string_alloc();
-
     subghz_txrx_get_frequency_and_modulation(subghz->txrx, frequency_str, modulation_str);
-    widget_add_string_element(
-        subghz->widget,
-        78,
-        0,
-        AlignLeft,
-        AlignTop,
-        FontSecondary,
-        furi_string_get_cstr(frequency_str));
 
-    widget_add_string_element(
-        subghz->widget,
-        113,
-        0,
-        AlignLeft,
-        AlignTop,
-        FontSecondary,
+    furi_string_cat_printf(
+        text_out,
+        "%s %s",
+        furi_string_get_cstr(frequency_str),
         furi_string_get_cstr(modulation_str));
-    subghz_protocol_decoder_base_get_string(subghz_txrx_get_decoder(subghz->txrx), text);
-    widget_add_string_multiline_element(
-        subghz->widget, 0, 0, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(text));
+
+    widget_add_text_box_element(
+        subghz->widget, 0, 0, 128, 54, AlignCenter, AlignTop, furi_string_get_cstr(text_out), false);
 
     furi_string_free(frequency_str);
     furi_string_free(modulation_str);
-    furi_string_free(text);
+    furi_string_free(text_out);
 
     widget_add_button_element(
         subghz->widget, GuiButtonTypeRight, "Delete", subghz_scene_delete_callback, subghz);
+    widget_add_button_element(
+        subghz->widget, GuiButtonTypeLeft, "Cancel", subghz_scene_delete_callback, subghz);
 
     view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);
 }
@@ -63,6 +73,8 @@ bool subghz_scene_delete_on_event(void* context, SceneManagerEvent event) {
                     subghz->scene_manager, SubGhzSceneStart);
             }
             return true;
+        } else if(event.event == SubGhzCustomEventSceneDeleteBack) {
+            return scene_manager_previous_scene(subghz->scene_manager);
         }
     }
     return false;

applications/main/subghz/scenes/subghz_scene_delete_raw.c

@@ -17,48 +17,37 @@ void subghz_scene_delete_raw_on_enter(void* context) {
     SubGhz* subghz = context;
     FuriString* frequency_str;
     FuriString* modulation_str;
+    FuriString* text_out;
+    FuriString* file_name;
+    text_out = furi_string_alloc();
+    file_name = furi_string_alloc();
+
+    path_extract_filename(subghz->file_path, file_name, true);
+    furi_string_cat_printf(
+        text_out, "\e#Delete %s?\e#\nRAW signal\n", furi_string_get_cstr(file_name));
+    furi_string_free(file_name);
 
     frequency_str = furi_string_alloc();
     modulation_str = furi_string_alloc();
+    subghz_txrx_get_frequency_and_modulation(subghz->txrx, frequency_str, modulation_str);
 
-    char delete_str[SUBGHZ_MAX_LEN_NAME + 16];
-    FuriString* file_name;
-    file_name = furi_string_alloc();
-    path_extract_filename(subghz->file_path, file_name, true);
-    snprintf(delete_str, sizeof(delete_str), "\e#Delete %s?\e#", furi_string_get_cstr(file_name));
-    furi_string_free(file_name);
+    furi_string_cat_printf(
+        text_out,
+        "%s %s",
+        furi_string_get_cstr(frequency_str),
+        furi_string_get_cstr(modulation_str));
 
     widget_add_text_box_element(
-        subghz->widget, 0, 0, 128, 23, AlignCenter, AlignCenter, delete_str, false);
-
-    widget_add_string_element(
-        subghz->widget, 38, 25, AlignLeft, AlignTop, FontSecondary, "RAW signal");
-    subghz_txrx_get_frequency_and_modulation(subghz->txrx, frequency_str, modulation_str);
-    widget_add_string_element(
-        subghz->widget,
-        35,
-        37,
-        AlignLeft,
-        AlignTop,
-        FontSecondary,
-        furi_string_get_cstr(frequency_str));
-
-    widget_add_string_element(
-        subghz->widget,
-        72,
-        37,
-        AlignLeft,
-        AlignTop,
-        FontSecondary,
-        furi_string_get_cstr(modulation_str));
+        subghz->widget, 0, 0, 128, 54, AlignCenter, AlignTop, furi_string_get_cstr(text_out), false);
 
     furi_string_free(frequency_str);
     furi_string_free(modulation_str);
+    furi_string_free(text_out);
 
     widget_add_button_element(
         subghz->widget, GuiButtonTypeRight, "Delete", subghz_scene_delete_raw_callback, subghz);
     widget_add_button_element(
-        subghz->widget, GuiButtonTypeLeft, "Back", subghz_scene_delete_raw_callback, subghz);
+        subghz->widget, GuiButtonTypeLeft, "Cancel", subghz_scene_delete_raw_callback, subghz);
 
     view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);
 }

applications/main/subghz/scenes/subghz_scene_need_saving.c

@@ -15,16 +15,16 @@ void subghz_scene_need_saving_callback(GuiButtonType result, InputType type, voi
 void subghz_scene_need_saving_on_enter(void* context) {
     SubGhz* subghz = context;
 
-    widget_add_string_multiline_element(
-        subghz->widget, 64, 13, AlignCenter, AlignCenter, FontPrimary, "Exit to Sub-GHz Menu?");
-    widget_add_string_multiline_element(
+    widget_add_text_box_element(
         subghz->widget,
-        64,
-        32,
+        0,
+        0,
+        128,
+        54,
         AlignCenter,
-        AlignCenter,
-        FontSecondary,
-        "All unsaved data\nwill be lost!");
+        AlignTop,
+        "\e#Exit to Sub-GHz Menu?\e#\nAll unsaved data will be lost",
+        false);
 
     widget_add_button_element(
         subghz->widget, GuiButtonTypeRight, "Stay", subghz_scene_need_saving_callback, subghz);

applications/main/subghz/scenes/subghz_scene_receiver_info.c

@@ -1,20 +1,11 @@
 #include "../subghz_i.h"
 #include "../helpers/subghz_custom_event.h"
+#include "../views/transmitter.h"
 
-void subghz_scene_receiver_info_callback(GuiButtonType result, InputType type, void* context) {
+void subghz_scene_receiver_info_callback(SubGhzCustomEvent event, void* context) {
     furi_assert(context);
     SubGhz* subghz = context;
-
-    if((result == GuiButtonTypeCenter) && (type == InputTypePress)) {
-        view_dispatcher_send_custom_event(
-            subghz->view_dispatcher, SubGhzCustomEventSceneReceiverInfoTxStart);
-    } else if((result == GuiButtonTypeCenter) && (type == InputTypeRelease)) {
-        view_dispatcher_send_custom_event(
-            subghz->view_dispatcher, SubGhzCustomEventSceneReceiverInfoTxStop);
-    } else if((result == GuiButtonTypeRight) && (type == InputTypeShort)) {
-        view_dispatcher_send_custom_event(
-            subghz->view_dispatcher, SubGhzCustomEventSceneReceiverInfoSave);
-    }
+    view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
 }
 
 static bool subghz_scene_receiver_info_update_parser(void* context) {
@@ -37,6 +28,28 @@ static bool subghz_scene_receiver_info_update_parser(void* context) {
             preset->data,
             preset->data_size);
 
+        FuriString* key_str = furi_string_alloc();
+        FuriString* frequency_str = furi_string_alloc();
+        FuriString* modulation_str = furi_string_alloc();
+
+        subghz_protocol_decoder_base_get_string(subghz_txrx_get_decoder(subghz->txrx), key_str);
+        subghz_txrx_get_frequency_and_modulation(subghz->txrx, frequency_str, modulation_str);
+        subghz_view_transmitter_add_data_to_show(
+            subghz->subghz_transmitter,
+            furi_string_get_cstr(key_str),
+            furi_string_get_cstr(frequency_str),
+            furi_string_get_cstr(modulation_str),
+            subghz_txrx_protocol_is_transmittable(subghz->txrx, true));
+
+        furi_string_free(frequency_str);
+        furi_string_free(modulation_str);
+        furi_string_free(key_str);
+
+        subghz_view_transmitter_set_radio_device_type(
+            subghz->subghz_transmitter, subghz_txrx_radio_device_get(subghz->txrx));
+        subghz_view_transmitter_set_model_type(
+            subghz->subghz_transmitter, SubGhzViewTransmitterModelTypeInfo);
+
         return true;
     }
     return false;
@@ -44,67 +57,23 @@ static bool subghz_scene_receiver_info_update_parser(void* context) {
 
 void subghz_scene_receiver_info_on_enter(void* context) {
     SubGhz* subghz = context;
-
     if(subghz_scene_receiver_info_update_parser(subghz)) {
-        FuriString* frequency_str = furi_string_alloc();
-        FuriString* modulation_str = furi_string_alloc();
-        FuriString* text = furi_string_alloc();
-
-        subghz_txrx_get_frequency_and_modulation(subghz->txrx, frequency_str, modulation_str);
-        widget_add_string_element(
-            subghz->widget,
-            78,
-            0,
-            AlignLeft,
-            AlignTop,
-            FontSecondary,
-            furi_string_get_cstr(frequency_str));
-
-        widget_add_string_element(
-            subghz->widget,
-            113,
-            0,
-            AlignLeft,
-            AlignTop,
-            FontSecondary,
-            furi_string_get_cstr(modulation_str));
-        subghz_protocol_decoder_base_get_string(subghz_txrx_get_decoder(subghz->txrx), text);
-        widget_add_string_multiline_element(
-            subghz->widget, 0, 0, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(text));
-
-        furi_string_free(frequency_str);
-        furi_string_free(modulation_str);
-        furi_string_free(text);
-
-        if(subghz_txrx_protocol_is_serializable(subghz->txrx)) {
-            widget_add_button_element(
-                subghz->widget,
-                GuiButtonTypeRight,
-                "Save",
-                subghz_scene_receiver_info_callback,
-                subghz);
-        }
-        if(subghz_txrx_protocol_is_transmittable(subghz->txrx, true)) {
-            widget_add_button_element(
-                subghz->widget,
-                GuiButtonTypeCenter,
-                "Send",
-                subghz_scene_receiver_info_callback,
-                subghz);
-        }
     } else {
-        widget_add_icon_element(subghz->widget, 83, 22, &I_WarningDolphinFlip_45x42);
-        widget_add_string_element(
-            subghz->widget, 13, 8, AlignLeft, AlignBottom, FontSecondary, "Error history parse.");
+        view_dispatcher_send_custom_event(
+            subghz->view_dispatcher, SubGhzCustomEventSceneShowErrorSub);
     }
 
-    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);
+    subghz_view_transmitter_set_callback(
+        subghz->subghz_transmitter, subghz_scene_receiver_info_callback, subghz);
+
+    subghz->state_notifications = SubGhzNotificationStateIDLE;
+    view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdTransmitter);
 }
 
 bool subghz_scene_receiver_info_on_event(void* context, SceneManagerEvent event) {
     SubGhz* subghz = context;
     if(event.type == SceneManagerEventTypeCustom) {
-        if(event.event == SubGhzCustomEventSceneReceiverInfoTxStart) {
+        if(event.event == SubGhzCustomEventViewTransmitterSendStart) {
             if(!subghz_scene_receiver_info_update_parser(subghz)) {
                 return false;
             }
@@ -120,7 +89,7 @@ bool subghz_scene_receiver_info_on_event(void* context, SceneManagerEvent event)
                 subghz->state_notifications = SubGhzNotificationStateTx;
             }
             return true;
-        } else if(event.event == SubGhzCustomEventSceneReceiverInfoTxStop) {
+        } else if(event.event == SubGhzCustomEventViewTransmitterSendStop) {
             //CC1101 Stop Tx -> Start RX
             subghz->state_notifications = SubGhzNotificationStateIDLE;
 
@@ -129,7 +98,7 @@ bool subghz_scene_receiver_info_on_event(void* context, SceneManagerEvent event)
             subghz_txrx_hopper_unpause(subghz->txrx);
             subghz->state_notifications = SubGhzNotificationStateRx;
             return true;
-        } else if(event.event == SubGhzCustomEventSceneReceiverInfoSave) {
+        } else if(event.event == SubGhzCustomEventViewTransmitterSendSave) {
             //CC1101 Stop RX -> Save
             subghz->state_notifications = SubGhzNotificationStateIDLE;
             subghz_txrx_hopper_set_state(subghz->txrx, SubGhzHopperStateOFF);
@@ -144,7 +113,11 @@ bool subghz_scene_receiver_info_on_event(void* context, SceneManagerEvent event)
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveName);
             }
             return true;
+        } else if(event.event == SubGhzCustomEventSceneShowErrorSub) {
+            furi_string_set(subghz->error_str, "Error history parse.");
+            scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowErrorSub);
         }
+
     } else if(event.type == SceneManagerEventTypeTick) {
         if(subghz_txrx_hopper_get_state(subghz->txrx) != SubGhzHopperStateOFF) {
             subghz_txrx_hopper_update(subghz->txrx);

applications/main/subghz/scenes/subghz_scene_region_info.c

@@ -6,12 +6,13 @@ void subghz_scene_region_info_on_enter(void* context) {
     SubGhz* subghz = context;
     const FuriHalRegion* const region = furi_hal_region_get();
     FuriString* buffer = furi_string_alloc();
+
     if(region) {
-        furi_string_cat_printf(buffer, "Region: %s,  bands:\n", region->country_code);
+        furi_string_cat_printf(buffer, "Region: %s\nBands:\n", region->country_code);
         for(uint16_t i = 0; i < region->bands_count; ++i) {
             furi_string_cat_printf(
                 buffer,
-                "   %lu-%lu kHz\n",
+                "%lu-%lu kHz\n",
                 region->bands[i].start / 1000,
                 region->bands[i].end / 1000);
         }
@@ -20,7 +21,10 @@ void subghz_scene_region_info_on_enter(void* context) {
     }
 
     widget_add_string_multiline_element(
-        subghz->widget, 0, 0, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(buffer));
+        subghz->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, "Region Information");
+
+    widget_add_string_multiline_element(
+        subghz->widget, 0, 13, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(buffer));
 
     furi_string_free(buffer);
     view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdWidget);

applications/main/subghz/scenes/subghz_scene_save_name.c

@@ -132,7 +132,7 @@ bool subghz_scene_save_name_on_event(void* context, SceneManagerEvent event) {
                     scene_manager_set_scene_state(
                         subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerNoSet);
                 } else {
-                    subghz_file_name_clear(subghz);
+                    furi_string_reset(subghz->file_path_tmp);
                 }
 
                 scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveSuccess);

applications/main/subghz/scenes/subghz_scene_saved.c

@@ -22,5 +22,7 @@ bool subghz_scene_saved_on_event(void* context, SceneManagerEvent event) {
 }
 
 void subghz_scene_saved_on_exit(void* context) {
+    SubGhz* subghz = context;
+    scene_manager_set_scene_state(subghz->scene_manager, SubGhzSceneSavedMenu, 0);
     UNUSED(context);
 }

applications/main/subghz/scenes/subghz_scene_transmitter.c

@@ -37,6 +37,8 @@ bool subghz_scene_transmitter_update_data_show(void* context) {
     }
     subghz_view_transmitter_set_radio_device_type(
         subghz->subghz_transmitter, subghz_txrx_radio_device_get(subghz->txrx));
+    subghz_view_transmitter_set_model_type(
+        subghz->subghz_transmitter, SubGhzViewTransmitterModelTypeTx);
     return ret;
 }
 

applications/main/subghz/views/receiver.c

@@ -251,9 +251,9 @@ void subghz_view_receiver_draw(Canvas* canvas, SubGhzViewReceiverModel* model) {
     }
 
     if(model->device_type == SubGhzRadioDeviceTypeInternal) {
-        canvas_draw_icon(canvas, 108, 0, &I_Internal_antenna_20x12);
+        canvas_draw_icon(canvas, 109, 0, &I_Internal_ant_1_9x11);
     } else {
-        canvas_draw_icon(canvas, 108, 0, &I_External_antenna_20x12);
+        canvas_draw_icon(canvas, 109, 0, &I_External_ant_1_9x11);
     }
 
     subghz_view_rssi_draw(canvas, model);

applications/main/subghz/views/subghz_frequency_analyzer.c

@@ -178,7 +178,7 @@ void subghz_frequency_analyzer_draw(Canvas* canvas, SubGhzFrequencyAnalyzerModel
         subghz_frequency_analyzer_log_frequency_draw(canvas, model);
     } else {
         canvas_draw_str(canvas, 0, 8, "Frequency Analyzer");
-        canvas_draw_icon(canvas, 108, 0, &I_Internal_antenna_20x12);
+        canvas_draw_icon(canvas, 109, 0, &I_Internal_ant_1_9x11);
         canvas_draw_str(canvas, 0, 64, "RSSI");
         subghz_frequency_analyzer_draw_rssi(canvas, model->rssi, 20, 64);
 

applications/main/subghz/views/subghz_read_raw.c

@@ -294,9 +294,9 @@ void subghz_read_raw_draw(Canvas* canvas, SubGhzReadRAWModel* model) {
         canvas, 106, 2, AlignRight, AlignTop, furi_string_get_cstr(model->sample_write));
 
     if(model->device_type == SubGhzRadioDeviceTypeInternal) {
-        canvas_draw_icon(canvas, 108, 0, &I_Internal_antenna_20x12);
+        canvas_draw_icon(canvas, 109, 0, &I_Internal_ant_1_9x11);
     } else {
-        canvas_draw_icon(canvas, 108, 0, &I_External_antenna_20x12);
+        canvas_draw_icon(canvas, 109, 0, &I_External_ant_1_9x11);
     }
     canvas_draw_line(canvas, 0, 14, 115, 14);
     canvas_draw_line(canvas, 0, 48, 115, 48);

applications/main/subghz/views/transmitter.c

@@ -16,6 +16,9 @@ typedef struct {
     FuriString* key_str;
     bool show_button;
     SubGhzRadioDeviceType device_type;
+    SubGhzViewTransmitterModelType model_type;
+    IconAnimation* icon_int_ant;
+    IconAnimation* icon_ext_ant;
 } SubGhzViewTransmitterModel;
 
 void subghz_view_transmitter_set_callback(
@@ -58,6 +61,17 @@ void subghz_view_transmitter_set_radio_device_type(
         true);
 }
 
+void subghz_view_transmitter_set_model_type(
+    SubGhzViewTransmitter* subghz_transmitter,
+    SubGhzViewTransmitterModelType model_type) {
+    furi_assert(subghz_transmitter);
+    with_view_model(
+        subghz_transmitter->view,
+        SubGhzViewTransmitterModel * model,
+        { model->model_type = model_type; },
+        true);
+}
+
 static void subghz_view_transmitter_button_right(Canvas* canvas, const char* str) {
     const uint8_t button_height = 12;
     const uint8_t vertical_offset = 3;
@@ -100,13 +114,21 @@ void subghz_view_transmitter_draw(Canvas* canvas, SubGhzViewTransmitterModel* mo
         canvas, 0, 0, AlignLeft, AlignTop, furi_string_get_cstr(model->key_str));
     canvas_draw_str(canvas, 78, 7, furi_string_get_cstr(model->frequency_str));
     canvas_draw_str(canvas, 113, 7, furi_string_get_cstr(model->preset_str));
+
     if(model->show_button) {
-        if(model->device_type == SubGhzRadioDeviceTypeInternal) {
-            canvas_draw_icon(canvas, 108, 39, &I_Internal_antenna_20x12);
+        if(model->model_type == SubGhzViewTransmitterModelTypeInfo) {
+            elements_button_center(canvas, "Send");
+            elements_button_right(canvas, "Save");
         } else {
-            canvas_draw_icon(canvas, 108, 39, &I_External_antenna_20x12);
+            //default type SubGhzViewTransmitterModelTypeTx
+            subghz_view_transmitter_button_right(canvas, "Send");
+        }
+
+        if(model->device_type == SubGhzRadioDeviceTypeInternal) {
+            canvas_draw_icon_animation(canvas, 109, 40, model->icon_int_ant);
+        } else {
+            canvas_draw_icon_animation(canvas, 109, 40, model->icon_ext_ant);
         }
-        subghz_view_transmitter_button_right(canvas, "Send");
     }
 }
 
@@ -140,13 +162,32 @@ bool subghz_view_transmitter_input(InputEvent* event, void* context) {
         true);
 
     if(can_be_sent && event->key == InputKeyOk && event->type == InputTypePress) {
+        with_view_model(
+            subghz_transmitter->view,
+            SubGhzViewTransmitterModel * model,
+            {
+                icon_animation_start(model->icon_int_ant);
+                icon_animation_start(model->icon_ext_ant);
+            },
+            false);
         subghz_transmitter->callback(
             SubGhzCustomEventViewTransmitterSendStart, subghz_transmitter->context);
         return true;
     } else if(can_be_sent && event->key == InputKeyOk && event->type == InputTypeRelease) {
+        with_view_model(
+            subghz_transmitter->view,
+            SubGhzViewTransmitterModel * model,
+            {
+                icon_animation_stop(model->icon_int_ant);
+                icon_animation_stop(model->icon_ext_ant);
+            },
+            false);
         subghz_transmitter->callback(
             SubGhzCustomEventViewTransmitterSendStop, subghz_transmitter->context);
         return true;
+    } else if(can_be_sent && event->key == InputKeyRight && event->type == InputTypeShort) {
+        subghz_transmitter->callback(
+            SubGhzCustomEventViewTransmitterSendSave, subghz_transmitter->context);
     }
 
     return true;
@@ -181,6 +222,11 @@ SubGhzViewTransmitter* subghz_view_transmitter_alloc() {
             model->frequency_str = furi_string_alloc();
             model->preset_str = furi_string_alloc();
             model->key_str = furi_string_alloc();
+            model->model_type = SubGhzViewTransmitterModelTypeTx;
+            model->icon_int_ant = icon_animation_alloc(&A_SubGhz_Internal_ant);
+            view_tie_icon_animation(subghz_transmitter->view, model->icon_int_ant);
+            model->icon_ext_ant = icon_animation_alloc(&A_SubGhz_External_ant);
+            view_tie_icon_animation(subghz_transmitter->view, model->icon_ext_ant);
         },
         true);
     return subghz_transmitter;
@@ -196,6 +242,8 @@ void subghz_view_transmitter_free(SubGhzViewTransmitter* subghz_transmitter) {
             furi_string_free(model->frequency_str);
             furi_string_free(model->preset_str);
             furi_string_free(model->key_str);
+            icon_animation_free(model->icon_int_ant);
+            icon_animation_free(model->icon_ext_ant);
         },
         true);
     view_free(subghz_transmitter->view);

applications/main/subghz/views/transmitter.h

@@ -6,6 +6,11 @@
 
 typedef struct SubGhzViewTransmitter SubGhzViewTransmitter;
 
+typedef enum {
+    SubGhzViewTransmitterModelTypeTx,
+    SubGhzViewTransmitterModelTypeInfo,
+} SubGhzViewTransmitterModelType;
+
 typedef void (*SubGhzViewTransmitterCallback)(SubGhzCustomEvent event, void* context);
 
 void subghz_view_transmitter_set_callback(
@@ -17,6 +22,10 @@ void subghz_view_transmitter_set_radio_device_type(
     SubGhzViewTransmitter* subghz_transmitter,
     SubGhzRadioDeviceType device_type);
 
+void subghz_view_transmitter_set_model_type(
+    SubGhzViewTransmitter* subghz_transmitter,
+    SubGhzViewTransmitterModelType model_type);
+
 SubGhzViewTransmitter* subghz_view_transmitter_alloc();
 
 void subghz_view_transmitter_free(SubGhzViewTransmitter* subghz_transmitter);

assets/icons/SubGhz/SubGhz_External_ant/frame_rate

@@ -0,0 +1 @@
+6

assets/icons/SubGhz/SubGhz_Internal_ant/frame_rate

@@ -0,0 +1 @@
+6