removed files

application.fam

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

evil_portal_app.c

@@ -64,14 +64,6 @@ Evil_PortalApp *evil_portal_app_alloc() {
   app->text_box_store = furi_string_alloc();
   furi_string_reserve(app->text_box_store, EVIL_PORTAL_TEXT_BOX_STORE_SIZE);
 
-  app->text_input = uart_text_input_alloc();
-  view_dispatcher_add_view(app->view_dispatcher, Evil_PortalAppViewTextInput,
-                           uart_text_input_get_view(app->text_input));
-
-  app->text_input = uart_text_input_alloc();
-  view_dispatcher_add_view(app->view_dispatcher, Evil_PortalAppViewStartPortal,
-                           uart_text_input_get_view(app->text_input));
-
   scene_manager_next_scene(app->scene_manager, Evil_PortalSceneStart);
 
   return app;
@@ -101,7 +93,6 @@ void evil_portal_app_free(Evil_PortalApp *app) {
 
   text_box_free(app->text_box);
   furi_string_free(app->text_box_store);
-  uart_text_input_free(app->text_input);
 
   // View dispatcher
   view_dispatcher_free(app->view_dispatcher);

evil_portal_app_i.h

@@ -4,7 +4,7 @@
 #include "evil_portal_custom_event.h"
 #include "evil_portal_uart.h"
 #include "scenes/evil_portal_scene.h"
-#include "uart_text_input.h"
+// #include "uart_text_input.h"
 
 #include <gui/gui.h>
 #include <gui/modules/text_box.h>
@@ -29,7 +29,6 @@ struct Evil_PortalApp {
   FuriString *text_box_store;
   size_t text_box_store_strlen;
   TextBox *text_box;
-  UART_TextInput *text_input;
 
   VariableItemList *var_item_list;
 

scenes/evil_portal_scene_config.h

@@ -1,3 +1,2 @@
 ADD_SCENE(evil_portal, start, Start)
 ADD_SCENE(evil_portal, console_output, ConsoleOutput)
-ADD_SCENE(evil_portal, text_input, UART_TextInput)

scenes/evil_portal_scene_console_output.c

@@ -38,7 +38,9 @@ void evil_portal_scene_console_output_on_enter(void *context) {
     app->text_box_store_strlen = 0;
 
     if (0 == strncmp("help", app->selected_tx_string, strlen("help"))) {
-      const char *help_msg = "This project is a WIP.\ngithub.com/.\n\n";
+      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";
       furi_string_cat_str(app->text_box_store, help_msg);
       app->text_box_store_strlen += strlen(help_msg);
     }

scenes/evil_portal_scene_start_portal.c

@@ -1,65 +0,0 @@
-#include "../evil_portal_app_i.h"
-
-void evil_portal_scene_start_portal_callback(void *context) {
-  Evil_PortalApp *app = context;
-
-  view_dispatcher_send_custom_event(app->view_dispatcher,
-                                    Evil_PortalEventStartConsole);
-}
-
-void evil_portal_scene_start_portal_on_enter(void *context) {
-  Evil_PortalApp *app = context;
-
-  if (false == app->is_custom_tx_string) {
-    // Fill text input with selected string so that user can add to it
-    size_t length = strlen(app->selected_tx_string);
-    furi_assert(length < EVIL_PORTAL_TEXT_INPUT_STORE_SIZE);
-    bzero(app->text_input_store, EVIL_PORTAL_TEXT_INPUT_STORE_SIZE);
-    strncpy(app->text_input_store, app->selected_tx_string, length);
-
-    // Add space - because flipper keyboard currently doesn't have a space
-    // app->start_portal_store[length] = ' ';
-    app->text_input_store[length + 1] = '\0';
-    app->is_custom_tx_string = true;
-  }
-
-  // Setup view
-  UART_TextInput *text_input = app->text_input;
-  // Add help message to header
-  if (0 == strncmp("AT", app->selected_tx_string, strlen("AT"))) {
-    app->TERMINAL_MODE = 1;
-    uart_text_input_set_header_text(text_input, "Send AT command to UART");
-  } else {
-    app->TERMINAL_MODE = 0;
-    uart_text_input_set_header_text(text_input, "Send command to UART");
-  }
-  uart_text_input_set_result_callback(
-      text_input, evil_portal_scene_start_portal_callback, app,
-      app->text_input_store, EVIL_PORTAL_TEXT_INPUT_STORE_SIZE, false);
-
-  view_dispatcher_switch_to_view(app->view_dispatcher,
-                                 Evil_PortalAppViewTextInput);
-}
-
-bool evil_portal_scene_start_portal_on_event(void *context,
-                                           SceneManagerEvent event) {
-  Evil_PortalApp *app = context;
-  bool consumed = false;
-
-  if (event.type == SceneManagerEventTypeCustom) {
-    if (event.event == Evil_PortalEventStartConsole) {
-      app->selected_tx_string = app->text_input_store;
-      scene_manager_next_scene(app->scene_manager,
-                               Evil_PortalAppViewConsoleOutput);
-      consumed = true;
-    }
-  }
-
-  return consumed;
-}
-
-void evil_portal_scene_start_portal_on_exit(void *context) {
-  Evil_PortalApp *app = context;
-
-  uart_text_input_reset(app->text_input);
-}

scenes/evil_portal_scene_text_input.c

@@ -1,65 +0,0 @@
-#include "../evil_portal_app_i.h"
-
-void evil_portal_scene_text_input_callback(void *context) {
-  Evil_PortalApp *app = context;
-
-  view_dispatcher_send_custom_event(app->view_dispatcher,
-                                    Evil_PortalEventStartConsole);
-}
-
-void evil_portal_scene_text_input_on_enter(void *context) {
-  Evil_PortalApp *app = context;
-
-  if (false == app->is_custom_tx_string) {
-    // Fill text input with selected string so that user can add to it
-    size_t length = strlen(app->selected_tx_string);
-    furi_assert(length < EVIL_PORTAL_TEXT_INPUT_STORE_SIZE);
-    bzero(app->text_input_store, EVIL_PORTAL_TEXT_INPUT_STORE_SIZE);
-    strncpy(app->text_input_store, app->selected_tx_string, length);
-
-    // Add space - because flipper keyboard currently doesn't have a space
-    // app->text_input_store[length] = ' ';
-    app->text_input_store[length + 1] = '\0';
-    app->is_custom_tx_string = true;
-  }
-
-  // Setup view
-  UART_TextInput *text_input = app->text_input;
-  // Add help message to header
-  if (0 == strncmp("AT", app->selected_tx_string, strlen("AT"))) {
-    app->TERMINAL_MODE = 1;
-    uart_text_input_set_header_text(text_input, "Send AT command to UART");
-  } else {
-    app->TERMINAL_MODE = 0;
-    uart_text_input_set_header_text(text_input, "Send command to UART");
-  }
-  uart_text_input_set_result_callback(
-      text_input, evil_portal_scene_text_input_callback, app,
-      app->text_input_store, EVIL_PORTAL_TEXT_INPUT_STORE_SIZE, false);
-
-  view_dispatcher_switch_to_view(app->view_dispatcher,
-                                 Evil_PortalAppViewTextInput);
-}
-
-bool evil_portal_scene_text_input_on_event(void *context,
-                                           SceneManagerEvent event) {
-  Evil_PortalApp *app = context;
-  bool consumed = false;
-
-  if (event.type == SceneManagerEventTypeCustom) {
-    if (event.event == Evil_PortalEventStartConsole) {
-      app->selected_tx_string = app->text_input_store;
-      scene_manager_next_scene(app->scene_manager,
-                               Evil_PortalAppViewConsoleOutput);
-      consumed = true;
-    }
-  }
-
-  return consumed;
-}
-
-void evil_portal_scene_text_input_on_exit(void *context) {
-  Evil_PortalApp *app = context;
-
-  uart_text_input_reset(app->text_input);
-}

uart_text_input.c

@@ -1,623 +0,0 @@
-#include "uart_text_input.h"
-#include <gui/elements.h>
-// #include "evil_portal_icons.h"
-#include "evil_portal_app_i.h"
-#include <furi.h>
-
-struct UART_TextInput {
-  View *view;
-  FuriTimer *timer;
-};
-
-typedef struct {
-  const char text;
-  const uint8_t x;
-  const uint8_t y;
-} UART_TextInputKey;
-
-typedef struct {
-  const char *header;
-  char *text_buffer;
-  size_t text_buffer_size;
-  bool clear_default_text;
-
-  UART_TextInputCallback callback;
-  void *callback_context;
-
-  uint8_t selected_row;
-  uint8_t selected_column;
-
-  UART_TextInputValidatorCallback validator_callback;
-  void *validator_callback_context;
-  FuriString *validator_text;
-  bool valadator_message_visible;
-} UART_TextInputModel;
-
-static const uint8_t keyboard_origin_x = 1;
-static const uint8_t keyboard_origin_y = 29;
-static const uint8_t keyboard_row_count = 4;
-
-#define mode_AT "Send AT command to UART"
-
-#define ENTER_KEY '\r'
-#define BACKSPACE_KEY '\b'
-
-static const UART_TextInputKey keyboard_keys_row_1[] = {
-    {'{', 1, 0},  {'(', 9, 0},    {'[', 17, 0},  {'|', 25, 0},
-    {'@', 33, 0}, {'&', 41, 0},   {'#', 49, 0},  {';', 57, 0},
-    {'^', 65, 0}, {'*', 73, 0},   {'`', 81, 0},  {'"', 89, 0},
-    {'~', 97, 0}, {'\'', 105, 0}, {'.', 113, 0}, {'/', 120, 0},
-};
-
-static const UART_TextInputKey keyboard_keys_row_2[] = {
-    {'q', 1, 10},  {'w', 9, 10},   {'e', 17, 10},  {'r', 25, 10},
-    {'t', 33, 10}, {'y', 41, 10},  {'u', 49, 10},  {'i', 57, 10},
-    {'o', 65, 10}, {'p', 73, 10},  {'0', 81, 10},  {'1', 89, 10},
-    {'2', 97, 10}, {'3', 105, 10}, {'=', 113, 10}, {'-', 120, 10},
-};
-
-static const UART_TextInputKey keyboard_keys_row_3[] = {
-    {'a', 1, 21},   {'s', 9, 21},
-    {'d', 18, 21},  {'f', 25, 21},
-    {'g', 33, 21},  {'h', 41, 21},
-    {'j', 49, 21},  {'k', 57, 21},
-    {'l', 65, 21},  {BACKSPACE_KEY, 72, 13},
-    {'4', 89, 21},  {'5', 97, 21},
-    {'6', 105, 21}, {'$', 113, 21},
-    {'%', 120, 21},
-
-};
-
-static const UART_TextInputKey keyboard_keys_row_4[] = {
-    {'z', 1, 33},        {'x', 9, 33},   {'c', 18, 33}, {'v', 25, 33},
-    {'b', 33, 33},       {'n', 41, 33},  {'m', 49, 33}, {'_', 57, 33},
-    {ENTER_KEY, 64, 24}, {'7', 89, 33},  {'8', 97, 33}, {'9', 105, 33},
-    {'!', 113, 33},      {'+', 120, 33},
-};
-
-static uint8_t get_row_size(uint8_t row_index) {
-  uint8_t row_size = 0;
-
-  switch (row_index + 1) {
-  case 1:
-    row_size = sizeof(keyboard_keys_row_1) / sizeof(UART_TextInputKey);
-    break;
-  case 2:
-    row_size = sizeof(keyboard_keys_row_2) / sizeof(UART_TextInputKey);
-    break;
-  case 3:
-    row_size = sizeof(keyboard_keys_row_3) / sizeof(UART_TextInputKey);
-    break;
-  case 4:
-    row_size = sizeof(keyboard_keys_row_4) / sizeof(UART_TextInputKey);
-    break;
-  }
-
-  return row_size;
-}
-
-static const UART_TextInputKey *get_row(uint8_t row_index) {
-  const UART_TextInputKey *row = NULL;
-
-  switch (row_index + 1) {
-  case 1:
-    row = keyboard_keys_row_1;
-    break;
-  case 2:
-    row = keyboard_keys_row_2;
-    break;
-  case 3:
-    row = keyboard_keys_row_3;
-    break;
-  case 4:
-    row = keyboard_keys_row_4;
-    break;
-  }
-
-  return row;
-}
-
-static char get_selected_char(UART_TextInputModel *model) {
-  return get_row(model->selected_row)[model->selected_column].text;
-}
-
-static bool char_is_lowercase(char letter) {
-  return (letter >= 0x61 && letter <= 0x7A);
-}
-
-static bool char_is_uppercase(char letter) {
-  return (letter >= 0x41 && letter <= 0x5A);
-}
-
-static char char_to_lowercase(const char letter) {
-  switch (letter) {
-  case ' ':
-    return 0x5f;
-    break;
-  case ')':
-    return 0x28;
-    break;
-  case '}':
-    return 0x7b;
-    break;
-  case ']':
-    return 0x5b;
-    break;
-  case '\\':
-    return 0x2f;
-    break;
-  case ':':
-    return 0x3b;
-    break;
-  case ',':
-    return 0x2e;
-    break;
-  case '?':
-    return 0x21;
-    break;
-  case '>':
-    return 0x3c;
-    break;
-  }
-  if (char_is_uppercase(letter)) {
-    return (letter + 0x20);
-  } else {
-    return letter;
-  }
-}
-
-static char char_to_uppercase(const char letter) {
-  switch (letter) {
-  case '_':
-    return 0x20;
-    break;
-  case '(':
-    return 0x29;
-    break;
-  case '{':
-    return 0x7d;
-    break;
-  case '[':
-    return 0x5d;
-    break;
-  case '/':
-    return 0x5c;
-    break;
-  case ';':
-    return 0x3a;
-    break;
-  case '.':
-    return 0x2c;
-    break;
-  case '!':
-    return 0x3f;
-    break;
-  case '<':
-    return 0x3e;
-    break;
-  }
-  if (char_is_lowercase(letter)) {
-    return (letter - 0x20);
-  } else {
-    return letter;
-  }
-}
-
-static void uart_text_input_backspace_cb(UART_TextInputModel *model) {
-  uint8_t text_length =
-      model->clear_default_text ? 1 : strlen(model->text_buffer);
-  if (text_length > 0) {
-    model->text_buffer[text_length - 1] = 0;
-  }
-}
-
-static void uart_text_input_view_draw_callback(Canvas *canvas, void *_model) {
-  UART_TextInputModel *model = _model;
-  // uint8_t text_length = model->text_buffer ? strlen(model->text_buffer) : 0;
-  uint8_t needed_string_width = canvas_width(canvas) - 8;
-  uint8_t start_pos = 4;
-
-  const char *text = model->text_buffer;
-
-  canvas_clear(canvas);
-  canvas_set_color(canvas, ColorBlack);
-
-  canvas_draw_str(canvas, 2, 7, model->header);
-  elements_slightly_rounded_frame(canvas, 1, 8, 126, 12);
-
-  if (canvas_string_width(canvas, text) > needed_string_width) {
-    canvas_draw_str(canvas, start_pos, 17, "...");
-    start_pos += 6;
-    needed_string_width -= 8;
-  }
-
-  while (text != 0 && canvas_string_width(canvas, text) > needed_string_width) {
-    text++;
-  }
-
-  if (model->clear_default_text) {
-    elements_slightly_rounded_box(canvas, start_pos - 1, 14,
-                                  canvas_string_width(canvas, text) + 2, 10);
-    canvas_set_color(canvas, ColorWhite);
-  } else {
-    canvas_draw_str(canvas, start_pos + canvas_string_width(canvas, text) + 1,
-                    18, "|");
-    canvas_draw_str(canvas, start_pos + canvas_string_width(canvas, text) + 2,
-                    18, "|");
-  }
-  canvas_draw_str(canvas, start_pos, 17, text);
-
-  canvas_set_font(canvas, FontKeyboard);
-
-  for (uint8_t row = 0; row <= keyboard_row_count; row++) {
-    const uint8_t column_count = get_row_size(row);
-    const UART_TextInputKey *keys = get_row(row);
-
-    for (size_t column = 0; column < column_count; column++) {
-      if (keys[column].text == ENTER_KEY) {
-        canvas_set_color(canvas, ColorBlack);
-        if (model->selected_row == row && model->selected_column == column) {
-          //   canvas_draw_icon(canvas, keyboard_origin_x + keys[column].x,
-          //                    keyboard_origin_y + keys[column].y,
-          //                    &I_KeySaveSelected_24x11);
-        } else {
-          //   canvas_draw_icon(canvas, keyboard_origin_x + keys[column].x,
-          //                    keyboard_origin_y + keys[column].y,
-          //                    &I_KeySave_24x11);
-        }
-      } else if (keys[column].text == BACKSPACE_KEY) {
-        canvas_set_color(canvas, ColorBlack);
-        if (model->selected_row == row && model->selected_column == column) {
-          //   canvas_draw_icon(canvas, keyboard_origin_x + keys[column].x,
-          //                    keyboard_origin_y + keys[column].y,
-          //                    &I_KeyBackspaceSelected_16x9);
-        } else {
-          //   canvas_draw_icon(canvas, keyboard_origin_x + keys[column].x,
-          //                    keyboard_origin_y + keys[column].y,
-          //                    &I_KeyBackspace_16x9);
-        }
-      } else {
-        if (model->selected_row == row && model->selected_column == column) {
-          canvas_set_color(canvas, ColorBlack);
-          canvas_draw_box(canvas, keyboard_origin_x + keys[column].x - 1,
-                          keyboard_origin_y + keys[column].y - 8, 7, 10);
-          canvas_set_color(canvas, ColorWhite);
-        } else {
-          canvas_set_color(canvas, ColorBlack);
-        }
-        if (0 == strcmp(model->header, mode_AT)) {
-          canvas_draw_glyph(canvas, keyboard_origin_x + keys[column].x,
-                            keyboard_origin_y + keys[column].y,
-                            char_to_uppercase(keys[column].text));
-        } else {
-          canvas_draw_glyph(canvas, keyboard_origin_x + keys[column].x,
-                            keyboard_origin_y + keys[column].y,
-                            keys[column].text);
-        }
-      }
-    }
-  }
-  if (model->valadator_message_visible) {
-    canvas_set_font(canvas, FontSecondary);
-    canvas_set_color(canvas, ColorWhite);
-    canvas_draw_box(canvas, 8, 10, 110, 48);
-    canvas_set_color(canvas, ColorBlack);
-    // canvas_draw_icon(canvas, 10, 14, &I_WarningDolphin_45x42);
-    canvas_draw_rframe(canvas, 8, 8, 112, 50, 3);
-    canvas_draw_rframe(canvas, 9, 9, 110, 48, 2);
-    elements_multiline_text(canvas, 62, 20,
-                            furi_string_get_cstr(model->validator_text));
-    canvas_set_font(canvas, FontKeyboard);
-  }
-}
-
-static void uart_text_input_handle_up(UART_TextInput *uart_text_input,
-                                      UART_TextInputModel *model) {
-  UNUSED(uart_text_input);
-  if (model->selected_row > 0) {
-    model->selected_row--;
-    if (model->selected_column > get_row_size(model->selected_row) - 6) {
-      model->selected_column = model->selected_column + 1;
-    }
-  }
-}
-
-static void uart_text_input_handle_down(UART_TextInput *uart_text_input,
-                                        UART_TextInputModel *model) {
-  UNUSED(uart_text_input);
-  if (model->selected_row < keyboard_row_count - 1) {
-    model->selected_row++;
-    if (model->selected_column > get_row_size(model->selected_row) - 4) {
-      model->selected_column = model->selected_column - 1;
-    }
-  }
-}
-
-static void uart_text_input_handle_left(UART_TextInput *uart_text_input,
-                                        UART_TextInputModel *model) {
-  UNUSED(uart_text_input);
-  if (model->selected_column > 0) {
-    model->selected_column--;
-  } else {
-    model->selected_column = get_row_size(model->selected_row) - 1;
-  }
-}
-
-static void uart_text_input_handle_right(UART_TextInput *uart_text_input,
-                                         UART_TextInputModel *model) {
-  UNUSED(uart_text_input);
-  if (model->selected_column < get_row_size(model->selected_row) - 1) {
-    model->selected_column++;
-  } else {
-    model->selected_column = 0;
-  }
-}
-
-static void uart_text_input_handle_ok(UART_TextInput *uart_text_input,
-                                      UART_TextInputModel *model, bool shift) {
-  char selected = get_selected_char(model);
-  uint8_t text_length = strlen(model->text_buffer);
-
-  if (0 == strcmp(model->header, mode_AT)) {
-    selected = char_to_uppercase(selected);
-  }
-
-  if (shift) {
-    if (0 == strcmp(model->header, mode_AT)) {
-      selected = char_to_lowercase(selected);
-    } else {
-      selected = char_to_uppercase(selected);
-    }
-  }
-
-  if (selected == ENTER_KEY) {
-    if (model->validator_callback &&
-        (!model->validator_callback(model->text_buffer, model->validator_text,
-                                    model->validator_callback_context))) {
-      model->valadator_message_visible = true;
-      furi_timer_start(uart_text_input->timer,
-                       furi_kernel_get_tick_frequency() * 4);
-    } else if (model->callback != 0 && text_length > 0) {
-      model->callback(model->callback_context);
-    }
-  } else if (selected == BACKSPACE_KEY) {
-    uart_text_input_backspace_cb(model);
-  } else {
-    if (model->clear_default_text) {
-      text_length = 0;
-    }
-    if (text_length < (model->text_buffer_size - 1)) {
-      model->text_buffer[text_length] = selected;
-      model->text_buffer[text_length + 1] = 0;
-    }
-  }
-  model->clear_default_text = false;
-}
-
-static bool uart_text_input_view_input_callback(InputEvent *event,
-                                                void *context) {
-  UART_TextInput *uart_text_input = context;
-  furi_assert(uart_text_input);
-
-  bool consumed = false;
-
-  // Acquire model
-  UART_TextInputModel *model = view_get_model(uart_text_input->view);
-
-  if ((!(event->type == InputTypePress) &&
-       !(event->type == InputTypeRelease)) &&
-      model->valadator_message_visible) {
-    model->valadator_message_visible = false;
-    consumed = true;
-  } else if (event->type == InputTypeShort) {
-    consumed = true;
-    switch (event->key) {
-    case InputKeyUp:
-      uart_text_input_handle_up(uart_text_input, model);
-      break;
-    case InputKeyDown:
-      uart_text_input_handle_down(uart_text_input, model);
-      break;
-    case InputKeyLeft:
-      uart_text_input_handle_left(uart_text_input, model);
-      break;
-    case InputKeyRight:
-      uart_text_input_handle_right(uart_text_input, model);
-      break;
-    case InputKeyOk:
-      uart_text_input_handle_ok(uart_text_input, model, false);
-      break;
-    default:
-      consumed = false;
-      break;
-    }
-  } else if (event->type == InputTypeLong) {
-    consumed = true;
-    switch (event->key) {
-    case InputKeyUp:
-      uart_text_input_handle_up(uart_text_input, model);
-      break;
-    case InputKeyDown:
-      uart_text_input_handle_down(uart_text_input, model);
-      break;
-    case InputKeyLeft:
-      uart_text_input_handle_left(uart_text_input, model);
-      break;
-    case InputKeyRight:
-      uart_text_input_handle_right(uart_text_input, model);
-      break;
-    case InputKeyOk:
-      uart_text_input_handle_ok(uart_text_input, model, true);
-      break;
-    case InputKeyBack:
-      uart_text_input_backspace_cb(model);
-      break;
-    default:
-      consumed = false;
-      break;
-    }
-  } else if (event->type == InputTypeRepeat) {
-    consumed = true;
-    switch (event->key) {
-    case InputKeyUp:
-      uart_text_input_handle_up(uart_text_input, model);
-      break;
-    case InputKeyDown:
-      uart_text_input_handle_down(uart_text_input, model);
-      break;
-    case InputKeyLeft:
-      uart_text_input_handle_left(uart_text_input, model);
-      break;
-    case InputKeyRight:
-      uart_text_input_handle_right(uart_text_input, model);
-      break;
-    case InputKeyBack:
-      uart_text_input_backspace_cb(model);
-      break;
-    default:
-      consumed = false;
-      break;
-    }
-  }
-
-  // Commit model
-  view_commit_model(uart_text_input->view, consumed);
-
-  return consumed;
-}
-
-void uart_text_input_timer_callback(void *context) {
-  furi_assert(context);
-  UART_TextInput *uart_text_input = context;
-
-  with_view_model(
-      uart_text_input->view, UART_TextInputModel * model,
-      { model->valadator_message_visible = false; }, true);
-}
-
-UART_TextInput *uart_text_input_alloc() {
-  UART_TextInput *uart_text_input = malloc(sizeof(UART_TextInput));
-  uart_text_input->view = view_alloc();
-  view_set_context(uart_text_input->view, uart_text_input);
-  view_allocate_model(uart_text_input->view, ViewModelTypeLocking,
-                      sizeof(UART_TextInputModel));
-  view_set_draw_callback(uart_text_input->view,
-                         uart_text_input_view_draw_callback);
-  view_set_input_callback(uart_text_input->view,
-                          uart_text_input_view_input_callback);
-
-  uart_text_input->timer = furi_timer_alloc(uart_text_input_timer_callback,
-                                            FuriTimerTypeOnce, uart_text_input);
-
-  with_view_model(
-      uart_text_input->view, UART_TextInputModel * model,
-      { model->validator_text = furi_string_alloc(); }, false);
-
-  uart_text_input_reset(uart_text_input);
-
-  return uart_text_input;
-}
-
-void uart_text_input_free(UART_TextInput *uart_text_input) {
-  furi_assert(uart_text_input);
-  with_view_model(
-      uart_text_input->view, UART_TextInputModel * model,
-      { furi_string_free(model->validator_text); }, false);
-
-  // Send stop command
-  furi_timer_stop(uart_text_input->timer);
-  // Release allocated memory
-  furi_timer_free(uart_text_input->timer);
-
-  view_free(uart_text_input->view);
-
-  free(uart_text_input);
-}
-
-void uart_text_input_reset(UART_TextInput *uart_text_input) {
-  furi_assert(uart_text_input);
-  with_view_model(
-      uart_text_input->view, UART_TextInputModel * model,
-      {
-        model->text_buffer_size = 0;
-        model->header = "";
-        model->selected_row = 0;
-        model->selected_column = 0;
-        model->clear_default_text = false;
-        model->text_buffer = NULL;
-        model->text_buffer_size = 0;
-        model->callback = NULL;
-        model->callback_context = NULL;
-        model->validator_callback = NULL;
-        model->validator_callback_context = NULL;
-        furi_string_reset(model->validator_text);
-        model->valadator_message_visible = false;
-      },
-      true);
-}
-
-View *uart_text_input_get_view(UART_TextInput *uart_text_input) {
-  furi_assert(uart_text_input);
-  return uart_text_input->view;
-}
-
-void uart_text_input_set_result_callback(UART_TextInput *uart_text_input,
-                                         UART_TextInputCallback callback,
-                                         void *callback_context,
-                                         char *text_buffer,
-                                         size_t text_buffer_size,
-                                         bool clear_default_text) {
-  with_view_model(
-      uart_text_input->view, UART_TextInputModel * model,
-      {
-        model->callback = callback;
-        model->callback_context = callback_context;
-        model->text_buffer = text_buffer;
-        model->text_buffer_size = text_buffer_size;
-        model->clear_default_text = clear_default_text;
-        if (text_buffer && text_buffer[0] != '\0') {
-          // Set focus on Save
-          model->selected_row = 2;
-          model->selected_column = 8;
-        }
-      },
-      true);
-}
-
-void uart_text_input_set_validator(UART_TextInput *uart_text_input,
-                                   UART_TextInputValidatorCallback callback,
-                                   void *callback_context) {
-  with_view_model(
-      uart_text_input->view, UART_TextInputModel * model,
-      {
-        model->validator_callback = callback;
-        model->validator_callback_context = callback_context;
-      },
-      true);
-}
-
-UART_TextInputValidatorCallback
-uart_text_input_get_validator_callback(UART_TextInput *uart_text_input) {
-  UART_TextInputValidatorCallback validator_callback = NULL;
-  with_view_model(
-      uart_text_input->view, UART_TextInputModel * model,
-      { validator_callback = model->validator_callback; }, false);
-  return validator_callback;
-}
-
-void *uart_text_input_get_validator_callback_context(
-    UART_TextInput *uart_text_input) {
-  void *validator_callback_context = NULL;
-  with_view_model(
-      uart_text_input->view, UART_TextInputModel * model,
-      { validator_callback_context = model->validator_callback_context; },
-      false);
-  return validator_callback_context;
-}
-
-void uart_text_input_set_header_text(UART_TextInput *uart_text_input,
-                                     const char *text) {
-  with_view_model(
-      uart_text_input->view, UART_TextInputModel * model,
-      { model->header = text; }, true);
-}

uart_text_input.h

@@ -1,82 +0,0 @@
-#pragma once
-
-#include <gui/view.h>
-#include "uart_validators.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** Text input anonymous structure */
-typedef struct UART_TextInput UART_TextInput;
-typedef void (*UART_TextInputCallback)(void* context);
-typedef bool (*UART_TextInputValidatorCallback)(const char* text, FuriString* error, void* context);
-
-/** Allocate and initialize text input 
- * 
- * This text input is used to enter string
- *
- * @return     UART_TextInput instance
- */
-UART_TextInput* uart_text_input_alloc();
-
-/** Deinitialize and free text input
- *
- * @param      uart_text_input  UART_TextInput instance
- */
-void uart_text_input_free(UART_TextInput* uart_text_input);
-
-/** Clean text input view Note: this function does not free memory
- *
- * @param      uart_text_input  Text input instance
- */
-void uart_text_input_reset(UART_TextInput* uart_text_input);
-
-/** Get text input view
- *
- * @param      uart_text_input  UART_TextInput instance
- *
- * @return     View instance that can be used for embedding
- */
-View* uart_text_input_get_view(UART_TextInput* uart_text_input);
-
-/** Set text input result callback
- *
- * @param      uart_text_input          UART_TextInput instance
- * @param      callback            callback fn
- * @param      callback_context    callback context
- * @param      text_buffer         pointer to YOUR text buffer, that we going
- *                                 to modify
- * @param      text_buffer_size    YOUR text buffer size in bytes. Max string
- *                                 length will be text_buffer_size-1.
- * @param      clear_default_text  clear text from text_buffer on first OK
- *                                 event
- */
-void uart_text_input_set_result_callback(
-    UART_TextInput* uart_text_input,
-    UART_TextInputCallback callback,
-    void* callback_context,
-    char* text_buffer,
-    size_t text_buffer_size,
-    bool clear_default_text);
-
-void uart_text_input_set_validator(
-    UART_TextInput* uart_text_input,
-    UART_TextInputValidatorCallback callback,
-    void* callback_context);
-
-UART_TextInputValidatorCallback
-    uart_text_input_get_validator_callback(UART_TextInput* uart_text_input);
-
-void* uart_text_input_get_validator_callback_context(UART_TextInput* uart_text_input);
-
-/** Set text input header text
- *
- * @param      uart_text_input  UART_TextInput instance
- * @param      text        text to be shown
- */
-void uart_text_input_set_header_text(UART_TextInput* uart_text_input, const char* text);
-
-#ifdef __cplusplus
-}
-#endif