Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-16 04:24:45 -07:00
Code Issues Packages Projects Releases Wiki Activity

<:Nami2:939038794794020874>

Browse Source
This commit is contained in:
ClaraCrazy
2023-07-17 18:36:51 +02:00
parent 1b095c3f90
commit 5988521cc8
12 changed files with 555 additions and 600 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
applications/external/evil_portal/application.fam vendored
View File

@@ -8,5 +8,5 @@ App(
stack_size=1 * 1024, stack_size=1 * 1024,
order=90, order=90,
fap_icon="icons/evil_portal_10px.png", fap_icon="icons/evil_portal_10px.png",
fap_category="GPIO", fap_category="GPIO",
) )

156
applications/external/evil_portal/evil_portal_app.c vendored
View File

@@ -4,116 +4,112 @@
#include <furi.h> #include <furi.h>
#include <furi_hal.h> #include <furi_hal.h>
static bool evil_portal_app_custom_event_callback(void *context, static bool evil_portal_app_custom_event_callback(void* context, uint32_t event) {
uint32_t event) { furi_assert(context);
furi_assert(context); Evil_PortalApp* app = context;
Evil_PortalApp *app = context; return scene_manager_handle_custom_event(app->scene_manager, event);
return scene_manager_handle_custom_event(app->scene_manager, event);
} }
static bool evil_portal_app_back_event_callback(void *context) { static bool evil_portal_app_back_event_callback(void* context) {
furi_assert(context); furi_assert(context);
Evil_PortalApp *app = context; Evil_PortalApp* app = context;
return scene_manager_handle_back_event(app->scene_manager); return scene_manager_handle_back_event(app->scene_manager);
} }
static void evil_portal_app_tick_event_callback(void *context) { static void evil_portal_app_tick_event_callback(void* context) {
furi_assert(context); furi_assert(context);
Evil_PortalApp *app = context; Evil_PortalApp* app = context;
scene_manager_handle_tick_event(app->scene_manager); scene_manager_handle_tick_event(app->scene_manager);
} }
Evil_PortalApp *evil_portal_app_alloc() { Evil_PortalApp* evil_portal_app_alloc() {
Evil_PortalApp *app = malloc(sizeof(Evil_PortalApp)); Evil_PortalApp* app = malloc(sizeof(Evil_PortalApp));
app->sent_html = false; app->sent_html = false;
app->sent_ap = false; app->sent_ap = false;
app->sent_reset = false; app->sent_reset = false;
app->has_command_queue = false; app->has_command_queue = false;
app->command_index = 0; app->command_index = 0;
app->portal_logs = furi_string_alloc(); app->portal_logs = furi_string_alloc();
app->gui = furi_record_open(RECORD_GUI); app->gui = furi_record_open(RECORD_GUI);
app->view_dispatcher = view_dispatcher_alloc(); app->view_dispatcher = view_dispatcher_alloc();
app->scene_manager = scene_manager_alloc(&evil_portal_scene_handlers, app); app->scene_manager = scene_manager_alloc(&evil_portal_scene_handlers, app);
view_dispatcher_enable_queue(app->view_dispatcher); view_dispatcher_enable_queue(app->view_dispatcher);
view_dispatcher_set_event_callback_context(app->view_dispatcher, app); view_dispatcher_set_event_callback_context(app->view_dispatcher, app);
view_dispatcher_set_custom_event_callback( view_dispatcher_set_custom_event_callback(
app->view_dispatcher, evil_portal_app_custom_event_callback); app->view_dispatcher, evil_portal_app_custom_event_callback);
view_dispatcher_set_navigation_event_callback( view_dispatcher_set_navigation_event_callback(
app->view_dispatcher, evil_portal_app_back_event_callback); app->view_dispatcher, evil_portal_app_back_event_callback);
view_dispatcher_set_tick_event_callback( view_dispatcher_set_tick_event_callback(
app->view_dispatcher, evil_portal_app_tick_event_callback, 100); app->view_dispatcher, evil_portal_app_tick_event_callback, 100);
view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
ViewDispatcherTypeFullscreen);
app->var_item_list = variable_item_list_alloc(); app->var_item_list = variable_item_list_alloc();
view_dispatcher_add_view(app->view_dispatcher, Evil_PortalAppViewVarItemList, view_dispatcher_add_view(
variable_item_list_get_view(app->var_item_list)); app->view_dispatcher,
Evil_PortalAppViewVarItemList,
variable_item_list_get_view(app->var_item_list));
for (int i = 0; i < NUM_MENU_ITEMS; ++i) { for(int i = 0; i < NUM_MENU_ITEMS; ++i) {
app->selected_option_index[i] = 0; app->selected_option_index[i] = 0;
} }
app->text_box = text_box_alloc(); app->text_box = text_box_alloc();
view_dispatcher_add_view(app->view_dispatcher, view_dispatcher_add_view(
Evil_PortalAppViewConsoleOutput, app->view_dispatcher, Evil_PortalAppViewConsoleOutput, text_box_get_view(app->text_box));
text_box_get_view(app->text_box)); app->text_box_store = furi_string_alloc();
app->text_box_store = furi_string_alloc(); furi_string_reserve(app->text_box_store, EVIL_PORTAL_TEXT_BOX_STORE_SIZE);
furi_string_reserve(app->text_box_store, EVIL_PORTAL_TEXT_BOX_STORE_SIZE);
scene_manager_next_scene(app->scene_manager, Evil_PortalSceneStart); scene_manager_next_scene(app->scene_manager, Evil_PortalSceneStart);
return app; return app;
} }
void evil_portal_app_free(Evil_PortalApp *app) { void evil_portal_app_free(Evil_PortalApp* app) {
// save latest logs
if(furi_string_utf8_length(app->portal_logs) > 0) {
write_logs(app->portal_logs);
furi_string_free(app->portal_logs);
}
// save latest logs // Send reset event to dev board
if (furi_string_utf8_length(app->portal_logs) > 0) { evil_portal_uart_tx((uint8_t*)(RESET_CMD), strlen(RESET_CMD));
write_logs(app->portal_logs); evil_portal_uart_tx((uint8_t*)("\n"), 1);
furi_string_free(app->portal_logs);
}
// Send reset event to dev board furi_assert(app);
evil_portal_uart_tx((uint8_t *)(RESET_CMD), strlen(RESET_CMD));
evil_portal_uart_tx((uint8_t *)("\n"), 1);
furi_assert(app); // Views
view_dispatcher_remove_view(app->view_dispatcher, Evil_PortalAppViewVarItemList);
view_dispatcher_remove_view(app->view_dispatcher, Evil_PortalAppViewConsoleOutput);
// Views text_box_free(app->text_box);
view_dispatcher_remove_view(app->view_dispatcher, furi_string_free(app->text_box_store);
Evil_PortalAppViewVarItemList);
view_dispatcher_remove_view(app->view_dispatcher,
Evil_PortalAppViewConsoleOutput);
text_box_free(app->text_box); // View dispatcher
furi_string_free(app->text_box_store); view_dispatcher_free(app->view_dispatcher);
scene_manager_free(app->scene_manager);
// View dispatcher evil_portal_uart_free(app->uart);
view_dispatcher_free(app->view_dispatcher);
scene_manager_free(app->scene_manager);
evil_portal_uart_free(app->uart); // Close records
furi_record_close(RECORD_GUI);
// Close records free(app);
furi_record_close(RECORD_GUI);
free(app);
} }
int32_t evil_portal_app(void *p) { int32_t evil_portal_app(void* p) {
UNUSED(p); UNUSED(p);
Evil_PortalApp *evil_portal_app = evil_portal_app_alloc(); Evil_PortalApp* evil_portal_app = evil_portal_app_alloc();
evil_portal_app->uart = evil_portal_uart_init(evil_portal_app); evil_portal_app->uart = evil_portal_uart_init(evil_portal_app);
view_dispatcher_run(evil_portal_app->view_dispatcher); view_dispatcher_run(evil_portal_app->view_dispatcher);
evil_portal_app_free(evil_portal_app); evil_portal_app_free(evil_portal_app);
return 0; return 0;
} }

56
applications/external/evil_portal/evil_portal_app_i.h vendored
View File

@@ -21,40 +21,40 @@
#define RESET_CMD "reset" #define RESET_CMD "reset"
struct Evil_PortalApp { struct Evil_PortalApp {
Gui *gui; Gui* gui;
ViewDispatcher *view_dispatcher; ViewDispatcher* view_dispatcher;
SceneManager *scene_manager; SceneManager* scene_manager;
FuriString* portal_logs; FuriString* portal_logs;
const char *command_queue[1]; const char* command_queue[1];
int command_index; int command_index;
bool has_command_queue; bool has_command_queue;
FuriString *text_box_store; FuriString* text_box_store;
size_t text_box_store_strlen; size_t text_box_store_strlen;
TextBox *text_box; TextBox* text_box;
VariableItemList *var_item_list; VariableItemList* var_item_list;
Evil_PortalUart *uart; Evil_PortalUart* uart;
int selected_menu_index; int selected_menu_index;
int selected_option_index[NUM_MENU_ITEMS]; int selected_option_index[NUM_MENU_ITEMS];
const char *selected_tx_string; const char* selected_tx_string;
bool is_command; bool is_command;
bool is_custom_tx_string; bool is_custom_tx_string;
bool focus_console_start; bool focus_console_start;
bool show_stopscan_tip; bool show_stopscan_tip;
bool sent_ap; bool sent_ap;
bool sent_html; bool sent_html;
bool sent_reset; bool sent_reset;
int BAUDRATE; int BAUDRATE;
uint8_t *index_html; uint8_t* index_html;
uint8_t *ap_name; uint8_t* ap_name;
}; };
typedef enum { typedef enum {
Evil_PortalAppViewVarItemList, Evil_PortalAppViewVarItemList,
Evil_PortalAppViewConsoleOutput, Evil_PortalAppViewConsoleOutput,
Evil_PortalAppViewStartPortal, Evil_PortalAppViewStartPortal,
} Evil_PortalAppView; } Evil_PortalAppView;

8
applications/external/evil_portal/evil_portal_custom_event.h vendored
View File

@@ -1,8 +1,8 @@
#pragma once #pragma once
typedef enum { typedef enum {
Evil_PortalEventRefreshConsoleOutput = 0, Evil_PortalEventRefreshConsoleOutput = 0,
Evil_PortalEventStartConsole, Evil_PortalEventStartConsole,
Evil_PortalEventStartKeyboard, Evil_PortalEventStartKeyboard,
Evil_PortalEventStartPortal, Evil_PortalEventStartPortal,
} Evil_PortalCustomEvent; } Evil_PortalCustomEvent;

238
applications/external/evil_portal/evil_portal_uart.c vendored
View File

@@ -3,145 +3,143 @@
#include "helpers/evil_portal_storage.h" #include "helpers/evil_portal_storage.h"
struct Evil_PortalUart { struct Evil_PortalUart {
Evil_PortalApp *app; Evil_PortalApp* app;
FuriThread *rx_thread; FuriThread* rx_thread;
FuriStreamBuffer *rx_stream; FuriStreamBuffer* rx_stream;
uint8_t rx_buf[RX_BUF_SIZE + 1]; uint8_t rx_buf[RX_BUF_SIZE + 1];
void (*handle_rx_data_cb)(uint8_t *buf, size_t len, void *context); void (*handle_rx_data_cb)(uint8_t* buf, size_t len, void* context);
}; };
typedef enum { typedef enum {
WorkerEvtStop = (1 << 0), WorkerEvtStop = (1 << 0),
WorkerEvtRxDone = (1 << 1), WorkerEvtRxDone = (1 << 1),
} WorkerEvtFlags; } WorkerEvtFlags;
void evil_portal_uart_set_handle_rx_data_cb( void evil_portal_uart_set_handle_rx_data_cb(
Evil_PortalUart *uart, Evil_PortalUart* uart,
void (*handle_rx_data_cb)(uint8_t *buf, size_t len, void *context)) { void (*handle_rx_data_cb)(uint8_t* buf, size_t len, void* context)) {
furi_assert(uart); furi_assert(uart);
uart->handle_rx_data_cb = handle_rx_data_cb; uart->handle_rx_data_cb = handle_rx_data_cb;
} }
#define WORKER_ALL_RX_EVENTS (WorkerEvtStop | WorkerEvtRxDone) #define WORKER_ALL_RX_EVENTS (WorkerEvtStop | WorkerEvtRxDone)
void evil_portal_uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void *context) { void evil_portal_uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
Evil_PortalUart *uart = (Evil_PortalUart *)context; Evil_PortalUart* uart = (Evil_PortalUart*)context;
if (ev == UartIrqEventRXNE) { if(ev == UartIrqEventRXNE) {
furi_stream_buffer_send(uart->rx_stream, &data, 1, 0); furi_stream_buffer_send(uart->rx_stream, &data, 1, 0);
furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtRxDone); furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtRxDone);
}
}
static int32_t uart_worker(void *context) {
Evil_PortalUart *uart = (void *)context;
while (1) {
uint32_t events = furi_thread_flags_wait(WORKER_ALL_RX_EVENTS,
FuriFlagWaitAny, FuriWaitForever);
furi_check((events & FuriFlagError) == 0);
if (events & WorkerEvtStop)
break;
if (events & WorkerEvtRxDone) {
size_t len = furi_stream_buffer_receive(uart->rx_stream, uart->rx_buf,
RX_BUF_SIZE, 0);
if (len > 0) {
if (uart->handle_rx_data_cb) {
uart->handle_rx_data_cb(uart->rx_buf, len, uart->app);
if (uart->app->has_command_queue) {
if (uart->app->command_index < 1) {
if (0 ==
strncmp(SET_AP_CMD,
uart->app->command_queue[uart->app->command_index],
strlen(SET_AP_CMD))) {
FuriString *out_data = furi_string_alloc();
furi_string_cat(out_data, "setap=");
furi_string_cat(out_data, (char *)uart->app->ap_name);
evil_portal_uart_tx((uint8_t *)(furi_string_get_cstr(out_data)),
strlen(furi_string_get_cstr(out_data)));
evil_portal_uart_tx((uint8_t *)("\n"), 1);
uart->app->sent_ap = true;
free(out_data);
free(uart->app->ap_name);
}
uart->app->command_index = 0;
uart->app->has_command_queue = false;
uart->app->command_queue[0] = "";
}
}
if (uart->app->sent_reset == false) {
furi_string_cat(uart->app->portal_logs, (char *)uart->rx_buf);
}
if (furi_string_utf8_length(uart->app->portal_logs) > 4000) {
write_logs(uart->app->portal_logs);
furi_string_reset(uart->app->portal_logs);
}
} else {
uart->rx_buf[len] = '\0';
if (uart->app->sent_reset == false) {
furi_string_cat(uart->app->portal_logs, (char *)uart->rx_buf);
}
if (furi_string_utf8_length(uart->app->portal_logs) > 4000) {
write_logs(uart->app->portal_logs);
furi_string_reset(uart->app->portal_logs);
}
}
}
} }
}
furi_stream_buffer_free(uart->rx_stream);
return 0;
} }
void evil_portal_uart_tx(uint8_t *data, size_t len) { static int32_t uart_worker(void* context) {
furi_hal_uart_tx(UART_CH, data, len); Evil_PortalUart* uart = (void*)context;
while(1) {
uint32_t events =
furi_thread_flags_wait(WORKER_ALL_RX_EVENTS, FuriFlagWaitAny, FuriWaitForever);
furi_check((events & FuriFlagError) == 0);
if(events & WorkerEvtStop) break;
if(events & WorkerEvtRxDone) {
size_t len = furi_stream_buffer_receive(uart->rx_stream, uart->rx_buf, RX_BUF_SIZE, 0);
if(len > 0) {
if(uart->handle_rx_data_cb) {
uart->handle_rx_data_cb(uart->rx_buf, len, uart->app);
if(uart->app->has_command_queue) {
if(uart->app->command_index < 1) {
if(0 == strncmp(
SET_AP_CMD,
uart->app->command_queue[uart->app->command_index],
strlen(SET_AP_CMD))) {
FuriString* out_data = furi_string_alloc();
furi_string_cat(out_data, "setap=");
furi_string_cat(out_data, (char*)uart->app->ap_name);
evil_portal_uart_tx(
(uint8_t*)(furi_string_get_cstr(out_data)),
strlen(furi_string_get_cstr(out_data)));
evil_portal_uart_tx((uint8_t*)("\n"), 1);
uart->app->sent_ap = true;
free(out_data);
free(uart->app->ap_name);
}
uart->app->command_index = 0;
uart->app->has_command_queue = false;
uart->app->command_queue[0] = "";
}
}
if(uart->app->sent_reset == false) {
furi_string_cat(uart->app->portal_logs, (char*)uart->rx_buf);
}
if(furi_string_utf8_length(uart->app->portal_logs) > 4000) {
write_logs(uart->app->portal_logs);
furi_string_reset(uart->app->portal_logs);
}
} else {
uart->rx_buf[len] = '\0';
if(uart->app->sent_reset == false) {
furi_string_cat(uart->app->portal_logs, (char*)uart->rx_buf);
}
if(furi_string_utf8_length(uart->app->portal_logs) > 4000) {
write_logs(uart->app->portal_logs);
furi_string_reset(uart->app->portal_logs);
}
}
}
}
}
furi_stream_buffer_free(uart->rx_stream);
return 0;
} }
Evil_PortalUart *evil_portal_uart_init(Evil_PortalApp *app) { void evil_portal_uart_tx(uint8_t* data, size_t len) {
Evil_PortalUart *uart = malloc(sizeof(Evil_PortalUart)); furi_hal_uart_tx(UART_CH, data, len);
uart->app = app;
// Init all rx stream and thread early to avoid crashes
uart->rx_stream = furi_stream_buffer_alloc(RX_BUF_SIZE, 1);
uart->rx_thread = furi_thread_alloc();
furi_thread_set_name(uart->rx_thread, "Evil_PortalUartRxThread");
furi_thread_set_stack_size(uart->rx_thread, 1024);
furi_thread_set_context(uart->rx_thread, uart);
furi_thread_set_callback(uart->rx_thread, uart_worker);
furi_thread_start(uart->rx_thread);
furi_hal_console_disable();
if (app->BAUDRATE == 0) {
app->BAUDRATE = 115200;
}
furi_hal_uart_set_br(UART_CH, app->BAUDRATE);
furi_hal_uart_set_irq_cb(UART_CH, evil_portal_uart_on_irq_cb, uart);
return uart;
} }
void evil_portal_uart_free(Evil_PortalUart *uart) { Evil_PortalUart* evil_portal_uart_init(Evil_PortalApp* app) {
furi_assert(uart); Evil_PortalUart* uart = malloc(sizeof(Evil_PortalUart));
uart->app = app;
// Init all rx stream and thread early to avoid crashes
uart->rx_stream = furi_stream_buffer_alloc(RX_BUF_SIZE, 1);
uart->rx_thread = furi_thread_alloc();
furi_thread_set_name(uart->rx_thread, "Evil_PortalUartRxThread");
furi_thread_set_stack_size(uart->rx_thread, 1024);
furi_thread_set_context(uart->rx_thread, uart);
furi_thread_set_callback(uart->rx_thread, uart_worker);
furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtStop); furi_thread_start(uart->rx_thread);
furi_thread_join(uart->rx_thread);
furi_thread_free(uart->rx_thread);
furi_hal_uart_set_irq_cb(UART_CH, NULL, NULL); furi_hal_console_disable();
furi_hal_console_enable(); if(app->BAUDRATE == 0) {
app->BAUDRATE = 115200;
}
furi_hal_uart_set_br(UART_CH, app->BAUDRATE);
furi_hal_uart_set_irq_cb(UART_CH, evil_portal_uart_on_irq_cb, uart);
free(uart); return uart;
}
void evil_portal_uart_free(Evil_PortalUart* uart) {
furi_assert(uart);
furi_thread_flags_set(furi_thread_get_id(uart->rx_thread), WorkerEvtStop);
furi_thread_join(uart->rx_thread);
furi_thread_free(uart->rx_thread);
furi_hal_uart_set_irq_cb(UART_CH, NULL, NULL);
furi_hal_console_enable();
free(uart);
} }

10
applications/external/evil_portal/evil_portal_uart.h vendored
View File

@@ -7,8 +7,8 @@
typedef struct Evil_PortalUart Evil_PortalUart; typedef struct Evil_PortalUart Evil_PortalUart;
void evil_portal_uart_set_handle_rx_data_cb( void evil_portal_uart_set_handle_rx_data_cb(
Evil_PortalUart *uart, Evil_PortalUart* uart,
void (*handle_rx_data_cb)(uint8_t *buf, size_t len, void *context)); void (*handle_rx_data_cb)(uint8_t* buf, size_t len, void* context));
void evil_portal_uart_tx(uint8_t *data, size_t len); void evil_portal_uart_tx(uint8_t* data, size_t len);
Evil_PortalUart *evil_portal_uart_init(Evil_PortalApp *app); Evil_PortalUart* evil_portal_uart_init(Evil_PortalApp* app);
void evil_portal_uart_free(Evil_PortalUart *uart); void evil_portal_uart_free(Evil_PortalUart* uart);

189
applications/external/evil_portal/helpers/evil_portal_storage.c vendored
View File

@@ -1,118 +1,117 @@
#include "evil_portal_storage.h" #include "evil_portal_storage.h"
static Storage *evil_portal_open_storage() { static Storage* evil_portal_open_storage() {
return furi_record_open(RECORD_STORAGE); return furi_record_open(RECORD_STORAGE);
} }
static void evil_portal_close_storage() { furi_record_close(RECORD_STORAGE); } static void evil_portal_close_storage() {
furi_record_close(RECORD_STORAGE);
}
void evil_portal_read_index_html(void *context) { void evil_portal_read_index_html(void* context) {
Evil_PortalApp* app = context;
Storage* storage = evil_portal_open_storage();
FileInfo fi;
Evil_PortalApp *app = context; if(storage_common_stat(storage, EVIL_PORTAL_INDEX_SAVE_PATH, &fi) == FSE_OK) {
Storage *storage = evil_portal_open_storage(); File* index_html = storage_file_alloc(storage);
FileInfo fi; if(storage_file_open(
index_html, EVIL_PORTAL_INDEX_SAVE_PATH, FSAM_READ, FSOM_OPEN_EXISTING)) {
if (storage_common_stat(storage, EVIL_PORTAL_INDEX_SAVE_PATH, &fi) == app->index_html = malloc((size_t)fi.size);
FSE_OK) { uint8_t* buf_ptr = app->index_html;
File *index_html = storage_file_alloc(storage); size_t read = 0;
if (storage_file_open(index_html, EVIL_PORTAL_INDEX_SAVE_PATH, FSAM_READ, while(read < fi.size) {
FSOM_OPEN_EXISTING)) { size_t to_read = fi.size - read;
app->index_html = malloc((size_t)fi.size); if(to_read > UINT16_MAX) to_read = UINT16_MAX;
uint8_t *buf_ptr = app->index_html; uint16_t now_read = storage_file_read(index_html, buf_ptr, (uint16_t)to_read);
size_t read = 0; read += now_read;
while (read < fi.size) { buf_ptr += now_read;
size_t to_read = fi.size - read; }
if (to_read > UINT16_MAX) free(buf_ptr);
to_read = UINT16_MAX; }
uint16_t now_read = storage_file_close(index_html);
storage_file_read(index_html, buf_ptr, (uint16_t)to_read); storage_file_free(index_html);
read += now_read; } else {
buf_ptr += now_read; char* html_error = "<b>Evil portal</b><br>Unable to read the html file.<br>"
} "Is the SD Card set up correctly? <br>See instructions @ "
free(buf_ptr); "github.com/bigbrodude6119/flipper-zero-evil-portal<br>"
"Under the 'Install pre-built app on the flipper' section.";
app->index_html = (uint8_t*)html_error;
} }
storage_file_close(index_html);
storage_file_free(index_html);
} else {
char *html_error =
"<b>Evil portal</b><br>Unable to read the html file.<br>"
"Is the SD Card set up correctly? <br>See instructions @ "
"github.com/bigbrodude6119/flipper-zero-evil-portal<br>"
"Under the 'Install pre-built app on the flipper' section.";
app->index_html = (uint8_t *)html_error;
}
evil_portal_close_storage(); evil_portal_close_storage();
} }
void evil_portal_read_ap_name(void *context) { void evil_portal_read_ap_name(void* context) {
Evil_PortalApp *app = context; Evil_PortalApp* app = context;
Storage *storage = evil_portal_open_storage(); Storage* storage = evil_portal_open_storage();
FileInfo fi; FileInfo fi;
if (storage_common_stat(storage, EVIL_PORTAL_AP_SAVE_PATH, &fi) == FSE_OK) { if(storage_common_stat(storage, EVIL_PORTAL_AP_SAVE_PATH, &fi) == FSE_OK) {
File *ap_name = storage_file_alloc(storage); File* ap_name = storage_file_alloc(storage);
if (storage_file_open(ap_name, EVIL_PORTAL_AP_SAVE_PATH, FSAM_READ, if(storage_file_open(ap_name, EVIL_PORTAL_AP_SAVE_PATH, FSAM_READ, FSOM_OPEN_EXISTING)) {
FSOM_OPEN_EXISTING)) { app->ap_name = malloc((size_t)fi.size);
app->ap_name = malloc((size_t)fi.size); uint8_t* buf_ptr = app->ap_name;
uint8_t *buf_ptr = app->ap_name; size_t read = 0;
size_t read = 0; while(read < fi.size) {
while (read < fi.size) { size_t to_read = fi.size - read;
size_t to_read = fi.size - read; if(to_read > UINT16_MAX) to_read = UINT16_MAX;
if (to_read > UINT16_MAX) uint16_t now_read = storage_file_read(ap_name, buf_ptr, (uint16_t)to_read);
to_read = UINT16_MAX; read += now_read;
uint16_t now_read = buf_ptr += now_read;
storage_file_read(ap_name, buf_ptr, (uint16_t)to_read); }
read += now_read; free(buf_ptr);
buf_ptr += now_read; }
} storage_file_close(ap_name);
free(buf_ptr); storage_file_free(ap_name);
} else {
char* app_default = "Evil Portal";
app->ap_name = (uint8_t*)app_default;
} }
storage_file_close(ap_name); evil_portal_close_storage();
storage_file_free(ap_name);
} else {
char *app_default = "Evil Portal";
app->ap_name = (uint8_t *)app_default;
}
evil_portal_close_storage();
} }
char *sequential_file_resolve_path(Storage *storage, const char *dir, char* sequential_file_resolve_path(
const char *prefix, const char *extension) { Storage* storage,
if (storage == NULL || dir == NULL || prefix == NULL || extension == NULL) { const char* dir,
return NULL; const char* prefix,
} const char* extension) {
if(storage == NULL || dir == NULL || prefix == NULL || extension == NULL) {
char file_path[256]; return NULL;
int file_index = 0;
do {
if (snprintf(file_path, sizeof(file_path), "%s/%s_%d.%s", dir, prefix,
file_index, extension) < 0) {
return NULL;
} }
file_index++;
} while (storage_file_exists(storage, file_path));
return strdup(file_path); char file_path[256];
int file_index = 0;
do {
if(snprintf(
file_path, sizeof(file_path), "%s/%s_%d.%s", dir, prefix, file_index, extension) <
0) {
return NULL;
}
file_index++;
} while(storage_file_exists(storage, file_path));
return strdup(file_path);
} }
void write_logs(FuriString *portal_logs) { void write_logs(FuriString* portal_logs) {
Storage *storage = evil_portal_open_storage(); Storage* storage = evil_portal_open_storage();
if (!storage_file_exists(storage, EVIL_PORTAL_LOG_SAVE_PATH)) { if(!storage_file_exists(storage, EVIL_PORTAL_LOG_SAVE_PATH)) {
storage_simply_mkdir(storage, EVIL_PORTAL_LOG_SAVE_PATH); storage_simply_mkdir(storage, EVIL_PORTAL_LOG_SAVE_PATH);
} }
char *seq_file_path = sequential_file_resolve_path( char* seq_file_path =
storage, EVIL_PORTAL_LOG_SAVE_PATH, "log", "txt"); sequential_file_resolve_path(storage, EVIL_PORTAL_LOG_SAVE_PATH, "log", "txt");
File *file = storage_file_alloc(storage); File* file = storage_file_alloc(storage);
if (storage_file_open(file, seq_file_path, FSAM_WRITE, FSOM_CREATE_ALWAYS)) { if(storage_file_open(file, seq_file_path, FSAM_WRITE, FSOM_CREATE_ALWAYS)) {
storage_file_write(file, furi_string_get_cstr(portal_logs), furi_string_utf8_length(portal_logs)); storage_file_write(
} file, furi_string_get_cstr(portal_logs), furi_string_utf8_length(portal_logs));
storage_file_close(file); }
storage_file_free(file); storage_file_close(file);
evil_portal_close_storage(); storage_file_free(file);
evil_portal_close_storage();
} }

11
applications/external/evil_portal/helpers/evil_portal_storage.h vendored
View File

@@ -10,8 +10,11 @@
#define EVIL_PORTAL_AP_SAVE_PATH PORTAL_FILE_DIRECTORY_PATH "/ap.config.txt" #define EVIL_PORTAL_AP_SAVE_PATH PORTAL_FILE_DIRECTORY_PATH "/ap.config.txt"
#define EVIL_PORTAL_LOG_SAVE_PATH PORTAL_FILE_DIRECTORY_PATH "/logs" #define EVIL_PORTAL_LOG_SAVE_PATH PORTAL_FILE_DIRECTORY_PATH "/logs"
void evil_portal_read_index_html(void *context); void evil_portal_read_index_html(void* context);
void evil_portal_read_ap_name(void *context); void evil_portal_read_ap_name(void* context);
void write_logs(FuriString* portal_logs); void write_logs(FuriString* portal_logs);
char *sequential_file_resolve_path(Storage *storage, const char *dir, char* sequential_file_resolve_path(
const char *prefix, const char *extension); Storage* storage,
const char* dir,
const char* prefix,
const char* extension);

7
applications/external/evil_portal/scenes/evil_portal_scene.c vendored
View File

@@ -2,22 +2,21 @@
// Generate scene on_enter handlers array // Generate scene on_enter handlers array
#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter, #define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
void (*const evil_portal_scene_on_enter_handlers[])(void *) = { void (*const evil_portal_scene_on_enter_handlers[])(void*) = {
#include "evil_portal_scene_config.h" #include "evil_portal_scene_config.h"
}; };
#undef ADD_SCENE #undef ADD_SCENE
// Generate scene on_event handlers array // Generate scene on_event handlers array
#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_event, #define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_event,
bool (*const evil_portal_scene_on_event_handlers[])(void *context, bool (*const evil_portal_scene_on_event_handlers[])(void* context, SceneManagerEvent event) = {
SceneManagerEvent event) = {
#include "evil_portal_scene_config.h" #include "evil_portal_scene_config.h"
}; };
#undef ADD_SCENE #undef ADD_SCENE
// Generate scene on_exit handlers array // Generate scene on_exit handlers array
#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_exit, #define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_exit,
void (*const evil_portal_scene_on_exit_handlers[])(void *context) = { void (*const evil_portal_scene_on_exit_handlers[])(void* context) = {
#include "evil_portal_scene_config.h" #include "evil_portal_scene_config.h"
}; };
#undef ADD_SCENE #undef ADD_SCENE

12
applications/external/evil_portal/scenes/evil_portal_scene.h vendored
View File

@@ -6,26 +6,24 @@
#define ADD_SCENE(prefix, name, id) Evil_PortalScene##id, #define ADD_SCENE(prefix, name, id) Evil_PortalScene##id,
typedef enum { typedef enum {
#include "evil_portal_scene_config.h" #include "evil_portal_scene_config.h"
Evil_PortalSceneNum, Evil_PortalSceneNum,
} Evil_PortalScene; } Evil_PortalScene;
#undef ADD_SCENE #undef ADD_SCENE
extern const SceneManagerHandlers evil_portal_scene_handlers; extern const SceneManagerHandlers evil_portal_scene_handlers;
// Generate scene on_enter handlers declaration // Generate scene on_enter handlers declaration
#define ADD_SCENE(prefix, name, id) \ #define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
void prefix##_scene_##name##_on_enter(void *);
#include "evil_portal_scene_config.h" #include "evil_portal_scene_config.h"
#undef ADD_SCENE #undef ADD_SCENE
// Generate scene on_event handlers declaration // Generate scene on_event handlers declaration
#define ADD_SCENE(prefix, name, id) \ #define ADD_SCENE(prefix, name, id) \
bool prefix##_scene_##name##_on_event(void *context, SceneManagerEvent event); bool prefix##_scene_##name##_on_event(void* context, SceneManagerEvent event);
#include "evil_portal_scene_config.h" #include "evil_portal_scene_config.h"
#undef ADD_SCENE #undef ADD_SCENE
// Generate scene on_exit handlers declaration // Generate scene on_exit handlers declaration
#define ADD_SCENE(prefix, name, id) \ #define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_exit(void* context);
void prefix##_scene_##name##_on_exit(void *context);
#include "evil_portal_scene_config.h" #include "evil_portal_scene_config.h"
#undef ADD_SCENE #undef ADD_SCENE

266
applications/external/evil_portal/scenes/evil_portal_scene_console_output.c vendored
View File

@@ -1,157 +1,147 @@
#include "../evil_portal_app_i.h" #include "../evil_portal_app_i.h"
#include "../helpers/evil_portal_storage.h" #include "../helpers/evil_portal_storage.h"
void evil_portal_console_output_handle_rx_data_cb(uint8_t *buf, size_t len, void evil_portal_console_output_handle_rx_data_cb(uint8_t* buf, size_t len, void* context) {
void *context) { furi_assert(context);
furi_assert(context); Evil_PortalApp* app = context;
Evil_PortalApp *app = context;
// If text box store gets too big, then truncate it // If text box store gets too big, then truncate it
app->text_box_store_strlen += len; app->text_box_store_strlen += len;
if (app->text_box_store_strlen >= EVIL_PORTAL_TEXT_BOX_STORE_SIZE - 1) { if(app->text_box_store_strlen >= EVIL_PORTAL_TEXT_BOX_STORE_SIZE - 1) {
furi_string_right(app->text_box_store, app->text_box_store_strlen / 2); furi_string_right(app->text_box_store, app->text_box_store_strlen / 2);
app->text_box_store_strlen = furi_string_size(app->text_box_store) + len; app->text_box_store_strlen = furi_string_size(app->text_box_store) + len;
} }
// Null-terminate buf and append to text box store // Null-terminate buf and append to text box store
buf[len] = '\0'; buf[len] = '\0';
furi_string_cat_printf(app->text_box_store, "%s", buf); furi_string_cat_printf(app->text_box_store, "%s", buf);
view_dispatcher_send_custom_event(app->view_dispatcher, view_dispatcher_send_custom_event(app->view_dispatcher, Evil_PortalEventRefreshConsoleOutput);
Evil_PortalEventRefreshConsoleOutput);
} }
void evil_portal_scene_console_output_on_enter(void *context) { void evil_portal_scene_console_output_on_enter(void* context) {
Evil_PortalApp *app = context; Evil_PortalApp* app = context;
TextBox *text_box = app->text_box; TextBox* text_box = app->text_box;
text_box_reset(app->text_box); text_box_reset(app->text_box);
text_box_set_font(text_box, TextBoxFontText); text_box_set_font(text_box, TextBoxFontText);
if (app->focus_console_start) { if(app->focus_console_start) {
text_box_set_focus(text_box, TextBoxFocusStart); text_box_set_focus(text_box, TextBoxFocusStart);
} else { } else {
text_box_set_focus(text_box, TextBoxFocusEnd); text_box_set_focus(text_box, TextBoxFocusEnd);
}
if (app->is_command) {
furi_string_reset(app->text_box_store);
app->text_box_store_strlen = 0;
app->sent_reset = false;
if (0 == strncmp("help", app->selected_tx_string, strlen("help"))) {
const char *help_msg =
"BLUE = Waiting\nGREEN = Good\nRED = Bad\n\nThis project is a "
"WIP.\ngithub.com/bigbrodude6119/flipper-zero-evil-portal\n\n"
"Version 0.0.2\n\n";
furi_string_cat_str(app->text_box_store, help_msg);
app->text_box_store_strlen += strlen(help_msg);
if (app->show_stopscan_tip) {
const char *msg = "Press BACK to return\n";
furi_string_cat_str(app->text_box_store, msg);
app->text_box_store_strlen += strlen(msg);
}
} }
if (0 == strncmp("savelogs", app->selected_tx_string, strlen("savelogs"))) { if(app->is_command) {
const char *help_msg = "Logs saved.\n\n"; furi_string_reset(app->text_box_store);
furi_string_cat_str(app->text_box_store, help_msg); app->text_box_store_strlen = 0;
app->text_box_store_strlen += strlen(help_msg); app->sent_reset = false;
write_logs(app->portal_logs);
furi_string_reset(app->portal_logs); if(0 == strncmp("help", app->selected_tx_string, strlen("help"))) {
if (app->show_stopscan_tip) { const char* help_msg = "BLUE = Waiting\nGREEN = Good\nRED = Bad\n\nThis project is a "
const char *msg = "Press BACK to return\n"; "WIP.\ngithub.com/bigbrodude6119/flipper-zero-evil-portal\n\n"
furi_string_cat_str(app->text_box_store, msg); "Version 0.0.2\n\n";
app->text_box_store_strlen += strlen(msg); furi_string_cat_str(app->text_box_store, help_msg);
} app->text_box_store_strlen += strlen(help_msg);
if(app->show_stopscan_tip) {
const char* msg = "Press BACK to return\n";
furi_string_cat_str(app->text_box_store, msg);
app->text_box_store_strlen += strlen(msg);
}
}
if(0 == strncmp("savelogs", app->selected_tx_string, strlen("savelogs"))) {
const char* help_msg = "Logs saved.\n\n";
furi_string_cat_str(app->text_box_store, help_msg);
app->text_box_store_strlen += strlen(help_msg);
write_logs(app->portal_logs);
furi_string_reset(app->portal_logs);
if(app->show_stopscan_tip) {
const char* msg = "Press BACK to return\n";
furi_string_cat_str(app->text_box_store, msg);
app->text_box_store_strlen += strlen(msg);
}
}
if(0 == strncmp(SET_HTML_CMD, app->selected_tx_string, strlen(SET_HTML_CMD))) {
app->command_queue[0] = SET_AP_CMD;
app->has_command_queue = true;
app->command_index = 0;
if(app->show_stopscan_tip) {
const char* msg = "Starting portal\nIf no response press\nBACK to return\n";
furi_string_cat_str(app->text_box_store, msg);
app->text_box_store_strlen += strlen(msg);
}
}
if(0 == strncmp(RESET_CMD, app->selected_tx_string, strlen(RESET_CMD))) {
app->sent_reset = true;
if(app->show_stopscan_tip) {
const char* msg = "Reseting portal\nPress BACK to return\n\n\n\n";
furi_string_cat_str(app->text_box_store, msg);
app->text_box_store_strlen += strlen(msg);
}
}
} }
if (0 ==
strncmp(SET_HTML_CMD, app->selected_tx_string, strlen(SET_HTML_CMD))) {
app->command_queue[0] = SET_AP_CMD;
app->has_command_queue = true;
app->command_index = 0;
if (app->show_stopscan_tip) {
const char *msg =
"Starting portal\nIf no response press\nBACK to return\n";
furi_string_cat_str(app->text_box_store, msg);
app->text_box_store_strlen += strlen(msg);
}
}
if (0 == strncmp(RESET_CMD, app->selected_tx_string, strlen(RESET_CMD))) {
app->sent_reset = true;
if (app->show_stopscan_tip) {
const char *msg = "Reseting portal\nPress BACK to return\n\n\n\n";
furi_string_cat_str(app->text_box_store, msg);
app->text_box_store_strlen += strlen(msg);
}
}
}
text_box_set_text(app->text_box, furi_string_get_cstr(app->text_box_store));
scene_manager_set_scene_state(app->scene_manager,
Evil_PortalSceneConsoleOutput, 0);
view_dispatcher_switch_to_view(app->view_dispatcher,
Evil_PortalAppViewConsoleOutput);
// Register callback to receive data
evil_portal_uart_set_handle_rx_data_cb(
app->uart, evil_portal_console_output_handle_rx_data_cb);
if (app->is_command && app->selected_tx_string) {
if (0 ==
strncmp(SET_HTML_CMD, app->selected_tx_string, strlen(SET_HTML_CMD))) {
evil_portal_read_index_html(context);
FuriString *data = furi_string_alloc();
furi_string_cat(data, "sethtml=");
furi_string_cat(data, (char *)app->index_html);
evil_portal_uart_tx((uint8_t *)(furi_string_get_cstr(data)),
strlen(furi_string_get_cstr(data)));
evil_portal_uart_tx((uint8_t *)("\n"), 1);
app->sent_html = true;
free(data);
free(app->index_html);
evil_portal_read_ap_name(context);
} else if (0 ==
strncmp(RESET_CMD, app->selected_tx_string, strlen(RESET_CMD))) {
app->sent_html = false;
app->sent_ap = false;
evil_portal_uart_tx((uint8_t *)(app->selected_tx_string),
strlen(app->selected_tx_string));
evil_portal_uart_tx((uint8_t *)("\n"), 1);
} else if (1 == strncmp("help", app->selected_tx_string, strlen("help"))) {
evil_portal_uart_tx((uint8_t *)(app->selected_tx_string),
strlen(app->selected_tx_string));
evil_portal_uart_tx((uint8_t *)("\n"), 1);
}
}
}
bool evil_portal_scene_console_output_on_event(void *context,
SceneManagerEvent event) {
Evil_PortalApp *app = context;
bool consumed = false;
if (event.type == SceneManagerEventTypeCustom) {
text_box_set_text(app->text_box, furi_string_get_cstr(app->text_box_store)); text_box_set_text(app->text_box, furi_string_get_cstr(app->text_box_store));
consumed = true;
} else if (event.type == SceneManagerEventTypeTick) {
consumed = true;
}
return consumed; scene_manager_set_scene_state(app->scene_manager, Evil_PortalSceneConsoleOutput, 0);
view_dispatcher_switch_to_view(app->view_dispatcher, Evil_PortalAppViewConsoleOutput);
// Register callback to receive data
evil_portal_uart_set_handle_rx_data_cb(
app->uart, evil_portal_console_output_handle_rx_data_cb);
if(app->is_command && app->selected_tx_string) {
if(0 == strncmp(SET_HTML_CMD, app->selected_tx_string, strlen(SET_HTML_CMD))) {
evil_portal_read_index_html(context);
FuriString* data = furi_string_alloc();
furi_string_cat(data, "sethtml=");
furi_string_cat(data, (char*)app->index_html);
evil_portal_uart_tx(
(uint8_t*)(furi_string_get_cstr(data)), strlen(furi_string_get_cstr(data)));
evil_portal_uart_tx((uint8_t*)("\n"), 1);
app->sent_html = true;
free(data);
free(app->index_html);
evil_portal_read_ap_name(context);
} else if(0 == strncmp(RESET_CMD, app->selected_tx_string, strlen(RESET_CMD))) {
app->sent_html = false;
app->sent_ap = false;
evil_portal_uart_tx(
(uint8_t*)(app->selected_tx_string), strlen(app->selected_tx_string));
evil_portal_uart_tx((uint8_t*)("\n"), 1);
} else if(1 == strncmp("help", app->selected_tx_string, strlen("help"))) {
evil_portal_uart_tx(
(uint8_t*)(app->selected_tx_string), strlen(app->selected_tx_string));
evil_portal_uart_tx((uint8_t*)("\n"), 1);
}
}
} }
void evil_portal_scene_console_output_on_exit(void *context) { bool evil_portal_scene_console_output_on_event(void* context, SceneManagerEvent event) {
Evil_PortalApp *app = context; Evil_PortalApp* app = context;
// Unregister rx callback bool consumed = false;
evil_portal_uart_set_handle_rx_data_cb(app->uart, NULL);
if(event.type == SceneManagerEventTypeCustom) {
text_box_set_text(app->text_box, furi_string_get_cstr(app->text_box_store));
consumed = true;
} else if(event.type == SceneManagerEventTypeTick) {
consumed = true;
}
return consumed;
}
void evil_portal_scene_console_output_on_exit(void* context) {
Evil_PortalApp* app = context;
// Unregister rx callback
evil_portal_uart_set_handle_rx_data_cb(app->uart, NULL);
} }

200
applications/external/evil_portal/scenes/evil_portal_scene_start.c vendored
View File

@@ -5,154 +5,126 @@
// text box should focus at the start of the output or the end // text box should focus at the start of the output or the end
typedef enum { NO_ARGS = 0, INPUT_ARGS, TOGGLE_ARGS } InputArgs; typedef enum { NO_ARGS = 0, INPUT_ARGS, TOGGLE_ARGS } InputArgs;
typedef enum { typedef enum { FOCUS_CONSOLE_END = 0, FOCUS_CONSOLE_START, FOCUS_CONSOLE_TOGGLE } FocusConsole;
FOCUS_CONSOLE_END = 0,
FOCUS_CONSOLE_START,
FOCUS_CONSOLE_TOGGLE
} FocusConsole;
#define SHOW_STOPSCAN_TIP (true) #define SHOW_STOPSCAN_TIP (true)
#define NO_TIP (false) #define NO_TIP (false)
#define MAX_OPTIONS (9) #define MAX_OPTIONS (9)
typedef struct { typedef struct {
const char *item_string; const char* item_string;
const char *options_menu[MAX_OPTIONS]; const char* options_menu[MAX_OPTIONS];
int num_options_menu; int num_options_menu;
const char *actual_commands[MAX_OPTIONS]; const char* actual_commands[MAX_OPTIONS];
InputArgs needs_keyboard; InputArgs needs_keyboard;
FocusConsole focus_console; FocusConsole focus_console;
bool show_stopscan_tip; bool show_stopscan_tip;
} Evil_PortalItem; } Evil_PortalItem;
// NUM_MENU_ITEMS defined in evil_portal_app_i.h - if you add an entry here, // NUM_MENU_ITEMS defined in evil_portal_app_i.h - if you add an entry here,
// increment it! // increment it!
const Evil_PortalItem items[NUM_MENU_ITEMS] = { const Evil_PortalItem items[NUM_MENU_ITEMS] = {
// send command // send command
{"Start portal", {"Start portal", {""}, 1, {SET_HTML_CMD}, NO_ARGS, FOCUS_CONSOLE_END, SHOW_STOPSCAN_TIP},
{""},
1,
{SET_HTML_CMD},
NO_ARGS,
FOCUS_CONSOLE_END,
SHOW_STOPSCAN_TIP},
// stop portal // stop portal
{"Stop portal", {""}, 1, {RESET_CMD}, NO_ARGS, FOCUS_CONSOLE_START, SHOW_STOPSCAN_TIP}, {"Stop portal", {""}, 1, {RESET_CMD}, NO_ARGS, FOCUS_CONSOLE_START, SHOW_STOPSCAN_TIP},
// console // console
{"Save logs", {"Save logs", {""}, 1, {"savelogs"}, NO_ARGS, FOCUS_CONSOLE_START, SHOW_STOPSCAN_TIP},
{""},
1,
{"savelogs"},
NO_ARGS,
FOCUS_CONSOLE_START,
SHOW_STOPSCAN_TIP},
// help // help
{"Help", {"Help", {""}, 1, {"help"}, NO_ARGS, FOCUS_CONSOLE_START, SHOW_STOPSCAN_TIP},
{""},
1,
{"help"},
NO_ARGS,
FOCUS_CONSOLE_START,
SHOW_STOPSCAN_TIP},
}; };
static void evil_portal_scene_start_var_list_enter_callback(void *context, static void evil_portal_scene_start_var_list_enter_callback(void* context, uint32_t index) {
uint32_t index) { furi_assert(context);
furi_assert(context); Evil_PortalApp* app = context;
Evil_PortalApp *app = context;
furi_assert(index < NUM_MENU_ITEMS); furi_assert(index < NUM_MENU_ITEMS);
const Evil_PortalItem *item = &items[index]; const Evil_PortalItem* item = &items[index];
const int selected_option_index = app->selected_option_index[index]; const int selected_option_index = app->selected_option_index[index];
furi_assert(selected_option_index < item->num_options_menu); furi_assert(selected_option_index < item->num_options_menu);
app->selected_tx_string = item->actual_commands[selected_option_index]; app->selected_tx_string = item->actual_commands[selected_option_index];
app->is_command = true; app->is_command = true;
app->is_custom_tx_string = false; app->is_custom_tx_string = false;
app->selected_menu_index = index; app->selected_menu_index = index;
app->focus_console_start = (item->focus_console == FOCUS_CONSOLE_TOGGLE) app->focus_console_start = (item->focus_console == FOCUS_CONSOLE_TOGGLE) ?
? (selected_option_index == 0) (selected_option_index == 0) :
: item->focus_console; item->focus_console;
app->show_stopscan_tip = item->show_stopscan_tip; app->show_stopscan_tip = item->show_stopscan_tip;
view_dispatcher_send_custom_event(app->view_dispatcher, view_dispatcher_send_custom_event(app->view_dispatcher, Evil_PortalEventStartConsole);
Evil_PortalEventStartConsole);
} }
static void static void evil_portal_scene_start_var_list_change_callback(VariableItem* item) {
evil_portal_scene_start_var_list_change_callback(VariableItem *item) { furi_assert(item);
furi_assert(item);
Evil_PortalApp *app = variable_item_get_context(item); Evil_PortalApp* app = variable_item_get_context(item);
furi_assert(app); furi_assert(app);
const Evil_PortalItem *menu_item = &items[app->selected_menu_index]; const Evil_PortalItem* menu_item = &items[app->selected_menu_index];
uint8_t item_index = variable_item_get_current_value_index(item); uint8_t item_index = variable_item_get_current_value_index(item);
furi_assert(item_index < menu_item->num_options_menu); furi_assert(item_index < menu_item->num_options_menu);
variable_item_set_current_value_text(item, variable_item_set_current_value_text(item, menu_item->options_menu[item_index]);
menu_item->options_menu[item_index]); app->selected_option_index[app->selected_menu_index] = item_index;
app->selected_option_index[app->selected_menu_index] = item_index;
} }
void evil_portal_scene_start_on_enter(void *context) { void evil_portal_scene_start_on_enter(void* context) {
Evil_PortalApp *app = context; Evil_PortalApp* app = context;
VariableItemList *var_item_list = app->var_item_list; VariableItemList* var_item_list = app->var_item_list;
variable_item_list_set_enter_callback( variable_item_list_set_enter_callback(
var_item_list, evil_portal_scene_start_var_list_enter_callback, app); var_item_list, evil_portal_scene_start_var_list_enter_callback, app);
VariableItem *item; VariableItem* item;
for (int i = 0; i < NUM_MENU_ITEMS; ++i) { for(int i = 0; i < NUM_MENU_ITEMS; ++i) {
item = variable_item_list_add( item = variable_item_list_add(
var_item_list, items[i].item_string, items[i].num_options_menu, var_item_list,
evil_portal_scene_start_var_list_change_callback, app); items[i].item_string,
variable_item_set_current_value_index(item, app->selected_option_index[i]); items[i].num_options_menu,
variable_item_set_current_value_text( evil_portal_scene_start_var_list_change_callback,
item, items[i].options_menu[app->selected_option_index[i]]); app);
} variable_item_set_current_value_index(item, app->selected_option_index[i]);
variable_item_set_current_value_text(
variable_item_list_set_selected_item( item, items[i].options_menu[app->selected_option_index[i]]);
var_item_list,
scene_manager_get_scene_state(app->scene_manager, Evil_PortalSceneStart));
view_dispatcher_switch_to_view(app->view_dispatcher,
Evil_PortalAppViewVarItemList);
}
bool evil_portal_scene_start_on_event(void *context, SceneManagerEvent event) {
UNUSED(context);
Evil_PortalApp *app = context;
bool consumed = false;
if (event.type == SceneManagerEventTypeCustom) {
if (event.event == Evil_PortalEventStartPortal) {
scene_manager_set_scene_state(app->scene_manager, Evil_PortalSceneStart,
app->selected_menu_index);
scene_manager_next_scene(app->scene_manager,
Evil_PortalAppViewStartPortal);
} else if (event.event == Evil_PortalEventStartKeyboard) {
scene_manager_set_scene_state(app->scene_manager, Evil_PortalSceneStart,
app->selected_menu_index);
} else if (event.event == Evil_PortalEventStartConsole) {
scene_manager_set_scene_state(app->scene_manager, Evil_PortalSceneStart,
app->selected_menu_index);
scene_manager_next_scene(app->scene_manager,
Evil_PortalAppViewConsoleOutput);
} }
consumed = true;
} else if (event.type == SceneManagerEventTypeTick) {
app->selected_menu_index =
variable_item_list_get_selected_item_index(app->var_item_list);
consumed = true;
}
return consumed; variable_item_list_set_selected_item(
var_item_list, scene_manager_get_scene_state(app->scene_manager, Evil_PortalSceneStart));
view_dispatcher_switch_to_view(app->view_dispatcher, Evil_PortalAppViewVarItemList);
} }
void evil_portal_scene_start_on_exit(void *context) { bool evil_portal_scene_start_on_event(void* context, SceneManagerEvent event) {
Evil_PortalApp *app = context; UNUSED(context);
variable_item_list_reset(app->var_item_list); Evil_PortalApp* app = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == Evil_PortalEventStartPortal) {
scene_manager_set_scene_state(
app->scene_manager, Evil_PortalSceneStart, app->selected_menu_index);
scene_manager_next_scene(app->scene_manager, Evil_PortalAppViewStartPortal);
} else if(event.event == Evil_PortalEventStartKeyboard) {
scene_manager_set_scene_state(
app->scene_manager, Evil_PortalSceneStart, app->selected_menu_index);
} else if(event.event == Evil_PortalEventStartConsole) {
scene_manager_set_scene_state(
app->scene_manager, Evil_PortalSceneStart, app->selected_menu_index);
scene_manager_next_scene(app->scene_manager, Evil_PortalAppViewConsoleOutput);
}
consumed = true;
} else if(event.type == SceneManagerEventTypeTick) {
app->selected_menu_index = variable_item_list_get_selected_item_index(app->var_item_list);
consumed = true;
}
return consumed;
}
void evil_portal_scene_start_on_exit(void* context) {
Evil_PortalApp* app = context;
variable_item_list_reset(app->var_item_list);
} }