flipperzero-firmware/applications/desktop/views/desktop_view_pin_input.c
Nikolay Minaylov 2f3ea9494e
HAL to LL migration: GPIO, HSEM, AES (#1069)
* gpio, hsem, crypto: switch from HAL to LL/registers
* Moved GPIO initialization to furi_hal
* More HAL removed
* All HAL modules disabled
* HAL is finally removed
* hal_gpio -> furi_hal_gpio, main.h removed
* Bootloader build fix
* RTOS config moved to freertos-glue
* delay -> furi_hal_delay

Co-authored-by: あく <alleteam@gmail.com>
2022-03-30 18:23:40 +03:00

341 lines
10 KiB
C

#include <gui/canvas.h>
#include <furi.h>
#include <gui/view.h>
#include <gui/elements.h>
#include <stdint.h>
#include <portmacro.h>
#include "desktop_view_pin_input.h"
#include "../desktop_settings/desktop_settings.h"
#define NO_ACTIVITY_TIMEOUT 15000
#define PIN_CELL_WIDTH 13
#define DEFAULT_PIN_X 64
#define DEFAULT_PIN_Y 32
struct DesktopViewPinInput {
View* view;
DesktopViewPinInputCallback back_callback;
DesktopViewPinInputCallback timeout_callback;
DesktopViewPinInputDoneCallback done_callback;
void* context;
TimerHandle_t timer;
};
typedef struct {
PinCode pin;
bool pin_hidden;
bool locked_input;
uint8_t pin_x;
uint8_t pin_y;
const char* primary_str;
uint8_t primary_str_x;
uint8_t primary_str_y;
const char* secondary_str;
uint8_t secondary_str_x;
uint8_t secondary_str_y;
const char* button_label;
} DesktopViewPinInputModel;
static bool desktop_view_pin_input_input(InputEvent* event, void* context) {
furi_assert(event);
furi_assert(context);
DesktopViewPinInput* pin_input = context;
DesktopViewPinInputModel* model = view_get_model(pin_input->view);
bool call_back_callback = false;
bool call_done_callback = false;
PinCode pin_code = {0};
if(event->type == InputTypeShort) {
switch(event->key) {
case InputKeyRight:
case InputKeyLeft:
case InputKeyDown:
case InputKeyUp:
if(!model->locked_input) {
if(model->pin.length < MAX_PIN_SIZE) {
model->pin.data[model->pin.length++] = event->key;
}
}
break;
case InputKeyOk:
if(model->pin.length >= MIN_PIN_SIZE) {
call_done_callback = true;
pin_code = model->pin;
}
break;
case InputKeyBack:
if(!model->locked_input) {
if(model->pin.length > 0) {
model->pin.length = 0;
} else {
call_back_callback = true;
}
}
break;
default:
furi_assert(0);
break;
}
}
view_commit_model(pin_input->view, true);
if(call_done_callback && pin_input->done_callback) {
pin_input->done_callback(&pin_code, pin_input->context);
} else if(call_back_callback && pin_input->back_callback) {
pin_input->back_callback(pin_input->context);
}
xTimerStart(pin_input->timer, 0);
return true;
}
static void desktop_view_pin_input_draw_cells(Canvas* canvas, DesktopViewPinInputModel* model) {
furi_assert(canvas);
furi_assert(model);
uint8_t draw_pin_size = MAX(4, model->pin.length + 1);
if(model->locked_input || (model->pin.length == MAX_PIN_SIZE)) {
draw_pin_size = model->pin.length;
}
uint8_t x = model->pin_x - (draw_pin_size * (PIN_CELL_WIDTH - 1)) / 2;
uint8_t y = model->pin_y - (PIN_CELL_WIDTH / 2);
for(int i = 0; i < draw_pin_size; ++i) {
canvas_draw_frame(canvas, x, y, PIN_CELL_WIDTH, PIN_CELL_WIDTH);
if(i < model->pin.length) {
if(model->pin_hidden) {
canvas_draw_icon(canvas, x + 3, y + 3, &I_Pin_star_7x7);
} else {
switch(model->pin.data[i]) {
case InputKeyDown:
canvas_draw_icon(canvas, x + 3, y + 2, &I_Pin_arrow_down_7x9);
break;
case InputKeyUp:
canvas_draw_icon(canvas, x + 3, y + 2, &I_Pin_arrow_up7x9);
break;
case InputKeyLeft:
canvas_draw_icon(canvas, x + 2, y + 3, &I_Pin_arrow_left_9x7);
break;
case InputKeyRight:
canvas_draw_icon(canvas, x + 2, y + 3, &I_Pin_arrow_right_9x7);
break;
default:
furi_assert(0);
break;
}
}
} else if(i == model->pin.length) {
canvas_draw_icon(canvas, x + 4, y + PIN_CELL_WIDTH + 1, &I_Pin_pointer_5x3);
}
x += PIN_CELL_WIDTH - 1;
}
}
static void desktop_view_pin_input_draw(Canvas* canvas, void* context) {
furi_assert(canvas);
furi_assert(context);
canvas_set_font(canvas, FontSecondary);
DesktopViewPinInputModel* model = context;
desktop_view_pin_input_draw_cells(canvas, model);
if((model->pin.length > 0) && !model->locked_input) {
canvas_draw_icon(canvas, 4, 53, &I_Pin_back_full_40x8);
}
if(model->button_label && ((model->pin.length >= MIN_PIN_SIZE) || model->locked_input)) {
elements_button_center(canvas, model->button_label);
}
if(model->primary_str) {
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, model->primary_str_x, model->primary_str_y, model->primary_str);
canvas_set_font(canvas, FontSecondary);
}
if(model->secondary_str) {
canvas_set_font(canvas, FontSecondary);
canvas_draw_str(
canvas, model->secondary_str_x, model->secondary_str_y, model->secondary_str);
}
}
void desktop_view_pin_input_timer_callback(TimerHandle_t timer) {
DesktopViewPinInput* pin_input = pvTimerGetTimerID(timer);
if(pin_input->timeout_callback) {
pin_input->timeout_callback(pin_input->context);
}
}
static void desktop_view_pin_input_enter(void* context) {
DesktopViewPinInput* pin_input = context;
xTimerStart(pin_input->timer, portMAX_DELAY);
}
static void desktop_view_pin_input_exit(void* context) {
DesktopViewPinInput* pin_input = context;
xTimerStop(pin_input->timer, portMAX_DELAY);
}
DesktopViewPinInput* desktop_view_pin_input_alloc(void) {
DesktopViewPinInput* pin_input = malloc(sizeof(DesktopViewPinInput));
pin_input->view = view_alloc();
view_allocate_model(pin_input->view, ViewModelTypeLocking, sizeof(DesktopViewPinInputModel));
view_set_context(pin_input->view, pin_input);
view_set_draw_callback(pin_input->view, desktop_view_pin_input_draw);
view_set_input_callback(pin_input->view, desktop_view_pin_input_input);
pin_input->timer = xTimerCreate(
NULL,
pdMS_TO_TICKS(NO_ACTIVITY_TIMEOUT),
pdFALSE,
pin_input,
desktop_view_pin_input_timer_callback);
view_set_enter_callback(pin_input->view, desktop_view_pin_input_enter);
view_set_exit_callback(pin_input->view, desktop_view_pin_input_exit);
DesktopViewPinInputModel* model = view_get_model(pin_input->view);
model->pin_x = DEFAULT_PIN_X;
model->pin_y = DEFAULT_PIN_Y;
model->pin.length = 0;
view_commit_model(pin_input->view, false);
return pin_input;
}
void desktop_view_pin_input_free(DesktopViewPinInput* pin_input) {
furi_assert(pin_input);
xTimerStop(pin_input->timer, portMAX_DELAY);
while(xTimerIsTimerActive(pin_input->timer)) {
furi_hal_delay_ms(1);
}
xTimerDelete(pin_input->timer, portMAX_DELAY);
view_free(pin_input->view);
free(pin_input);
}
void desktop_view_pin_input_lock_input(DesktopViewPinInput* pin_input) {
furi_assert(pin_input);
DesktopViewPinInputModel* model = view_get_model(pin_input->view);
model->locked_input = true;
view_commit_model(pin_input->view, true);
}
void desktop_view_pin_input_unlock_input(DesktopViewPinInput* pin_input) {
furi_assert(pin_input);
DesktopViewPinInputModel* model = view_get_model(pin_input->view);
model->locked_input = false;
view_commit_model(pin_input->view, true);
}
void desktop_view_pin_input_set_pin(DesktopViewPinInput* pin_input, const PinCode* pin) {
furi_assert(pin_input);
furi_assert(pin);
DesktopViewPinInputModel* model = view_get_model(pin_input->view);
model->pin = *pin;
view_commit_model(pin_input->view, true);
}
void desktop_view_pin_input_reset_pin(DesktopViewPinInput* pin_input) {
furi_assert(pin_input);
DesktopViewPinInputModel* model = view_get_model(pin_input->view);
model->pin.length = 0;
view_commit_model(pin_input->view, true);
}
void desktop_view_pin_input_hide_pin(DesktopViewPinInput* pin_input, bool pin_hidden) {
furi_assert(pin_input);
DesktopViewPinInputModel* model = view_get_model(pin_input->view);
model->pin_hidden = pin_hidden;
view_commit_model(pin_input->view, true);
}
void desktop_view_pin_input_set_label_button(DesktopViewPinInput* pin_input, const char* label) {
furi_assert(pin_input);
DesktopViewPinInputModel* model = view_get_model(pin_input->view);
model->button_label = label;
view_commit_model(pin_input->view, true);
}
void desktop_view_pin_input_set_label_primary(
DesktopViewPinInput* pin_input,
uint8_t x,
uint8_t y,
const char* label) {
furi_assert(pin_input);
DesktopViewPinInputModel* model = view_get_model(pin_input->view);
model->primary_str = label;
model->primary_str_x = x;
model->primary_str_y = y;
view_commit_model(pin_input->view, true);
}
void desktop_view_pin_input_set_label_secondary(
DesktopViewPinInput* pin_input,
uint8_t x,
uint8_t y,
const char* label) {
furi_assert(pin_input);
DesktopViewPinInputModel* model = view_get_model(pin_input->view);
model->secondary_str = label;
model->secondary_str_x = x;
model->secondary_str_y = y;
view_commit_model(pin_input->view, true);
}
void desktop_view_pin_input_set_pin_position(DesktopViewPinInput* pin_input, uint8_t x, uint8_t y) {
furi_assert(pin_input);
DesktopViewPinInputModel* model = view_get_model(pin_input->view);
model->pin_x = x;
model->pin_y = y;
view_commit_model(pin_input->view, true);
}
void desktop_view_pin_input_set_context(DesktopViewPinInput* pin_input, void* context) {
furi_assert(pin_input);
pin_input->context = context;
}
void desktop_view_pin_input_set_timeout_callback(
DesktopViewPinInput* pin_input,
DesktopViewPinInputCallback callback) {
furi_assert(pin_input);
pin_input->timeout_callback = callback;
}
void desktop_view_pin_input_set_back_callback(
DesktopViewPinInput* pin_input,
DesktopViewPinInputCallback callback) {
furi_assert(pin_input);
pin_input->back_callback = callback;
}
void desktop_view_pin_input_set_done_callback(
DesktopViewPinInput* pin_input,
DesktopViewPinInputDoneCallback callback) {
furi_assert(pin_input);
pin_input->done_callback = callback;
}
View* desktop_view_pin_input_get_view(DesktopViewPinInput* pin_input) {
furi_assert(pin_input);
return pin_input->view;
}