Merge pull request #452 from clipboard1/dev

Added numpad keyboard to HID app

applications/external/hid_app/hid.c

@@ -9,6 +9,7 @@ enum HidDebugSubmenuIndex {
     HidSubmenuIndexKeynote,
     HidSubmenuIndexKeynoteVertical,
     HidSubmenuIndexKeyboard,
+    HidSubmenuIndexNumpad,
     HidSubmenuIndexMedia,
     HidSubmenuIndexTikTok,
     HidSubmenuIndexYTShorts,
@@ -29,6 +30,9 @@ static void hid_submenu_callback(void* context, uint32_t index) {
     } else if(index == HidSubmenuIndexKeyboard) {
         app->view_id = HidViewKeyboard;
         view_dispatcher_switch_to_view(app->view_dispatcher, HidViewKeyboard);
+    } else if(index == HidSubmenuIndexNumpad) {
+        app->view_id = HidViewNumpad;
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewNumpad);
     } else if(index == HidSubmenuIndexMedia) {
         app->view_id = HidViewMedia;
         view_dispatcher_switch_to_view(app->view_dispatcher, HidViewMedia);
@@ -64,6 +68,7 @@ static void bt_hid_connection_status_changed_callback(BtStatus status, void* con
     hid_keynote_set_connected_status(hid->hid_keynote, connected);
     hid_keynote_vertical_set_connected_status(hid->hid_keynote_vertical, connected);
     hid_keyboard_set_connected_status(hid->hid_keyboard, connected);
+    hid_numpad_set_connected_status(hid->hid_numpad, connected);
     hid_media_set_connected_status(hid->hid_media, connected);
     hid_mouse_set_connected_status(hid->hid_mouse, connected);
     hid_mouse_clicker_set_connected_status(hid->hid_mouse_clicker, connected);
@@ -123,6 +128,8 @@ Hid* hid_alloc(HidTransport transport) {
         app);
     submenu_add_item(
         app->device_type_submenu, "Keyboard", HidSubmenuIndexKeyboard, hid_submenu_callback, app);
+    submenu_add_item(
+        app->device_type_submenu, "Numpad", HidSubmenuIndexNumpad, hid_submenu_callback, app);
     submenu_add_item(
         app->device_type_submenu, "Media", HidSubmenuIndexMedia, hid_submenu_callback, app);
     submenu_add_item(
@@ -196,6 +203,12 @@ Hid* hid_app_alloc_view(void* context) {
     view_dispatcher_add_view(
         app->view_dispatcher, HidViewKeyboard, hid_keyboard_get_view(app->hid_keyboard));
 
+    //Numpad keyboard view
+    app->hid_numpad = hid_numpad_alloc(app);
+    view_set_previous_callback(hid_numpad_get_view(app->hid_numpad), hid_exit_confirm_view);
+    view_dispatcher_add_view(
+        app->view_dispatcher, HidViewNumpad, hid_numpad_get_view(app->hid_numpad));
+
     // Media view
     app->hid_media = hid_media_alloc(app);
     view_set_previous_callback(hid_media_get_view(app->hid_media), hid_exit_confirm_view);
@@ -259,6 +272,8 @@ void hid_free(Hid* app) {
     hid_keynote_vertical_free(app->hid_keynote_vertical);
     view_dispatcher_remove_view(app->view_dispatcher, HidViewKeyboard);
     hid_keyboard_free(app->hid_keyboard);
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewNumpad);
+    hid_numpad_free(app->hid_numpad);
     view_dispatcher_remove_view(app->view_dispatcher, HidViewMedia);
     hid_media_free(app->hid_media);
     view_dispatcher_remove_view(app->view_dispatcher, HidViewMouse);

applications/external/hid_app/hid.h

@@ -19,6 +19,7 @@
 #include "views/hid_keynote.h"
 #include "views/hid_keynote_vertical.h"
 #include "views/hid_keyboard.h"
+#include "views/hid_numpad.h"
 #include "views/hid_media.h"
 #include "views/hid_mouse.h"
 #include "views/hid_mouse_jiggler.h"
@@ -45,6 +46,7 @@ struct Hid {
     HidKeynote* hid_keynote;
     HidKeynoteVertical* hid_keynote_vertical;
     HidKeyboard* hid_keyboard;
+    HidNumpad* hid_numpad;
     HidMedia* hid_media;
     HidMouse* hid_mouse;
     HidMouseClicker* hid_mouse_clicker;

applications/external/hid_app/views.h

@@ -3,6 +3,7 @@ typedef enum {
     HidViewKeynote,
     HidViewKeynoteVertical,
     HidViewKeyboard,
+    HidViewNumpad,
     HidViewMedia,
     HidViewMouse,
     HidViewMouseClicker,

applications/external/hid_app/views/hid_numpad.c

@@ -0,0 +1,302 @@
+#include "hid_numpad.h"
+#include <furi.h>
+#include <gui/elements.h>
+#include <gui/icon_i.h>
+#include "../hid.h"
+#include "hid_icons.h"
+
+#define TAG "HidNumpad"
+
+struct HidNumpad {
+    View* view;
+    Hid* hid;
+};
+
+typedef struct {
+    uint8_t last_x;
+    uint8_t last_y;
+    uint8_t x;
+    uint8_t y;
+    uint8_t last_key_code;
+    uint16_t modifier_code;
+    bool ok_pressed;
+    bool back_pressed;
+    bool connected;
+    char key_string[5];
+    HidTransport transport;
+} HidNumpadModel;
+
+typedef struct {
+    uint8_t width;
+    char* key;
+    uint8_t height;
+    const Icon* icon;
+    uint8_t value;
+} HidNumpadKey;
+
+typedef struct {
+    int8_t x;
+    int8_t y;
+} HidNumpadPoint;
+
+#define MARGIN_TOP 0
+#define MARGIN_LEFT 24
+#define KEY_WIDTH 20
+#define KEY_HEIGHT 15
+#define KEY_PADDING 1
+#define ROW_COUNT 5
+#define COLUMN_COUNT 4
+
+const HidNumpadKey hid_numpad_keyset[ROW_COUNT][COLUMN_COUNT] = {
+    {
+        {.width = 1, .height = 1, .icon = NULL, .key = "NL", .value = HID_KEYPAD_NUMLOCK},
+        {.width = 1, .height = 1, .icon = NULL, .key = "/", .value = HID_KEYPAD_SLASH},
+        {.width = 1, .height = 1, .icon = NULL, .key = "*", .value = HID_KEYPAD_ASTERISK},
+        {.width = 1, .height = 1, .icon = NULL, .key = "-", .value = HID_KEYPAD_MINUS},
+    },
+    {
+        {.width = 1, .height = 1, .icon = NULL, .key = "7", .value = HID_KEYPAD_7},
+        {.width = 1, .height = 1, .icon = NULL, .key = "8", .value = HID_KEYBOARD_8},
+        {.width = 1, .height = 1, .icon = NULL, .key = "9", .value = HID_KEYBOARD_9},
+        {.width = 1, .height = 2, .icon = NULL, .key = "+", .value = HID_KEYPAD_PLUS},
+    },
+    {
+        {.width = 1, .height = 1, .icon = NULL, .key = "4", .value = HID_KEYPAD_4},
+        {.width = 1, .height = 1, .icon = NULL, .key = "5", .value = HID_KEYPAD_5},
+        {.width = 1, .height = 1, .icon = NULL, .key = "6", .value = HID_KEYPAD_6},
+    },
+    {
+        {.width = 1, .height = 1, .icon = NULL, .key = "1", .value = HID_KEYPAD_1},
+        {.width = 1, .height = 1, .icon = NULL, .key = "2", .value = HID_KEYPAD_2},
+        {.width = 1, .height = 1, .icon = NULL, .key = "3", .value = HID_KEYPAD_3},
+        {.width = 1, .height = 2, .icon = NULL, .key = "En", .value = HID_KEYPAD_ENTER},
+    },
+    {
+        {.width = 2, .height = 1, .icon = NULL, .key = "0", .value = HID_KEYBOARD_0},
+        {.width = 0, .height = 0, .icon = NULL, .key = "0", .value = HID_KEYBOARD_0},
+        {.width = 1, .height = 1, .icon = NULL, .key = ".", .value = HID_KEYPAD_DOT},
+    },
+};
+
+static void hid_numpad_draw_key(
+    Canvas* canvas,
+    HidNumpadModel* model,
+    uint8_t x,
+    uint8_t y,
+    HidNumpadKey key,
+    bool selected) {
+    if(!key.width || !key.height) return;
+
+    canvas_set_color(canvas, ColorBlack);
+    uint8_t keyWidth = KEY_WIDTH * key.width + KEY_PADDING * (key.width - 1);
+    uint8_t keyHeight = KEY_HEIGHT * key.height + KEY_PADDING * (key.height - 1);
+    if(selected) {
+        elements_slightly_rounded_box(
+            canvas,
+            MARGIN_LEFT + x * (KEY_WIDTH + KEY_PADDING),
+            MARGIN_TOP + y * (KEY_HEIGHT + KEY_PADDING),
+            keyWidth,
+            keyHeight);
+        canvas_set_color(canvas, ColorWhite);
+    } else {
+        elements_slightly_rounded_frame(
+            canvas,
+            MARGIN_LEFT + x * (KEY_WIDTH + KEY_PADDING),
+            MARGIN_TOP + y * (KEY_HEIGHT + KEY_PADDING),
+            keyWidth,
+            keyHeight);
+    }
+    if(key.icon != NULL) {
+        canvas_draw_icon(
+            canvas,
+            MARGIN_LEFT + x * (KEY_WIDTH + KEY_PADDING) + keyWidth / 2 - key.icon->width / 2,
+            MARGIN_TOP + y * (KEY_HEIGHT + KEY_PADDING) + keyHeight / 2 - key.icon->height / 2,
+            key.icon);
+    } else {
+        strcpy(model->key_string, key.key);
+        canvas_draw_str_aligned(
+            canvas,
+            MARGIN_LEFT + x * (KEY_WIDTH + KEY_PADDING) + keyWidth / 2 + 1,
+            MARGIN_TOP + y * (KEY_HEIGHT + KEY_PADDING) + keyHeight / 2 + 1,
+            AlignCenter,
+            AlignCenter,
+            model->key_string);
+    }
+}
+
+static void hid_numpad_draw_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidNumpadModel* model = context;
+
+    if((!model->connected) && (model->transport == HidTransportBle)) {
+        canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        canvas_set_font(canvas, FontPrimary);
+        elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Numpad");
+
+        canvas_draw_icon(canvas, 68, 3, &I_Pin_back_arrow_10x8);
+        canvas_set_font(canvas, FontSecondary);
+        elements_multiline_text_aligned(canvas, 127, 4, AlignRight, AlignTop, "Hold to exit");
+
+        elements_multiline_text_aligned(
+            canvas, 4, 60, AlignLeft, AlignBottom, "Waiting for Connection...");
+        return;
+    }
+
+    canvas_set_font(canvas, FontKeyboard);
+    uint8_t initY = model->y == 0 ? 0 : 1;
+
+    if(model->y > 5) {
+        initY = model->y - 4;
+    }
+
+    for(uint8_t y = initY; y < ROW_COUNT; y++) {
+        const HidNumpadKey* numpadKeyRow = hid_numpad_keyset[y];
+        uint8_t x = 0;
+        for(uint8_t i = 0; i < COLUMN_COUNT; i++) {
+            HidNumpadKey key = numpadKeyRow[i];
+            bool keySelected = (x <= model->x && model->x < (x + key.width)) && y == model->y;
+            bool backSelected = model->back_pressed && key.value == HID_KEYBOARD_DELETE;
+            hid_numpad_draw_key(
+                canvas,
+                model,
+                x,
+                y - initY,
+                key,
+                (!model->ok_pressed && keySelected) || backSelected);
+            x += key.width;
+        }
+    }
+}
+
+static uint8_t hid_numpad_get_selected_key(HidNumpadModel* model) {
+    HidNumpadKey key = hid_numpad_keyset[model->y][model->x];
+    return key.value;
+}
+
+static void hid_numpad_get_select_key(HidNumpadModel* model, HidNumpadPoint delta) {
+    do {
+        const int delta_sum = model->y + delta.y;
+        model->y = delta_sum < 0 ? ROW_COUNT - 1 : delta_sum % ROW_COUNT;
+    } while(delta.y != 0 && hid_numpad_keyset[model->y][model->x].value == 0);
+
+    do {
+        const int delta_sum = model->x + delta.x;
+        model->x = delta_sum < 0 ? COLUMN_COUNT - 1 : delta_sum % COLUMN_COUNT;
+    } while(delta.x != 0 && hid_numpad_keyset[model->y][model->x].width == 0);
+}
+
+static void hid_numpad_process(HidNumpad* hid_numpad, InputEvent* event) {
+    with_view_model(
+        hid_numpad->view,
+        HidNumpadModel * model,
+        {
+            if(event->key == InputKeyOk) {
+                if(event->type == InputTypePress) {
+                    model->ok_pressed = true;
+                } else if(event->type == InputTypeLong || event->type == InputTypeShort) {
+                    model->last_key_code = hid_numpad_get_selected_key(model);
+                    hid_hal_keyboard_press(
+                        hid_numpad->hid, model->modifier_code | model->last_key_code);
+                } else if(event->type == InputTypeRelease) {
+                    hid_hal_keyboard_release(
+                        hid_numpad->hid, model->modifier_code | model->last_key_code);
+                    model->ok_pressed = false;
+                }
+            } else if(event->key == InputKeyBack) {
+                if(event->type == InputTypePress) {
+                    model->back_pressed = true;
+                } else if(event->type == InputTypeShort) {
+                    hid_hal_keyboard_press(hid_numpad->hid, HID_KEYBOARD_DELETE);
+                    hid_hal_keyboard_release(hid_numpad->hid, HID_KEYBOARD_DELETE);
+                } else if(event->type == InputTypeRelease) {
+                    model->back_pressed = false;
+                }
+            } else if(event->type == InputTypePress || event->type == InputTypeRepeat) {
+                if(event->key == InputKeyUp) {
+                    hid_numpad_get_select_key(model, (HidNumpadPoint){.x = 0, .y = -1});
+                } else if(event->key == InputKeyDown) {
+                    hid_numpad_get_select_key(model, (HidNumpadPoint){.x = 0, .y = 1});
+                } else if(event->key == InputKeyLeft) {
+                    if(model->last_x == 2 && model->last_y == 2 && model->y == 1 &&
+                       model->x == 3) {
+                        model->x = model->last_x;
+                        model->y = model->last_y;
+                    } else if(
+                        model->last_x == 2 && model->last_y == 4 && model->y == 3 &&
+                        model->x == 3) {
+                        model->x = model->last_x;
+                        model->y = model->last_y;
+                    } else
+                        hid_numpad_get_select_key(model, (HidNumpadPoint){.x = -1, .y = 0});
+                    model->last_x = 0;
+                    model->last_y = 0;
+                } else if(event->key == InputKeyRight) {
+                    if(model->x == 2 && model->y == 2) {
+                        model->last_x = model->x;
+                        model->last_y = model->y;
+                        hid_numpad_get_select_key(model, (HidNumpadPoint){.x = 1, .y = -1});
+                    } else if(model->x == 2 && model->y == 4) {
+                        model->last_x = model->x;
+                        model->last_y = model->y;
+                        hid_numpad_get_select_key(model, (HidNumpadPoint){.x = 1, .y = -1});
+                    } else {
+                        hid_numpad_get_select_key(model, (HidNumpadPoint){.x = 1, .y = 0});
+                    }
+                }
+            }
+        },
+        true);
+}
+
+static bool hid_numpad_input_callback(InputEvent* event, void* context) {
+    furi_assert(context);
+    HidNumpad* hid_numpad = context;
+    bool consumed = false;
+
+    if(event->type == InputTypeLong && event->key == InputKeyBack) {
+        hid_hal_keyboard_release_all(hid_numpad->hid);
+    } else {
+        hid_numpad_process(hid_numpad, event);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+HidNumpad* hid_numpad_alloc(Hid* bt_hid) {
+    HidNumpad* hid_numpad = malloc(sizeof(HidNumpad));
+    hid_numpad->view = view_alloc();
+    hid_numpad->hid = bt_hid;
+    view_set_context(hid_numpad->view, hid_numpad);
+    view_allocate_model(hid_numpad->view, ViewModelTypeLocking, sizeof(HidNumpadModel));
+    view_set_draw_callback(hid_numpad->view, hid_numpad_draw_callback);
+    view_set_input_callback(hid_numpad->view, hid_numpad_input_callback);
+
+    with_view_model(
+        hid_numpad->view,
+        HidNumpadModel * model,
+        {
+            model->transport = bt_hid->transport;
+            model->y = 0;
+        },
+        true);
+
+    return hid_numpad;
+}
+
+void hid_numpad_free(HidNumpad* hid_numpad) {
+    furi_assert(hid_numpad);
+    view_free(hid_numpad->view);
+    free(hid_numpad);
+}
+
+View* hid_numpad_get_view(HidNumpad* hid_numpad) {
+    furi_assert(hid_numpad);
+    return hid_numpad->view;
+}
+
+void hid_numpad_set_connected_status(HidNumpad* hid_numpad, bool connected) {
+    furi_assert(hid_numpad);
+    with_view_model(
+        hid_numpad->view, HidNumpadModel * model, { model->connected = connected; }, true);
+}

applications/external/hid_app/views/hid_numpad.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <gui/view.h>
+
+typedef struct Hid Hid;
+typedef struct HidNumpad HidNumpad;
+
+HidNumpad* hid_numpad_alloc(Hid* bt_hid);
+
+void hid_numpad_free(HidNumpad* hid_numpad);
+
+View* hid_numpad_get_view(HidNumpad* hid_numpad);
+
+void hid_numpad_set_connected_status(HidNumpad* hid_numpad, bool connected);