liz/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

M*LIB: non-inlined strings, FuriString primitive (#1795)

Browse Source 
* Quicksave 1
* Header stage complete
* Source stage complete
* Lint & merge fixes
* Includes
* Documentation step 1
* FBT: output free size considering BT STACK
* Documentation step 2
* py lint
* Fix music player plugin
* unit test stage 1: string allocator, mem, getters, setters, appends, compare, search.
* unit test: string equality
* unit test: string replace
* unit test: string start_with, end_with
* unit test: string trim
* unit test: utf-8
* Rename
* Revert fw_size changes
* Simplify CLI backspace handling
* Simplify CLI character insert
* Merge fixes
* Furi: correct filenaming and spelling
* Bt: remove furi string include

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
This commit is contained in:
Sergey Gavrilov
2022-10-06 01:15:23 +10:00
committed by GitHub
parent 0f9ea925d3
commit 4bf29827f8
370 changed files with 5597 additions and 3963 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
applications/main/subghz/helpers/subghz_types.h
View File

@@ -1,6 +1,5 @@
#pragma once
#include "m-string.h"
#include <furi.h>
#include <furi_hal.h>
@@ -72,7 +71,7 @@ typedef enum {
} SubGhzViewId;
struct SubGhzPresetDefinition {
string_t name;
FuriString* name;
uint32_t frequency;
uint8_t* data;
size_t data_size;

32
applications/main/subghz/scenes/subghz_scene_delete.c
View File

@@ -11,17 +11,23 @@ void subghz_scene_delete_callback(GuiButtonType result, InputType type, void* co
void subghz_scene_delete_on_enter(void* context) {
SubGhz* subghz = context;
string_t frequency_str;
string_t modulation_str;
string_t text;
FuriString* frequency_str;
FuriString* modulation_str;
FuriString* text;
string_init(frequency_str);
string_init(modulation_str);
string_init(text);
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
text = furi_string_alloc();
subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
widget_add_string_element(
subghz->widget, 78, 0, AlignLeft, AlignTop, FontSecondary, string_get_cstr(frequency_str));
subghz->widget,
78,
0,
AlignLeft,
AlignTop,
FontSecondary,
furi_string_get_cstr(frequency_str));
widget_add_string_element(
subghz->widget,
@@ -30,14 +36,14 @@ void subghz_scene_delete_on_enter(void* context) {
AlignLeft,
AlignTop,
FontSecondary,
string_get_cstr(modulation_str));
furi_string_get_cstr(modulation_str));
subghz_protocol_decoder_base_get_string(subghz->txrx->decoder_result, text);
widget_add_string_multiline_element(
subghz->widget, 0, 0, AlignLeft, AlignTop, FontSecondary, string_get_cstr(text));
subghz->widget, 0, 0, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(text));
string_clear(frequency_str);
string_clear(modulation_str);
string_clear(text);
furi_string_free(frequency_str);
furi_string_free(modulation_str);
furi_string_free(text);
widget_add_button_element(
subghz->widget, GuiButtonTypeRight, "Delete", subghz_scene_delete_callback, subghz);
@@ -49,7 +55,7 @@ bool subghz_scene_delete_on_event(void* context, SceneManagerEvent event) {
SubGhz* subghz = context;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubGhzCustomEventSceneDelete) {
string_set(subghz->file_path_tmp, subghz->file_path);
furi_string_set(subghz->file_path_tmp, subghz->file_path);
if(subghz_delete_file(subghz)) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneDeleteSuccess);
} else {

32
applications/main/subghz/scenes/subghz_scene_delete_raw.c
View File

@@ -15,18 +15,18 @@ void subghz_scene_delete_raw_callback(GuiButtonType result, InputType type, void
void subghz_scene_delete_raw_on_enter(void* context) {
SubGhz* subghz = context;
string_t frequency_str;
string_t modulation_str;
FuriString* frequency_str;
FuriString* modulation_str;
string_init(frequency_str);
string_init(modulation_str);
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
char delete_str[SUBGHZ_MAX_LEN_NAME + 16];
string_t file_name;
string_init(file_name);
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#", string_get_cstr(file_name));
string_clear(file_name);
snprintf(delete_str, sizeof(delete_str), "\e#Delete %s?\e#", furi_string_get_cstr(file_name));
furi_string_free(file_name);
widget_add_text_box_element(
subghz->widget, 0, 0, 128, 23, AlignCenter, AlignCenter, delete_str, false);
@@ -35,7 +35,13 @@ void subghz_scene_delete_raw_on_enter(void* context) {
subghz->widget, 38, 25, AlignLeft, AlignTop, FontSecondary, "RAW signal");
subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
widget_add_string_element(
subghz->widget, 35, 37, AlignLeft, AlignTop, FontSecondary, string_get_cstr(frequency_str));
subghz->widget,
35,
37,
AlignLeft,
AlignTop,
FontSecondary,
furi_string_get_cstr(frequency_str));
widget_add_string_element(
subghz->widget,
@@ -44,10 +50,10 @@ void subghz_scene_delete_raw_on_enter(void* context) {
AlignLeft,
AlignTop,
FontSecondary,
string_get_cstr(modulation_str));
furi_string_get_cstr(modulation_str));
string_clear(frequency_str);
string_clear(modulation_str);
furi_string_free(frequency_str);
furi_string_free(modulation_str);
widget_add_button_element(
subghz->widget, GuiButtonTypeRight, "Delete", subghz_scene_delete_raw_callback, subghz);
@@ -61,7 +67,7 @@ bool subghz_scene_delete_raw_on_event(void* context, SceneManagerEvent event) {
SubGhz* subghz = context;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubGhzCustomEventSceneDeleteRAW) {
string_set(subghz->file_path_tmp, subghz->file_path);
furi_string_set(subghz->file_path_tmp, subghz->file_path);
if(subghz_delete_file(subghz)) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneDeleteSuccess);
} else {

2
applications/main/subghz/scenes/subghz_scene_more_raw.c
View File

@@ -45,7 +45,7 @@ bool subghz_scene_more_raw_on_event(void* context, SceneManagerEvent event) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneDeleteRAW);
return true;
} else if(event.event == SubmenuIndexEdit) {
string_reset(subghz->file_path_tmp);
furi_string_reset(subghz->file_path_tmp);
scene_manager_set_scene_state(
subghz->scene_manager, SubGhzSceneMoreRAW, SubmenuIndexEdit);
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveName);

54
applications/main/subghz/scenes/subghz_scene_read_raw.c
View File

@@ -10,8 +10,8 @@
bool subghz_scene_read_raw_update_filename(SubGhz* subghz) {
bool ret = false;
//set the path to read the file
string_t temp_str;
string_init(temp_str);
FuriString* temp_str;
temp_str = furi_string_alloc();
do {
if(!flipper_format_rewind(subghz->txrx->fff_data)) {
FURI_LOG_E(TAG, "Rewind error");
@@ -23,12 +23,12 @@ bool subghz_scene_read_raw_update_filename(SubGhz* subghz) {
break;
}
string_set(subghz->file_path, temp_str);
furi_string_set(subghz->file_path, temp_str);
ret = true;
} while(false);
string_clear(temp_str);
furi_string_free(temp_str);
return ret;
}
@@ -36,18 +36,20 @@ static void subghz_scene_read_raw_update_statusbar(void* context) {
furi_assert(context);
SubGhz* subghz = context;
string_t frequency_str;
string_t modulation_str;
FuriString* frequency_str;
FuriString* modulation_str;
string_init(frequency_str);
string_init(modulation_str);
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
subghz_read_raw_add_data_statusbar(
subghz->subghz_read_raw, string_get_cstr(frequency_str), string_get_cstr(modulation_str));
subghz->subghz_read_raw,
furi_string_get_cstr(frequency_str),
furi_string_get_cstr(modulation_str));
string_clear(frequency_str);
string_clear(modulation_str);
furi_string_free(frequency_str);
furi_string_free(modulation_str);
}
void subghz_scene_read_raw_callback(SubGhzCustomEvent event, void* context) {
@@ -65,8 +67,8 @@ void subghz_scene_read_raw_callback_end_tx(void* context) {
void subghz_scene_read_raw_on_enter(void* context) {
SubGhz* subghz = context;
string_t file_name;
string_init(file_name);
FuriString* file_name;
file_name = furi_string_alloc();
switch(subghz->txrx->rx_key_state) {
case SubGhzRxKeyStateBack:
@@ -75,13 +77,15 @@ void subghz_scene_read_raw_on_enter(void* context) {
case SubGhzRxKeyStateRAWLoad:
path_extract_filename(subghz->file_path, file_name, true);
subghz_read_raw_set_status(
subghz->subghz_read_raw, SubGhzReadRAWStatusLoadKeyTX, string_get_cstr(file_name));
subghz->subghz_read_raw,
SubGhzReadRAWStatusLoadKeyTX,
furi_string_get_cstr(file_name));
subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
break;
case SubGhzRxKeyStateRAWSave:
path_extract_filename(subghz->file_path, file_name, true);
subghz_read_raw_set_status(
subghz->subghz_read_raw, SubGhzReadRAWStatusSaveKey, string_get_cstr(file_name));
subghz->subghz_read_raw, SubGhzReadRAWStatusSaveKey, furi_string_get_cstr(file_name));
subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
break;
default:
@@ -89,7 +93,7 @@ void subghz_scene_read_raw_on_enter(void* context) {
subghz->txrx->rx_key_state = SubGhzRxKeyStateIDLE;
break;
}
string_clear(file_name);
furi_string_free(file_name);
subghz_scene_read_raw_update_statusbar(subghz);
//set callback view raw
@@ -174,7 +178,7 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
case SubGhzCustomEventViewReadRAWErase:
if(subghz->txrx->rx_key_state == SubGhzRxKeyStateAddKey) {
if(subghz_scene_read_raw_update_filename(subghz)) {
string_set(subghz->file_path_tmp, subghz->file_path);
furi_string_set(subghz->file_path_tmp, subghz->file_path);
subghz_delete_file(subghz);
}
}
@@ -245,12 +249,13 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
subghz_protocol_raw_save_to_file_stop(
(SubGhzProtocolDecoderRAW*)subghz->txrx->decoder_result);
string_t temp_str;
string_init(temp_str);
string_printf(
FuriString* temp_str;
temp_str = furi_string_alloc();
furi_string_printf(
temp_str, "%s/%s%s", SUBGHZ_RAW_FOLDER, RAW_FILE_NAME, SUBGHZ_APP_EXTENSION);
subghz_protocol_raw_gen_fff_data(subghz->txrx->fff_data, string_get_cstr(temp_str));
string_clear(temp_str);
subghz_protocol_raw_gen_fff_data(
subghz->txrx->fff_data, furi_string_get_cstr(temp_str));
furi_string_free(temp_str);
if(spl_count > 0) {
notification_message(subghz->notifications, &sequence_set_green_255);
@@ -279,13 +284,14 @@ bool subghz_scene_read_raw_on_event(void* context, SceneManagerEvent event) {
subghz_begin(
subghz,
subghz_setting_get_preset_data_by_name(
subghz->setting, string_get_cstr(subghz->txrx->preset->name)));
subghz->setting,
furi_string_get_cstr(subghz->txrx->preset->name)));
subghz_rx(subghz, subghz->txrx->preset->frequency);
}
subghz->state_notifications = SubGhzNotificationStateRx;
subghz->txrx->rx_key_state = SubGhzRxKeyStateAddKey;
} else {
string_set_str(subghz->error_str, "Function requires\nan SD card.");
furi_string_set(subghz->error_str, "Function requires\nan SD card.");
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowError);
}
}

48
applications/main/subghz/scenes/subghz_scene_receiver.c
View File

@@ -33,31 +33,31 @@ static const NotificationSequence subghs_sequence_rx_locked = {
static void subghz_scene_receiver_update_statusbar(void* context) {
SubGhz* subghz = context;
string_t history_stat_str;
string_init(history_stat_str);
FuriString* history_stat_str;
history_stat_str = furi_string_alloc();
if(!subghz_history_get_text_space_left(subghz->txrx->history, history_stat_str)) {
string_t frequency_str;
string_t modulation_str;
FuriString* frequency_str;
FuriString* modulation_str;
string_init(frequency_str);
string_init(modulation_str);
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
subghz_view_receiver_add_data_statusbar(
subghz->subghz_receiver,
string_get_cstr(frequency_str),
string_get_cstr(modulation_str),
string_get_cstr(history_stat_str));
furi_string_get_cstr(frequency_str),
furi_string_get_cstr(modulation_str),
furi_string_get_cstr(history_stat_str));
string_clear(frequency_str);
string_clear(modulation_str);
furi_string_free(frequency_str);
furi_string_free(modulation_str);
} else {
subghz_view_receiver_add_data_statusbar(
subghz->subghz_receiver, string_get_cstr(history_stat_str), "", "");
subghz->subghz_receiver, furi_string_get_cstr(history_stat_str), "", "");
subghz->state_notifications = SubGhzNotificationStateIDLE;
}
string_clear(history_stat_str);
furi_string_free(history_stat_str);
}
void subghz_scene_receiver_callback(SubGhzCustomEvent event, void* context) {
@@ -72,11 +72,11 @@ static void subghz_scene_add_to_history_callback(
void* context) {
furi_assert(context);
SubGhz* subghz = context;
string_t str_buff;
string_init(str_buff);
FuriString* str_buff;
str_buff = furi_string_alloc();
if(subghz_history_add_to_history(subghz->txrx->history, decoder_base, subghz->txrx->preset)) {
string_reset(str_buff);
furi_string_reset(str_buff);
subghz->state_notifications = SubGhzNotificationStateRxDone;
@@ -84,22 +84,22 @@ static void subghz_scene_add_to_history_callback(
subghz->txrx->history, str_buff, subghz_history_get_item(subghz->txrx->history) - 1);
subghz_view_receiver_add_item_to_menu(
subghz->subghz_receiver,
string_get_cstr(str_buff),
furi_string_get_cstr(str_buff),
subghz_history_get_type_protocol(
subghz->txrx->history, subghz_history_get_item(subghz->txrx->history) - 1));
subghz_scene_receiver_update_statusbar(subghz);
}
subghz_receiver_reset(receiver);
string_clear(str_buff);
furi_string_free(str_buff);
subghz->txrx->rx_key_state = SubGhzRxKeyStateAddKey;
}
void subghz_scene_receiver_on_enter(void* context) {
SubGhz* subghz = context;
string_t str_buff;
string_init(str_buff);
FuriString* str_buff;
str_buff = furi_string_alloc();
if(subghz->txrx->rx_key_state == SubGhzRxKeyStateIDLE) {
subghz_preset_init(
@@ -113,15 +113,15 @@ void subghz_scene_receiver_on_enter(void* context) {
//Load history to receiver
subghz_view_receiver_exit(subghz->subghz_receiver);
for(uint8_t i = 0; i < subghz_history_get_item(subghz->txrx->history); i++) {
string_reset(str_buff);
furi_string_reset(str_buff);
subghz_history_get_text_item_menu(subghz->txrx->history, str_buff, i);
subghz_view_receiver_add_item_to_menu(
subghz->subghz_receiver,
string_get_cstr(str_buff),
furi_string_get_cstr(str_buff),
subghz_history_get_type_protocol(subghz->txrx->history, i));
subghz->txrx->rx_key_state = SubGhzRxKeyStateAddKey;
}
string_clear(str_buff);
furi_string_free(str_buff);
subghz_scene_receiver_update_statusbar(subghz);
subghz_view_receiver_set_callback(
subghz->subghz_receiver, subghz_scene_receiver_callback, subghz);
@@ -137,7 +137,7 @@ void subghz_scene_receiver_on_enter(void* context) {
subghz_begin(
subghz,
subghz_setting_get_preset_data_by_name(
subghz->setting, string_get_cstr(subghz->txrx->preset->name)));
subghz->setting, furi_string_get_cstr(subghz->txrx->preset->name)));
subghz_rx(subghz, subghz->txrx->preset->frequency);
}
subghz_view_receiver_set_idx_menu(subghz->subghz_receiver, subghz->txrx->idx_menu_chosen);

2
applications/main/subghz/scenes/subghz_scene_receiver_config.c
View File

@@ -191,7 +191,7 @@ void subghz_scene_receiver_config_on_enter(void* context) {
subghz_scene_receiver_config_set_preset,
subghz);
value_index = subghz_scene_receiver_config_next_preset(
string_get_cstr(subghz->txrx->preset->name), subghz);
furi_string_get_cstr(subghz->txrx->preset->name), subghz);
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(
item, subghz_setting_get_preset_name(subghz->setting, value_index));

28
applications/main/subghz/scenes/subghz_scene_receiver_info.c
View File

@@ -32,7 +32,7 @@ static bool subghz_scene_receiver_info_update_parser(void* context) {
subghz_history_get_preset_def(subghz->txrx->history, subghz->txrx->idx_menu_chosen);
subghz_preset_init(
subghz,
string_get_cstr(preset->name),
furi_string_get_cstr(preset->name),
preset->frequency,
preset->data,
preset->data_size);
@@ -47,13 +47,13 @@ void subghz_scene_receiver_info_on_enter(void* context) {
DOLPHIN_DEED(DolphinDeedSubGhzReceiverInfo);
if(subghz_scene_receiver_info_update_parser(subghz)) {
string_t frequency_str;
string_t modulation_str;
string_t text;
FuriString* frequency_str;
FuriString* modulation_str;
FuriString* text;
string_init(frequency_str);
string_init(modulation_str);
string_init(text);
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
text = furi_string_alloc();
subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
widget_add_string_element(
@@ -63,7 +63,7 @@ void subghz_scene_receiver_info_on_enter(void* context) {
AlignLeft,
AlignTop,
FontSecondary,
string_get_cstr(frequency_str));
furi_string_get_cstr(frequency_str));
widget_add_string_element(
subghz->widget,
@@ -72,14 +72,14 @@ void subghz_scene_receiver_info_on_enter(void* context) {
AlignLeft,
AlignTop,
FontSecondary,
string_get_cstr(modulation_str));
furi_string_get_cstr(modulation_str));
subghz_protocol_decoder_base_get_string(subghz->txrx->decoder_result, text);
widget_add_string_multiline_element(
subghz->widget, 0, 0, AlignLeft, AlignTop, FontSecondary, string_get_cstr(text));
subghz->widget, 0, 0, AlignLeft, AlignTop, FontSecondary, furi_string_get_cstr(text));
string_clear(frequency_str);
string_clear(modulation_str);
string_clear(text);
furi_string_free(frequency_str);
furi_string_free(modulation_str);
furi_string_free(text);
if((subghz->txrx->decoder_result->protocol->flag & SubGhzProtocolFlag_Save) ==
SubGhzProtocolFlag_Save) {
@@ -146,7 +146,7 @@ bool subghz_scene_receiver_info_on_event(void* context, SceneManagerEvent event)
subghz_begin(
subghz,
subghz_setting_get_preset_data_by_name(
subghz->setting, string_get_cstr(subghz->txrx->preset->name)));
subghz->setting, furi_string_get_cstr(subghz->txrx->preset->name)));
subghz_rx(subghz, subghz->txrx->preset->frequency);
}
if(subghz->txrx->hopper_state == SubGhzHopperStatePause) {

10
applications/main/subghz/scenes/subghz_scene_rpc.c
View File

@@ -61,20 +61,20 @@ bool subghz_scene_rpc_on_event(void* context, SceneManagerEvent event) {
if(subghz_key_load(subghz, arg, false)) {
scene_manager_set_scene_state(
subghz->scene_manager, SubGhzSceneRpc, SubGhzRpcStateLoaded);
string_set_str(subghz->file_path, arg);
furi_string_set(subghz->file_path, arg);
result = true;
string_t file_name;
string_init(file_name);
FuriString* file_name;
file_name = furi_string_alloc();
path_extract_filename(subghz->file_path, file_name, true);
snprintf(
subghz->file_name_tmp,
SUBGHZ_MAX_LEN_NAME,
"loaded\n%s",
string_get_cstr(file_name));
furi_string_get_cstr(file_name));
popup_set_text(popup, subghz->file_name_tmp, 89, 44, AlignCenter, AlignTop);
string_clear(file_name);
furi_string_free(file_name);
}
}
rpc_system_app_confirm(subghz->rpc_ctx, RpcAppEventLoadFile, result);

43
applications/main/subghz/scenes/subghz_scene_save_name.c
View File

@@ -1,5 +1,4 @@
#include "../subghz_i.h"
#include "m-string.h"
#include "subghz/types.h"
#include <lib/toolbox/random_name.h>
#include "../helpers/subghz_custom_event.h"
@@ -21,21 +20,21 @@ void subghz_scene_save_name_on_enter(void* context) {
TextInput* text_input = subghz->text_input;
bool dev_name_empty = false;
string_t file_name;
string_t dir_name;
string_init(file_name);
string_init(dir_name);
FuriString* file_name;
FuriString* dir_name;
file_name = furi_string_alloc();
dir_name = furi_string_alloc();
if(!subghz_path_is_file(subghz->file_path)) {
char file_name_buf[SUBGHZ_MAX_LEN_NAME] = {0};
set_random_name(file_name_buf, SUBGHZ_MAX_LEN_NAME);
string_set_str(file_name, file_name_buf);
string_set_str(subghz->file_path, SUBGHZ_APP_FOLDER);
furi_string_set(file_name, file_name_buf);
furi_string_set(subghz->file_path, SUBGHZ_APP_FOLDER);
//highlighting the entire filename by default
dev_name_empty = true;
} else {
string_set(subghz->file_path_tmp, subghz->file_path);
path_extract_dirname(string_get_cstr(subghz->file_path), dir_name);
furi_string_set(subghz->file_path_tmp, subghz->file_path);
path_extract_dirname(furi_string_get_cstr(subghz->file_path), dir_name);
path_extract_filename(subghz->file_path, file_name, true);
if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=
SubGhzCustomEventManagerNoSet) {
@@ -46,10 +45,10 @@ void subghz_scene_save_name_on_enter(void* context) {
}
path_extract_filename(subghz->file_path, file_name, true);
}
string_set(subghz->file_path, dir_name);
furi_string_set(subghz->file_path, dir_name);
}
strncpy(subghz->file_name_tmp, string_get_cstr(file_name), SUBGHZ_MAX_LEN_NAME);
strncpy(subghz->file_name_tmp, furi_string_get_cstr(file_name), SUBGHZ_MAX_LEN_NAME);
text_input_set_header_text(text_input, "Name signal");
text_input_set_result_callback(
text_input,
@@ -59,12 +58,12 @@ void subghz_scene_save_name_on_enter(void* context) {
MAX_TEXT_INPUT_LEN, // buffer size
dev_name_empty);
ValidatorIsFile* validator_is_file =
validator_is_file_alloc_init(string_get_cstr(subghz->file_path), SUBGHZ_APP_EXTENSION, "");
ValidatorIsFile* validator_is_file = validator_is_file_alloc_init(
furi_string_get_cstr(subghz->file_path), SUBGHZ_APP_EXTENSION, "");
text_input_set_validator(text_input, validator_is_file_callback, validator_is_file);
string_clear(file_name);
string_clear(dir_name);
furi_string_free(file_name);
furi_string_free(dir_name);
view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdTextInput);
}
@@ -75,14 +74,14 @@ bool subghz_scene_save_name_on_event(void* context, SceneManagerEvent event) {
if(!strcmp(subghz->file_name_tmp, "") ||
scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=
SubGhzCustomEventManagerNoSet) {
string_set(subghz->file_path, subghz->file_path_tmp);
furi_string_set(subghz->file_path, subghz->file_path_tmp);
}
scene_manager_previous_scene(subghz->scene_manager);
return true;
} else if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubGhzCustomEventSceneSaveName) {
if(strcmp(subghz->file_name_tmp, "")) {
string_cat_printf(
furi_string_cat_printf(
subghz->file_path, "/%s%s", subghz->file_name_tmp, SUBGHZ_APP_EXTENSION);
if(subghz_path_is_file(subghz->file_path_tmp)) {
if(!subghz_rename_file(subghz)) {
@@ -92,7 +91,9 @@ bool subghz_scene_save_name_on_event(void* context, SceneManagerEvent event) {
if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneSetType) !=
SubGhzCustomEventManagerNoSet) {
subghz_save_protocol_to_file(
subghz, subghz->txrx->fff_data, string_get_cstr(subghz->file_path));
subghz,
subghz->txrx->fff_data,
furi_string_get_cstr(subghz->file_path));
scene_manager_set_scene_state(
subghz->scene_manager,
SubGhzSceneSetType,
@@ -102,14 +103,14 @@ bool subghz_scene_save_name_on_event(void* context, SceneManagerEvent event) {
subghz,
subghz_history_get_raw_data(
subghz->txrx->history, subghz->txrx->idx_menu_chosen),
string_get_cstr(subghz->file_path));
furi_string_get_cstr(subghz->file_path));
}
}
if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneReadRAW) !=
SubGhzCustomEventManagerNoSet) {
subghz_protocol_raw_gen_fff_data(
subghz->txrx->fff_data, string_get_cstr(subghz->file_path));
subghz->txrx->fff_data, furi_string_get_cstr(subghz->file_path));
scene_manager_set_scene_state(
subghz->scene_manager, SubGhzSceneReadRAW, SubGhzCustomEventManagerNoSet);
} else {
@@ -119,7 +120,7 @@ bool subghz_scene_save_name_on_event(void* context, SceneManagerEvent event) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneSaveSuccess);
return true;
} else {
string_set_str(subghz->error_str, "No name file");
furi_string_set(subghz->error_str, "No name file");
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowErrorSub);
return true;
}

6
applications/main/subghz/scenes/subghz_scene_set_type.c
View File

@@ -27,7 +27,7 @@ bool subghz_scene_set_type_submenu_gen_data_protocol(
subghz_receiver_search_decoder_base_by_name(subghz->txrx->receiver, protocol_name);
if(subghz->txrx->decoder_result == NULL) {
string_set_str(subghz->error_str, "Protocol not\nfound!");
furi_string_set(subghz->error_str, "Protocol not\nfound!");
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowErrorSub);
return false;
}
@@ -261,7 +261,7 @@ bool subghz_scene_set_type_on_event(void* context, SceneManagerEvent event) {
}
subghz_transmitter_free(subghz->txrx->transmitter);
if(!generated_protocol) {
string_set_str(
furi_string_set(
subghz->error_str, "Function requires\nan SD card with\nfresh databases.");
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowError);
}
@@ -285,7 +285,7 @@ bool subghz_scene_set_type_on_event(void* context, SceneManagerEvent event) {
}
subghz_transmitter_free(subghz->txrx->transmitter);
if(!generated_protocol) {
string_set_str(
furi_string_set(
subghz->error_str, "Function requires\nan SD card with\nfresh databases.");
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowError);
}

4
applications/main/subghz/scenes/subghz_scene_show_error.c
View File

@@ -33,7 +33,7 @@ void subghz_scene_show_error_on_enter(void* context) {
AlignCenter,
AlignCenter,
FontSecondary,
string_get_cstr(subghz->error_str));
furi_string_get_cstr(subghz->error_str));
if(scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneShowError) ==
SubGhzCustomEventManagerSet) {
widget_add_button_element(
@@ -89,6 +89,6 @@ void subghz_scene_show_error_on_exit(void* context) {
scene_manager_set_scene_state(
subghz->scene_manager, SubGhzSceneShowError, SubGhzCustomEventManagerNoSet);
widget_reset(subghz->widget);
string_reset(subghz->error_str);
furi_string_reset(subghz->error_str);
notification_message(subghz->notifications, &sequence_reset_rgb);
}

4
applications/main/subghz/scenes/subghz_scene_show_error_sub.c
View File

@@ -12,7 +12,7 @@ void subghz_scene_show_error_sub_on_enter(void* context) {
// Setup view
Popup* popup = subghz->popup;
popup_set_icon(popup, 72, 17, &I_DolphinCommon_56x48);
popup_set_header(popup, string_get_cstr(subghz->error_str), 14, 15, AlignLeft, AlignTop);
popup_set_header(popup, furi_string_get_cstr(subghz->error_str), 14, 15, AlignLeft, AlignTop);
popup_set_timeout(popup, 1500);
popup_set_context(popup, subghz);
popup_set_callback(popup, subghz_scene_show_error_sub_popup_callback);
@@ -46,7 +46,7 @@ void subghz_scene_show_error_sub_on_exit(void* context) {
popup_set_context(popup, NULL);
popup_set_timeout(popup, 0);
popup_disable_timeout(popup);
string_reset(subghz->error_str);
furi_string_reset(subghz->error_str);
notification_message(subghz->notifications, &sequence_reset_rgb);
}

26
applications/main/subghz/scenes/subghz_scene_transmitter.c
View File

@@ -13,13 +13,13 @@ bool subghz_scene_transmitter_update_data_show(void* context) {
SubGhz* subghz = context;
if(subghz->txrx->decoder_result) {
string_t key_str;
string_t frequency_str;
string_t modulation_str;
FuriString* key_str;
FuriString* frequency_str;
FuriString* modulation_str;
string_init(key_str);
string_init(frequency_str);
string_init(modulation_str);
key_str = furi_string_alloc();
frequency_str = furi_string_alloc();
modulation_str = furi_string_alloc();
uint8_t show_button = 0;
subghz_protocol_decoder_base_deserialize(
@@ -34,14 +34,14 @@ bool subghz_scene_transmitter_update_data_show(void* context) {
subghz_get_frequency_modulation(subghz, frequency_str, modulation_str);
subghz_view_transmitter_add_data_to_show(
subghz->subghz_transmitter,
string_get_cstr(key_str),
string_get_cstr(frequency_str),
string_get_cstr(modulation_str),
furi_string_get_cstr(key_str),
furi_string_get_cstr(frequency_str),
furi_string_get_cstr(modulation_str),
show_button);
string_clear(frequency_str);
string_clear(modulation_str);
string_clear(key_str);
furi_string_free(frequency_str);
furi_string_free(modulation_str);
furi_string_free(key_str);
return true;
}
@@ -94,7 +94,7 @@ bool subghz_scene_transmitter_on_event(void* context, SceneManagerEvent event) {
subghz->scene_manager, SubGhzSceneStart);
return true;
} else if(event.event == SubGhzCustomEventViewTransmitterError) {
string_set_str(subghz->error_str, "Protocol not\nfound!");
furi_string_set(subghz->error_str, "Protocol not\nfound!");
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowErrorSub);
}
} else if(event.type == SceneManagerEventTypeTick) {

23
applications/main/subghz/subghz.c
View File

@@ -1,6 +1,5 @@
/* Abandon hope, all ye who enter here. */
#include "m-string.h"
#include "subghz/types.h"
#include "subghz_i.h"
#include <lib/toolbox/path.h>
@@ -62,8 +61,8 @@ void subghz_blink_stop(SubGhz* instance) {
SubGhz* subghz_alloc() {
SubGhz* subghz = malloc(sizeof(SubGhz));
string_init(subghz->file_path);
string_init(subghz->file_path_tmp);
subghz->file_path = furi_string_alloc();
subghz->file_path_tmp = furi_string_alloc();
// GUI
subghz->gui = furi_record_open(RECORD_GUI);
@@ -171,7 +170,7 @@ SubGhz* subghz_alloc() {
subghz->lock = SubGhzLockOff;
subghz->txrx = malloc(sizeof(SubGhzTxRx));
subghz->txrx->preset = malloc(sizeof(SubGhzPresetDefinition));
string_init(subghz->txrx->preset->name);
subghz->txrx->preset->name = furi_string_alloc();
subghz_preset_init(
subghz, "AM650", subghz_setting_get_default_frequency(subghz->setting), NULL, 0);
@@ -197,7 +196,7 @@ SubGhz* subghz_alloc() {
subghz_worker_set_context(subghz->txrx->worker, subghz->txrx->receiver);
//Init Error_str
string_init(subghz->error_str);
subghz->error_str = furi_string_alloc();
return subghz;
}
@@ -282,20 +281,20 @@ void subghz_free(SubGhz* subghz) {
subghz_worker_free(subghz->txrx->worker);
flipper_format_free(subghz->txrx->fff_data);
subghz_history_free(subghz->txrx->history);
string_clear(subghz->txrx->preset->name);
furi_string_free(subghz->txrx->preset->name);
free(subghz->txrx->preset);
free(subghz->txrx);
//Error string
string_clear(subghz->error_str);
furi_string_free(subghz->error_str);
// Notifications
furi_record_close(RECORD_NOTIFICATION);
subghz->notifications = NULL;
// Path strings
string_clear(subghz->file_path);
string_clear(subghz->file_path_tmp);
furi_string_free(subghz->file_path);
furi_string_free(subghz->file_path_tmp);
// The rest
free(subghz);
@@ -329,7 +328,7 @@ int32_t subghz_app(void* p) {
view_dispatcher_attach_to_gui(
subghz->view_dispatcher, subghz->gui, ViewDispatcherTypeFullscreen);
if(subghz_key_load(subghz, p, true)) {
string_set_str(subghz->file_path, p);
furi_string_set(subghz->file_path, (const char*)p);
if((!strcmp(subghz->txrx->decoder_result->protocol->name, "RAW"))) {
//Load Raw TX
@@ -348,13 +347,13 @@ int32_t subghz_app(void* p) {
} else {
view_dispatcher_attach_to_gui(
subghz->view_dispatcher, subghz->gui, ViewDispatcherTypeFullscreen);
string_set_str(subghz->file_path, SUBGHZ_APP_FOLDER);
furi_string_set(subghz->file_path, SUBGHZ_APP_FOLDER);
if(load_database) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneStart);
} else {
scene_manager_set_scene_state(
subghz->scene_manager, SubGhzSceneShowError, SubGhzCustomEventManagerSet);
string_set_str(
furi_string_set(
subghz->error_str,
"No SD card or\ndatabase found.\nSome app function\nmay be reduced.");
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowError);

229
applications/main/subghz/subghz_cli.c
View File

@@ -24,15 +24,15 @@
#define SUBGHZ_REGION_FILENAME "/int/.region_data"
void subghz_cli_command_tx_carrier(Cli* cli, string_t args, void* context) {
void subghz_cli_command_tx_carrier(Cli* cli, FuriString* args, void* context) {
UNUSED(context);
uint32_t frequency = 433920000;
if(string_size(args)) {
int ret = sscanf(string_get_cstr(args), "%lu", &frequency);
if(furi_string_size(args)) {
int ret = sscanf(furi_string_get_cstr(args), "%lu", &frequency);
if(ret != 1) {
printf("sscanf returned %d, frequency: %lu\r\n", ret, frequency);
cli_print_usage("subghz tx_carrier", "<Frequency: in Hz>", string_get_cstr(args));
cli_print_usage("subghz tx_carrier", "<Frequency: in Hz>", furi_string_get_cstr(args));
return;
}
if(!furi_hal_subghz_is_frequency_valid(frequency)) {
@@ -68,15 +68,15 @@ void subghz_cli_command_tx_carrier(Cli* cli, string_t args, void* context) {
furi_hal_power_suppress_charge_exit();
}
void subghz_cli_command_rx_carrier(Cli* cli, string_t args, void* context) {
void subghz_cli_command_rx_carrier(Cli* cli, FuriString* args, void* context) {
UNUSED(context);
uint32_t frequency = 433920000;
if(string_size(args)) {
int ret = sscanf(string_get_cstr(args), "%lu", &frequency);
if(furi_string_size(args)) {
int ret = sscanf(furi_string_get_cstr(args), "%lu", &frequency);
if(ret != 1) {
printf("sscanf returned %d, frequency: %lu\r\n", ret, frequency);
cli_print_usage("subghz rx_carrier", "<Frequency: in Hz>", string_get_cstr(args));
cli_print_usage("subghz rx_carrier", "<Frequency: in Hz>", furi_string_get_cstr(args));
return;
}
if(!furi_hal_subghz_is_frequency_valid(frequency)) {
@@ -109,15 +109,16 @@ void subghz_cli_command_rx_carrier(Cli* cli, string_t args, void* context) {
furi_hal_subghz_sleep();
}
void subghz_cli_command_tx(Cli* cli, string_t args, void* context) {
void subghz_cli_command_tx(Cli* cli, FuriString* args, void* context) {
UNUSED(context);
uint32_t frequency = 433920000;
uint32_t key = 0x0074BADE;
uint32_t repeat = 10;
uint32_t te = 403;
if(string_size(args)) {
int ret = sscanf(string_get_cstr(args), "%lx %lu %lu %lu", &key, &frequency, &te, &repeat);
if(furi_string_size(args)) {
int ret =
sscanf(furi_string_get_cstr(args), "%lx %lu %lu %lu", &key, &frequency, &te, &repeat);
if(ret != 4) {
printf(
"sscanf returned %d, key: %lx, frequency: %lu, te:%lu, repeat: %lu\r\n",
@@ -129,7 +130,7 @@ void subghz_cli_command_tx(Cli* cli, string_t args, void* context) {
cli_print_usage(
"subghz tx",
"<3 Byte Key: in hex> <Frequency: in Hz> <Te us> <Repeat count>",
string_get_cstr(args));
furi_string_get_cstr(args));
return;
}
if(!furi_hal_subghz_is_frequency_valid(frequency)) {
@@ -147,9 +148,7 @@ void subghz_cli_command_tx(Cli* cli, string_t args, void* context) {
te,
repeat);
string_t flipper_format_string;
string_init_printf(
flipper_format_string,
FuriString* flipper_format_string = furi_string_alloc_printf(
"Protocol: Princeton\n"
"Bit: 24\n"
"Key: 00 00 00 00 00 %02X %02X %02X\n"
@@ -163,7 +162,7 @@ void subghz_cli_command_tx(Cli* cli, string_t args, void* context) {
FlipperFormat* flipper_format = flipper_format_string_alloc();
Stream* stream = flipper_format_get_raw_stream(flipper_format);
stream_clean(stream);
stream_write_cstring(stream, string_get_cstr(flipper_format_string));
stream_write_cstring(stream, furi_string_get_cstr(flipper_format_string));
SubGhzEnvironment* environment = subghz_environment_alloc();
@@ -221,23 +220,23 @@ static void subghz_cli_command_rx_callback(
SubGhzCliCommandRx* instance = context;
instance->packet_count++;
string_t text;
string_init(text);
FuriString* text;
text = furi_string_alloc();
subghz_protocol_decoder_base_get_string(decoder_base, text);
subghz_receiver_reset(receiver);
printf("%s", string_get_cstr(text));
string_clear(text);
printf("%s", furi_string_get_cstr(text));
furi_string_free(text);
}
void subghz_cli_command_rx(Cli* cli, string_t args, void* context) {
void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
UNUSED(context);
uint32_t frequency = 433920000;
if(string_size(args)) {
int ret = sscanf(string_get_cstr(args), "%lu", &frequency);
if(furi_string_size(args)) {
int ret = sscanf(furi_string_get_cstr(args), "%lu", &frequency);
if(ret != 1) {
printf("sscanf returned %d, frequency: %lu\r\n", ret, frequency);
cli_print_usage("subghz rx", "<Frequency: in Hz>", string_get_cstr(args));
cli_print_usage("subghz rx", "<Frequency: in Hz>", furi_string_get_cstr(args));
return;
}
if(!furi_hal_subghz_is_frequency_valid(frequency)) {
@@ -309,32 +308,32 @@ void subghz_cli_command_rx(Cli* cli, string_t args, void* context) {
free(instance);
}
void subghz_cli_command_decode_raw(Cli* cli, string_t args, void* context) {
void subghz_cli_command_decode_raw(Cli* cli, FuriString* args, void* context) {
UNUSED(context);
string_t file_name;
string_init(file_name);
string_set_str(file_name, ANY_PATH("subghz/test.sub"));
FuriString* file_name;
file_name = furi_string_alloc();
furi_string_set(file_name, ANY_PATH("subghz/test.sub"));
Storage* storage = furi_record_open(RECORD_STORAGE);
FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
string_t temp_str;
string_init(temp_str);
FuriString* temp_str;
temp_str = furi_string_alloc();
uint32_t temp_data32;
bool check_file = false;
do {
if(string_size(args)) {
if(furi_string_size(args)) {
if(!args_read_string_and_trim(args, file_name)) {
cli_print_usage(
"subghz decode_raw", "<file_name: path_RAW_file>", string_get_cstr(args));
"subghz decode_raw", "<file_name: path_RAW_file>", furi_string_get_cstr(args));
break;
}
}
if(!flipper_format_file_open_existing(fff_data_file, string_get_cstr(file_name))) {
if(!flipper_format_file_open_existing(fff_data_file, furi_string_get_cstr(file_name))) {
printf(
"subghz decode_raw \033[0;31mError open file\033[0m %s\r\n",
string_get_cstr(file_name));
furi_string_get_cstr(file_name));
break;
}
@@ -343,7 +342,7 @@ void subghz_cli_command_decode_raw(Cli* cli, string_t args, void* context) {
break;
}
if(!strcmp(string_get_cstr(temp_str), SUBGHZ_RAW_FILE_TYPE) &&
if(!strcmp(furi_string_get_cstr(temp_str), SUBGHZ_RAW_FILE_TYPE) &&
temp_data32 == SUBGHZ_KEY_FILE_VERSION) {
} else {
printf("subghz decode_raw \033[0;31mType or version mismatch\033[0m\r\n");
@@ -353,7 +352,7 @@ void subghz_cli_command_decode_raw(Cli* cli, string_t args, void* context) {
check_file = true;
} while(false);
string_clear(temp_str);
furi_string_free(temp_str);
flipper_format_free(fff_data_file);
furi_record_close(RECORD_STORAGE);
@@ -385,14 +384,14 @@ void subghz_cli_command_decode_raw(Cli* cli, string_t args, void* context) {
subghz_receiver_set_rx_callback(receiver, subghz_cli_command_rx_callback, instance);
SubGhzFileEncoderWorker* file_worker_encoder = subghz_file_encoder_worker_alloc();
if(subghz_file_encoder_worker_start(file_worker_encoder, string_get_cstr(file_name))) {
if(subghz_file_encoder_worker_start(file_worker_encoder, furi_string_get_cstr(file_name))) {
//the worker needs a file in order to open and read part of the file
furi_delay_ms(100);
}
printf(
"Listening at \033[0;33m%s\033[0m.\r\n\r\nPress CTRL+C to stop\r\n\r\n",
string_get_cstr(file_name));
furi_string_get_cstr(file_name));
LevelDuration level_duration;
while(!cli_cmd_interrupt_received(cli)) {
@@ -419,7 +418,7 @@ void subghz_cli_command_decode_raw(Cli* cli, string_t args, void* context) {
subghz_file_encoder_worker_free(file_worker_encoder);
free(instance);
}
string_clear(file_name);
furi_string_free(file_name);
}
static void subghz_cli_command_print_usage() {
@@ -445,14 +444,14 @@ static void subghz_cli_command_print_usage() {
}
}
static void subghz_cli_command_encrypt_keeloq(Cli* cli, string_t args) {
static void subghz_cli_command_encrypt_keeloq(Cli* cli, FuriString* args) {
UNUSED(cli);
uint8_t iv[16];
string_t source;
string_t destination;
string_init(source);
string_init(destination);
FuriString* source;
FuriString* destination;
source = furi_string_alloc();
destination = furi_string_alloc();
SubGhzKeystore* keystore = subghz_keystore_alloc();
@@ -472,30 +471,30 @@ static void subghz_cli_command_encrypt_keeloq(Cli* cli, string_t args) {
break;
}
if(!subghz_keystore_load(keystore, string_get_cstr(source))) {
if(!subghz_keystore_load(keystore, furi_string_get_cstr(source))) {
printf("Failed to load Keystore");
break;
}
if(!subghz_keystore_save(keystore, string_get_cstr(destination), iv)) {
if(!subghz_keystore_save(keystore, furi_string_get_cstr(destination), iv)) {
printf("Failed to save Keystore");
break;
}
} while(false);
subghz_keystore_free(keystore);
string_clear(destination);
string_clear(source);
furi_string_free(destination);
furi_string_free(source);
}
static void subghz_cli_command_encrypt_raw(Cli* cli, string_t args) {
static void subghz_cli_command_encrypt_raw(Cli* cli, FuriString* args) {
UNUSED(cli);
uint8_t iv[16];
string_t source;
string_t destination;
string_init(source);
string_init(destination);
FuriString* source;
FuriString* destination;
source = furi_string_alloc();
destination = furi_string_alloc();
do {
if(!args_read_string_and_trim(args, source)) {
@@ -514,25 +513,25 @@ static void subghz_cli_command_encrypt_raw(Cli* cli, string_t args) {
}
if(!subghz_keystore_raw_encrypted_save(
string_get_cstr(source), string_get_cstr(destination), iv)) {
furi_string_get_cstr(source), furi_string_get_cstr(destination), iv)) {
printf("Failed to save Keystore");
break;
}
} while(false);
string_clear(destination);
string_clear(source);
furi_string_free(destination);
furi_string_free(source);
}
static void subghz_cli_command_chat(Cli* cli, string_t args) {
static void subghz_cli_command_chat(Cli* cli, FuriString* args) {
uint32_t frequency = 433920000;
if(string_size(args)) {
int ret = sscanf(string_get_cstr(args), "%lu", &frequency);
if(furi_string_size(args)) {
int ret = sscanf(furi_string_get_cstr(args), "%lu", &frequency);
if(ret != 1) {
printf("sscanf returned %d, frequency: %lu\r\n", ret, frequency);
cli_print_usage("subghz chat", "<Frequency: in Hz>", string_get_cstr(args));
cli_print_usage("subghz chat", "<Frequency: in Hz>", furi_string_get_cstr(args));
return;
}
if(!furi_hal_subghz_is_frequency_valid(frequency)) {
@@ -568,22 +567,22 @@ static void subghz_cli_command_chat(Cli* cli, string_t args) {
size_t message_max_len = 64;
uint8_t message[64] = {0};
string_t input;
string_init(input);
string_t name;
string_init(name);
string_t output;
string_init(output);
string_t sysmsg;
string_init(sysmsg);
FuriString* input;
input = furi_string_alloc();
FuriString* name;
name = furi_string_alloc();
FuriString* output;
output = furi_string_alloc();
FuriString* sysmsg;
sysmsg = furi_string_alloc();
bool exit = false;
SubGhzChatEvent chat_event;
NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
string_printf(name, "\033[0;33m%s\033[0m: ", furi_hal_version_get_name_ptr());
string_set(input, name);
printf("%s", string_get_cstr(input));
furi_string_printf(name, "\033[0;33m%s\033[0m: ", furi_hal_version_get_name_ptr());
furi_string_set(input, name);
printf("%s", furi_string_get_cstr(input));
fflush(stdout);
while(!exit) {
@@ -597,63 +596,63 @@ static void subghz_cli_command_chat(Cli* cli, string_t args) {
break;
} else if(
(chat_event.c == CliSymbolAsciiBackspace) || (chat_event.c == CliSymbolAsciiDel)) {
size_t len = string_length_u(input);
if(len > string_length_u(name)) {
size_t len = furi_string_utf8_length(input);
if(len > furi_string_utf8_length(name)) {
printf("%s", "\e[D\e[1P");
fflush(stdout);
//delete 1 char UTF
const char* str = string_get_cstr(input);
const char* str = furi_string_get_cstr(input);
size_t size = 0;
m_str1ng_utf8_state_e s = M_STRING_UTF8_STARTING;
string_unicode_t u = 0;
string_reset(sysmsg);
FuriStringUTF8State s = FuriStringUTF8StateStarting;
FuriStringUnicodeValue u = 0;
furi_string_reset(sysmsg);
while(*str) {
m_str1ng_utf8_decode(*str, &s, &u);
if((s == M_STRING_UTF8_ERROR) || s == M_STRING_UTF8_STARTING) {
string_push_u(sysmsg, u);
furi_string_utf8_decode(*str, &s, &u);
if((s == FuriStringUTF8StateError) || s == FuriStringUTF8StateStarting) {
furi_string_utf8_push(sysmsg, u);
if(++size >= len - 1) break;
s = M_STRING_UTF8_STARTING;
s = FuriStringUTF8StateStarting;
}
str++;
}
string_set(input, sysmsg);
furi_string_set(input, sysmsg);
}
} else if(chat_event.c == CliSymbolAsciiCR) {
printf("\r\n");
string_push_back(input, '\r');
string_push_back(input, '\n');
furi_string_push_back(input, '\r');
furi_string_push_back(input, '\n');
while(!subghz_chat_worker_write(
subghz_chat,
(uint8_t*)string_get_cstr(input),
strlen(string_get_cstr(input)))) {
(uint8_t*)furi_string_get_cstr(input),
strlen(furi_string_get_cstr(input)))) {
furi_delay_ms(10);
}
string_printf(input, "%s", string_get_cstr(name));
printf("%s", string_get_cstr(input));
furi_string_printf(input, "%s", furi_string_get_cstr(name));
printf("%s", furi_string_get_cstr(input));
fflush(stdout);
} else if(chat_event.c == CliSymbolAsciiLF) {
//cut out the symbol \n
} else {
putc(chat_event.c, stdout);
fflush(stdout);
string_push_back(input, chat_event.c);
furi_string_push_back(input, chat_event.c);
break;
case SubGhzChatEventRXData:
do {
memset(message, 0x00, message_max_len);
size_t len = subghz_chat_worker_read(subghz_chat, message, message_max_len);
for(size_t i = 0; i < len; i++) {
string_push_back(output, message[i]);
furi_string_push_back(output, message[i]);
if(message[i] == '\n') {
printf("\r");
for(uint8_t i = 0; i < 80; i++) {
printf(" ");
}
printf("\r %s", string_get_cstr(output));
printf("%s", string_get_cstr(input));
printf("\r %s", furi_string_get_cstr(output));
printf("%s", furi_string_get_cstr(input));
fflush(stdout);
string_reset(output);
furi_string_reset(output);
}
}
} while(subghz_chat_worker_available(subghz_chat));
@@ -662,22 +661,22 @@ static void subghz_cli_command_chat(Cli* cli, string_t args) {
notification_message(notification, &sequence_single_vibro);
break;
case SubGhzChatEventUserEntrance:
string_printf(
furi_string_printf(
sysmsg,
"\033[0;34m%s joined chat.\033[0m\r\n",
furi_hal_version_get_name_ptr());
subghz_chat_worker_write(
subghz_chat,
(uint8_t*)string_get_cstr(sysmsg),
strlen(string_get_cstr(sysmsg)));
(uint8_t*)furi_string_get_cstr(sysmsg),
strlen(furi_string_get_cstr(sysmsg)));
break;
case SubGhzChatEventUserExit:
string_printf(
furi_string_printf(
sysmsg, "\033[0;31m%s left chat.\033[0m\r\n", furi_hal_version_get_name_ptr());
subghz_chat_worker_write(
subghz_chat,
(uint8_t*)string_get_cstr(sysmsg),
strlen(string_get_cstr(sysmsg)));
(uint8_t*)furi_string_get_cstr(sysmsg),
strlen(furi_string_get_cstr(sysmsg)));
furi_delay_ms(10);
exit = true;
break;
@@ -693,10 +692,10 @@ static void subghz_cli_command_chat(Cli* cli, string_t args) {
}
}
string_clear(input);
string_clear(name);
string_clear(output);
string_clear(sysmsg);
furi_string_free(input);
furi_string_free(name);
furi_string_free(output);
furi_string_free(sysmsg);
furi_hal_power_suppress_charge_exit();
furi_record_close(RECORD_NOTIFICATION);
@@ -707,9 +706,9 @@ static void subghz_cli_command_chat(Cli* cli, string_t args) {
printf("\r\nExit chat\r\n");
}
static void subghz_cli_command(Cli* cli, string_t args, void* context) {
string_t cmd;
string_init(cmd);
static void subghz_cli_command(Cli* cli, FuriString* args, void* context) {
FuriString* cmd;
cmd = furi_string_alloc();
do {
if(!args_read_string_and_trim(args, cmd)) {
@@ -717,43 +716,43 @@ static void subghz_cli_command(Cli* cli, string_t args, void* context) {
break;
}
if(string_cmp_str(cmd, "chat") == 0) {
if(furi_string_cmp_str(cmd, "chat") == 0) {
subghz_cli_command_chat(cli, args);
break;
}
if(string_cmp_str(cmd, "tx") == 0) {
if(furi_string_cmp_str(cmd, "tx") == 0) {
subghz_cli_command_tx(cli, args, context);
break;
}
if(string_cmp_str(cmd, "rx") == 0) {
if(furi_string_cmp_str(cmd, "rx") == 0) {
subghz_cli_command_rx(cli, args, context);
break;
}
if(string_cmp_str(cmd, "decode_raw") == 0) {
if(furi_string_cmp_str(cmd, "decode_raw") == 0) {
subghz_cli_command_decode_raw(cli, args, context);
break;
}
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
if(string_cmp_str(cmd, "encrypt_keeloq") == 0) {
if(furi_string_cmp_str(cmd, "encrypt_keeloq") == 0) {
subghz_cli_command_encrypt_keeloq(cli, args);
break;
}
if(string_cmp_str(cmd, "encrypt_raw") == 0) {
if(furi_string_cmp_str(cmd, "encrypt_raw") == 0) {
subghz_cli_command_encrypt_raw(cli, args);
break;
}
if(string_cmp_str(cmd, "tx_carrier") == 0) {
if(furi_string_cmp_str(cmd, "tx_carrier") == 0) {
subghz_cli_command_tx_carrier(cli, args, context);
break;
}
if(string_cmp_str(cmd, "rx_carrier") == 0) {
if(furi_string_cmp_str(cmd, "rx_carrier") == 0) {
subghz_cli_command_rx_carrier(cli, args, context);
break;
}
@@ -762,7 +761,7 @@ static void subghz_cli_command(Cli* cli, string_t args, void* context) {
subghz_cli_command_print_usage();
} while(false);
string_clear(cmd);
furi_string_free(cmd);
}
static bool

67
applications/main/subghz/subghz_history.c
View File

@@ -3,13 +3,12 @@
#include <lib/subghz/protocols/came.h>
#include <furi.h>
#include <m-string.h>
#define SUBGHZ_HISTORY_MAX 50
#define TAG "SubGhzHistory"
typedef struct {
string_t item_str;
FuriString* item_str;
FlipperFormat* flipper_string;
uint8_t type;
SubGhzPresetDefinition* preset;
@@ -27,13 +26,13 @@ struct SubGhzHistory {
uint32_t last_update_timestamp;
uint16_t last_index_write;
uint8_t code_last_hash_data;
string_t tmp_string;
FuriString* tmp_string;
SubGhzHistoryStruct* history;
};
SubGhzHistory* subghz_history_alloc(void) {
SubGhzHistory* instance = malloc(sizeof(SubGhzHistory));
string_init(instance->tmp_string);
instance->tmp_string = furi_string_alloc();
instance->history = malloc(sizeof(SubGhzHistoryStruct));
SubGhzHistoryItemArray_init(instance->history->data);
return instance;
@@ -41,11 +40,11 @@ SubGhzHistory* subghz_history_alloc(void) {
void subghz_history_free(SubGhzHistory* instance) {
furi_assert(instance);
string_clear(instance->tmp_string);
furi_string_free(instance->tmp_string);
for
M_EACH(item, instance->history->data, SubGhzHistoryItemArray_t) {
string_clear(item->item_str);
string_clear(item->preset->name);
furi_string_free(item->item_str);
furi_string_free(item->preset->name);
free(item->preset);
flipper_format_free(item->flipper_string);
item->type = 0;
@@ -70,16 +69,16 @@ SubGhzPresetDefinition* subghz_history_get_preset_def(SubGhzHistory* instance, u
const char* subghz_history_get_preset(SubGhzHistory* instance, uint16_t idx) {
furi_assert(instance);
SubGhzHistoryItem* item = SubGhzHistoryItemArray_get(instance->history->data, idx);
return string_get_cstr(item->preset->name);
return furi_string_get_cstr(item->preset->name);
}
void subghz_history_reset(SubGhzHistory* instance) {
furi_assert(instance);
string_reset(instance->tmp_string);
furi_string_reset(instance->tmp_string);
for
M_EACH(item, instance->history->data, SubGhzHistoryItemArray_t) {
string_clear(item->item_str);
string_clear(item->preset->name);
furi_string_free(item->item_str);
furi_string_free(item->preset->name);
free(item->preset);
flipper_format_free(item->flipper_string);
item->type = 0;
@@ -106,9 +105,9 @@ const char* subghz_history_get_protocol_name(SubGhzHistory* instance, uint16_t i
flipper_format_rewind(item->flipper_string);
if(!flipper_format_read_string(item->flipper_string, "Protocol", instance->tmp_string)) {
FURI_LOG_E(TAG, "Missing Protocol");
string_reset(instance->tmp_string);
furi_string_reset(instance->tmp_string);
}
return string_get_cstr(instance->tmp_string);
return furi_string_get_cstr(instance->tmp_string);
}
FlipperFormat* subghz_history_get_raw_data(SubGhzHistory* instance, uint16_t idx) {
@@ -120,20 +119,20 @@ FlipperFormat* subghz_history_get_raw_data(SubGhzHistory* instance, uint16_t idx
return NULL;
}
}
bool subghz_history_get_text_space_left(SubGhzHistory* instance, string_t output) {
bool subghz_history_get_text_space_left(SubGhzHistory* instance, FuriString* output) {
furi_assert(instance);
if(instance->last_index_write == SUBGHZ_HISTORY_MAX) {
if(output != NULL) string_printf(output, "Memory is FULL");
if(output != NULL) furi_string_printf(output, "Memory is FULL");
return true;
}
if(output != NULL)
string_printf(output, "%02u/%02u", instance->last_index_write, SUBGHZ_HISTORY_MAX);
furi_string_printf(output, "%02u/%02u", instance->last_index_write, SUBGHZ_HISTORY_MAX);
return false;
}
void subghz_history_get_text_item_menu(SubGhzHistory* instance, string_t output, uint16_t idx) {
void subghz_history_get_text_item_menu(SubGhzHistory* instance, FuriString* output, uint16_t idx) {
SubGhzHistoryItem* item = SubGhzHistoryItemArray_get(instance->history->data, idx);
string_set(output, item->item_str);
furi_string_set(output, item->item_str);
}
bool subghz_history_add_to_history(
@@ -156,18 +155,18 @@ bool subghz_history_add_to_history(
instance->code_last_hash_data = subghz_protocol_decoder_base_get_hash_data(decoder_base);
instance->last_update_timestamp = furi_get_tick();
string_t text;
string_init(text);
FuriString* text;
text = furi_string_alloc();
SubGhzHistoryItem* item = SubGhzHistoryItemArray_push_raw(instance->history->data);
item->preset = malloc(sizeof(SubGhzPresetDefinition));
item->type = decoder_base->protocol->type;
item->preset->frequency = preset->frequency;
string_init(item->preset->name);
string_set(item->preset->name, preset->name);
item->preset->name = furi_string_alloc();
furi_string_set(item->preset->name, preset->name);
item->preset->data = preset->data;
item->preset->data_size = preset->data_size;
string_init(item->item_str);
item->item_str = furi_string_alloc();
item->flipper_string = flipper_format_string_alloc();
subghz_protocol_decoder_base_serialize(decoder_base, item->flipper_string, preset);
@@ -180,20 +179,20 @@ bool subghz_history_add_to_history(
FURI_LOG_E(TAG, "Missing Protocol");
break;
}
if(!strcmp(string_get_cstr(instance->tmp_string), "KeeLoq")) {
string_set_str(instance->tmp_string, "KL ");
if(!strcmp(furi_string_get_cstr(instance->tmp_string), "KeeLoq")) {
furi_string_set(instance->tmp_string, "KL ");
if(!flipper_format_read_string(item->flipper_string, "Manufacture", text)) {
FURI_LOG_E(TAG, "Missing Protocol");
break;
}
string_cat(instance->tmp_string, text);
} else if(!strcmp(string_get_cstr(instance->tmp_string), "Star Line")) {
string_set_str(instance->tmp_string, "SL ");
furi_string_cat(instance->tmp_string, text);
} else if(!strcmp(furi_string_get_cstr(instance->tmp_string), "Star Line")) {
furi_string_set(instance->tmp_string, "SL ");
if(!flipper_format_read_string(item->flipper_string, "Manufacture", text)) {
FURI_LOG_E(TAG, "Missing Protocol");
break;
}
string_cat(instance->tmp_string, text);
furi_string_cat(instance->tmp_string, text);
}
if(!flipper_format_rewind(item->flipper_string)) {
FURI_LOG_E(TAG, "Rewind error");
@@ -209,22 +208,22 @@ bool subghz_history_add_to_history(
data = (data << 8) | key_data[i];
}
if(!(uint32_t)(data >> 32)) {
string_printf(
furi_string_printf(
item->item_str,
"%s %lX",
string_get_cstr(instance->tmp_string),
furi_string_get_cstr(instance->tmp_string),
(uint32_t)(data & 0xFFFFFFFF));
} else {
string_printf(
furi_string_printf(
item->item_str,
"%s %lX%08lX",
string_get_cstr(instance->tmp_string),
furi_string_get_cstr(instance->tmp_string),
(uint32_t)(data >> 32),
(uint32_t)(data & 0xFFFFFFFF));
}
} while(false);
string_clear(text);
furi_string_free(text);
instance->last_index_write++;
return true;
}

8
applications/main/subghz/subghz_history.h
View File

@@ -71,18 +71,18 @@ const char* subghz_history_get_protocol_name(SubGhzHistory* instance, uint16_t i
/** Get string item menu to history[idx]
*
* @param instance - SubGhzHistory instance
* @param output - string_t output
* @param output - FuriString* output
* @param idx - record index
*/
void subghz_history_get_text_item_menu(SubGhzHistory* instance, string_t output, uint16_t idx);
void subghz_history_get_text_item_menu(SubGhzHistory* instance, FuriString* output, uint16_t idx);
/** Get string the remaining number of records to history
*
* @param instance - SubGhzHistory instance
* @param output - string_t output
* @param output - FuriString* output
* @return bool - is FUUL
*/
bool subghz_history_get_text_space_left(SubGhzHistory* instance, string_t output);
bool subghz_history_get_text_space_left(SubGhzHistory* instance, FuriString* output);
/** Add protocol to history
*

128
applications/main/subghz/subghz_i.c
View File

@@ -26,7 +26,7 @@ void subghz_preset_init(
size_t preset_data_size) {
furi_assert(context);
SubGhz* subghz = context;
string_set(subghz->txrx->preset->name, preset_name);
furi_string_set(subghz->txrx->preset->name, preset_name);
subghz->txrx->preset->frequency = frequency;
subghz->txrx->preset->data = preset_data;
subghz->txrx->preset->data_size = preset_data_size;
@@ -34,15 +34,15 @@ void subghz_preset_init(
bool subghz_set_preset(SubGhz* subghz, const char* preset) {
if(!strcmp(preset, "FuriHalSubGhzPresetOok270Async")) {
string_set(subghz->txrx->preset->name, "AM270");
furi_string_set(subghz->txrx->preset->name, "AM270");
} else if(!strcmp(preset, "FuriHalSubGhzPresetOok650Async")) {
string_set(subghz->txrx->preset->name, "AM650");
furi_string_set(subghz->txrx->preset->name, "AM650");
} else if(!strcmp(preset, "FuriHalSubGhzPreset2FSKDev238Async")) {
string_set(subghz->txrx->preset->name, "FM238");
furi_string_set(subghz->txrx->preset->name, "FM238");
} else if(!strcmp(preset, "FuriHalSubGhzPreset2FSKDev476Async")) {
string_set(subghz->txrx->preset->name, "FM476");
furi_string_set(subghz->txrx->preset->name, "FM476");
} else if(!strcmp(preset, "FuriHalSubGhzPresetCustom")) {
string_set(subghz->txrx->preset->name, "CUSTOM");
furi_string_set(subghz->txrx->preset->name, "CUSTOM");
} else {
FURI_LOG_E(TAG, "Unknown preset");
return false;
@@ -50,17 +50,17 @@ bool subghz_set_preset(SubGhz* subghz, const char* preset) {
return true;
}
void subghz_get_frequency_modulation(SubGhz* subghz, string_t frequency, string_t modulation) {
void subghz_get_frequency_modulation(SubGhz* subghz, FuriString* frequency, FuriString* modulation) {
furi_assert(subghz);
if(frequency != NULL) {
string_printf(
furi_string_printf(
frequency,
"%03ld.%02ld",
subghz->txrx->preset->frequency / 1000000 % 1000,
subghz->txrx->preset->frequency / 10000 % 100);
}
if(modulation != NULL) {
string_printf(modulation, "%0.2s", string_get_cstr(subghz->txrx->preset->name));
furi_string_printf(modulation, "%0.2s", furi_string_get_cstr(subghz->txrx->preset->name));
}
}
@@ -137,8 +137,8 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) {
furi_assert(subghz);
bool ret = false;
string_t temp_str;
string_init(temp_str);
FuriString* temp_str;
temp_str = furi_string_alloc();
uint32_t repeat = 200;
do {
if(!flipper_format_rewind(flipper_format)) {
@@ -155,21 +155,21 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) {
break;
}
subghz->txrx->transmitter =
subghz_transmitter_alloc_init(subghz->txrx->environment, string_get_cstr(temp_str));
subghz->txrx->transmitter = subghz_transmitter_alloc_init(
subghz->txrx->environment, furi_string_get_cstr(temp_str));
if(subghz->txrx->transmitter) {
if(subghz_transmitter_deserialize(subghz->txrx->transmitter, flipper_format)) {
if(strcmp(string_get_cstr(subghz->txrx->preset->name), "")) {
if(strcmp(furi_string_get_cstr(subghz->txrx->preset->name), "")) {
subghz_begin(
subghz,
subghz_setting_get_preset_data_by_name(
subghz->setting, string_get_cstr(subghz->txrx->preset->name)));
subghz->setting, furi_string_get_cstr(subghz->txrx->preset->name)));
} else {
FURI_LOG_E(
TAG,
"Unknown name preset \" %s \"",
string_get_cstr(subghz->txrx->preset->name));
furi_string_get_cstr(subghz->txrx->preset->name));
subghz_begin(
subghz, subghz_setting_get_preset_data_by_name(subghz->setting, "AM650"));
}
@@ -193,7 +193,7 @@ bool subghz_tx_start(SubGhz* subghz, FlipperFormat* flipper_format) {
}
} while(false);
string_clear(temp_str);
furi_string_free(temp_str);
return ret;
}
@@ -209,7 +209,7 @@ void subghz_tx_stop(SubGhz* subghz) {
if((subghz->txrx->decoder_result->protocol->type == SubGhzProtocolTypeDynamic) &&
(subghz_path_is_file(subghz->file_path))) {
subghz_save_protocol_to_file(
subghz, subghz->txrx->fff_data, string_get_cstr(subghz->file_path));
subghz, subghz->txrx->fff_data, furi_string_get_cstr(subghz->file_path));
}
subghz_idle(subghz);
notification_message(subghz->notifications, &sequence_reset_red);
@@ -244,8 +244,8 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
Stream* fff_data_stream = flipper_format_get_raw_stream(subghz->txrx->fff_data);
SubGhzLoadKeyState load_key_state = SubGhzLoadKeyStateParseErr;
string_t temp_str;
string_init(temp_str);
FuriString* temp_str;
temp_str = furi_string_alloc();
uint32_t temp_data32;
do {
@@ -260,8 +260,8 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
break;
}
if(((!strcmp(string_get_cstr(temp_str), SUBGHZ_KEY_FILE_TYPE)) ||
(!strcmp(string_get_cstr(temp_str), SUBGHZ_RAW_FILE_TYPE))) &&
if(((!strcmp(furi_string_get_cstr(temp_str), SUBGHZ_KEY_FILE_TYPE)) ||
(!strcmp(furi_string_get_cstr(temp_str), SUBGHZ_RAW_FILE_TYPE))) &&
temp_data32 == SUBGHZ_KEY_FILE_VERSION) {
} else {
FURI_LOG_E(TAG, "Type or version mismatch");
@@ -285,27 +285,29 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
break;
}
if(!subghz_set_preset(subghz, string_get_cstr(temp_str))) {
if(!subghz_set_preset(subghz, furi_string_get_cstr(temp_str))) {
break;
}
if(!strcmp(string_get_cstr(temp_str), "FuriHalSubGhzPresetCustom")) {
if(!strcmp(furi_string_get_cstr(temp_str), "FuriHalSubGhzPresetCustom")) {
//Todo add Custom_preset_module
//delete preset if it already exists
subghz_setting_delete_custom_preset(
subghz->setting, string_get_cstr(subghz->txrx->preset->name));
subghz->setting, furi_string_get_cstr(subghz->txrx->preset->name));
//load custom preset from file
if(!subghz_setting_load_custom_preset(
subghz->setting, string_get_cstr(subghz->txrx->preset->name), fff_data_file)) {
subghz->setting,
furi_string_get_cstr(subghz->txrx->preset->name),
fff_data_file)) {
FURI_LOG_E(TAG, "Missing Custom preset");
break;
}
}
size_t preset_index = subghz_setting_get_inx_preset_by_name(
subghz->setting, string_get_cstr(subghz->txrx->preset->name));
subghz->setting, furi_string_get_cstr(subghz->txrx->preset->name));
subghz_preset_init(
subghz,
string_get_cstr(subghz->txrx->preset->name),
furi_string_get_cstr(subghz->txrx->preset->name),
subghz->txrx->preset->frequency,
subghz_setting_get_preset_data(subghz->setting, preset_index),
subghz_setting_get_preset_data_size(subghz->setting, preset_index));
@@ -314,7 +316,7 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
FURI_LOG_E(TAG, "Missing Protocol");
break;
}
if(!strcmp(string_get_cstr(temp_str), "RAW")) {
if(!strcmp(furi_string_get_cstr(temp_str), "RAW")) {
//if RAW
subghz_protocol_raw_gen_fff_data(subghz->txrx->fff_data, file_path);
} else {
@@ -324,7 +326,7 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
}
subghz->txrx->decoder_result = subghz_receiver_search_decoder_base_by_name(
subghz->txrx->receiver, string_get_cstr(temp_str));
subghz->txrx->receiver, furi_string_get_cstr(temp_str));
if(subghz->txrx->decoder_result) {
if(!subghz_protocol_decoder_base_deserialize(
subghz->txrx->decoder_result, subghz->txrx->fff_data)) {
@@ -338,7 +340,7 @@ bool subghz_key_load(SubGhz* subghz, const char* file_path, bool show_dialog) {
load_key_state = SubGhzLoadKeyStateOK;
} while(0);
string_clear(temp_str);
furi_string_free(temp_str);
flipper_format_free(fff_data_file);
furi_record_close(RECORD_STORAGE);
@@ -362,42 +364,42 @@ bool subghz_get_next_name_file(SubGhz* subghz, uint8_t max_len) {
furi_assert(subghz);
Storage* storage = furi_record_open(RECORD_STORAGE);
string_t temp_str;
string_t file_name;
string_t file_path;
FuriString* temp_str;
FuriString* file_name;
FuriString* file_path;
string_init(temp_str);
string_init(file_name);
string_init(file_path);
temp_str = furi_string_alloc();
file_name = furi_string_alloc();
file_path = furi_string_alloc();
bool res = false;
if(subghz_path_is_file(subghz->file_path)) {
//get the name of the next free file
path_extract_filename(subghz->file_path, file_name, true);
path_extract_dirname(string_get_cstr(subghz->file_path), file_path);
path_extract_dirname(furi_string_get_cstr(subghz->file_path), file_path);
storage_get_next_filename(
storage,
string_get_cstr(file_path),
string_get_cstr(file_name),
furi_string_get_cstr(file_path),
furi_string_get_cstr(file_name),
SUBGHZ_APP_EXTENSION,
file_name,
max_len);
string_printf(
furi_string_printf(
temp_str,
"%s/%s%s",
string_get_cstr(file_path),
string_get_cstr(file_name),
furi_string_get_cstr(file_path),
furi_string_get_cstr(file_name),
SUBGHZ_APP_EXTENSION);
string_set(subghz->file_path, temp_str);
furi_string_set(subghz->file_path, temp_str);
res = true;
}
string_clear(temp_str);
string_clear(file_path);
string_clear(file_name);
furi_string_free(temp_str);
furi_string_free(file_path);
furi_string_free(file_name);
furi_record_close(RECORD_STORAGE);
return res;
@@ -415,8 +417,8 @@ bool subghz_save_protocol_to_file(
Stream* flipper_format_stream = flipper_format_get_raw_stream(flipper_format);
bool saved = false;
string_t file_dir;
string_init(file_dir);
FuriString* file_dir;
file_dir = furi_string_alloc();
path_extract_dirname(dev_file_name, file_dir);
do {
@@ -425,7 +427,7 @@ bool subghz_save_protocol_to_file(
flipper_format_delete_key(flipper_format, "Manufacture");
// Create subghz folder directory if necessary
if(!storage_simply_mkdir(storage, string_get_cstr(file_dir))) {
if(!storage_simply_mkdir(storage, furi_string_get_cstr(file_dir))) {
dialog_message_show_storage_error(subghz->dialogs, "Cannot create\nfolder");
break;
}
@@ -439,7 +441,7 @@ bool subghz_save_protocol_to_file(
saved = true;
} while(0);
string_clear(file_dir);
furi_string_free(file_dir);
furi_record_close(RECORD_STORAGE);
return saved;
}
@@ -447,8 +449,8 @@ bool subghz_save_protocol_to_file(
bool subghz_load_protocol_from_file(SubGhz* subghz) {
furi_assert(subghz);
string_t file_path;
string_init(file_path);
FuriString* file_path;
file_path = furi_string_alloc();
DialogsFileBrowserOptions browser_options;
dialog_file_browser_set_basic_options(&browser_options, SUBGHZ_APP_EXTENSION, &I_sub1_10px);
@@ -458,10 +460,10 @@ bool subghz_load_protocol_from_file(SubGhz* subghz) {
subghz->dialogs, subghz->file_path, subghz->file_path, &browser_options);
if(res) {
res = subghz_key_load(subghz, string_get_cstr(subghz->file_path), true);
res = subghz_key_load(subghz, furi_string_get_cstr(subghz->file_path), true);
}
string_clear(file_path);
furi_string_free(file_path);
return res;
}
@@ -472,9 +474,11 @@ bool subghz_rename_file(SubGhz* subghz) {
Storage* storage = furi_record_open(RECORD_STORAGE);
if(string_cmp(subghz->file_path_tmp, subghz->file_path)) {
if(furi_string_cmp(subghz->file_path_tmp, subghz->file_path)) {
FS_Error fs_result = storage_common_rename(
storage, string_get_cstr(subghz->file_path_tmp), string_get_cstr(subghz->file_path));
storage,
furi_string_get_cstr(subghz->file_path_tmp),
furi_string_get_cstr(subghz->file_path));
if(fs_result != FSE_OK) {
dialog_message_show_storage_error(subghz->dialogs, "Cannot rename\n file/directory");
@@ -490,7 +494,7 @@ bool subghz_delete_file(SubGhz* subghz) {
furi_assert(subghz);
Storage* storage = furi_record_open(RECORD_STORAGE);
bool result = storage_simply_remove(storage, string_get_cstr(subghz->file_path_tmp));
bool result = storage_simply_remove(storage, furi_string_get_cstr(subghz->file_path_tmp));
furi_record_close(RECORD_STORAGE);
subghz_file_name_clear(subghz);
@@ -500,12 +504,12 @@ bool subghz_delete_file(SubGhz* subghz) {
void subghz_file_name_clear(SubGhz* subghz) {
furi_assert(subghz);
string_set_str(subghz->file_path, SUBGHZ_APP_FOLDER);
string_reset(subghz->file_path_tmp);
furi_string_set(subghz->file_path, SUBGHZ_APP_FOLDER);
furi_string_reset(subghz->file_path_tmp);
}
bool subghz_path_is_file(string_t path) {
return string_end_with_str_p(path, SUBGHZ_APP_EXTENSION);
bool subghz_path_is_file(FuriString* path) {
return furi_string_end_with(path, SUBGHZ_APP_EXTENSION);
}
uint32_t subghz_random_serial(void) {

10
applications/main/subghz/subghz_i.h
View File

@@ -75,8 +75,8 @@ struct SubGhz {
TextInput* text_input;
Widget* widget;
DialogsApp* dialogs;
string_t file_path;
string_t file_path_tmp;
FuriString* file_path;
FuriString* file_path_tmp;
char file_name_tmp[SUBGHZ_MAX_LEN_NAME];
SubGhzNotificationState state_notifications;
@@ -89,7 +89,7 @@ struct SubGhz {
SubGhzTestStatic* subghz_test_static;
SubGhzTestCarrier* subghz_test_carrier;
SubGhzTestPacket* subghz_test_packet;
string_t error_str;
FuriString* error_str;
SubGhzSetting* setting;
SubGhzLock lock;
@@ -103,7 +103,7 @@ void subghz_preset_init(
uint8_t* preset_data,
size_t preset_data_size);
bool subghz_set_preset(SubGhz* subghz, const char* preset);
void subghz_get_frequency_modulation(SubGhz* subghz, string_t frequency, string_t modulation);
void subghz_get_frequency_modulation(SubGhz* subghz, FuriString* frequency, FuriString* modulation);
void subghz_begin(SubGhz* subghz, uint8_t* preset_data);
uint32_t subghz_rx(SubGhz* subghz, uint32_t frequency);
void subghz_rx_end(SubGhz* subghz);
@@ -125,6 +125,6 @@ bool subghz_load_protocol_from_file(SubGhz* subghz);
bool subghz_rename_file(SubGhz* subghz);
bool subghz_delete_file(SubGhz* subghz);
void subghz_file_name_clear(SubGhz* subghz);
bool subghz_path_is_file(string_t path);
bool subghz_path_is_file(FuriString* path);
uint32_t subghz_random_serial(void);
void subghz_hopper_update(SubGhz* subghz);

34
applications/main/subghz/subghz_setting.c
View File

@@ -158,7 +158,7 @@ static const uint32_t subghz_hopper_frequency_list_region_jp[] = {
};
typedef struct {
string_t custom_preset_name;
FuriString* custom_preset_name;
uint8_t* custom_preset_data;
size_t custom_preset_data_size;
} SubGhzSettingCustomPresetItem;
@@ -194,7 +194,7 @@ SubGhzSetting* subghz_setting_alloc(void) {
static void subghz_setting_preset_reset(SubGhzSetting* instance) {
for
M_EACH(item, instance->preset->data, SubGhzSettingCustomPresetItemArray_t) {
string_clear(item->custom_preset_name);
furi_string_free(item->custom_preset_name);
free(item->custom_preset_data);
}
SubGhzSettingCustomPresetItemArray_reset(instance->preset->data);
@@ -206,7 +206,7 @@ void subghz_setting_free(SubGhzSetting* instance) {
FrequencyList_clear(instance->hopper_frequencies);
for
M_EACH(item, instance->preset->data, SubGhzSettingCustomPresetItemArray_t) {
string_clear(item->custom_preset_name);
furi_string_free(item->custom_preset_name);
free(item->custom_preset_data);
}
SubGhzSettingCustomPresetItemArray_clear(instance->preset->data);
@@ -225,8 +225,8 @@ static void subghz_setting_load_default_preset(
SubGhzSettingCustomPresetItem* item =
SubGhzSettingCustomPresetItemArray_push_raw(instance->preset->data);
string_init(item->custom_preset_name);
string_set(item->custom_preset_name, preset_name);
item->custom_preset_name = furi_string_alloc();
furi_string_set(item->custom_preset_name, preset_name);
while(preset_data[preset_data_count]) {
preset_data_count += 2;
@@ -314,8 +314,8 @@ void subghz_setting_load(SubGhzSetting* instance, const char* file_path) {
Storage* storage = furi_record_open(RECORD_STORAGE);
FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
string_t temp_str;
string_init(temp_str);
FuriString* temp_str;
temp_str = furi_string_alloc();
uint32_t temp_data32;
bool temp_bool;
@@ -333,7 +333,7 @@ void subghz_setting_load(SubGhzSetting* instance, const char* file_path) {
break;
}
if((!strcmp(string_get_cstr(temp_str), SUBGHZ_SETTING_FILE_TYPE)) &&
if((!strcmp(furi_string_get_cstr(temp_str), SUBGHZ_SETTING_FILE_TYPE)) &&
temp_data32 == SUBGHZ_SETTING_FILE_VERSION) {
} else {
FURI_LOG_E(TAG, "Type or version mismatch");
@@ -402,15 +402,15 @@ void subghz_setting_load(SubGhzSetting* instance, const char* file_path) {
break;
}
while(flipper_format_read_string(fff_data_file, "Custom_preset_name", temp_str)) {
FURI_LOG_I(TAG, "Custom preset loaded %s", string_get_cstr(temp_str));
FURI_LOG_I(TAG, "Custom preset loaded %s", furi_string_get_cstr(temp_str));
subghz_setting_load_custom_preset(
instance, string_get_cstr(temp_str), fff_data_file);
instance, furi_string_get_cstr(temp_str), fff_data_file);
}
} while(false);
}
string_clear(temp_str);
furi_string_free(temp_str);
flipper_format_free(fff_data_file);
furi_record_close(RECORD_STORAGE);
@@ -440,7 +440,7 @@ const char* subghz_setting_get_preset_name(SubGhzSetting* instance, size_t idx)
furi_assert(instance);
SubGhzSettingCustomPresetItem* item =
SubGhzSettingCustomPresetItemArray_get(instance->preset->data, idx);
return string_get_cstr(item->custom_preset_name);
return furi_string_get_cstr(item->custom_preset_name);
}
int subghz_setting_get_inx_preset_by_name(SubGhzSetting* instance, const char* preset_name) {
@@ -448,7 +448,7 @@ int subghz_setting_get_inx_preset_by_name(SubGhzSetting* instance, const char* p
size_t idx = 0;
for
M_EACH(item, instance->preset->data, SubGhzSettingCustomPresetItemArray_t) {
if(strcmp(string_get_cstr(item->custom_preset_name), preset_name) == 0) {
if(strcmp(furi_string_get_cstr(item->custom_preset_name), preset_name) == 0) {
return idx;
}
idx++;
@@ -466,8 +466,8 @@ bool subghz_setting_load_custom_preset(
uint32_t temp_data32;
SubGhzSettingCustomPresetItem* item =
SubGhzSettingCustomPresetItemArray_push_raw(instance->preset->data);
string_init(item->custom_preset_name);
string_set(item->custom_preset_name, preset_name);
item->custom_preset_name = furi_string_alloc();
furi_string_set(item->custom_preset_name, preset_name);
do {
if(!flipper_format_get_value_count(fff_data_file, "Custom_preset_data", &temp_data32))
break;
@@ -497,8 +497,8 @@ bool subghz_setting_delete_custom_preset(SubGhzSetting* instance, const char* pr
SubGhzSettingCustomPresetItemArray_it_last(it, instance->preset->data);
while(!SubGhzSettingCustomPresetItemArray_end_p(it)) {
SubGhzSettingCustomPresetItem* item = SubGhzSettingCustomPresetItemArray_ref(it);
if(strcmp(string_get_cstr(item->custom_preset_name), preset_name) == 0) {
string_clear(item->custom_preset_name);
if(strcmp(furi_string_get_cstr(item->custom_preset_name), preset_name) == 0) {
furi_string_free(item->custom_preset_name);
free(item->custom_preset_data);
SubGhzSettingCustomPresetItemArray_remove(instance->preset->data, it);
return true;

63
applications/main/subghz/views/receiver.c
View File

@@ -5,7 +5,6 @@
#include <input/input.h>
#include <gui/elements.h>
#include <assets_icons.h>
#include <m-string.h>
#include <m-array.h>
#define FRAME_HEIGHT 12
@@ -14,7 +13,7 @@
#define UNLOCK_CNT 3
typedef struct {
string_t item_str;
FuriString* item_str;
uint8_t type;
} SubGhzReceiverMenuItem;
@@ -52,9 +51,9 @@ struct SubGhzViewReceiver {
};
typedef struct {
string_t frequency_str;
string_t preset_str;
string_t history_stat_str;
FuriString* frequency_str;
FuriString* preset_str;
FuriString* history_stat_str;
SubGhzReceiverHistory* history;
uint16_t idx;
uint16_t list_offset;
@@ -121,7 +120,7 @@ void subghz_view_receiver_add_item_to_menu(
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
SubGhzReceiverMenuItem* item_menu =
SubGhzReceiverMenuItemArray_push_raw(model->history->data);
string_init_set_str(item_menu->item_str, name);
item_menu->item_str = furi_string_alloc_set(name);
item_menu->type = type;
if((model->idx == model->history_item - 1)) {
model->history_item++;
@@ -143,9 +142,9 @@ void subghz_view_receiver_add_data_statusbar(
furi_assert(subghz_receiver);
with_view_model(
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
string_set_str(model->frequency_str, frequency_str);
string_set_str(model->preset_str, preset_str);
string_set_str(model->history_stat_str, history_stat_str);
furi_string_set(model->frequency_str, frequency_str);
furi_string_set(model->preset_str, preset_str);
furi_string_set(model->history_stat_str, history_stat_str);
return true;
});
}
@@ -173,15 +172,15 @@ void subghz_view_receiver_draw(Canvas* canvas, SubGhzViewReceiverModel* model) {
canvas_draw_line(canvas, 46, 51, 125, 51);
bool scrollbar = model->history_item > 4;
string_t str_buff;
string_init(str_buff);
FuriString* str_buff;
str_buff = furi_string_alloc();
SubGhzReceiverMenuItem* item_menu;
for(size_t i = 0; i < MIN(model->history_item, MENU_ITEMS); ++i) {
size_t idx = CLAMP((uint16_t)(i + model->list_offset), model->history_item, 0);
item_menu = SubGhzReceiverMenuItemArray_get(model->history->data, idx);
string_set(str_buff, item_menu->item_str);
furi_string_set(str_buff, item_menu->item_str);
elements_string_fit_width(canvas, str_buff, scrollbar ? MAX_LEN_PX - 6 : MAX_LEN_PX);
if(model->idx == idx) {
subghz_view_receiver_draw_frame(canvas, i, scrollbar);
@@ -189,13 +188,13 @@ void subghz_view_receiver_draw(Canvas* canvas, SubGhzViewReceiverModel* model) {
canvas_set_color(canvas, ColorBlack);
}
canvas_draw_icon(canvas, 1, 2 + i * FRAME_HEIGHT, ReceiverItemIcons[item_menu->type]);
canvas_draw_str(canvas, 15, 9 + i * FRAME_HEIGHT, string_get_cstr(str_buff));
string_reset(str_buff);
canvas_draw_str(canvas, 15, 9 + i * FRAME_HEIGHT, furi_string_get_cstr(str_buff));
furi_string_reset(str_buff);
}
if(scrollbar) {
elements_scrollbar_pos(canvas, 128, 0, 49, model->idx, model->history_item);
}
string_clear(str_buff);
furi_string_free(str_buff);
canvas_set_color(canvas, ColorBlack);
@@ -213,9 +212,9 @@ void subghz_view_receiver_draw(Canvas* canvas, SubGhzViewReceiverModel* model) {
canvas_draw_str(canvas, 74, 62, "Locked");
break;
case SubGhzViewReceiverBarShowToUnlockPress:
canvas_draw_str(canvas, 44, 62, string_get_cstr(model->frequency_str));
canvas_draw_str(canvas, 79, 62, string_get_cstr(model->preset_str));
canvas_draw_str(canvas, 96, 62, string_get_cstr(model->history_stat_str));
canvas_draw_str(canvas, 44, 62, furi_string_get_cstr(model->frequency_str));
canvas_draw_str(canvas, 79, 62, furi_string_get_cstr(model->preset_str));
canvas_draw_str(canvas, 96, 62, furi_string_get_cstr(model->history_stat_str));
canvas_set_font(canvas, FontSecondary);
elements_bold_rounded_frame(canvas, 14, 8, 99, 48);
elements_multiline_text(canvas, 65, 26, "To unlock\npress:");
@@ -230,9 +229,9 @@ void subghz_view_receiver_draw(Canvas* canvas, SubGhzViewReceiverModel* model) {
canvas_draw_str(canvas, 74, 62, "Unlocked");
break;
default:
canvas_draw_str(canvas, 44, 62, string_get_cstr(model->frequency_str));
canvas_draw_str(canvas, 79, 62, string_get_cstr(model->preset_str));
canvas_draw_str(canvas, 96, 62, string_get_cstr(model->history_stat_str));
canvas_draw_str(canvas, 44, 62, furi_string_get_cstr(model->frequency_str));
canvas_draw_str(canvas, 79, 62, furi_string_get_cstr(model->preset_str));
canvas_draw_str(canvas, 96, 62, furi_string_get_cstr(model->history_stat_str));
break;
}
}
@@ -331,12 +330,12 @@ void subghz_view_receiver_exit(void* context) {
SubGhzViewReceiver* subghz_receiver = context;
with_view_model(
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
string_reset(model->frequency_str);
string_reset(model->preset_str);
string_reset(model->history_stat_str);
furi_string_reset(model->frequency_str);
furi_string_reset(model->preset_str);
furi_string_reset(model->history_stat_str);
for
M_EACH(item_menu, model->history->data, SubGhzReceiverMenuItemArray_t) {
string_clear(item_menu->item_str);
furi_string_free(item_menu->item_str);
item_menu->type = 0;
}
SubGhzReceiverMenuItemArray_reset(model->history->data);
@@ -366,9 +365,9 @@ SubGhzViewReceiver* subghz_view_receiver_alloc() {
with_view_model(
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
string_init(model->frequency_str);
string_init(model->preset_str);
string_init(model->history_stat_str);
model->frequency_str = furi_string_alloc();
model->preset_str = furi_string_alloc();
model->history_stat_str = furi_string_alloc();
model->bar_show = SubGhzViewReceiverBarShowDefault;
model->history = malloc(sizeof(SubGhzReceiverHistory));
SubGhzReceiverMenuItemArray_init(model->history->data);
@@ -384,12 +383,12 @@ void subghz_view_receiver_free(SubGhzViewReceiver* subghz_receiver) {
with_view_model(
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
string_clear(model->frequency_str);
string_clear(model->preset_str);
string_clear(model->history_stat_str);
furi_string_free(model->frequency_str);
furi_string_free(model->preset_str);
furi_string_free(model->history_stat_str);
for
M_EACH(item_menu, model->history->data, SubGhzReceiverMenuItemArray_t) {
string_clear(item_menu->item_str);
furi_string_free(item_menu->item_str);
item_menu->type = 0;
}
SubGhzReceiverMenuItemArray_clear(model->history->data);

56
applications/main/subghz/views/subghz_read_raw.c
View File

@@ -18,10 +18,10 @@ struct SubGhzReadRAW {
};
typedef struct {
string_t frequency_str;
string_t preset_str;
string_t sample_write;
string_t file_name;
FuriString* frequency_str;
FuriString* preset_str;
FuriString* sample_write;
FuriString* file_name;
uint8_t* rssi_history;
bool rssi_history_end;
uint8_t ind_write;
@@ -46,8 +46,8 @@ void subghz_read_raw_add_data_statusbar(
furi_assert(instance);
with_view_model(
instance->view, (SubGhzReadRAWModel * model) {
string_set_str(model->frequency_str, frequency_str);
string_set_str(model->preset_str, preset_str);
furi_string_set(model->frequency_str, frequency_str);
furi_string_set(model->preset_str, preset_str);
return true;
});
}
@@ -78,7 +78,7 @@ void subghz_read_raw_update_sample_write(SubGhzReadRAW* instance, size_t sample)
with_view_model(
instance->view, (SubGhzReadRAWModel * model) {
string_printf(model->sample_write, "%d spl.", sample);
furi_string_printf(model->sample_write, "%d spl.", sample);
return false;
});
}
@@ -216,10 +216,10 @@ void subghz_read_raw_draw(Canvas* canvas, SubGhzReadRAWModel* model) {
uint8_t graphics_mode = 1;
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontSecondary);
canvas_draw_str(canvas, 5, 7, string_get_cstr(model->frequency_str));
canvas_draw_str(canvas, 40, 7, string_get_cstr(model->preset_str));
canvas_draw_str(canvas, 5, 7, furi_string_get_cstr(model->frequency_str));
canvas_draw_str(canvas, 40, 7, furi_string_get_cstr(model->preset_str));
canvas_draw_str_aligned(
canvas, 126, 0, AlignRight, AlignTop, string_get_cstr(model->sample_write));
canvas, 126, 0, AlignRight, AlignTop, furi_string_get_cstr(model->sample_write));
canvas_draw_line(canvas, 0, 14, 115, 14);
canvas_draw_line(canvas, 0, 48, 115, 48);
@@ -243,7 +243,7 @@ void subghz_read_raw_draw(Canvas* canvas, SubGhzReadRAWModel* model) {
30,
AlignCenter,
AlignCenter,
string_get_cstr(model->file_name),
furi_string_get_cstr(model->file_name),
true);
break;
@@ -372,8 +372,8 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
model->status = SubGhzReadRAWStatusStart;
model->rssi_history_end = false;
model->ind_write = 0;
string_set_str(model->sample_write, "0 spl.");
string_reset(model->file_name);
furi_string_set(model->sample_write, "0 spl.");
furi_string_reset(model->file_name);
instance->callback(SubGhzCustomEventViewReadRAWErase, instance->context);
}
return true;
@@ -423,8 +423,8 @@ void subghz_read_raw_set_status(
model->status = SubGhzReadRAWStatusStart;
model->rssi_history_end = false;
model->ind_write = 0;
string_reset(model->file_name);
string_set_str(model->sample_write, "0 spl.");
furi_string_reset(model->file_name);
furi_string_set(model->sample_write, "0 spl.");
return true;
});
break;
@@ -441,8 +441,8 @@ void subghz_read_raw_set_status(
model->status = SubGhzReadRAWStatusLoadKeyIDLE;
model->rssi_history_end = false;
model->ind_write = 0;
string_set_str(model->file_name, file_name);
string_set_str(model->sample_write, "RAW");
furi_string_set(model->file_name, file_name);
furi_string_set(model->sample_write, "RAW");
return true;
});
break;
@@ -451,10 +451,10 @@ void subghz_read_raw_set_status(
instance->view, (SubGhzReadRAWModel * model) {
model->status = SubGhzReadRAWStatusLoadKeyIDLE;
if(!model->ind_write) {
string_set_str(model->file_name, file_name);
string_set_str(model->sample_write, "RAW");
furi_string_set(model->file_name, file_name);
furi_string_set(model->sample_write, "RAW");
} else {
string_reset(model->file_name);
furi_string_reset(model->file_name);
}
return true;
});
@@ -501,10 +501,10 @@ SubGhzReadRAW* subghz_read_raw_alloc() {
with_view_model(
instance->view, (SubGhzReadRAWModel * model) {
string_init(model->frequency_str);
string_init(model->preset_str);
string_init(model->sample_write);
string_init(model->file_name);
model->frequency_str = furi_string_alloc();
model->preset_str = furi_string_alloc();
model->sample_write = furi_string_alloc();
model->file_name = furi_string_alloc();
model->rssi_history = malloc(SUBGHZ_READ_RAW_RSSI_HISTORY_SIZE * sizeof(uint8_t));
return true;
});
@@ -517,10 +517,10 @@ void subghz_read_raw_free(SubGhzReadRAW* instance) {
with_view_model(
instance->view, (SubGhzReadRAWModel * model) {
string_clear(model->frequency_str);
string_clear(model->preset_str);
string_clear(model->sample_write);
string_clear(model->file_name);
furi_string_free(model->frequency_str);
furi_string_free(model->preset_str);
furi_string_free(model->sample_write);
furi_string_free(model->file_name);
free(model->rssi_history);
return true;
});

36
applications/main/subghz/views/transmitter.c
View File

@@ -11,9 +11,9 @@ struct SubGhzViewTransmitter {
};
typedef struct {
string_t frequency_str;
string_t preset_str;
string_t key_str;
FuriString* frequency_str;
FuriString* preset_str;
FuriString* key_str;
uint8_t show_button;
} SubGhzViewTransmitterModel;
@@ -36,9 +36,9 @@ void subghz_view_transmitter_add_data_to_show(
furi_assert(subghz_transmitter);
with_view_model(
subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
string_set_str(model->key_str, key_str);
string_set_str(model->frequency_str, frequency_str);
string_set_str(model->preset_str, preset_str);
furi_string_set(model->key_str, key_str);
furi_string_set(model->frequency_str, frequency_str);
furi_string_set(model->preset_str, preset_str);
model->show_button = show_button;
return true;
});
@@ -82,9 +82,9 @@ void subghz_view_transmitter_draw(Canvas* canvas, SubGhzViewTransmitterModel* mo
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontSecondary);
elements_multiline_text(canvas, 0, 8, string_get_cstr(model->key_str));
canvas_draw_str(canvas, 78, 8, string_get_cstr(model->frequency_str));
canvas_draw_str(canvas, 113, 8, string_get_cstr(model->preset_str));
elements_multiline_text(canvas, 0, 8, furi_string_get_cstr(model->key_str));
canvas_draw_str(canvas, 78, 8, furi_string_get_cstr(model->frequency_str));
canvas_draw_str(canvas, 113, 8, furi_string_get_cstr(model->preset_str));
if(model->show_button) subghz_view_transmitter_button_right(canvas, "Send");
}
@@ -96,9 +96,9 @@ bool subghz_view_transmitter_input(InputEvent* event, void* context) {
if(event->key == InputKeyBack && event->type == InputTypeShort) {
with_view_model(
subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
string_reset(model->frequency_str);
string_reset(model->preset_str);
string_reset(model->key_str);
furi_string_reset(model->frequency_str);
furi_string_reset(model->preset_str);
furi_string_reset(model->key_str);
model->show_button = 0;
return false;
});
@@ -150,9 +150,9 @@ SubGhzViewTransmitter* subghz_view_transmitter_alloc() {
with_view_model(
subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
string_init(model->frequency_str);
string_init(model->preset_str);
string_init(model->key_str);
model->frequency_str = furi_string_alloc();
model->preset_str = furi_string_alloc();
model->key_str = furi_string_alloc();
return true;
});
return subghz_transmitter;
@@ -163,9 +163,9 @@ void subghz_view_transmitter_free(SubGhzViewTransmitter* subghz_transmitter) {
with_view_model(
subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
string_clear(model->frequency_str);
string_clear(model->preset_str);
string_clear(model->key_str);
furi_string_free(model->frequency_str);
furi_string_free(model->preset_str);
furi_string_free(model->key_str);
return true;
});
view_free(subghz_transmitter->view);