Momentum-Apps/uart_text_input.c

#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);
}