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

[FL-1369, FL-1397, FL-1420] IRDA + SDcard (#513)

Browse Source 
* Add saving to SD-Card (not ready yet)
* Add saving to SD-card (done)
* Select previous menu item
* Fix central button
* Fix current_button
* Refactoring
* Add notifications
* [FL-1417] Add IRDA CLI
  CLI commands:
  1) ir_rx
  Receives all IR-trafic, decodes and prints result to stdout
  2) ir_tx <protocol> <address> <command>
  Transmits IR-signal. Address and command are hex-formatted
* Fix BUG with random memory corruption at random time in random place in random universe in random unknown space and time forever amen
* Fix submenu set_selected_item
* Bring protocol order back
* Add TODO sdcard check
This commit is contained in:
Albert Kharisov
2021-06-09 16:04:49 +03:00
committed by GitHub
parent 498ffe8d2c
commit 6c74ea65c2
31 changed files with 846 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
applications/irda/cli/irda-cli.cpp Normal file
View File

@@ -0,0 +1,104 @@
#include "app-template.h"
#include "cli/cli.h"
#include "cmsis_os2.h"
#include <furi.h>
#include <api-hal-irda.h>
#include "irda.h"
#include <sstream>
#include <string>
#include <m-string.h>
typedef struct IrdaCli {
IrdaHandler* handler;
osMessageQueueId_t message_queue;
} IrdaCli;
static void irda_rx_callback(void* ctx, bool level, uint32_t duration) {
IrdaCli* irda_cli = (IrdaCli*)ctx;
const IrdaMessage* message;
message = irda_decode(irda_cli->handler, level, duration);
if(message) {
osMessageQueuePut(irda_cli->message_queue, message, 0, 0);
}
}
static void irda_cli_start_ir_rx(Cli* cli, string_t args, void* context) {
if(api_hal_irda_rx_irq_is_busy()) {
printf("IRDA is busy. Exit.");
return;
}
IrdaCli irda_cli;
irda_cli.handler = irda_alloc_decoder();
irda_cli.message_queue = osMessageQueueNew(2, sizeof(IrdaMessage), NULL);
api_hal_irda_rx_irq_init();
api_hal_irda_rx_irq_set_callback(irda_rx_callback, &irda_cli);
printf("Receiving IRDA...\r\nPress Ctrl+C to abort\r\n");
while(!cli_cmd_interrupt_received(cli)) {
IrdaMessage message;
if(osOK == osMessageQueueGet(irda_cli.message_queue, &message, NULL, 50)) {
printf(
"%s, A:0x%0*lX, C:0x%0*lX%s\r\n",
irda_get_protocol_name(message.protocol),
irda_get_protocol_address_length(message.protocol),
message.address,
irda_get_protocol_command_length(message.protocol),
message.command,
message.repeat ? " R" : "");
}
}
api_hal_irda_rx_irq_deinit();
irda_free_decoder(irda_cli.handler);
osMessageQueueDelete(irda_cli.message_queue);
}
static void irda_cli_print_usage(void) {
printf("Usage:\r\n\tir_tx <protocol> <command> <address>\r\n");
printf("\t<command> and <address> are hex-formatted\r\n");
printf("\tAvailable protocols:");
for(int i = 0; irda_is_protocol_valid((IrdaProtocol)i); ++i) {
printf(" %s", irda_get_protocol_name((IrdaProtocol)i));
}
printf("\r\n");
}
static void irda_cli_start_ir_tx(Cli* cli, string_t args, void* context) {
if(api_hal_irda_rx_irq_is_busy()) {
printf("IRDA is busy. Exit.");
return;
}
auto ss = std::istringstream(string_get_cstr(args));
uint32_t command = 0;
uint32_t address = 0;
std::string protocol_name;
if(!(ss >> protocol_name) || !(ss >> std::hex >> address) || !(ss >> std::hex >> command)) {
printf("Wrong arguments.\r\n");
irda_cli_print_usage();
return;
}
IrdaProtocol protocol = irda_get_protocol_by_name(protocol_name.c_str());
if(!irda_is_protocol_valid(protocol)) {
printf("Unknown protocol.\r\n");
irda_cli_print_usage();
return;
}
IrdaMessage message = {
.protocol = protocol,
.address = address,
.command = command,
.repeat = false,
};
irda_send(&message, 1);
}
extern "C" void irda_cli_init() {
Cli* cli = (Cli*)furi_record_open("cli");
cli_add_command(cli, "ir_rx", irda_cli_start_ir_rx, NULL);
cli_add_command(cli, "ir_tx", irda_cli_start_ir_tx, NULL);
furi_record_close("cli");
}

414
applications/irda/irda-app-remote-manager.cpp
View File

@@ -1,51 +1,78 @@
#include "irda-app-remote-manager.hpp"
#include "filesystem-api.h"
#include "furi.h"
#include "furi/check.h"
#include "gui/modules/button_menu.h"
#include "irda.h"
#include "sys/_stdint.h"
#include <cstdio>
#include <string>
#include <utility>
IrdaAppRemoteManager::IrdaAppRemoteManager() {
// Read from api-hal-storage, and fill remotes
}
const char* IrdaAppRemoteManager::irda_directory = "irda";
const char* IrdaAppRemoteManager::irda_extension = ".ir";
static const std::string default_remote_name = "remote";
void IrdaAppRemoteManager::add_button(const char* button_name, const IrdaMessage* message) {
remotes[current_remote_index].buttons.emplace_back(button_name, message);
static bool find_string(const std::vector<std::string>& strings, const std::string& match_string) {
for(const auto& string : strings) {
if(!string.compare(match_string)) return true;
}
return false;
}
void IrdaAppRemoteManager::add_remote_with_button(
static std::string
find_vacant_name(const std::vector<std::string>& strings, const std::string& name) {
// if suggested name is occupied, try another one (name2, name3, etc)
if(find_string(strings, name)) {
int i = 1;
while(find_string(strings, name + std::to_string(++i)))
;
return name + std::to_string(i);
} else {
return name;
}
}
IrdaAppRemoteManager::IrdaAppRemoteManager() {
sd_ex_api = static_cast<SdCard_Api*>(furi_record_open("sdcard-ex"));
fs_api = static_cast<FS_Api*>(furi_record_open("sdcard"));
}
IrdaAppRemoteManager::~IrdaAppRemoteManager() {
furi_record_close("sdcard");
furi_record_close("sdcard-ex");
}
bool IrdaAppRemoteManager::add_button(const char* button_name, const IrdaMessage* message) {
remote->buttons.emplace_back(button_name, message);
return store();
}
bool IrdaAppRemoteManager::add_remote_with_button(
const char* button_name,
const IrdaMessage* message) {
bool found = true;
int i = 0;
furi_check(button_name != nullptr);
furi_check(message != nullptr);
// find first free common name for remote
do {
found = false;
++i;
for(const auto& it : remotes) {
if(it.name == (default_remote_name + std::to_string(i))) {
found = true;
break;
}
}
} while(found);
std::vector<std::string> remote_list;
bool result = get_remote_list(remote_list);
if(!result) return false;
remotes.emplace_back(default_remote_name + std::to_string(i));
current_remote_index = remotes.size() - 1;
add_button(button_name, message);
auto new_name = find_vacant_name(remote_list, default_remote_name);
remote = std::make_unique<IrdaAppRemote>(new_name);
return add_button(button_name, message);
}
IrdaAppRemote::IrdaAppRemote(std::string name)
IrdaAppRemote::IrdaAppRemote(const std::string& name)
: name(name) {
}
std::vector<std::string> IrdaAppRemoteManager::get_button_list(void) const {
std::vector<std::string> name_vector;
auto remote = remotes[current_remote_index];
name_vector.reserve(remote.buttons.size());
name_vector.reserve(remote->buttons.size());
for(const auto& it : remote.buttons) {
for(const auto& it : remote->buttons) {
name_vector.emplace_back(it.name);
}
@@ -53,78 +80,289 @@ std::vector<std::string> IrdaAppRemoteManager::get_button_list(void) const {
return name_vector;
}
std::vector<std::string> IrdaAppRemoteManager::get_remote_list() const {
std::vector<std::string> name_vector;
name_vector.reserve(remotes.size());
const IrdaMessage* IrdaAppRemoteManager::get_button_data(size_t index) const {
furi_check(remote.get() != nullptr);
auto& buttons = remote->buttons;
furi_check(index < buttons.size());
for(const auto& it : remotes) {
name_vector.push_back(it.name);
return &buttons.at(index).message;
}
std::string IrdaAppRemoteManager::make_filename(const std::string& name) const {
return std::string("/") + irda_directory + "/" + name + irda_extension;
}
bool IrdaAppRemoteManager::delete_remote() {
FS_Error fs_res;
fs_res = fs_api->common.remove(make_filename(remote->name).c_str());
if(fs_res != FSE_OK) {
show_file_error_message("Error deleting file");
return false;
}
remote.reset();
return true;
}
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();
}
std::string IrdaAppRemoteManager::get_button_name(uint32_t index) {
furi_check(remote.get() != nullptr);
auto& buttons = remote->buttons;
furi_check(index < buttons.size());
return buttons[index].name;
}
std::string IrdaAppRemoteManager::get_remote_name() {
furi_check(remote.get() != nullptr);
return remote->name;
}
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;
}
bool IrdaAppRemoteManager::rename_remote(const char* str) {
furi_check(str != nullptr);
furi_check(remote.get() != nullptr);
if(!remote->name.compare(str)) return true;
std::vector<std::string> remote_list;
bool result = get_remote_list(remote_list);
if(!result) return false;
auto new_name = find_vacant_name(remote_list, str);
FS_Error fs_err = fs_api->common.rename(
make_filename(remote->name).c_str(), make_filename(new_name).c_str());
remote->name = new_name;
if(fs_err != FSE_OK) {
show_file_error_message("Error renaming\nremote file");
}
return fs_err == FSE_OK;
}
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();
}
size_t IrdaAppRemoteManager::get_number_of_buttons() {
furi_check(remote.get() != nullptr);
return remote->buttons.size();
}
void IrdaAppRemoteManager::show_file_error_message(const char* error_text) const {
sd_ex_api->show_error(sd_ex_api->context, error_text);
}
bool IrdaAppRemoteManager::store(void) {
File file;
uint16_t write_count;
std::string dirname(std::string("/") + irda_directory);
FS_Error fs_err = fs_api->common.mkdir(dirname.c_str());
if((fs_err != FSE_OK) && (fs_err != FSE_EXIST)) {
show_file_error_message("Can't create directory");
return false;
}
// copy elision
return name_vector;
std::string filename = dirname + "/" + remote->name + irda_extension;
bool res = fs_api->file.open(&file, filename.c_str(), FSAM_WRITE, FSOM_CREATE_ALWAYS);
if(!res) {
show_file_error_message("Cannot create\nnew remote file");
return false;
}
char content[128];
for(const auto& button : remote->buttons) {
auto protocol = button.message.protocol;
sniprintf(
content,
sizeof(content),
"%.31s %.31s A:%0*lX C:%0*lX\n",
button.name.c_str(),
irda_get_protocol_name(protocol),
irda_get_protocol_address_length(protocol),
button.message.address,
irda_get_protocol_command_length(protocol),
button.message.command);
auto content_len = strlen(content);
write_count = fs_api->file.write(&file, content, content_len);
if(file.error_id != FSE_OK || write_count != content_len) {
show_file_error_message("Cannot write\nto key file");
fs_api->file.close(&file);
return false;
}
}
fs_api->file.close(&file);
sd_ex_api->check_error(sd_ex_api->context);
return true;
}
size_t IrdaAppRemoteManager::get_current_remote(void) const {
return current_remote_index;
bool IrdaAppRemoteManager::parse_button(std::string& str) {
char button_name[32];
char protocol_name[32];
uint32_t address;
uint32_t command;
int parsed = std::sscanf(
str.c_str(), "%31s %31s A:%lX C:%lX", button_name, protocol_name, &address, &command);
if(parsed != 4) {
return false;
}
IrdaProtocol protocol = irda_get_protocol_by_name(protocol_name);
if(!irda_is_protocol_valid((IrdaProtocol)protocol)) {
return false;
}
int address_length = irda_get_protocol_address_length(protocol);
uint32_t address_mask = (1LU << (4 * address_length)) - 1;
if(address != (address & address_mask)) {
return false;
}
int command_length = irda_get_protocol_command_length(protocol);
uint32_t command_mask = (1LU << (4 * command_length)) - 1;
if(command != (command & command_mask)) {
return false;
}
IrdaMessage irda_message = {
.protocol = protocol,
.address = address,
.command = command,
.repeat = false,
};
remote->buttons.emplace_back(button_name, &irda_message);
return true;
}
size_t IrdaAppRemoteManager::get_current_button(void) const {
return current_button_index;
std::string getline(
const FS_Api* fs_api,
File& file,
char file_buf[],
size_t file_buf_size,
size_t& file_buf_cnt) {
std::string str;
size_t newline_index = 0;
bool found_eol = false;
while(1) {
if(file_buf_cnt > 0) {
size_t end_index = 0;
char* endline_ptr = (char*)memchr(file_buf, '\n', file_buf_cnt);
newline_index = endline_ptr - file_buf;
if(endline_ptr == 0) {
end_index = file_buf_cnt;
} else if(newline_index < file_buf_cnt) {
end_index = newline_index + 1;
found_eol = true;
} else {
furi_assert(0);
}
str.append(file_buf, end_index);
memmove(file_buf, &file_buf[end_index], file_buf_cnt - end_index);
file_buf_cnt = file_buf_cnt - end_index;
if(found_eol) break;
}
file_buf_cnt +=
fs_api->file.read(&file, &file_buf[file_buf_cnt], file_buf_size - file_buf_cnt);
if(file_buf_cnt == 0) {
break; // end of reading
}
}
return str;
}
void IrdaAppRemote::add_button(
size_t remote_index,
const char* button_name,
const IrdaMessage* message) {
buttons.emplace_back(button_name, message);
bool IrdaAppRemoteManager::get_remote_list(std::vector<std::string>& remote_names) const {
bool fs_res = false;
char name[128];
File dir;
std::string dirname(std::string("/") + irda_directory);
remote_names.clear();
fs_res = fs_api->dir.open(&dir, dirname.c_str());
if(!fs_res) {
if(!check_fs()) {
show_file_error_message("Cannot open\napplication directory");
return false;
} else {
return true; // SD ok, but no files written yet
}
}
while(fs_api->dir.read(&dir, nullptr, name, sizeof(name)) && strlen(name)) {
std::string filename(name);
auto extension_index = filename.rfind(irda_extension);
if((extension_index == std::string::npos) ||
(extension_index + strlen(irda_extension) != filename.size())) {
continue;
}
remote_names.push_back(filename.erase(extension_index));
}
fs_api->dir.close(&dir);
return true;
}
const IrdaMessage* IrdaAppRemoteManager::get_button_data(size_t button_index) const {
furi_check(remotes[current_remote_index].buttons.size() > button_index);
auto& b = remotes[current_remote_index].buttons.at(button_index);
return &b.message;
bool IrdaAppRemoteManager::load(const std::string& name) {
bool fs_res = false;
File file;
fs_res = fs_api->file.open(&file, make_filename(name).c_str(), FSAM_READ, FSOM_OPEN_EXISTING);
if(!fs_res) {
show_file_error_message("Error opening file");
return false;
}
remote = std::make_unique<IrdaAppRemote>(name);
while(1) {
auto str = getline(fs_api, file, file_buf, sizeof(file_buf), file_buf_cnt);
if(str.empty()) break;
parse_button(str);
}
fs_api->file.close(&file);
return true;
}
void IrdaAppRemoteManager::set_current_remote(size_t index) {
furi_check(index < remotes.size());
current_remote_index = index;
}
void IrdaAppRemoteManager::set_current_button(size_t index) {
furi_check(current_remote_index < remotes.size());
furi_check(index < remotes[current_remote_index].buttons.size());
current_button_index = index;
}
void IrdaAppRemoteManager::delete_current_remote() {
remotes.erase(remotes.begin() + current_remote_index);
current_remote_index = 0;
}
void IrdaAppRemoteManager::delete_current_button() {
auto& buttons = remotes[current_remote_index].buttons;
buttons.erase(buttons.begin() + current_button_index);
current_button_index = 0;
}
std::string IrdaAppRemoteManager::get_current_button_name() {
auto buttons = remotes[current_remote_index].buttons;
return buttons[current_button_index].name;
}
std::string IrdaAppRemoteManager::get_current_remote_name() {
return remotes[current_remote_index].name;
}
void IrdaAppRemoteManager::rename_remote(const char* str) {
remotes[current_remote_index].name = str;
}
void IrdaAppRemoteManager::rename_button(const char* str) {
remotes[current_remote_index].buttons[current_button_index].name = str;
}
size_t IrdaAppRemoteManager::get_current_remote_buttons_number() {
return remotes[current_remote_index].buttons.size();
bool IrdaAppRemoteManager::check_fs() const {
// TODO: [FL-1431] Add return value to sd_ex_api->check_error() and replace get_fs_info().
auto fs_err = fs_api->common.get_fs_info(nullptr, nullptr);
if(fs_err != FSE_OK) show_file_error_message("SD card not found");
return fs_err == FSE_OK;
}

66
applications/irda/irda-app-remote-manager.hpp
View File

@@ -1,9 +1,14 @@
#pragma once
#include "sys/_stdint.h"
#include <algorithm>
#include <stdint.h>
#include <string>
#include <list>
#include <vector>
#include <memory>
#include <irda.h>
#include <sd-card-api.h>
#include <filesystem-api.h>
class IrdaAppRemoteButton {
friend class IrdaAppRemoteManager;
@@ -19,35 +24,50 @@ class IrdaAppRemote {
friend class IrdaAppRemoteManager;
std::vector<IrdaAppRemoteButton> buttons;
std::string name;
bool add(const IrdaMessage*);
void add_button(size_t remote_index, const char* button_name, const IrdaMessage* message);
public:
IrdaAppRemote(std::string name);
IrdaAppRemote(const std::string& name);
IrdaAppRemote& operator=(std::string& new_name) noexcept
{
name = new_name;
buttons.clear();
return *this;
}
};
class IrdaAppRemoteManager {
size_t current_remote_index;
size_t current_button_index;
std::vector<IrdaAppRemote> remotes;
public:
std::vector<std::string> get_remote_list() const;
std::vector<std::string> get_button_list() const;
void add_remote_with_button(const char* button_name, const IrdaMessage* message);
void add_button(const char* button_name, const IrdaMessage* message);
static const char* irda_directory;
static const char* irda_extension;
std::unique_ptr<IrdaAppRemote> remote;
// TODO: make FS_Api and SdCard_Api unique_ptr
SdCard_Api* sd_ex_api;
FS_Api* fs_api;
void show_file_error_message(const char* error_text) const;
bool parse_button(std::string& str);
std::string make_filename(const std::string& name) const;
char file_buf[48];
size_t file_buf_cnt = 0;
size_t get_current_remote(void) const;
size_t get_current_button(void) const;
public:
bool add_remote_with_button(const char* button_name, const IrdaMessage* message);
bool add_button(const char* button_name, const IrdaMessage* message);
int find_remote_name(const std::vector<std::string>& strings);
bool rename_button(uint32_t index, const char* str);
bool rename_remote(const char* str);
bool get_remote_list(std::vector<std::string>& remote_names) const;
std::vector<std::string> get_button_list() const;
std::string get_button_name(uint32_t index);
std::string get_remote_name();
size_t get_number_of_buttons();
const IrdaMessage* get_button_data(size_t button_index) const;
void set_current_remote(size_t index);
void set_current_button(size_t index);
void rename_button(const char* str);
void rename_remote(const char* str);
std::string get_current_button_name();
std::string get_current_remote_name();
size_t get_current_remote_buttons_number();
void delete_current_button();
void delete_current_remote();
bool delete_button(uint32_t index);
bool delete_remote();
IrdaAppRemoteManager();
~IrdaAppRemoteManager() {};
~IrdaAppRemoteManager();
bool store();
bool load(const std::string& name);
bool check_fs() const;
};

68
applications/irda/irda-app.cpp
View File

@@ -1,4 +1,5 @@
#include "irda-app.hpp"
#include "sys/_stdint.h"
#include <furi.h>
#include <gui/gui.h>
#include <input/input.h>
@@ -154,3 +155,70 @@ void IrdaApp::set_edit_action(IrdaApp::EditAction value) {
IrdaApp::EditAction IrdaApp::get_edit_action(void) {
return action;
}
void IrdaApp::set_current_button(int value) {
current_button = value;
}
int IrdaApp::get_current_button() {
return current_button;
}
void IrdaApp::notify_success() {
notification_message(notification, &sequence_success);
}
void IrdaApp::notify_red_blink() {
notification_message(notification, &sequence_blink_red_10);
}
void IrdaApp::notify_space_blink() {
static const NotificationSequence sequence = {
&message_green_0,
&message_delay_50,
&message_green_255,
&message_do_not_reset,
NULL,
};
notification_message_block(notification, &sequence);
}
void IrdaApp::notify_click() {
static const NotificationSequence sequence = {
&message_click,
&message_delay_1,
&message_sound_off,
NULL,
};
notification_message_block(notification, &sequence);
}
void IrdaApp::notify_click_and_blink() {
static const NotificationSequence sequence = {
&message_click,
&message_delay_1,
&message_sound_off,
&message_red_0,
&message_green_255,
&message_blue_0,
&message_delay_10,
&message_green_0,
NULL,
};
notification_message_block(notification, &sequence);
}
void IrdaApp::notify_double_vibro() {
notification_message(notification, &sequence_double_vibro);
}
void IrdaApp::notify_green_on() {
notification_message(notification, &sequence_set_only_green_255);
}
void IrdaApp::notify_green_off() {
notification_message(notification, &sequence_reset_green);
}

24
applications/irda/irda-app.hpp
View File

@@ -1,4 +1,5 @@
#pragma once
#include "sys/_stdint.h"
#include <map>
#include <irda.h>
#include <furi.h>
@@ -9,6 +10,7 @@
#include "irda-app-receiver.hpp"
#include <forward_list>
#include <stdint.h>
#include <notification/notification-messages.h>
class IrdaApp {
@@ -65,11 +67,29 @@ public:
bool get_learn_new_remote();
void set_learn_new_remote(bool value);
enum : int {
ButtonNA = -1,
};
int get_current_button();
void set_current_button(int value);
void notify_success();
void notify_red_blink();
void notify_space_blink();
void notify_double_vibro();
void notify_green_on();
void notify_green_off();
void notify_click();
void notify_click_and_blink();
static void text_input_callback(void* context, char* text);
static void popup_callback(void* context);
IrdaApp() {}
IrdaApp() {
notification = static_cast<NotificationApp*>(furi_record_open("notification"));
}
~IrdaApp() {
furi_record_close("notification");
for (auto &it : scenes)
delete it.second;
}
@@ -80,7 +100,9 @@ private:
bool learn_new_remote;
EditElement element;
EditAction action;
uint32_t current_button;
NotificationApp* notification;
IrdaAppSignalReceiver receiver;
IrdaAppViewManager view_manager;
IrdaAppRemoteManager remote_manager;

22
applications/irda/scene/irda-app-scene-edit-delete.cpp
View File

@@ -1,5 +1,6 @@
#include "../irda-app.hpp"
#include "irda.h"
#include "irda/scene/irda-app-scene.hpp"
#include <string>
#include <stdio.h>
@@ -20,12 +21,12 @@ void IrdaAppSceneEditDelete::on_enter(IrdaApp* app) {
auto remote_manager = app->get_remote_manager();
if(app->get_edit_element() == IrdaApp::EditElement::Button) {
auto message = remote_manager->get_button_data(remote_manager->get_current_button());
auto message = remote_manager->get_button_data(app->get_current_button());
dialog_ex_set_header(dialog_ex, "Delete button?", 64, 6, AlignCenter, AlignCenter);
app->set_text_store(
0,
"%s\n%s\nA=0x%0*lX C=0x%0*lX",
remote_manager->get_current_button_name().c_str(),
remote_manager->get_button_name(app->get_current_button()).c_str(),
irda_get_protocol_name(message->protocol),
irda_get_protocol_address_length(message->protocol),
message->address,
@@ -36,8 +37,8 @@ void IrdaAppSceneEditDelete::on_enter(IrdaApp* app) {
app->set_text_store(
0,
"%s\n with %lu buttons",
remote_manager->get_current_remote_name().c_str(),
remote_manager->get_current_remote_buttons_number());
remote_manager->get_remote_name().c_str(),
remote_manager->get_number_of_buttons());
}
dialog_ex_set_text(dialog_ex, app->get_text_store(0), 64, 32, AlignCenter, AlignCenter);
@@ -63,13 +64,20 @@ bool IrdaAppSceneEditDelete::on_event(IrdaApp* app, IrdaAppEvent* event) {
break;
case DialogExResultRight:
auto remote_manager = app->get_remote_manager();
bool result = false;
if(app->get_edit_element() == IrdaApp::EditElement::Remote) {
remote_manager->delete_current_remote();
result = remote_manager->delete_remote();
} else {
remote_manager->delete_current_button();
result = remote_manager->delete_button(app->get_current_button());
app->set_current_button(IrdaApp::ButtonNA);
}
app->switch_to_next_scene(IrdaApp::Scene::EditDeleteDone);
if(!result) {
app->search_and_switch_to_previous_scene(
{IrdaApp::Scene::RemoteList, IrdaApp::Scene::Start});
} else {
app->switch_to_next_scene(IrdaApp::Scene::EditDeleteDone);
}
break;
}
}

11
applications/irda/scene/irda-app-scene-edit-key-select.cpp
View File

@@ -14,7 +14,7 @@ static void submenu_callback(void* context, uint32_t index) {
void IrdaAppSceneEditKeySelect::on_enter(IrdaApp* app) {
IrdaAppViewManager* view_manager = app->get_view_manager();
Submenu* submenu = view_manager->get_submenu();
int i = 0;
int item_number = 0;
const char* header = app->get_edit_action() == IrdaApp::EditAction::Rename ? "Rename key:" :
"Delete key:";
@@ -23,7 +23,11 @@ void IrdaAppSceneEditKeySelect::on_enter(IrdaApp* app) {
auto remote_manager = app->get_remote_manager();
buttons_names = remote_manager->get_button_list();
for(const auto& it : buttons_names) {
submenu_add_item(submenu, it.c_str(), i++, submenu_callback, app);
submenu_add_item(submenu, it.c_str(), item_number++, submenu_callback, app);
}
if((item_number > 0) && (app->get_current_button() != IrdaApp::ButtonNA)) {
submenu_set_selected_item(submenu, app->get_current_button());
app->set_current_button(IrdaApp::ButtonNA);
}
view_manager->switch_to(IrdaAppViewManager::ViewType::Submenu);
@@ -33,8 +37,7 @@ bool IrdaAppSceneEditKeySelect::on_event(IrdaApp* app, IrdaAppEvent* event) {
bool consumed = false;
if(event->type == IrdaAppEvent::Type::MenuSelected) {
auto remote_manager = app->get_remote_manager();
remote_manager->set_current_button(event->payload.menu_index);
app->set_current_button(event->payload.menu_index);
consumed = true;
if(app->get_edit_action() == IrdaApp::EditAction::Rename) {
app->switch_to_next_scene(IrdaApp::Scene::EditRename);

19
applications/irda/scene/irda-app-scene-edit-rename.cpp
View File

@@ -7,10 +7,11 @@ void IrdaAppSceneEditRename::on_enter(IrdaApp* app) {
auto remote_manager = app->get_remote_manager();
if(app->get_edit_element() == IrdaApp::EditElement::Button) {
auto button_name = remote_manager->get_current_button_name();
furi_assert(app->get_current_button() != IrdaApp::ButtonNA);
auto button_name = remote_manager->get_button_name(app->get_current_button());
strncpy(app->get_text_store(0), button_name.c_str(), app->get_text_store_size());
} else {
auto remote_name = remote_manager->get_current_remote_name();
auto remote_name = remote_manager->get_remote_name();
strncpy(app->get_text_store(0), remote_name.c_str(), app->get_text_store_size());
}
@@ -30,12 +31,20 @@ bool IrdaAppSceneEditRename::on_event(IrdaApp* app, IrdaAppEvent* event) {
if(event->type == IrdaAppEvent::Type::TextEditDone) {
auto remote_manager = app->get_remote_manager();
bool result = false;
if(app->get_edit_element() == IrdaApp::EditElement::Button) {
remote_manager->rename_button(app->get_text_store(0));
result =
remote_manager->rename_button(app->get_current_button(), app->get_text_store(0));
app->set_current_button(IrdaApp::ButtonNA);
} else {
remote_manager->rename_remote(app->get_text_store(0));
result = remote_manager->rename_remote(app->get_text_store(0));
}
if(!result) {
app->search_and_switch_to_previous_scene(
{IrdaApp::Scene::Start, IrdaApp::Scene::RemoteList});
} else {
app->switch_to_next_scene_without_saving(IrdaApp::Scene::EditRenameDone);
}
app->switch_to_next_scene_without_saving(IrdaApp::Scene::EditRenameDone);
consumed = true;
}

5
applications/irda/scene/irda-app-scene-edit.cpp
View File

@@ -1,4 +1,5 @@
#include "../irda-app.hpp"
#include "gui/modules/submenu.h"
typedef enum {
SubmenuIndexAddKey,
@@ -27,6 +28,8 @@ void IrdaAppSceneEdit::on_enter(IrdaApp* app) {
submenu_add_item(submenu, "Delete key", SubmenuIndexDeleteKey, submenu_callback, app);
submenu_add_item(submenu, "Rename remote", SubmenuIndexRenameRemote, submenu_callback, app);
submenu_add_item(submenu, "Delete remote", SubmenuIndexDeleteRemote, submenu_callback, app);
submenu_set_selected_item(submenu, submenu_item_selected);
submenu_item_selected = 0;
view_manager->switch_to(IrdaAppViewManager::ViewType::Submenu);
}
@@ -35,8 +38,10 @@ bool IrdaAppSceneEdit::on_event(IrdaApp* app, IrdaAppEvent* event) {
bool consumed = false;
if(event->type == IrdaAppEvent::Type::MenuSelected) {
submenu_item_selected = event->payload.menu_index;
switch(event->payload.menu_index) {
case SubmenuIndexAddKey:
app->set_learn_new_remote(false);
app->switch_to_next_scene(IrdaApp::Scene::Learn);
break;
case SubmenuIndexRenameKey:

13
applications/irda/scene/irda-app-scene-learn-enter-name.cpp
View File

@@ -35,14 +35,21 @@ bool IrdaAppSceneLearnEnterName::on_event(IrdaApp* app, IrdaAppEvent* event) {
if(event->type == IrdaAppEvent::Type::TextEditDone) {
auto remote_manager = app->get_remote_manager();
auto receiver = app->get_receiver();
bool result = false;
if(app->get_learn_new_remote()) {
remote_manager->add_remote_with_button(
result = remote_manager->add_remote_with_button(
app->get_text_store(0), receiver->get_last_message());
} else {
remote_manager->add_button(app->get_text_store(0), receiver->get_last_message());
result =
remote_manager->add_button(app->get_text_store(0), receiver->get_last_message());
}
app->switch_to_next_scene_without_saving(IrdaApp::Scene::LearnDone);
if(!result) {
app->search_and_switch_to_previous_scene(
{IrdaApp::Scene::Start, IrdaApp::Scene::RemoteList});
} else {
app->switch_to_next_scene_without_saving(IrdaApp::Scene::LearnDone);
}
}
return consumed;
}

22
applications/irda/scene/irda-app-scene-learn-success.cpp
View File

@@ -17,6 +17,8 @@ void IrdaAppSceneLearnSuccess::on_enter(IrdaApp* app) {
IrdaAppViewManager* view_manager = app->get_view_manager();
DialogEx* dialog_ex = view_manager->get_dialog_ex();
app->notify_green_on();
auto receiver = app->get_receiver();
auto message = receiver->get_last_message();
@@ -32,6 +34,7 @@ void IrdaAppSceneLearnSuccess::on_enter(IrdaApp* app) {
dialog_ex_set_text(dialog_ex, app->get_text_store(1), 75, 23, AlignLeft, AlignTop);
dialog_ex_set_left_button_text(dialog_ex, "Retry");
dialog_ex_set_right_button_text(dialog_ex, "Save");
dialog_ex_set_center_button_text(dialog_ex, "Send");
dialog_ex_set_icon(dialog_ex, 0, 1, I_DolphinExcited_64x63);
dialog_ex_set_result_callback(dialog_ex, dialog_result_callback);
dialog_ex_set_context(dialog_ex, app);
@@ -47,11 +50,20 @@ bool IrdaAppSceneLearnSuccess::on_event(IrdaApp* app, IrdaAppEvent* event) {
case DialogExResultLeft:
app->switch_to_next_scene_without_saving(IrdaApp::Scene::Learn);
break;
case DialogExResultCenter:
furi_assert(0);
case DialogExResultCenter: {
app->notify_space_blink();
auto receiver = app->get_receiver();
auto message = receiver->get_last_message();
irda_send(message, 1);
break;
}
case DialogExResultRight:
app->switch_to_next_scene(IrdaApp::Scene::LearnEnterName);
auto remote_manager = app->get_remote_manager();
if(remote_manager->check_fs()) {
app->switch_to_next_scene(IrdaApp::Scene::LearnEnterName);
} else {
app->switch_to_previous_scene();
}
break;
}
}
@@ -60,4 +72,8 @@ bool IrdaAppSceneLearnSuccess::on_event(IrdaApp* app, IrdaAppEvent* event) {
}
void IrdaAppSceneLearnSuccess::on_exit(IrdaApp* app) {
IrdaAppViewManager* view_manager = app->get_view_manager();
DialogEx* dialog_ex = view_manager->get_dialog_ex();
dialog_ex_set_center_button_text(dialog_ex, nullptr);
app->notify_green_off();
}

9
applications/irda/scene/irda-app-scene-learn.cpp
View File

@@ -14,13 +14,22 @@ void IrdaAppSceneLearn::on_enter(IrdaApp* app) {
popup, "Point the remote at IR port\nand push the button", 5, 10, AlignLeft, AlignCenter);
popup_set_callback(popup, NULL);
if(app->get_learn_new_remote()) {
app->notify_double_vibro();
}
view_manager->switch_to(IrdaAppViewManager::ViewType::Popup);
}
bool IrdaAppSceneLearn::on_event(IrdaApp* app, IrdaAppEvent* event) {
bool consumed = false;
if(event->type == IrdaAppEvent::Type::Tick) {
consumed = true;
app->notify_red_blink();
}
if(event->type == IrdaAppEvent::Type::IrdaMessageReceived) {
app->notify_success();
app->switch_to_next_scene_without_saving(IrdaApp::Scene::LearnSuccess);
}

26
applications/irda/scene/irda-app-scene-remote-list.cpp
View File

@@ -20,13 +20,26 @@ void IrdaAppSceneRemoteList::on_enter(IrdaApp* app) {
auto remote_manager = app->get_remote_manager();
int i = 0;
remote_names = remote_manager->get_remote_list();
for(auto& a : remote_names) {
submenu_add_item(submenu, a.c_str(), i++, submenu_callback, app);
bool result = remote_manager->get_remote_list(remote_names);
if(!result) {
app->switch_to_previous_scene();
return;
}
for(auto& name : remote_names) {
submenu_add_item(submenu, name.c_str(), i++, submenu_callback, app);
}
submenu_add_item(
submenu, " +", SubmenuIndexPlus, submenu_callback, app);
if((SubmenuIndex)submenu_item_selected == SubmenuIndexPlus) {
submenu_set_selected_item(submenu, submenu_item_selected);
} else {
int remote_index = remote_manager->find_remote_name(remote_names);
submenu_set_selected_item(submenu, (remote_index >= 0) ? remote_index : 0);
}
submenu_item_selected = 0;
view_manager->switch_to(IrdaAppViewManager::ViewType::Submenu);
}
@@ -38,11 +51,14 @@ bool IrdaAppSceneRemoteList::on_event(IrdaApp* app, IrdaAppEvent* event) {
case SubmenuIndexPlus:
app->set_learn_new_remote(true);
app->switch_to_next_scene(IrdaApp::Scene::Learn);
submenu_item_selected = event->payload.menu_index;
break;
default:
auto remote_manager = app->get_remote_manager();
remote_manager->set_current_remote(event->payload.menu_index);
app->switch_to_next_scene(IrdaApp::Scene::Remote);
bool result = remote_manager->load(remote_names.at(event->payload.menu_index));
if(result) {
app->switch_to_next_scene(IrdaApp::Scene::Remote);
}
consumed = true;
break;
}

13
applications/irda/scene/irda-app-scene-remote.cpp
View File

@@ -4,6 +4,7 @@
typedef enum {
ButtonIndexPlus = -2,
ButtonIndexEdit = -1,
ButtonIndexNA = 0,
} ButtonIndex;
static void button_menu_callback(void* context, int32_t index) {
@@ -35,8 +36,12 @@ void IrdaAppSceneRemote::on_enter(IrdaApp* app) {
button_menu_add_item(
button_menu, "Edit", ButtonIndexEdit, button_menu_callback, ButtonMenuItemTypeControl, app);
app->set_text_store(0, "%s", remote_manager->get_current_remote_name().c_str());
app->set_text_store(0, "%s", remote_manager->get_remote_name().c_str());
button_menu_set_header(button_menu, app->get_text_store(0));
if(buttonmenu_item_selected != ButtonIndexNA) {
button_menu_set_selected_item(button_menu, buttonmenu_item_selected);
buttonmenu_item_selected = ButtonIndexNA;
}
view_manager->switch_to(IrdaAppViewManager::ViewType::ButtonMenu);
}
@@ -46,12 +51,18 @@ bool IrdaAppSceneRemote::on_event(IrdaApp* app, IrdaAppEvent* event) {
if(event->type == IrdaAppEvent::Type::MenuSelected) {
switch(event->payload.menu_index) {
case ButtonIndexPlus:
app->notify_click();
buttonmenu_item_selected = event->payload.menu_index;
app->set_learn_new_remote(false);
app->switch_to_next_scene(IrdaApp::Scene::Learn);
break;
case ButtonIndexEdit:
app->notify_click();
buttonmenu_item_selected = event->payload.menu_index;
app->switch_to_next_scene(IrdaApp::Scene::Edit);
break;
default:
app->notify_click_and_blink();
auto remote_manager = app->get_remote_manager();
auto message = remote_manager->get_button_data(event->payload.menu_index);
app->get_receiver()->send_message(message);

6
applications/irda/scene/irda-app-scene-start.cpp
View File

@@ -25,6 +25,8 @@ void IrdaAppSceneStart::on_enter(IrdaApp* app) {
submenu_add_item(
submenu, "Learn new remote", SubmenuIndexLearnNewRemote, submenu_callback, app);
submenu_add_item(submenu, "Saved remotes", SubmenuIndexSavedRemotes, submenu_callback, app);
submenu_set_selected_item(submenu, submenu_item_selected);
submenu_item_selected = 0;
view_manager->switch_to(IrdaAppViewManager::ViewType::Submenu);
}
@@ -33,6 +35,7 @@ bool IrdaAppSceneStart::on_event(IrdaApp* app, IrdaAppEvent* event) {
bool consumed = false;
if(event->type == IrdaAppEvent::Type::MenuSelected) {
submenu_item_selected = event->payload.menu_index;
switch(event->payload.menu_index) {
case SubmenuIndexUniversalLibrary:
app->switch_to_next_scene(IrdaApp::Scene::Universal);
@@ -44,6 +47,9 @@ bool IrdaAppSceneStart::on_event(IrdaApp* app, IrdaAppEvent* event) {
case SubmenuIndexSavedRemotes:
app->switch_to_next_scene(IrdaApp::Scene::RemoteList);
break;
default:
furi_assert(0);
break;
}
consumed = true;
}

3
applications/irda/scene/irda-app-scene-universal.cpp
View File

@@ -24,6 +24,8 @@ void IrdaAppSceneUniversal::on_enter(IrdaApp* app) {
submenu_add_item(submenu, "Audio Players", SubmenuIndexUniversalAudio, submenu_callback, app);
submenu_add_item(
submenu, "Air Conditioners", SubmenuIndexUniversalAirConditioner, submenu_callback, app);
submenu_set_selected_item(submenu, submenu_item_selected);
submenu_item_selected = 0;
view_manager->switch_to(IrdaAppViewManager::ViewType::Submenu);
}
@@ -32,6 +34,7 @@ bool IrdaAppSceneUniversal::on_event(IrdaApp* app, IrdaAppEvent* event) {
bool consumed = false;
if(event->type == IrdaAppEvent::Type::MenuSelected) {
submenu_item_selected = event->payload.menu_index;
switch(event->payload.menu_index) {
case SubmenuIndexUniversalTV:
// app->switch_to_next_scene(IrdaApp::Scene::UniversalTV);

9
applications/irda/scene/irda-app-scene.hpp
View File

@@ -23,6 +23,8 @@ public:
void on_enter(IrdaApp* app) final;
bool on_event(IrdaApp* app, IrdaAppEvent* event) final;
void on_exit(IrdaApp* app) final;
private:
uint32_t submenu_item_selected = 0;
};
class IrdaAppSceneUniversal : public IrdaAppScene {
@@ -30,6 +32,8 @@ public:
void on_enter(IrdaApp* app) final;
bool on_event(IrdaApp* app, IrdaAppEvent* event) final;
void on_exit(IrdaApp* app) final;
private:
uint32_t submenu_item_selected = 0;
};
class IrdaAppSceneLearn : public IrdaAppScene {
@@ -74,6 +78,7 @@ public:
void on_exit(IrdaApp* app) final;
private:
std::vector<std::string> buttons_names;
uint32_t buttonmenu_item_selected = 0;
};
class IrdaAppSceneRemoteList : public IrdaAppScene {
@@ -81,6 +86,8 @@ public:
void on_enter(IrdaApp* app) final;
bool on_event(IrdaApp* app, IrdaAppEvent* event) final;
void on_exit(IrdaApp* app) final;
private:
uint32_t submenu_item_selected = 0;
std::vector<std::string> remote_names;
};
@@ -89,6 +96,8 @@ public:
void on_enter(IrdaApp* app) final;
bool on_event(IrdaApp* app, IrdaAppEvent* event) final;
void on_exit(IrdaApp* app) final;
private:
uint32_t submenu_item_selected = 0;
};
class IrdaAppSceneEditKeySelect : public IrdaAppScene {