2021-08-11 17:51:06 +00:00
|
|
|
#include "irda-app-remote-manager.h"
|
[FL-1191][FL-1524] Filesystem rework (#568)
* FS-Api: removed datetime manipulation functions and most of the file flags
* Filesystem: common proxy api
* Filesystem: renamed to Storage. Work has begun on a glue layer. Added functions for reentrance.
* Storage: sd mount and sd file open
* Storage: sd file close
* Storage: temporary test app
* Storage: free filedata on close
* Storage: sd file read and write
* Storage: added internal storage (LittleFS)
* Storage: renamed internal commands
* Storage: seek, tell, truncate, size, sync, eof
* Storage: error descriptions
* Storage: directory management api (open, close, read, rewind)
* Storage: common management api (stat, fs_stat, remove, rename, mkdir)
* Dolphin app and Notifications app now use raw storage.
* Storage: storage statuses renamed. Implemented sd card icon.
* Storage: added raw sd-card api.
* Storage settings: work started
* Assets: use new icons approach
* Storage settings: working storage settings
* Storage: completely redesigned api, no longer sticking out FS_Api
* Storage: more simplified api, getting error_id from file is hidden from user, pointer to api is hidden inside file
* Storage: cli info and format commands
* Storage-cli: file list
* Storage: a simpler and more reliable api
* FatFS: slightly lighter and faster config. Also disabled reentrancy and file locking functions. They moved to a storage service.
* Storage-cli: accommodate to the new cli api.
* Storage: filesystem api is separated into internal and common api.
* Cli: added the ability to print the list of free heap blocks
* Storage: uses a list instead of an array to store the StorageFile. Rewrote api calls to use semaphores instead of thread flags.
* Storage settings: added the ability to benchmark the SD card.
* Gui module file select: uses new storage api
* Apps: removed deprecated sd_card_test application
* Args lib: support for enquoted arguments
* Dialogs: a new gui app for simple non-asynchronous apps
* Dialogs: view holder for easy single view work
* File worker: use new storage api
* IButton and lfrrfid apps: save keys to any storage
* Apps: fix ibutton and lfrfid stack, remove sd_card_test.
* SD filesystem: app removed
* File worker: fixed api pointer type
* Subghz: loading assets using the new storage api
* NFC: use the new storage api
* Dialogs: the better api for the message element
* Archive: use new storage api
* Irda: changed assest path, changed app path
* FileWorker: removed unused file_buf_cnt
* Storage: copying and renaming files now works between storages
* Storage cli: read, copy, remove, rename commands
* Archive: removed commented code
* Storage cli: write command
* Applications: add SRV_STORAGE and SRV_DIALOGS
* Internal-storage: removed
* Storage: improved api
* Storage app: changed api pointer from StorageApp to Storage
* Storage: better file_id handling
* Storage: more consistent errors
* Loader: support for NULL icons
* Storage: do nothing with the lfs file or directory if it is not open
* Storage: fix typo
* Storage: minor float usage cleanup, rename some symbols.
* Storage: compact doxygen comments.
Co-authored-by: あく <alleteam@gmail.com>
2021-07-23 12:20:19 +00:00
|
|
|
#include <storage/storage.h>
|
2021-06-02 15:16:05 +00:00
|
|
|
#include "furi.h"
|
2021-06-09 13:04:49 +00:00
|
|
|
#include "furi/check.h"
|
|
|
|
#include "gui/modules/button_menu.h"
|
|
|
|
#include "irda.h"
|
|
|
|
#include <cstdio>
|
2021-07-22 00:07:00 +00:00
|
|
|
#include <stdint.h>
|
2021-06-02 15:16:05 +00:00
|
|
|
#include <string>
|
|
|
|
#include <utility>
|
2021-08-11 17:51:06 +00:00
|
|
|
#include "irda-app-file-parser.h"
|
2021-06-02 15:16:05 +00:00
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
static const std::string default_remote_name = "remote";
|
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
std::string IrdaAppRemoteManager::find_vacant_remote_name(const std::string& name) {
|
|
|
|
IrdaAppFileParser file_parser;
|
|
|
|
bool exist = true;
|
2021-06-09 13:04:49 +00:00
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
if(!file_parser.is_irda_file_exist(name.c_str(), &exist)) {
|
|
|
|
return std::string();
|
|
|
|
} else if(!exist) {
|
2021-06-09 13:04:49 +00:00
|
|
|
return name;
|
|
|
|
}
|
2021-07-22 00:07:00 +00:00
|
|
|
|
|
|
|
uint32_t i = 1;
|
|
|
|
/* if suggested name is occupied, try another one (name2, name3, etc) */
|
|
|
|
while(file_parser.is_irda_file_exist((name + std::to_string(++i)).c_str(), &exist) && exist)
|
|
|
|
;
|
|
|
|
|
|
|
|
return !exist ? name + std::to_string(i) : std::string();
|
2021-06-09 13:04:49 +00:00
|
|
|
}
|
|
|
|
|
2021-07-16 16:43:54 +00:00
|
|
|
bool IrdaAppRemoteManager::add_button(const char* button_name, const IrdaAppSignal& signal) {
|
|
|
|
remote->buttons.emplace_back(button_name, signal);
|
2021-06-09 13:04:49 +00:00
|
|
|
return store();
|
2021-06-02 15:16:05 +00:00
|
|
|
}
|
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
bool IrdaAppRemoteManager::add_remote_with_button(
|
2021-06-02 15:16:05 +00:00
|
|
|
const char* button_name,
|
2021-07-16 16:43:54 +00:00
|
|
|
const IrdaAppSignal& signal) {
|
2021-06-09 13:04:49 +00:00
|
|
|
furi_check(button_name != nullptr);
|
2021-06-02 15:16:05 +00:00
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
auto new_name = find_vacant_remote_name(default_remote_name);
|
|
|
|
if(new_name.empty()) {
|
|
|
|
return false;
|
|
|
|
}
|
2021-06-09 13:04:49 +00:00
|
|
|
|
|
|
|
remote = std::make_unique<IrdaAppRemote>(new_name);
|
2021-07-16 16:43:54 +00:00
|
|
|
return add_button(button_name, signal);
|
2021-06-02 15:16:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<std::string> IrdaAppRemoteManager::get_button_list(void) const {
|
|
|
|
std::vector<std::string> name_vector;
|
2021-06-09 13:04:49 +00:00
|
|
|
name_vector.reserve(remote->buttons.size());
|
2021-06-02 15:16:05 +00:00
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
for(const auto& it : remote->buttons) {
|
2021-06-02 15:16:05 +00:00
|
|
|
name_vector.emplace_back(it.name);
|
|
|
|
}
|
|
|
|
|
|
|
|
// copy elision
|
|
|
|
return name_vector;
|
|
|
|
}
|
|
|
|
|
2021-07-16 16:43:54 +00:00
|
|
|
const IrdaAppSignal& IrdaAppRemoteManager::get_button_data(size_t index) const {
|
2021-06-09 13:04:49 +00:00
|
|
|
furi_check(remote.get() != nullptr);
|
|
|
|
auto& buttons = remote->buttons;
|
|
|
|
furi_check(index < buttons.size());
|
|
|
|
|
2021-07-16 16:43:54 +00:00
|
|
|
return buttons.at(index).signal;
|
2021-06-09 13:04:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool IrdaAppRemoteManager::delete_remote() {
|
2021-07-22 00:07:00 +00:00
|
|
|
bool result;
|
2021-06-25 13:52:27 +00:00
|
|
|
IrdaAppFileParser file_parser;
|
2021-06-02 15:16:05 +00:00
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
result = file_parser.remove_irda_file(remote->name.c_str());
|
|
|
|
reset_remote();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void IrdaAppRemoteManager::reset_remote() {
|
2021-06-09 13:04:49 +00:00
|
|
|
remote.reset();
|
|
|
|
}
|
2021-06-02 15:16:05 +00:00
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
bool IrdaAppRemoteManager::delete_button(uint32_t index) {
|
|
|
|
furi_check(remote.get() != nullptr);
|
|
|
|
auto& buttons = remote->buttons;
|
|
|
|
furi_check(index < buttons.size());
|
|
|
|
|
|
|
|
buttons.erase(buttons.begin() + index);
|
|
|
|
return store();
|
2021-06-02 15:16:05 +00:00
|
|
|
}
|
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
std::string IrdaAppRemoteManager::get_button_name(uint32_t index) {
|
|
|
|
furi_check(remote.get() != nullptr);
|
|
|
|
auto& buttons = remote->buttons;
|
|
|
|
furi_check(index < buttons.size());
|
2021-07-22 00:07:00 +00:00
|
|
|
return buttons[index].name.c_str();
|
2021-06-02 15:16:05 +00:00
|
|
|
}
|
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
std::string IrdaAppRemoteManager::get_remote_name() {
|
2021-07-22 00:07:00 +00:00
|
|
|
return remote ? remote->name : std::string();
|
2021-06-02 15:16:05 +00:00
|
|
|
}
|
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
int IrdaAppRemoteManager::find_remote_name(const std::vector<std::string>& strings) {
|
|
|
|
int i = 0;
|
|
|
|
for(const auto& str : strings) {
|
|
|
|
if(!str.compare(remote->name)) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
return -1;
|
2021-06-02 15:16:05 +00:00
|
|
|
}
|
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
bool IrdaAppRemoteManager::rename_remote(const char* str) {
|
|
|
|
furi_check(str != nullptr);
|
|
|
|
furi_check(remote.get() != nullptr);
|
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
if(!remote->name.compare(str)) {
|
|
|
|
return true;
|
|
|
|
}
|
2021-06-09 13:04:49 +00:00
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
auto new_name = find_vacant_remote_name(str);
|
|
|
|
if(new_name.empty()) {
|
|
|
|
return false;
|
|
|
|
}
|
2021-06-09 13:04:49 +00:00
|
|
|
|
2021-06-25 13:52:27 +00:00
|
|
|
IrdaAppFileParser file_parser;
|
2021-07-22 00:07:00 +00:00
|
|
|
bool result = file_parser.rename_irda_file(remote->name.c_str(), new_name.c_str());
|
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
remote->name = new_name;
|
2021-07-22 00:07:00 +00:00
|
|
|
|
|
|
|
return result;
|
2021-06-02 15:16:05 +00:00
|
|
|
}
|
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
bool IrdaAppRemoteManager::rename_button(uint32_t index, const char* str) {
|
|
|
|
furi_check(remote.get() != nullptr);
|
|
|
|
auto& buttons = remote->buttons;
|
|
|
|
furi_check(index < buttons.size());
|
|
|
|
|
|
|
|
buttons[index].name = str;
|
|
|
|
return store();
|
2021-06-02 15:16:05 +00:00
|
|
|
}
|
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
size_t IrdaAppRemoteManager::get_number_of_buttons() {
|
|
|
|
furi_check(remote.get() != nullptr);
|
|
|
|
return remote->buttons.size();
|
2021-06-02 15:16:05 +00:00
|
|
|
}
|
|
|
|
|
2021-06-09 13:04:49 +00:00
|
|
|
bool IrdaAppRemoteManager::store(void) {
|
2021-06-25 13:52:27 +00:00
|
|
|
IrdaAppFileParser file_parser;
|
2021-07-22 00:07:00 +00:00
|
|
|
bool result = true;
|
2021-06-09 13:04:49 +00:00
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
if(!file_parser.open_irda_file_write(remote->name.c_str())) {
|
2021-06-09 13:04:49 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
for(const auto& button : remote->buttons) {
|
2021-07-22 00:07:00 +00:00
|
|
|
bool result = file_parser.save_signal(button.signal, button.name.c_str());
|
2021-07-16 16:43:54 +00:00
|
|
|
if(!result) {
|
2021-07-22 00:07:00 +00:00
|
|
|
result = false;
|
|
|
|
break;
|
2021-06-09 13:04:49 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
file_parser.close();
|
2021-06-09 13:04:49 +00:00
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
return result;
|
2021-06-02 15:16:05 +00:00
|
|
|
}
|
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
bool IrdaAppRemoteManager::load(const std::string& name) {
|
2021-06-09 13:04:49 +00:00
|
|
|
bool fs_res = false;
|
2021-06-25 13:52:27 +00:00
|
|
|
IrdaAppFileParser file_parser;
|
2021-06-09 13:04:49 +00:00
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
fs_res = file_parser.open_irda_file_read(name.c_str());
|
2021-06-09 13:04:49 +00:00
|
|
|
if(!fs_res) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-07-22 00:07:00 +00:00
|
|
|
remote = std::make_unique<IrdaAppRemote>(name);
|
2021-06-09 13:04:49 +00:00
|
|
|
|
|
|
|
while(1) {
|
2021-07-22 00:07:00 +00:00
|
|
|
auto file_signal = file_parser.read_signal();
|
|
|
|
if(!file_signal) {
|
|
|
|
break;
|
|
|
|
}
|
2021-07-16 16:43:54 +00:00
|
|
|
remote->buttons.emplace_back(file_signal->name, file_signal->signal);
|
2021-06-09 13:04:49 +00:00
|
|
|
}
|
2021-07-22 00:07:00 +00:00
|
|
|
file_parser.close();
|
2021-06-09 13:04:49 +00:00
|
|
|
|
|
|
|
return true;
|
2021-06-02 15:16:05 +00:00
|
|
|
}
|