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

89
applications/main/infrared/infrared.c
View File

@@ -65,51 +65,52 @@ static void infrared_rpc_command_callback(RpcAppSystemEvent event, void* context
}
}
static void infrared_find_vacant_remote_name(string_t name, const char* path) {
static void infrared_find_vacant_remote_name(FuriString* name, const char* path) {
Storage* storage = furi_record_open(RECORD_STORAGE);
string_t base_path;
string_init_set_str(base_path, path);
FuriString* base_path;
base_path = furi_string_alloc_set(path);
if(string_end_with_str_p(base_path, INFRARED_APP_EXTENSION)) {
size_t filename_start = string_search_rchar(base_path, '/');
string_left(base_path, filename_start);
if(furi_string_end_with(base_path, INFRARED_APP_EXTENSION)) {
size_t filename_start = furi_string_search_rchar(base_path, '/');
furi_string_left(base_path, filename_start);
}
string_printf(base_path, "%s/%s%s", path, string_get_cstr(name), INFRARED_APP_EXTENSION);
furi_string_printf(
base_path, "%s/%s%s", path, furi_string_get_cstr(name), INFRARED_APP_EXTENSION);
FS_Error status = storage_common_stat(storage, string_get_cstr(base_path), NULL);
FS_Error status = storage_common_stat(storage, furi_string_get_cstr(base_path), NULL);
if(status == FSE_OK) {
/* If the suggested name is occupied, try another one (name2, name3, etc) */
size_t dot = string_search_rchar(base_path, '.');
string_left(base_path, dot);
size_t dot = furi_string_search_rchar(base_path, '.');
furi_string_left(base_path, dot);
string_t path_temp;
string_init(path_temp);
FuriString* path_temp;
path_temp = furi_string_alloc();
uint32_t i = 1;
do {
string_printf(
path_temp, "%s%u%s", string_get_cstr(base_path), ++i, INFRARED_APP_EXTENSION);
status = storage_common_stat(storage, string_get_cstr(path_temp), NULL);
furi_string_printf(
path_temp, "%s%u%s", furi_string_get_cstr(base_path), ++i, INFRARED_APP_EXTENSION);
status = storage_common_stat(storage, furi_string_get_cstr(path_temp), NULL);
} while(status == FSE_OK);
string_clear(path_temp);
furi_string_free(path_temp);
if(status == FSE_NOT_EXIST) {
string_cat_printf(name, "%u", i);
furi_string_cat_printf(name, "%u", i);
}
}
string_clear(base_path);
furi_string_free(base_path);
furi_record_close(RECORD_STORAGE);
}
static Infrared* infrared_alloc() {
Infrared* infrared = malloc(sizeof(Infrared));
string_init(infrared->file_path);
infrared->file_path = furi_string_alloc();
InfraredAppState* app_state = &infrared->app_state;
app_state->is_learning_new_remote = false;
@@ -232,7 +233,7 @@ static void infrared_free(Infrared* infrared) {
furi_record_close(RECORD_GUI);
infrared->gui = NULL;
string_clear(infrared->file_path);
furi_string_free(infrared->file_path);
free(infrared);
}
@@ -243,19 +244,20 @@ bool infrared_add_remote_with_button(
InfraredSignal* signal) {
InfraredRemote* remote = infrared->remote;
string_t new_name, new_path;
string_init_set_str(new_name, INFRARED_DEFAULT_REMOTE_NAME);
string_init_set_str(new_path, INFRARED_APP_FOLDER);
FuriString *new_name, *new_path;
new_name = furi_string_alloc_set(INFRARED_DEFAULT_REMOTE_NAME);
new_path = furi_string_alloc_set(INFRARED_APP_FOLDER);
infrared_find_vacant_remote_name(new_name, string_get_cstr(new_path));
string_cat_printf(new_path, "/%s%s", string_get_cstr(new_name), INFRARED_APP_EXTENSION);
infrared_find_vacant_remote_name(new_name, furi_string_get_cstr(new_path));
furi_string_cat_printf(
new_path, "/%s%s", furi_string_get_cstr(new_name), INFRARED_APP_EXTENSION);
infrared_remote_reset(remote);
infrared_remote_set_name(remote, string_get_cstr(new_name));
infrared_remote_set_path(remote, string_get_cstr(new_path));
infrared_remote_set_name(remote, furi_string_get_cstr(new_name));
infrared_remote_set_path(remote, furi_string_get_cstr(new_path));
string_clear(new_name);
string_clear(new_path);
furi_string_free(new_name);
furi_string_free(new_path);
return infrared_remote_add_button(remote, button_name, signal);
}
@@ -267,28 +269,29 @@ bool infrared_rename_current_remote(Infrared* infrared, const char* name) {
return true;
}
string_t new_name;
string_init_set_str(new_name, name);
FuriString* new_name;
new_name = furi_string_alloc_set(name);
infrared_find_vacant_remote_name(new_name, remote_path);
string_t new_path;
string_init_set(new_path, infrared_remote_get_path(remote));
if(string_end_with_str_p(new_path, INFRARED_APP_EXTENSION)) {
size_t filename_start = string_search_rchar(new_path, '/');
string_left(new_path, filename_start);
FuriString* new_path;
new_path = furi_string_alloc_set(infrared_remote_get_path(remote));
if(furi_string_end_with(new_path, INFRARED_APP_EXTENSION)) {
size_t filename_start = furi_string_search_rchar(new_path, '/');
furi_string_left(new_path, filename_start);
}
string_cat_printf(new_path, "/%s%s", string_get_cstr(new_name), INFRARED_APP_EXTENSION);
furi_string_cat_printf(
new_path, "/%s%s", furi_string_get_cstr(new_name), INFRARED_APP_EXTENSION);
Storage* storage = furi_record_open(RECORD_STORAGE);
FS_Error status = storage_common_rename(
storage, infrared_remote_get_path(remote), string_get_cstr(new_path));
infrared_remote_set_name(remote, string_get_cstr(new_name));
infrared_remote_set_path(remote, string_get_cstr(new_path));
storage, infrared_remote_get_path(remote), furi_string_get_cstr(new_path));
infrared_remote_set_name(remote, furi_string_get_cstr(new_name));
infrared_remote_set_path(remote, furi_string_get_cstr(new_path));
string_clear(new_name);
string_clear(new_path);
furi_string_free(new_name);
furi_string_free(new_path);
furi_record_close(RECORD_STORAGE);
return (status == FSE_OK || status == FSE_EXIST);
@@ -435,7 +438,7 @@ int32_t infrared_app(void* p) {
rpc_system_app_send_started(infrared->rpc_ctx);
is_rpc_mode = true;
} else {
string_set_str(infrared->file_path, (const char*)p);
furi_string_set(infrared->file_path, (const char*)p);
is_remote_loaded = infrared_remote_load(infrared->remote, infrared->file_path);
if(!is_remote_loaded) {
dialog_message_show_storage_error(

27
applications/main/infrared/infrared_brute_force.c
View File

@@ -2,7 +2,6 @@
#include <stdlib.h>
#include <m-dict.h>
#include <m-string.h>
#include <flipper_format/flipper_format.h>
#include "infrared_signal.h"
@@ -14,15 +13,15 @@ typedef struct {
DICT_DEF2(
InfraredBruteForceRecordDict,
string_t,
STRING_OPLIST,
FuriString*,
FURI_STRING_OPLIST,
InfraredBruteForceRecord,
M_POD_OPLIST);
struct InfraredBruteForce {
FlipperFormat* ff;
const char* db_filename;
string_t current_record_name;
FuriString* current_record_name;
InfraredSignal* current_signal;
InfraredBruteForceRecordDict_t records;
bool is_started;
@@ -34,7 +33,7 @@ InfraredBruteForce* infrared_brute_force_alloc() {
brute_force->db_filename = NULL;
brute_force->current_signal = NULL;
brute_force->is_started = false;
string_init(brute_force->current_record_name);
brute_force->current_record_name = furi_string_alloc();
InfraredBruteForceRecordDict_init(brute_force->records);
return brute_force;
}
@@ -42,7 +41,7 @@ InfraredBruteForce* infrared_brute_force_alloc() {
void infrared_brute_force_free(InfraredBruteForce* brute_force) {
furi_assert(!brute_force->is_started);
InfraredBruteForceRecordDict_clear(brute_force->records);
string_clear(brute_force->current_record_name);
furi_string_free(brute_force->current_record_name);
free(brute_force);
}
@@ -61,8 +60,8 @@ bool infrared_brute_force_calculate_messages(InfraredBruteForce* brute_force) {
success = flipper_format_buffered_file_open_existing(ff, brute_force->db_filename);
if(success) {
string_t signal_name;
string_init(signal_name);
FuriString* signal_name;
signal_name = furi_string_alloc();
while(flipper_format_read_string(ff, "name", signal_name)) {
InfraredBruteForceRecord* record =
InfraredBruteForceRecordDict_get(brute_force->records, signal_name);
@@ -70,7 +69,7 @@ bool infrared_brute_force_calculate_messages(InfraredBruteForce* brute_force) {
++(record->count);
}
}
string_clear(signal_name);
furi_string_free(signal_name);
}
flipper_format_free(ff);
@@ -94,7 +93,7 @@ bool infrared_brute_force_start(
if(record->value.index == index) {
*record_count = record->value.count;
if(*record_count) {
string_set(brute_force->current_record_name, record->key);
furi_string_set(brute_force->current_record_name, record->key);
}
break;
}
@@ -118,7 +117,7 @@ bool infrared_brute_force_is_started(InfraredBruteForce* brute_force) {
void infrared_brute_force_stop(InfraredBruteForce* brute_force) {
furi_assert(brute_force->is_started);
string_reset(brute_force->current_record_name);
furi_string_reset(brute_force->current_record_name);
infrared_signal_free(brute_force->current_signal);
flipper_format_free(brute_force->ff);
brute_force->current_signal = NULL;
@@ -142,10 +141,10 @@ void infrared_brute_force_add_record(
uint32_t index,
const char* name) {
InfraredBruteForceRecord value = {.index = index, .count = 0};
string_t key;
string_init_set_str(key, name);
FuriString* key;
key = furi_string_alloc_set(name);
InfraredBruteForceRecordDict_set_at(brute_force->records, key, value);
string_clear(key);
furi_string_free(key);
}
void infrared_brute_force_reset(InfraredBruteForce* brute_force) {

83
applications/main/infrared/infrared_cli.c
View File

@@ -1,4 +1,3 @@
#include <m-string.h>
#include <cli/cli.h>
#include <infrared.h>
#include <infrared_worker.h>
@@ -10,13 +9,13 @@
#define INFRARED_CLI_BUF_SIZE 10
static void infrared_cli_start_ir_rx(Cli* cli, string_t args);
static void infrared_cli_start_ir_tx(Cli* cli, string_t args);
static void infrared_cli_process_decode(Cli* cli, string_t args);
static void infrared_cli_start_ir_rx(Cli* cli, FuriString* args);
static void infrared_cli_start_ir_tx(Cli* cli, FuriString* args);
static void infrared_cli_process_decode(Cli* cli, FuriString* args);
static const struct {
const char* cmd;
void (*process_function)(Cli* cli, string_t args);
void (*process_function)(Cli* cli, FuriString* args);
} infrared_cli_commands[] = {
{.cmd = "rx", .process_function = infrared_cli_start_ir_rx},
{.cmd = "tx", .process_function = infrared_cli_start_ir_tx},
@@ -58,7 +57,7 @@ static void signal_received_callback(void* context, InfraredWorkerSignal* receiv
}
}
static void infrared_cli_start_ir_rx(Cli* cli, string_t args) {
static void infrared_cli_start_ir_rx(Cli* cli, FuriString* args) {
UNUSED(cli);
UNUSED(args);
InfraredWorker* worker = infrared_worker_alloc();
@@ -151,9 +150,9 @@ static bool infrared_cli_parse_raw(const char* str, InfraredSignal* signal) {
return infrared_signal_is_valid(signal);
}
static void infrared_cli_start_ir_tx(Cli* cli, string_t args) {
static void infrared_cli_start_ir_tx(Cli* cli, FuriString* args) {
UNUSED(cli);
const char* str = string_get_cstr(args);
const char* str = furi_string_get_cstr(args);
InfraredSignal* signal = infrared_signal_alloc();
bool success = infrared_cli_parse_message(str, signal) || infrared_cli_parse_raw(str, signal);
@@ -231,8 +230,8 @@ static bool infrared_cli_decode_file(FlipperFormat* input_file, FlipperFormat* o
InfraredSignal* signal = infrared_signal_alloc();
InfraredDecoderHandler* decoder = infrared_alloc_decoder();
string_t tmp;
string_init(tmp);
FuriString* tmp;
tmp = furi_string_alloc();
while(infrared_signal_read(signal, input_file, tmp)) {
ret = false;
@@ -242,7 +241,7 @@ static bool infrared_cli_decode_file(FlipperFormat* input_file, FlipperFormat* o
}
if(!infrared_signal_is_raw(signal)) {
if(output_file &&
!infrared_cli_save_signal(signal, output_file, string_get_cstr(tmp))) {
!infrared_cli_save_signal(signal, output_file, furi_string_get_cstr(tmp))) {
break;
} else {
printf("Skipping decoded signal\r\n");
@@ -250,31 +249,33 @@ static bool infrared_cli_decode_file(FlipperFormat* input_file, FlipperFormat* o
}
}
InfraredRawSignal* raw_signal = infrared_signal_get_raw_signal(signal);
printf("Raw signal: %s, %u samples\r\n", string_get_cstr(tmp), raw_signal->timings_size);
if(!infrared_cli_decode_raw_signal(raw_signal, decoder, output_file, string_get_cstr(tmp)))
printf(
"Raw signal: %s, %u samples\r\n", furi_string_get_cstr(tmp), raw_signal->timings_size);
if(!infrared_cli_decode_raw_signal(
raw_signal, decoder, output_file, furi_string_get_cstr(tmp)))
break;
ret = true;
}
infrared_free_decoder(decoder);
infrared_signal_free(signal);
string_clear(tmp);
furi_string_free(tmp);
return ret;
}
static void infrared_cli_process_decode(Cli* cli, string_t args) {
static void infrared_cli_process_decode(Cli* cli, FuriString* args) {
UNUSED(cli);
Storage* storage = furi_record_open(RECORD_STORAGE);
FlipperFormat* input_file = flipper_format_buffered_file_alloc(storage);
FlipperFormat* output_file = NULL;
uint32_t version;
string_t tmp, header, input_path, output_path;
string_init(tmp);
string_init(header);
string_init(input_path);
string_init(output_path);
FuriString *tmp, *header, *input_path, *output_path;
tmp = furi_string_alloc();
header = furi_string_alloc();
input_path = furi_string_alloc();
output_path = furi_string_alloc();
do {
if(!args_read_probably_quoted_string_and_trim(args, input_path)) {
@@ -283,26 +284,32 @@ static void infrared_cli_process_decode(Cli* cli, string_t args) {
break;
}
args_read_probably_quoted_string_and_trim(args, output_path);
if(!flipper_format_buffered_file_open_existing(input_file, string_get_cstr(input_path))) {
printf("Failed to open file for reading: \"%s\"\r\n", string_get_cstr(input_path));
if(!flipper_format_buffered_file_open_existing(
input_file, furi_string_get_cstr(input_path))) {
printf(
"Failed to open file for reading: \"%s\"\r\n", furi_string_get_cstr(input_path));
break;
}
if(!flipper_format_read_header(input_file, header, &version) ||
(!string_start_with_str_p(header, "IR")) || version != 1) {
printf("Invalid or corrupted input file: \"%s\"\r\n", string_get_cstr(input_path));
(!furi_string_start_with_str(header, "IR")) || version != 1) {
printf(
"Invalid or corrupted input file: \"%s\"\r\n", furi_string_get_cstr(input_path));
break;
}
if(!string_empty_p(output_path)) {
printf("Writing output to file: \"%s\"\r\n", string_get_cstr(output_path));
if(!furi_string_empty(output_path)) {
printf("Writing output to file: \"%s\"\r\n", furi_string_get_cstr(output_path));
output_file = flipper_format_file_alloc(storage);
}
if(output_file &&
!flipper_format_file_open_always(output_file, string_get_cstr(output_path))) {
printf("Failed to open file for writing: \"%s\"\r\n", string_get_cstr(output_path));
!flipper_format_file_open_always(output_file, furi_string_get_cstr(output_path))) {
printf(
"Failed to open file for writing: \"%s\"\r\n", furi_string_get_cstr(output_path));
break;
}
if(output_file && !flipper_format_write_header(output_file, header, version)) {
printf("Failed to write to the output file: \"%s\"\r\n", string_get_cstr(output_path));
printf(
"Failed to write to the output file: \"%s\"\r\n",
furi_string_get_cstr(output_path));
break;
}
if(!infrared_cli_decode_file(input_file, output_file)) {
@@ -311,31 +318,31 @@ static void infrared_cli_process_decode(Cli* cli, string_t args) {
printf("File successfully decoded.\r\n");
} while(false);
string_clear(tmp);
string_clear(header);
string_clear(input_path);
string_clear(output_path);
furi_string_free(tmp);
furi_string_free(header);
furi_string_free(input_path);
furi_string_free(output_path);
flipper_format_free(input_file);
if(output_file) flipper_format_free(output_file);
furi_record_close(RECORD_STORAGE);
}
static void infrared_cli_start_ir(Cli* cli, string_t args, void* context) {
static void infrared_cli_start_ir(Cli* cli, FuriString* args, void* context) {
UNUSED(context);
if(furi_hal_infrared_is_busy()) {
printf("INFRARED is busy. Exiting.");
return;
}
string_t command;
string_init(command);
FuriString* command;
command = furi_string_alloc();
args_read_string_and_trim(args, command);
size_t i = 0;
for(; i < COUNT_OF(infrared_cli_commands); ++i) {
size_t cmd_len = strlen(infrared_cli_commands[i].cmd);
if(!strncmp(string_get_cstr(command), infrared_cli_commands[i].cmd, cmd_len)) {
if(!strncmp(furi_string_get_cstr(command), infrared_cli_commands[i].cmd, cmd_len)) {
break;
}
}
@@ -346,7 +353,7 @@ static void infrared_cli_start_ir(Cli* cli, string_t args, void* context) {
infrared_cli_print_usage();
}
string_clear(command);
furi_string_free(command);
}
void infrared_on_system_start() {
#ifdef SRV_CLI

2
applications/main/infrared/infrared_i.h
View File

@@ -96,7 +96,7 @@ struct Infrared {
Loading* loading;
InfraredProgressView* progress;
string_t file_path;
FuriString* file_path;
char text_store[INFRARED_TEXT_STORE_NUM][INFRARED_TEXT_STORE_SIZE + 1];
InfraredAppState app_state;

49
applications/main/infrared/infrared_remote.c
View File

@@ -3,7 +3,6 @@
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <m-string.h>
#include <m-array.h>
#include <toolbox/path.h>
#include <storage/storage.h>
@@ -15,8 +14,8 @@ ARRAY_DEF(InfraredButtonArray, InfraredRemoteButton*, M_PTR_OPLIST);
struct InfraredRemote {
InfraredButtonArray_t buttons;
string_t name;
string_t path;
FuriString* name;
FuriString* path;
};
static void infrared_remote_clear_buttons(InfraredRemote* remote) {
@@ -31,39 +30,39 @@ static void infrared_remote_clear_buttons(InfraredRemote* remote) {
InfraredRemote* infrared_remote_alloc() {
InfraredRemote* remote = malloc(sizeof(InfraredRemote));
InfraredButtonArray_init(remote->buttons);
string_init(remote->name);
string_init(remote->path);
remote->name = furi_string_alloc();
remote->path = furi_string_alloc();
return remote;
}
void infrared_remote_free(InfraredRemote* remote) {
infrared_remote_clear_buttons(remote);
InfraredButtonArray_clear(remote->buttons);
string_clear(remote->path);
string_clear(remote->name);
furi_string_free(remote->path);
furi_string_free(remote->name);
free(remote);
}
void infrared_remote_reset(InfraredRemote* remote) {
infrared_remote_clear_buttons(remote);
string_reset(remote->name);
string_reset(remote->path);
furi_string_reset(remote->name);
furi_string_reset(remote->path);
}
void infrared_remote_set_name(InfraredRemote* remote, const char* name) {
string_set_str(remote->name, name);
furi_string_set(remote->name, name);
}
const char* infrared_remote_get_name(InfraredRemote* remote) {
return string_get_cstr(remote->name);
return furi_string_get_cstr(remote->name);
}
void infrared_remote_set_path(InfraredRemote* remote, const char* path) {
string_set_str(remote->path, path);
furi_string_set(remote->path, path);
}
const char* infrared_remote_get_path(InfraredRemote* remote) {
return string_get_cstr(remote->path);
return furi_string_get_cstr(remote->path);
}
size_t infrared_remote_get_button_count(InfraredRemote* remote) {
@@ -112,7 +111,7 @@ bool infrared_remote_delete_button(InfraredRemote* remote, size_t index) {
bool infrared_remote_store(InfraredRemote* remote) {
Storage* storage = furi_record_open(RECORD_STORAGE);
FlipperFormat* ff = flipper_format_file_alloc(storage);
const char* path = string_get_cstr(remote->path);
const char* path = furi_string_get_cstr(remote->path);
FURI_LOG_I(TAG, "store file: \'%s\'", path);
@@ -138,33 +137,33 @@ bool infrared_remote_store(InfraredRemote* remote) {
return success;
}
bool infrared_remote_load(InfraredRemote* remote, string_t path) {
bool infrared_remote_load(InfraredRemote* remote, FuriString* path) {
Storage* storage = furi_record_open(RECORD_STORAGE);
FlipperFormat* ff = flipper_format_buffered_file_alloc(storage);
string_t buf;
string_init(buf);
FuriString* buf;
buf = furi_string_alloc();
FURI_LOG_I(TAG, "load file: \'%s\'", string_get_cstr(path));
bool success = flipper_format_buffered_file_open_existing(ff, string_get_cstr(path));
FURI_LOG_I(TAG, "load file: \'%s\'", furi_string_get_cstr(path));
bool success = flipper_format_buffered_file_open_existing(ff, furi_string_get_cstr(path));
if(success) {
uint32_t version;
success = flipper_format_read_header(ff, buf, &version) &&
!string_cmp_str(buf, "IR signals file") && (version == 1);
!furi_string_cmp(buf, "IR signals file") && (version == 1);
}
if(success) {
path_extract_filename(path, buf, true);
infrared_remote_clear_buttons(remote);
infrared_remote_set_name(remote, string_get_cstr(buf));
infrared_remote_set_path(remote, string_get_cstr(path));
infrared_remote_set_name(remote, furi_string_get_cstr(buf));
infrared_remote_set_path(remote, furi_string_get_cstr(path));
for(bool can_read = true; can_read;) {
InfraredRemoteButton* button = infrared_remote_button_alloc();
can_read = infrared_signal_read(infrared_remote_button_get_signal(button), ff, buf);
if(can_read) {
infrared_remote_button_set_name(button, string_get_cstr(buf));
infrared_remote_button_set_name(button, furi_string_get_cstr(buf));
InfraredButtonArray_push_back(remote->buttons, button);
} else {
infrared_remote_button_free(button);
@@ -172,7 +171,7 @@ bool infrared_remote_load(InfraredRemote* remote, string_t path) {
}
}
string_clear(buf);
furi_string_free(buf);
flipper_format_free(ff);
furi_record_close(RECORD_STORAGE);
return success;
@@ -181,7 +180,7 @@ bool infrared_remote_load(InfraredRemote* remote, string_t path) {
bool infrared_remote_remove(InfraredRemote* remote) {
Storage* storage = furi_record_open(RECORD_STORAGE);
FS_Error status = storage_common_remove(storage, string_get_cstr(remote->path));
FS_Error status = storage_common_remove(storage, furi_string_get_cstr(remote->path));
infrared_remote_reset(remote);
furi_record_close(RECORD_STORAGE);

2
applications/main/infrared/infrared_remote.h
View File

@@ -25,5 +25,5 @@ bool infrared_remote_rename_button(InfraredRemote* remote, const char* new_name,
bool infrared_remote_delete_button(InfraredRemote* remote, size_t index);
bool infrared_remote_store(InfraredRemote* remote);
bool infrared_remote_load(InfraredRemote* remote, string_t path);
bool infrared_remote_load(InfraredRemote* remote, FuriString* path);
bool infrared_remote_remove(InfraredRemote* remote);

11
applications/main/infrared/infrared_remote_button.c
View File

@@ -1,32 +1,31 @@
#include "infrared_remote_button.h"
#include <stdlib.h>
#include <m-string.h>
struct InfraredRemoteButton {
string_t name;
FuriString* name;
InfraredSignal* signal;
};
InfraredRemoteButton* infrared_remote_button_alloc() {
InfraredRemoteButton* button = malloc(sizeof(InfraredRemoteButton));
string_init(button->name);
button->name = furi_string_alloc();
button->signal = infrared_signal_alloc();
return button;
}
void infrared_remote_button_free(InfraredRemoteButton* button) {
string_clear(button->name);
furi_string_free(button->name);
infrared_signal_free(button->signal);
free(button);
}
void infrared_remote_button_set_name(InfraredRemoteButton* button, const char* name) {
string_set_str(button->name, name);
furi_string_set(button->name, name);
}
const char* infrared_remote_button_get_name(InfraredRemoteButton* button) {
return string_get_cstr(button->name);
return furi_string_get_cstr(button->name);
}
void infrared_remote_button_set_signal(InfraredRemoteButton* button, InfraredSignal* signal) {

37
applications/main/infrared/infrared_signal.c
View File

@@ -100,15 +100,15 @@ static inline bool infrared_signal_save_raw(InfraredRawSignal* raw, FlipperForma
}
static inline bool infrared_signal_read_message(InfraredSignal* signal, FlipperFormat* ff) {
string_t buf;
string_init(buf);
FuriString* buf;
buf = furi_string_alloc();
bool success = false;
do {
if(!flipper_format_read_string(ff, "protocol", buf)) break;
InfraredMessage message;
message.protocol = infrared_get_protocol_by_name(string_get_cstr(buf));
message.protocol = infrared_get_protocol_by_name(furi_string_get_cstr(buf));
success = flipper_format_read_hex(ff, "address", (uint8_t*)&message.address, 4) &&
flipper_format_read_hex(ff, "command", (uint8_t*)&message.command, 4) &&
@@ -119,7 +119,7 @@ static inline bool infrared_signal_read_message(InfraredSignal* signal, FlipperF
infrared_signal_set_message(signal, &message);
} while(0);
string_clear(buf);
furi_string_free(buf);
return success;
}
@@ -147,22 +147,22 @@ static inline bool infrared_signal_read_raw(InfraredSignal* signal, FlipperForma
}
static bool infrared_signal_read_body(InfraredSignal* signal, FlipperFormat* ff) {
string_t tmp;
string_init(tmp);
FuriString* tmp = furi_string_alloc();
bool success = false;
do {
if(!flipper_format_read_string(ff, "type", tmp)) break;
if(string_equal_p(tmp, "raw")) {
if(furi_string_equal(tmp, "raw")) {
success = infrared_signal_read_raw(signal, ff);
} else if(string_equal_p(tmp, "parsed")) {
} else if(furi_string_equal(tmp, "parsed")) {
success = infrared_signal_read_message(signal, ff);
} else {
FURI_LOG_E(TAG, "Unknown signal type");
}
} while(false);
string_clear(tmp);
furi_string_free(tmp);
return success;
}
@@ -246,34 +246,33 @@ bool infrared_signal_save(InfraredSignal* signal, FlipperFormat* ff, const char*
}
}
bool infrared_signal_read(InfraredSignal* signal, FlipperFormat* ff, string_t name) {
string_t tmp;
string_init(tmp);
bool infrared_signal_read(InfraredSignal* signal, FlipperFormat* ff, FuriString* name) {
FuriString* tmp = furi_string_alloc();
bool success = false;
do {
if(!flipper_format_read_string(ff, "name", tmp)) break;
string_set(name, tmp);
furi_string_set(name, tmp);
if(!infrared_signal_read_body(signal, ff)) break;
success = true;
} while(0);
string_clear(tmp);
furi_string_free(tmp);
return success;
}
bool infrared_signal_search_and_read(
InfraredSignal* signal,
FlipperFormat* ff,
const string_t name) {
const FuriString* name) {
bool success = false;
string_t tmp;
string_init(tmp);
FuriString* tmp = furi_string_alloc();
do {
bool is_name_found = false;
while(flipper_format_read_string(ff, "name", tmp)) {
is_name_found = string_equal_p(name, tmp);
is_name_found = furi_string_equal(name, tmp);
if(is_name_found) break;
}
if(!is_name_found) break;
@@ -281,7 +280,7 @@ bool infrared_signal_search_and_read(
success = true;
} while(false);
string_clear(tmp);
furi_string_free(tmp);
return success;
}

4
applications/main/infrared/infrared_signal.h
View File

@@ -36,10 +36,10 @@ void infrared_signal_set_message(InfraredSignal* signal, const InfraredMessage*
InfraredMessage* infrared_signal_get_message(InfraredSignal* signal);
bool infrared_signal_save(InfraredSignal* signal, FlipperFormat* ff, const char* name);
bool infrared_signal_read(InfraredSignal* signal, FlipperFormat* ff, string_t name);
bool infrared_signal_read(InfraredSignal* signal, FlipperFormat* ff, FuriString* name);
bool infrared_signal_search_and_read(
InfraredSignal* signal,
FlipperFormat* ff,
const string_t name);
const FuriString* name);
void infrared_signal_transmit(InfraredSignal* signal);

12
applications/main/infrared/scenes/infrared_scene_edit_rename.c
View File

@@ -29,20 +29,20 @@ void infrared_scene_edit_rename_on_enter(void* context) {
enter_name_length = INFRARED_MAX_REMOTE_NAME_LENGTH;
strncpy(infrared->text_store[0], infrared_remote_get_name(remote), enter_name_length);
string_t folder_path;
string_init(folder_path);
FuriString* folder_path;
folder_path = furi_string_alloc();
if(string_end_with_str_p(infrared->file_path, INFRARED_APP_EXTENSION)) {
path_extract_dirname(string_get_cstr(infrared->file_path), folder_path);
if(furi_string_end_with(infrared->file_path, INFRARED_APP_EXTENSION)) {
path_extract_dirname(furi_string_get_cstr(infrared->file_path), folder_path);
}
ValidatorIsFile* validator_is_file = validator_is_file_alloc_init(
string_get_cstr(folder_path),
furi_string_get_cstr(folder_path),
INFRARED_APP_EXTENSION,
infrared_remote_get_name(remote));
text_input_set_validator(text_input, validator_is_file_callback, validator_is_file);
string_clear(folder_path);
furi_string_free(folder_path);
} else {
furi_assert(0);
}

2
applications/main/infrared/scenes/infrared_scene_rpc.c
View File

@@ -42,7 +42,7 @@ bool infrared_scene_rpc_on_event(void* context, SceneManagerEvent event) {
bool result = false;
const char* arg = rpc_system_app_get_data(infrared->rpc_ctx);
if(arg && (state == InfraredRpcStateIdle)) {
string_set_str(infrared->file_path, arg);
furi_string_set(infrared->file_path, arg);
result = infrared_remote_load(infrared->remote, infrared->file_path);
if(result) {
scene_manager_set_scene_state(

2
applications/main/infrared/scenes/infrared_scene_start.c
View File

@@ -66,7 +66,7 @@ bool infrared_scene_start_on_event(void* context, SceneManagerEvent event) {
scene_manager_next_scene(scene_manager, InfraredSceneLearn);
consumed = true;
} else if(submenu_index == SubmenuIndexSavedRemotes) {
string_set_str(infrared->file_path, INFRARED_APP_FOLDER);
furi_string_set(infrared->file_path, INFRARED_APP_FOLDER);
scene_manager_next_scene(scene_manager, InfraredSceneRemoteList);
consumed = true;
} else if(submenu_index == SubmenuIndexDebug) {

1
applications/main/infrared/views/infrared_progress_view.c
View File

@@ -4,7 +4,6 @@
#include "gui/canvas.h"
#include "gui/view.h"
#include "input/input.h"
#include "m-string.h"
#include <gui/elements.h>
#include <furi.h>
#include "infrared_progress_view.h"