Various Fixes and Improvements (#3059)

* FuriHal: lower MGG display contrast by 4 points
* FuriHal: unify external gpio resources initialization
* Infrared: parse raw in universal TV file, cleanup it with new ifrared script. Other minor changes.
* Gui: fix elements_multiline_text_aligned eating symbols
* Lib: human readable errors in flipper application package
* Special request from marketing team

applications/services/gui/elements.c

@@ -290,8 +290,7 @@ void elements_multiline_text_aligned(
         } else if((y + font_height) > canvas_height(canvas)) {
             line = furi_string_alloc_printf("%.*s...\n", chars_fit, start);
         } else {
-            // Account for the added "-" in length
-            line = furi_string_alloc_printf("%.*s-\n", chars_fit - 1, start);
+            line = furi_string_alloc_printf("%.*s-\n", chars_fit, start);
         }
         canvas_draw_str_aligned(canvas, x, y, horizontal, vertical, furi_string_get_cstr(line));
         furi_string_free(line);

applications/system/hid_app/application.fam

@@ -0,0 +1,28 @@
+App(
+    appid="hid_usb",
+    name="Remote",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="hid_usb_app",
+    stack_size=1 * 1024,
+    fap_description="Use Flipper as a HID remote control over USB",
+    fap_version="1.0",
+    fap_category="USB",
+    fap_icon="hid_usb_10px.png",
+    fap_icon_assets="assets",
+    fap_icon_assets_symbol="hid",
+)
+
+
+App(
+    appid="hid_ble",
+    name="Remote",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="hid_ble_app",
+    stack_size=1 * 1024,
+    fap_description="Use Flipper as a HID remote control over Bluetooth",
+    fap_version="1.0",
+    fap_category="Bluetooth",
+    fap_icon="hid_ble_10px.png",
+    fap_icon_assets="assets",
+    fap_icon_assets_symbol="hid",
+)

applications/system/hid_app/hid.c

@@ -0,0 +1,452 @@
+#include "hid.h"
+#include "views.h"
+#include <notification/notification_messages.h>
+#include <dolphin/dolphin.h>
+
+#define TAG "HidApp"
+
+enum HidDebugSubmenuIndex {
+    HidSubmenuIndexKeynote,
+    HidSubmenuIndexKeynoteVertical,
+    HidSubmenuIndexKeyboard,
+    HidSubmenuIndexMedia,
+    HidSubmenuIndexTikTok,
+    HidSubmenuIndexMouse,
+    HidSubmenuIndexMouseClicker,
+    HidSubmenuIndexMouseJiggler,
+};
+
+static void hid_submenu_callback(void* context, uint32_t index) {
+    furi_assert(context);
+    Hid* app = context;
+    if(index == HidSubmenuIndexKeynote) {
+        app->view_id = HidViewKeynote;
+        hid_keynote_set_orientation(app->hid_keynote, false);
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewKeynote);
+    } else if(index == HidSubmenuIndexKeynoteVertical) {
+        app->view_id = HidViewKeynote;
+        hid_keynote_set_orientation(app->hid_keynote, true);
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewKeynote);
+    } else if(index == HidSubmenuIndexKeyboard) {
+        app->view_id = HidViewKeyboard;
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewKeyboard);
+    } else if(index == HidSubmenuIndexMedia) {
+        app->view_id = HidViewMedia;
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewMedia);
+    } else if(index == HidSubmenuIndexMouse) {
+        app->view_id = HidViewMouse;
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewMouse);
+    } else if(index == HidSubmenuIndexTikTok) {
+        app->view_id = BtHidViewTikTok;
+        view_dispatcher_switch_to_view(app->view_dispatcher, BtHidViewTikTok);
+    } else if(index == HidSubmenuIndexMouseClicker) {
+        app->view_id = HidViewMouseClicker;
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewMouseClicker);
+    } else if(index == HidSubmenuIndexMouseJiggler) {
+        app->view_id = HidViewMouseJiggler;
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewMouseJiggler);
+    }
+}
+
+static void bt_hid_connection_status_changed_callback(BtStatus status, void* context) {
+    furi_assert(context);
+    Hid* hid = context;
+    bool connected = (status == BtStatusConnected);
+    if(hid->transport == HidTransportBle) {
+        if(connected) {
+            notification_internal_message(hid->notifications, &sequence_set_blue_255);
+        } else {
+            notification_internal_message(hid->notifications, &sequence_reset_blue);
+        }
+    }
+    hid_keynote_set_connected_status(hid->hid_keynote, connected);
+    hid_keyboard_set_connected_status(hid->hid_keyboard, 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);
+    hid_mouse_jiggler_set_connected_status(hid->hid_mouse_jiggler, connected);
+    hid_tiktok_set_connected_status(hid->hid_tiktok, connected);
+}
+
+static void hid_dialog_callback(DialogExResult result, void* context) {
+    furi_assert(context);
+    Hid* app = context;
+    if(result == DialogExResultLeft) {
+        view_dispatcher_stop(app->view_dispatcher);
+    } else if(result == DialogExResultRight) {
+        view_dispatcher_switch_to_view(app->view_dispatcher, app->view_id); // Show last view
+    } else if(result == DialogExResultCenter) {
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewSubmenu);
+    }
+}
+
+static uint32_t hid_exit_confirm_view(void* context) {
+    UNUSED(context);
+    return HidViewExitConfirm;
+}
+
+static uint32_t hid_exit(void* context) {
+    UNUSED(context);
+    return VIEW_NONE;
+}
+
+Hid* hid_alloc(HidTransport transport) {
+    Hid* app = malloc(sizeof(Hid));
+    app->transport = transport;
+
+    // Gui
+    app->gui = furi_record_open(RECORD_GUI);
+
+    // Bt
+    app->bt = furi_record_open(RECORD_BT);
+
+    // Notifications
+    app->notifications = furi_record_open(RECORD_NOTIFICATION);
+
+    // View dispatcher
+    app->view_dispatcher = view_dispatcher_alloc();
+    view_dispatcher_enable_queue(app->view_dispatcher);
+    view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
+    // Device Type Submenu view
+    app->device_type_submenu = submenu_alloc();
+    submenu_add_item(
+        app->device_type_submenu, "Keynote", HidSubmenuIndexKeynote, hid_submenu_callback, app);
+    submenu_add_item(
+        app->device_type_submenu,
+        "Keynote Vertical",
+        HidSubmenuIndexKeynoteVertical,
+        hid_submenu_callback,
+        app);
+    submenu_add_item(
+        app->device_type_submenu, "Keyboard", HidSubmenuIndexKeyboard, hid_submenu_callback, app);
+    submenu_add_item(
+        app->device_type_submenu, "Media", HidSubmenuIndexMedia, hid_submenu_callback, app);
+    submenu_add_item(
+        app->device_type_submenu, "Mouse", HidSubmenuIndexMouse, hid_submenu_callback, app);
+    if(app->transport == HidTransportBle) {
+        submenu_add_item(
+            app->device_type_submenu,
+            "TikTok Controller",
+            HidSubmenuIndexTikTok,
+            hid_submenu_callback,
+            app);
+    }
+    submenu_add_item(
+        app->device_type_submenu,
+        "Mouse Clicker",
+        HidSubmenuIndexMouseClicker,
+        hid_submenu_callback,
+        app);
+    submenu_add_item(
+        app->device_type_submenu,
+        "Mouse Jiggler",
+        HidSubmenuIndexMouseJiggler,
+        hid_submenu_callback,
+        app);
+    view_set_previous_callback(submenu_get_view(app->device_type_submenu), hid_exit);
+    view_dispatcher_add_view(
+        app->view_dispatcher, HidViewSubmenu, submenu_get_view(app->device_type_submenu));
+    app->view_id = HidViewSubmenu;
+    view_dispatcher_switch_to_view(app->view_dispatcher, app->view_id);
+    return app;
+}
+
+Hid* hid_app_alloc_view(void* context) {
+    furi_assert(context);
+    Hid* app = context;
+    // Dialog view
+    app->dialog = dialog_ex_alloc();
+    dialog_ex_set_result_callback(app->dialog, hid_dialog_callback);
+    dialog_ex_set_context(app->dialog, app);
+    dialog_ex_set_left_button_text(app->dialog, "Exit");
+    dialog_ex_set_right_button_text(app->dialog, "Stay");
+    dialog_ex_set_center_button_text(app->dialog, "Menu");
+    dialog_ex_set_header(app->dialog, "Close Current App?", 16, 12, AlignLeft, AlignTop);
+    view_dispatcher_add_view(
+        app->view_dispatcher, HidViewExitConfirm, dialog_ex_get_view(app->dialog));
+
+    // Keynote view
+    app->hid_keynote = hid_keynote_alloc(app);
+    view_set_previous_callback(hid_keynote_get_view(app->hid_keynote), hid_exit_confirm_view);
+    view_dispatcher_add_view(
+        app->view_dispatcher, HidViewKeynote, hid_keynote_get_view(app->hid_keynote));
+
+    // Keyboard view
+    app->hid_keyboard = hid_keyboard_alloc(app);
+    view_set_previous_callback(hid_keyboard_get_view(app->hid_keyboard), hid_exit_confirm_view);
+    view_dispatcher_add_view(
+        app->view_dispatcher, HidViewKeyboard, hid_keyboard_get_view(app->hid_keyboard));
+
+    // Media view
+    app->hid_media = hid_media_alloc(app);
+    view_set_previous_callback(hid_media_get_view(app->hid_media), hid_exit_confirm_view);
+    view_dispatcher_add_view(
+        app->view_dispatcher, HidViewMedia, hid_media_get_view(app->hid_media));
+
+    // TikTok view
+    app->hid_tiktok = hid_tiktok_alloc(app);
+    view_set_previous_callback(hid_tiktok_get_view(app->hid_tiktok), hid_exit_confirm_view);
+    view_dispatcher_add_view(
+        app->view_dispatcher, BtHidViewTikTok, hid_tiktok_get_view(app->hid_tiktok));
+
+    // Mouse view
+    app->hid_mouse = hid_mouse_alloc(app);
+    view_set_previous_callback(hid_mouse_get_view(app->hid_mouse), hid_exit_confirm_view);
+    view_dispatcher_add_view(
+        app->view_dispatcher, HidViewMouse, hid_mouse_get_view(app->hid_mouse));
+
+    // Mouse clicker view
+    app->hid_mouse_clicker = hid_mouse_clicker_alloc(app);
+    view_set_previous_callback(
+        hid_mouse_clicker_get_view(app->hid_mouse_clicker), hid_exit_confirm_view);
+    view_dispatcher_add_view(
+        app->view_dispatcher,
+        HidViewMouseClicker,
+        hid_mouse_clicker_get_view(app->hid_mouse_clicker));
+
+    // Mouse jiggler view
+    app->hid_mouse_jiggler = hid_mouse_jiggler_alloc(app);
+    view_set_previous_callback(
+        hid_mouse_jiggler_get_view(app->hid_mouse_jiggler), hid_exit_confirm_view);
+    view_dispatcher_add_view(
+        app->view_dispatcher,
+        HidViewMouseJiggler,
+        hid_mouse_jiggler_get_view(app->hid_mouse_jiggler));
+
+    return app;
+}
+
+void hid_free(Hid* app) {
+    furi_assert(app);
+
+    // Reset notification
+    if(app->transport == HidTransportBle) {
+        notification_internal_message(app->notifications, &sequence_reset_blue);
+    }
+
+    // Free views
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewSubmenu);
+    submenu_free(app->device_type_submenu);
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewExitConfirm);
+    dialog_ex_free(app->dialog);
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewKeynote);
+    hid_keynote_free(app->hid_keynote);
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewKeyboard);
+    hid_keyboard_free(app->hid_keyboard);
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewMedia);
+    hid_media_free(app->hid_media);
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewMouse);
+    hid_mouse_free(app->hid_mouse);
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewMouseClicker);
+    hid_mouse_clicker_free(app->hid_mouse_clicker);
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewMouseJiggler);
+    hid_mouse_jiggler_free(app->hid_mouse_jiggler);
+    view_dispatcher_remove_view(app->view_dispatcher, BtHidViewTikTok);
+    hid_tiktok_free(app->hid_tiktok);
+    view_dispatcher_free(app->view_dispatcher);
+
+    // Close records
+    furi_record_close(RECORD_GUI);
+    app->gui = NULL;
+    furi_record_close(RECORD_NOTIFICATION);
+    app->notifications = NULL;
+    furi_record_close(RECORD_BT);
+    app->bt = NULL;
+
+    // Free rest
+    free(app);
+}
+
+void hid_hal_keyboard_press(Hid* instance, uint16_t event) {
+    furi_assert(instance);
+    if(instance->transport == HidTransportBle) {
+        furi_hal_bt_hid_kb_press(event);
+    } else if(instance->transport == HidTransportUsb) {
+        furi_hal_hid_kb_press(event);
+    } else {
+        furi_crash(NULL);
+    }
+}
+
+void hid_hal_keyboard_release(Hid* instance, uint16_t event) {
+    furi_assert(instance);
+    if(instance->transport == HidTransportBle) {
+        furi_hal_bt_hid_kb_release(event);
+    } else if(instance->transport == HidTransportUsb) {
+        furi_hal_hid_kb_release(event);
+    } else {
+        furi_crash(NULL);
+    }
+}
+
+void hid_hal_keyboard_release_all(Hid* instance) {
+    furi_assert(instance);
+    if(instance->transport == HidTransportBle) {
+        furi_hal_bt_hid_kb_release_all();
+    } else if(instance->transport == HidTransportUsb) {
+        furi_hal_hid_kb_release_all();
+    } else {
+        furi_crash(NULL);
+    }
+}
+
+void hid_hal_consumer_key_press(Hid* instance, uint16_t event) {
+    furi_assert(instance);
+    if(instance->transport == HidTransportBle) {
+        furi_hal_bt_hid_consumer_key_press(event);
+    } else if(instance->transport == HidTransportUsb) {
+        furi_hal_hid_consumer_key_press(event);
+    } else {
+        furi_crash(NULL);
+    }
+}
+
+void hid_hal_consumer_key_release(Hid* instance, uint16_t event) {
+    furi_assert(instance);
+    if(instance->transport == HidTransportBle) {
+        furi_hal_bt_hid_consumer_key_release(event);
+    } else if(instance->transport == HidTransportUsb) {
+        furi_hal_hid_consumer_key_release(event);
+    } else {
+        furi_crash(NULL);
+    }
+}
+
+void hid_hal_consumer_key_release_all(Hid* instance) {
+    furi_assert(instance);
+    if(instance->transport == HidTransportBle) {
+        furi_hal_bt_hid_consumer_key_release_all();
+    } else if(instance->transport == HidTransportUsb) {
+        furi_hal_hid_kb_release_all();
+    } else {
+        furi_crash(NULL);
+    }
+}
+
+void hid_hal_mouse_move(Hid* instance, int8_t dx, int8_t dy) {
+    furi_assert(instance);
+    if(instance->transport == HidTransportBle) {
+        furi_hal_bt_hid_mouse_move(dx, dy);
+    } else if(instance->transport == HidTransportUsb) {
+        furi_hal_hid_mouse_move(dx, dy);
+    } else {
+        furi_crash(NULL);
+    }
+}
+
+void hid_hal_mouse_scroll(Hid* instance, int8_t delta) {
+    furi_assert(instance);
+    if(instance->transport == HidTransportBle) {
+        furi_hal_bt_hid_mouse_scroll(delta);
+    } else if(instance->transport == HidTransportUsb) {
+        furi_hal_hid_mouse_scroll(delta);
+    } else {
+        furi_crash(NULL);
+    }
+}
+
+void hid_hal_mouse_press(Hid* instance, uint16_t event) {
+    furi_assert(instance);
+    if(instance->transport == HidTransportBle) {
+        furi_hal_bt_hid_mouse_press(event);
+    } else if(instance->transport == HidTransportUsb) {
+        furi_hal_hid_mouse_press(event);
+    } else {
+        furi_crash(NULL);
+    }
+}
+
+void hid_hal_mouse_release(Hid* instance, uint16_t event) {
+    furi_assert(instance);
+    if(instance->transport == HidTransportBle) {
+        furi_hal_bt_hid_mouse_release(event);
+    } else if(instance->transport == HidTransportUsb) {
+        furi_hal_hid_mouse_release(event);
+    } else {
+        furi_crash(NULL);
+    }
+}
+
+void hid_hal_mouse_release_all(Hid* instance) {
+    furi_assert(instance);
+    if(instance->transport == HidTransportBle) {
+        furi_hal_bt_hid_mouse_release_all();
+    } else if(instance->transport == HidTransportUsb) {
+        furi_hal_hid_mouse_release(HID_MOUSE_BTN_LEFT);
+        furi_hal_hid_mouse_release(HID_MOUSE_BTN_RIGHT);
+    } else {
+        furi_crash(NULL);
+    }
+}
+
+int32_t hid_usb_app(void* p) {
+    UNUSED(p);
+    Hid* app = hid_alloc(HidTransportUsb);
+    app = hid_app_alloc_view(app);
+    FuriHalUsbInterface* usb_mode_prev = furi_hal_usb_get_config();
+    furi_hal_usb_unlock();
+    furi_check(furi_hal_usb_set_config(&usb_hid, NULL) == true);
+
+    bt_hid_connection_status_changed_callback(BtStatusConnected, app);
+
+    dolphin_deed(DolphinDeedPluginStart);
+
+    view_dispatcher_run(app->view_dispatcher);
+
+    furi_hal_usb_set_config(usb_mode_prev, NULL);
+
+    hid_free(app);
+
+    return 0;
+}
+
+int32_t hid_ble_app(void* p) {
+    UNUSED(p);
+    Hid* app = hid_alloc(HidTransportBle);
+    app = hid_app_alloc_view(app);
+
+    bt_disconnect(app->bt);
+
+    // Wait 2nd core to update nvm storage
+    furi_delay_ms(200);
+
+    // Migrate data from old sd-card folder
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    storage_common_migrate(
+        storage,
+        EXT_PATH("apps/Tools/" HID_BT_KEYS_STORAGE_NAME),
+        APP_DATA_PATH(HID_BT_KEYS_STORAGE_NAME));
+
+    bt_keys_storage_set_storage_path(app->bt, APP_DATA_PATH(HID_BT_KEYS_STORAGE_NAME));
+
+    furi_record_close(RECORD_STORAGE);
+
+    if(!bt_set_profile(app->bt, BtProfileHidKeyboard)) {
+        FURI_LOG_E(TAG, "Failed to switch to HID profile");
+    }
+
+    furi_hal_bt_start_advertising();
+    bt_set_status_changed_callback(app->bt, bt_hid_connection_status_changed_callback, app);
+
+    dolphin_deed(DolphinDeedPluginStart);
+
+    view_dispatcher_run(app->view_dispatcher);
+
+    bt_set_status_changed_callback(app->bt, NULL, NULL);
+
+    bt_disconnect(app->bt);
+
+    // Wait 2nd core to update nvm storage
+    furi_delay_ms(200);
+
+    bt_keys_storage_set_default_path(app->bt);
+
+    if(!bt_set_profile(app->bt, BtProfileSerial)) {
+        FURI_LOG_E(TAG, "Failed to switch to Serial profile");
+    }
+
+    hid_free(app);
+
+    return 0;
+}

applications/system/hid_app/hid.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <furi.h>
+#include <furi_hal_bt.h>
+#include <furi_hal_bt_hid.h>
+#include <furi_hal_usb.h>
+#include <furi_hal_usb_hid.h>
+
+#include <bt/bt_service/bt.h>
+#include <gui/gui.h>
+#include <gui/view.h>
+#include <gui/view_dispatcher.h>
+#include <notification/notification.h>
+#include <storage/storage.h>
+
+#include <gui/modules/submenu.h>
+#include <gui/modules/dialog_ex.h>
+#include <gui/modules/popup.h>
+#include "views/hid_keynote.h"
+#include "views/hid_keyboard.h"
+#include "views/hid_media.h"
+#include "views/hid_mouse.h"
+#include "views/hid_mouse_clicker.h"
+#include "views/hid_mouse_jiggler.h"
+#include "views/hid_tiktok.h"
+
+#define HID_BT_KEYS_STORAGE_NAME ".bt_hid.keys"
+
+typedef enum {
+    HidTransportUsb,
+    HidTransportBle,
+} HidTransport;
+
+typedef struct Hid Hid;
+
+struct Hid {
+    Bt* bt;
+    Gui* gui;
+    NotificationApp* notifications;
+    ViewDispatcher* view_dispatcher;
+    Submenu* device_type_submenu;
+    DialogEx* dialog;
+    HidKeynote* hid_keynote;
+    HidKeyboard* hid_keyboard;
+    HidMedia* hid_media;
+    HidMouse* hid_mouse;
+    HidMouseClicker* hid_mouse_clicker;
+    HidMouseJiggler* hid_mouse_jiggler;
+    HidTikTok* hid_tiktok;
+
+    HidTransport transport;
+    uint32_t view_id;
+};
+
+void hid_hal_keyboard_press(Hid* instance, uint16_t event);
+void hid_hal_keyboard_release(Hid* instance, uint16_t event);
+void hid_hal_keyboard_release_all(Hid* instance);
+
+void hid_hal_consumer_key_press(Hid* instance, uint16_t event);
+void hid_hal_consumer_key_release(Hid* instance, uint16_t event);
+void hid_hal_consumer_key_release_all(Hid* instance);
+
+void hid_hal_mouse_move(Hid* instance, int8_t dx, int8_t dy);
+void hid_hal_mouse_scroll(Hid* instance, int8_t delta);
+void hid_hal_mouse_press(Hid* instance, uint16_t event);
+void hid_hal_mouse_release(Hid* instance, uint16_t event);
+void hid_hal_mouse_release_all(Hid* instance);

applications/system/hid_app/views.h

@@ -0,0 +1,11 @@
+typedef enum {
+    HidViewSubmenu,
+    HidViewKeynote,
+    HidViewKeyboard,
+    HidViewMedia,
+    HidViewMouse,
+    HidViewMouseClicker,
+    HidViewMouseJiggler,
+    BtHidViewTikTok,
+    HidViewExitConfirm,
+} HidView;

applications/system/hid_app/views/hid_keyboard.c

@@ -0,0 +1,411 @@
+#include "hid_keyboard.h"
+#include <furi.h>
+#include <gui/elements.h>
+#include <gui/icon_i.h>
+#include "../hid.h"
+#include "hid_icons.h"
+
+#define TAG "HidKeyboard"
+
+struct HidKeyboard {
+    View* view;
+    Hid* hid;
+};
+
+typedef struct {
+    bool shift;
+    bool alt;
+    bool ctrl;
+    bool gui;
+    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;
+} HidKeyboardModel;
+
+typedef struct {
+    uint8_t width;
+    char* key;
+    const Icon* icon;
+    char* shift_key;
+    uint8_t value;
+} HidKeyboardKey;
+
+typedef struct {
+    int8_t x;
+    int8_t y;
+} HidKeyboardPoint;
+// 4 BY 12
+#define MARGIN_TOP 0
+#define MARGIN_LEFT 4
+#define KEY_WIDTH 9
+#define KEY_HEIGHT 12
+#define KEY_PADDING 1
+#define ROW_COUNT 7
+#define COLUMN_COUNT 12
+
+// 0 width items are not drawn, but there value is used
+const HidKeyboardKey hid_keyboard_keyset[ROW_COUNT][COLUMN_COUNT] = {
+    {
+        {.width = 1, .icon = &I_ButtonF1_5x8, .value = HID_KEYBOARD_F1},
+        {.width = 1, .icon = &I_ButtonF2_5x8, .value = HID_KEYBOARD_F2},
+        {.width = 1, .icon = &I_ButtonF3_5x8, .value = HID_KEYBOARD_F3},
+        {.width = 1, .icon = &I_ButtonF4_5x8, .value = HID_KEYBOARD_F4},
+        {.width = 1, .icon = &I_ButtonF5_5x8, .value = HID_KEYBOARD_F5},
+        {.width = 1, .icon = &I_ButtonF6_5x8, .value = HID_KEYBOARD_F6},
+        {.width = 1, .icon = &I_ButtonF7_5x8, .value = HID_KEYBOARD_F7},
+        {.width = 1, .icon = &I_ButtonF8_5x8, .value = HID_KEYBOARD_F8},
+        {.width = 1, .icon = &I_ButtonF9_5x8, .value = HID_KEYBOARD_F9},
+        {.width = 1, .icon = &I_ButtonF10_5x8, .value = HID_KEYBOARD_F10},
+        {.width = 1, .icon = &I_ButtonF11_5x8, .value = HID_KEYBOARD_F11},
+        {.width = 1, .icon = &I_ButtonF12_5x8, .value = HID_KEYBOARD_F12},
+    },
+    {
+        {.width = 1, .icon = NULL, .key = "1", .shift_key = "!", .value = HID_KEYBOARD_1},
+        {.width = 1, .icon = NULL, .key = "2", .shift_key = "@", .value = HID_KEYBOARD_2},
+        {.width = 1, .icon = NULL, .key = "3", .shift_key = "#", .value = HID_KEYBOARD_3},
+        {.width = 1, .icon = NULL, .key = "4", .shift_key = "$", .value = HID_KEYBOARD_4},
+        {.width = 1, .icon = NULL, .key = "5", .shift_key = "%", .value = HID_KEYBOARD_5},
+        {.width = 1, .icon = NULL, .key = "6", .shift_key = "^", .value = HID_KEYBOARD_6},
+        {.width = 1, .icon = NULL, .key = "7", .shift_key = "&", .value = HID_KEYBOARD_7},
+        {.width = 1, .icon = NULL, .key = "8", .shift_key = "*", .value = HID_KEYBOARD_8},
+        {.width = 1, .icon = NULL, .key = "9", .shift_key = "(", .value = HID_KEYBOARD_9},
+        {.width = 1, .icon = NULL, .key = "0", .shift_key = ")", .value = HID_KEYBOARD_0},
+        {.width = 2, .icon = &I_Pin_arrow_left_9x7, .value = HID_KEYBOARD_DELETE},
+        {.width = 0, .value = HID_KEYBOARD_DELETE},
+    },
+    {
+        {.width = 1, .icon = NULL, .key = "q", .shift_key = "Q", .value = HID_KEYBOARD_Q},
+        {.width = 1, .icon = NULL, .key = "w", .shift_key = "W", .value = HID_KEYBOARD_W},
+        {.width = 1, .icon = NULL, .key = "e", .shift_key = "E", .value = HID_KEYBOARD_E},
+        {.width = 1, .icon = NULL, .key = "r", .shift_key = "R", .value = HID_KEYBOARD_R},
+        {.width = 1, .icon = NULL, .key = "t", .shift_key = "T", .value = HID_KEYBOARD_T},
+        {.width = 1, .icon = NULL, .key = "y", .shift_key = "Y", .value = HID_KEYBOARD_Y},
+        {.width = 1, .icon = NULL, .key = "u", .shift_key = "U", .value = HID_KEYBOARD_U},
+        {.width = 1, .icon = NULL, .key = "i", .shift_key = "I", .value = HID_KEYBOARD_I},
+        {.width = 1, .icon = NULL, .key = "o", .shift_key = "O", .value = HID_KEYBOARD_O},
+        {.width = 1, .icon = NULL, .key = "p", .shift_key = "P", .value = HID_KEYBOARD_P},
+        {.width = 1, .icon = NULL, .key = "[", .shift_key = "{", .value = HID_KEYBOARD_OPEN_BRACKET},
+        {.width = 1,
+         .icon = NULL,
+         .key = "]",
+         .shift_key = "}",
+         .value = HID_KEYBOARD_CLOSE_BRACKET},
+    },
+    {
+        {.width = 1, .icon = NULL, .key = "a", .shift_key = "A", .value = HID_KEYBOARD_A},
+        {.width = 1, .icon = NULL, .key = "s", .shift_key = "S", .value = HID_KEYBOARD_S},
+        {.width = 1, .icon = NULL, .key = "d", .shift_key = "D", .value = HID_KEYBOARD_D},
+        {.width = 1, .icon = NULL, .key = "f", .shift_key = "F", .value = HID_KEYBOARD_F},
+        {.width = 1, .icon = NULL, .key = "g", .shift_key = "G", .value = HID_KEYBOARD_G},
+        {.width = 1, .icon = NULL, .key = "h", .shift_key = "H", .value = HID_KEYBOARD_H},
+        {.width = 1, .icon = NULL, .key = "j", .shift_key = "J", .value = HID_KEYBOARD_J},
+        {.width = 1, .icon = NULL, .key = "k", .shift_key = "K", .value = HID_KEYBOARD_K},
+        {.width = 1, .icon = NULL, .key = "l", .shift_key = "L", .value = HID_KEYBOARD_L},
+        {.width = 1, .icon = NULL, .key = ";", .shift_key = ":", .value = HID_KEYBOARD_SEMICOLON},
+        {.width = 2, .icon = &I_Pin_arrow_right_9x7, .value = HID_KEYBOARD_RETURN},
+        {.width = 0, .value = HID_KEYBOARD_RETURN},
+    },
+    {
+        {.width = 1, .icon = NULL, .key = "z", .shift_key = "Z", .value = HID_KEYBOARD_Z},
+        {.width = 1, .icon = NULL, .key = "x", .shift_key = "X", .value = HID_KEYBOARD_X},
+        {.width = 1, .icon = NULL, .key = "c", .shift_key = "C", .value = HID_KEYBOARD_C},
+        {.width = 1, .icon = NULL, .key = "v", .shift_key = "V", .value = HID_KEYBOARD_V},
+        {.width = 1, .icon = NULL, .key = "b", .shift_key = "B", .value = HID_KEYBOARD_B},
+        {.width = 1, .icon = NULL, .key = "n", .shift_key = "N", .value = HID_KEYBOARD_N},
+        {.width = 1, .icon = NULL, .key = "m", .shift_key = "M", .value = HID_KEYBOARD_M},
+        {.width = 1, .icon = NULL, .key = "/", .shift_key = "?", .value = HID_KEYBOARD_SLASH},
+        {.width = 1, .icon = NULL, .key = "\\", .shift_key = "|", .value = HID_KEYBOARD_BACKSLASH},
+        {.width = 1, .icon = NULL, .key = "`", .shift_key = "~", .value = HID_KEYBOARD_GRAVE_ACCENT},
+        {.width = 1, .icon = &I_ButtonUp_7x4, .value = HID_KEYBOARD_UP_ARROW},
+        {.width = 1, .icon = NULL, .key = "-", .shift_key = "_", .value = HID_KEYBOARD_MINUS},
+    },
+    {
+        {.width = 1, .icon = &I_Pin_arrow_up_7x9, .value = HID_KEYBOARD_L_SHIFT},
+        {.width = 1, .icon = NULL, .key = ",", .shift_key = "<", .value = HID_KEYBOARD_COMMA},
+        {.width = 1, .icon = NULL, .key = ".", .shift_key = ">", .value = HID_KEYBOARD_DOT},
+        {.width = 4, .icon = NULL, .key = " ", .value = HID_KEYBOARD_SPACEBAR},
+        {.width = 0, .value = HID_KEYBOARD_SPACEBAR},
+        {.width = 0, .value = HID_KEYBOARD_SPACEBAR},
+        {.width = 0, .value = HID_KEYBOARD_SPACEBAR},
+        {.width = 1, .icon = NULL, .key = "'", .shift_key = "\"", .value = HID_KEYBOARD_APOSTROPHE},
+        {.width = 1, .icon = NULL, .key = "=", .shift_key = "+", .value = HID_KEYBOARD_EQUAL_SIGN},
+        {.width = 1, .icon = &I_ButtonLeft_4x7, .value = HID_KEYBOARD_LEFT_ARROW},
+        {.width = 1, .icon = &I_ButtonDown_7x4, .value = HID_KEYBOARD_DOWN_ARROW},
+        {.width = 1, .icon = &I_ButtonRight_4x7, .value = HID_KEYBOARD_RIGHT_ARROW},
+    },
+    {
+        {.width = 2, .icon = &I_Ctrl_15x7, .value = HID_KEYBOARD_L_CTRL},
+        {.width = 0, .value = HID_KEYBOARD_L_CTRL},
+        {.width = 2, .icon = &I_Alt_11x7, .value = HID_KEYBOARD_L_ALT},
+        {.width = 0, .value = HID_KEYBOARD_L_ALT},
+        {.width = 2, .icon = &I_Cmd_15x7, .value = HID_KEYBOARD_L_GUI},
+        {.width = 0, .value = HID_KEYBOARD_L_GUI},
+        {.width = 2, .icon = &I_Tab_15x7, .value = HID_KEYBOARD_TAB},
+        {.width = 0, .value = HID_KEYBOARD_TAB},
+        {.width = 2, .icon = &I_Esc_14x7, .value = HID_KEYBOARD_ESCAPE},
+        {.width = 0, .value = HID_KEYBOARD_ESCAPE},
+        {.width = 2, .icon = &I_Del_12x7, .value = HID_KEYBOARD_DELETE_FORWARD},
+        {.width = 0, .value = HID_KEYBOARD_DELETE_FORWARD},
+    },
+};
+
+static void hid_keyboard_to_upper(char* str) {
+    while(*str) {
+        *str = toupper((unsigned char)*str);
+        str++;
+    }
+}
+
+static void hid_keyboard_draw_key(
+    Canvas* canvas,
+    HidKeyboardModel* model,
+    uint8_t x,
+    uint8_t y,
+    HidKeyboardKey key,
+    bool selected) {
+    if(!key.width) return;
+
+    canvas_set_color(canvas, ColorBlack);
+    uint8_t keyWidth = KEY_WIDTH * key.width + KEY_PADDING * (key.width - 1);
+    if(selected) {
+        // Draw a filled box
+        elements_slightly_rounded_box(
+            canvas,
+            MARGIN_LEFT + x * (KEY_WIDTH + KEY_PADDING),
+            MARGIN_TOP + y * (KEY_HEIGHT + KEY_PADDING),
+            keyWidth,
+            KEY_HEIGHT);
+        canvas_set_color(canvas, ColorWhite);
+    } else {
+        // Draw a framed box
+        elements_slightly_rounded_frame(
+            canvas,
+            MARGIN_LEFT + x * (KEY_WIDTH + KEY_PADDING),
+            MARGIN_TOP + y * (KEY_HEIGHT + KEY_PADDING),
+            keyWidth,
+            KEY_HEIGHT);
+    }
+    if(key.icon != NULL) {
+        // Draw the icon centered on the button
+        canvas_draw_icon(
+            canvas,
+            MARGIN_LEFT + x * (KEY_WIDTH + KEY_PADDING) + keyWidth / 2 - key.icon->width / 2,
+            MARGIN_TOP + y * (KEY_HEIGHT + KEY_PADDING) + KEY_HEIGHT / 2 - key.icon->height / 2,
+            key.icon);
+    } else {
+        // If shift is toggled use the shift key when available
+        strcpy(model->key_string, (model->shift && key.shift_key != 0) ? key.shift_key : key.key);
+        // Upper case if ctrl or alt was toggled true
+        if((model->ctrl && key.value == HID_KEYBOARD_L_CTRL) ||
+           (model->alt && key.value == HID_KEYBOARD_L_ALT) ||
+           (model->gui && key.value == HID_KEYBOARD_L_GUI)) {
+            hid_keyboard_to_upper(model->key_string);
+        }
+        canvas_draw_str_aligned(
+            canvas,
+            MARGIN_LEFT + x * (KEY_WIDTH + KEY_PADDING) + keyWidth / 2 + 1,
+            MARGIN_TOP + y * (KEY_HEIGHT + KEY_PADDING) + KEY_HEIGHT / 2,
+            AlignCenter,
+            AlignCenter,
+            model->key_string);
+    }
+}
+
+static void hid_keyboard_draw_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidKeyboardModel* model = context;
+
+    // Header
+    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, "Keyboard");
+
+        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; // Dont render the keyboard if we are not yet connected
+    }
+
+    canvas_set_font(canvas, FontKeyboard);
+    // Start shifting the all keys up if on the next row (Scrolling)
+    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 HidKeyboardKey* keyboardKeyRow = hid_keyboard_keyset[y];
+        uint8_t x = 0;
+        for(uint8_t i = 0; i < COLUMN_COUNT; i++) {
+            HidKeyboardKey key = keyboardKeyRow[i];
+            // Select when the button is hovered
+            // Select if the button is hovered within its width
+            // Select if back is clicked and its the backspace key
+            // Deselect when the button clicked or not hovered
+            bool keySelected = (x <= model->x && model->x < (x + key.width)) && y == model->y;
+            bool backSelected = model->back_pressed && key.value == HID_KEYBOARD_DELETE;
+            hid_keyboard_draw_key(
+                canvas,
+                model,
+                x,
+                y - initY,
+                key,
+                (!model->ok_pressed && keySelected) || backSelected);
+            x += key.width;
+        }
+    }
+}
+
+static uint8_t hid_keyboard_get_selected_key(HidKeyboardModel* model) {
+    HidKeyboardKey key = hid_keyboard_keyset[model->y][model->x];
+    return key.value;
+}
+
+static void hid_keyboard_get_select_key(HidKeyboardModel* model, HidKeyboardPoint delta) {
+    // Keep going until a valid spot is found, this allows for nulls and zero width keys in the map
+    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_keyboard_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_keyboard_keyset[model->y][model->x].width ==
+                                0); // Skip zero width keys, pretend they are one key
+}
+
+static void hid_keyboard_process(HidKeyboard* hid_keyboard, InputEvent* event) {
+    with_view_model(
+        hid_keyboard->view,
+        HidKeyboardModel * 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_keyboard_get_selected_key(model);
+
+                    // Toggle the modifier key when clicked, and click the key
+                    if(model->last_key_code == HID_KEYBOARD_L_SHIFT) {
+                        model->shift = !model->shift;
+                        if(model->shift)
+                            model->modifier_code |= KEY_MOD_LEFT_SHIFT;
+                        else
+                            model->modifier_code &= ~KEY_MOD_LEFT_SHIFT;
+                    } else if(model->last_key_code == HID_KEYBOARD_L_ALT) {
+                        model->alt = !model->alt;
+                        if(model->alt)
+                            model->modifier_code |= KEY_MOD_LEFT_ALT;
+                        else
+                            model->modifier_code &= ~KEY_MOD_LEFT_ALT;
+                    } else if(model->last_key_code == HID_KEYBOARD_L_CTRL) {
+                        model->ctrl = !model->ctrl;
+                        if(model->ctrl)
+                            model->modifier_code |= KEY_MOD_LEFT_CTRL;
+                        else
+                            model->modifier_code &= ~KEY_MOD_LEFT_CTRL;
+                    } else if(model->last_key_code == HID_KEYBOARD_L_GUI) {
+                        model->gui = !model->gui;
+                        if(model->gui)
+                            model->modifier_code |= KEY_MOD_LEFT_GUI;
+                        else
+                            model->modifier_code &= ~KEY_MOD_LEFT_GUI;
+                    }
+                    hid_hal_keyboard_press(
+                        hid_keyboard->hid, model->modifier_code | model->last_key_code);
+                } else if(event->type == InputTypeRelease) {
+                    // Release happens after short and long presses
+                    hid_hal_keyboard_release(
+                        hid_keyboard->hid, model->modifier_code | model->last_key_code);
+                    model->ok_pressed = false;
+                }
+            } else if(event->key == InputKeyBack) {
+                // If back is pressed for a short time, backspace
+                if(event->type == InputTypePress) {
+                    model->back_pressed = true;
+                } else if(event->type == InputTypeShort) {
+                    hid_hal_keyboard_press(hid_keyboard->hid, HID_KEYBOARD_DELETE);
+                    hid_hal_keyboard_release(hid_keyboard->hid, HID_KEYBOARD_DELETE);
+                } else if(event->type == InputTypeRelease) {
+                    model->back_pressed = false;
+                }
+            } else if(event->type == InputTypePress || event->type == InputTypeRepeat) {
+                // Cycle the selected keys
+                if(event->key == InputKeyUp) {
+                    hid_keyboard_get_select_key(model, (HidKeyboardPoint){.x = 0, .y = -1});
+                } else if(event->key == InputKeyDown) {
+                    hid_keyboard_get_select_key(model, (HidKeyboardPoint){.x = 0, .y = 1});
+                } else if(event->key == InputKeyLeft) {
+                    hid_keyboard_get_select_key(model, (HidKeyboardPoint){.x = -1, .y = 0});
+                } else if(event->key == InputKeyRight) {
+                    hid_keyboard_get_select_key(model, (HidKeyboardPoint){.x = 1, .y = 0});
+                }
+            }
+        },
+        true);
+}
+
+static bool hid_keyboard_input_callback(InputEvent* event, void* context) {
+    furi_assert(context);
+    HidKeyboard* hid_keyboard = context;
+    bool consumed = false;
+
+    if(event->type == InputTypeLong && event->key == InputKeyBack) {
+        hid_hal_keyboard_release_all(hid_keyboard->hid);
+    } else {
+        hid_keyboard_process(hid_keyboard, event);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+HidKeyboard* hid_keyboard_alloc(Hid* bt_hid) {
+    HidKeyboard* hid_keyboard = malloc(sizeof(HidKeyboard));
+    hid_keyboard->view = view_alloc();
+    hid_keyboard->hid = bt_hid;
+    view_set_context(hid_keyboard->view, hid_keyboard);
+    view_allocate_model(hid_keyboard->view, ViewModelTypeLocking, sizeof(HidKeyboardModel));
+    view_set_draw_callback(hid_keyboard->view, hid_keyboard_draw_callback);
+    view_set_input_callback(hid_keyboard->view, hid_keyboard_input_callback);
+
+    with_view_model(
+        hid_keyboard->view,
+        HidKeyboardModel * model,
+        {
+            model->transport = bt_hid->transport;
+            model->y = 1;
+        },
+        true);
+
+    return hid_keyboard;
+}
+
+void hid_keyboard_free(HidKeyboard* hid_keyboard) {
+    furi_assert(hid_keyboard);
+    view_free(hid_keyboard->view);
+    free(hid_keyboard);
+}
+
+View* hid_keyboard_get_view(HidKeyboard* hid_keyboard) {
+    furi_assert(hid_keyboard);
+    return hid_keyboard->view;
+}
+
+void hid_keyboard_set_connected_status(HidKeyboard* hid_keyboard, bool connected) {
+    furi_assert(hid_keyboard);
+    with_view_model(
+        hid_keyboard->view, HidKeyboardModel * model, { model->connected = connected; }, true);
+}

applications/system/hid_app/views/hid_keyboard.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <gui/view.h>
+
+typedef struct Hid Hid;
+typedef struct HidKeyboard HidKeyboard;
+
+HidKeyboard* hid_keyboard_alloc(Hid* bt_hid);
+
+void hid_keyboard_free(HidKeyboard* hid_keyboard);
+
+View* hid_keyboard_get_view(HidKeyboard* hid_keyboard);
+
+void hid_keyboard_set_connected_status(HidKeyboard* hid_keyboard, bool connected);

applications/system/hid_app/views/hid_keynote.c

@@ -0,0 +1,312 @@
+#include "hid_keynote.h"
+#include <gui/elements.h>
+#include "../hid.h"
+
+#include "hid_icons.h"
+
+#define TAG "HidKeynote"
+
+struct HidKeynote {
+    View* view;
+    Hid* hid;
+};
+
+typedef struct {
+    bool left_pressed;
+    bool up_pressed;
+    bool right_pressed;
+    bool down_pressed;
+    bool ok_pressed;
+    bool back_pressed;
+    bool connected;
+    HidTransport transport;
+} HidKeynoteModel;
+
+static void hid_keynote_draw_arrow(Canvas* canvas, uint8_t x, uint8_t y, CanvasDirection dir) {
+    canvas_draw_triangle(canvas, x, y, 5, 3, dir);
+    if(dir == CanvasDirectionBottomToTop) {
+        canvas_draw_line(canvas, x, y + 6, x, y - 1);
+    } else if(dir == CanvasDirectionTopToBottom) {
+        canvas_draw_line(canvas, x, y - 6, x, y + 1);
+    } else if(dir == CanvasDirectionRightToLeft) {
+        canvas_draw_line(canvas, x + 6, y, x - 1, y);
+    } else if(dir == CanvasDirectionLeftToRight) {
+        canvas_draw_line(canvas, x - 6, y, x + 1, y);
+    }
+}
+
+static void hid_keynote_draw_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidKeynoteModel* model = context;
+
+    // Header
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
+    }
+
+    canvas_set_font(canvas, FontPrimary);
+    elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Keynote");
+
+    canvas_draw_icon(canvas, 68, 2, &I_Pin_back_arrow_10x8);
+    canvas_set_font(canvas, FontSecondary);
+    elements_multiline_text_aligned(canvas, 127, 3, AlignRight, AlignTop, "Hold to exit");
+
+    // Up
+    canvas_draw_icon(canvas, 21, 24, &I_Button_18x18);
+    if(model->up_pressed) {
+        elements_slightly_rounded_box(canvas, 24, 26, 13, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    hid_keynote_draw_arrow(canvas, 30, 30, CanvasDirectionBottomToTop);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Down
+    canvas_draw_icon(canvas, 21, 45, &I_Button_18x18);
+    if(model->down_pressed) {
+        elements_slightly_rounded_box(canvas, 24, 47, 13, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    hid_keynote_draw_arrow(canvas, 30, 55, CanvasDirectionTopToBottom);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Left
+    canvas_draw_icon(canvas, 0, 45, &I_Button_18x18);
+    if(model->left_pressed) {
+        elements_slightly_rounded_box(canvas, 3, 47, 13, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    hid_keynote_draw_arrow(canvas, 7, 53, CanvasDirectionRightToLeft);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Right
+    canvas_draw_icon(canvas, 42, 45, &I_Button_18x18);
+    if(model->right_pressed) {
+        elements_slightly_rounded_box(canvas, 45, 47, 13, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    hid_keynote_draw_arrow(canvas, 53, 53, CanvasDirectionLeftToRight);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Ok
+    canvas_draw_icon(canvas, 63, 25, &I_Space_65x18);
+    if(model->ok_pressed) {
+        elements_slightly_rounded_box(canvas, 66, 27, 60, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 74, 29, &I_Ok_btn_9x9);
+    elements_multiline_text_aligned(canvas, 91, 36, AlignLeft, AlignBottom, "Space");
+    canvas_set_color(canvas, ColorBlack);
+
+    // Back
+    canvas_draw_icon(canvas, 63, 45, &I_Space_65x18);
+    if(model->back_pressed) {
+        elements_slightly_rounded_box(canvas, 66, 47, 60, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 74, 49, &I_Pin_back_arrow_10x8);
+    elements_multiline_text_aligned(canvas, 91, 57, AlignLeft, AlignBottom, "Back");
+}
+
+static void hid_keynote_draw_vertical_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidKeynoteModel* model = context;
+
+    // Header
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
+        canvas_set_font(canvas, FontPrimary);
+        elements_multiline_text_aligned(canvas, 20, 3, AlignLeft, AlignTop, "Keynote");
+    } else {
+        canvas_set_font(canvas, FontPrimary);
+        elements_multiline_text_aligned(canvas, 12, 3, AlignLeft, AlignTop, "Keynote");
+    }
+
+    canvas_draw_icon(canvas, 2, 18, &I_Pin_back_arrow_10x8);
+    canvas_set_font(canvas, FontSecondary);
+    elements_multiline_text_aligned(canvas, 15, 19, AlignLeft, AlignTop, "Hold to exit");
+
+    const uint8_t x_2 = 23;
+    const uint8_t x_1 = 2;
+    const uint8_t x_3 = 44;
+
+    const uint8_t y_1 = 44;
+    const uint8_t y_2 = 65;
+
+    // Up
+    canvas_draw_icon(canvas, x_2, y_1, &I_Button_18x18);
+    if(model->up_pressed) {
+        elements_slightly_rounded_box(canvas, x_2 + 3, y_1 + 2, 13, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    hid_keynote_draw_arrow(canvas, x_2 + 9, y_1 + 6, CanvasDirectionBottomToTop);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Down
+    canvas_draw_icon(canvas, x_2, y_2, &I_Button_18x18);
+    if(model->down_pressed) {
+        elements_slightly_rounded_box(canvas, x_2 + 3, y_2 + 2, 13, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    hid_keynote_draw_arrow(canvas, x_2 + 9, y_2 + 10, CanvasDirectionTopToBottom);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Left
+    canvas_draw_icon(canvas, x_1, y_2, &I_Button_18x18);
+    if(model->left_pressed) {
+        elements_slightly_rounded_box(canvas, x_1 + 3, y_2 + 2, 13, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    hid_keynote_draw_arrow(canvas, x_1 + 7, y_2 + 8, CanvasDirectionRightToLeft);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Right
+    canvas_draw_icon(canvas, x_3, y_2, &I_Button_18x18);
+    if(model->right_pressed) {
+        elements_slightly_rounded_box(canvas, x_3 + 3, y_2 + 2, 13, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    hid_keynote_draw_arrow(canvas, x_3 + 11, y_2 + 8, CanvasDirectionLeftToRight);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Ok
+    canvas_draw_icon(canvas, 2, 86, &I_Space_60x18);
+    if(model->ok_pressed) {
+        elements_slightly_rounded_box(canvas, 5, 88, 55, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 11, 90, &I_Ok_btn_9x9);
+    elements_multiline_text_aligned(canvas, 26, 98, AlignLeft, AlignBottom, "Space");
+    canvas_set_color(canvas, ColorBlack);
+
+    // Back
+    canvas_draw_icon(canvas, 2, 107, &I_Space_60x18);
+    if(model->back_pressed) {
+        elements_slightly_rounded_box(canvas, 5, 109, 55, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 11, 111, &I_Pin_back_arrow_10x8);
+    elements_multiline_text_aligned(canvas, 26, 119, AlignLeft, AlignBottom, "Back");
+}
+
+static void hid_keynote_process(HidKeynote* hid_keynote, InputEvent* event) {
+    with_view_model(
+        hid_keynote->view,
+        HidKeynoteModel * model,
+        {
+            if(event->type == InputTypePress) {
+                if(event->key == InputKeyUp) {
+                    model->up_pressed = true;
+                    hid_hal_keyboard_press(hid_keynote->hid, HID_KEYBOARD_UP_ARROW);
+                } else if(event->key == InputKeyDown) {
+                    model->down_pressed = true;
+                    hid_hal_keyboard_press(hid_keynote->hid, HID_KEYBOARD_DOWN_ARROW);
+                } else if(event->key == InputKeyLeft) {
+                    model->left_pressed = true;
+                    hid_hal_keyboard_press(hid_keynote->hid, HID_KEYBOARD_LEFT_ARROW);
+                } else if(event->key == InputKeyRight) {
+                    model->right_pressed = true;
+                    hid_hal_keyboard_press(hid_keynote->hid, HID_KEYBOARD_RIGHT_ARROW);
+                } else if(event->key == InputKeyOk) {
+                    model->ok_pressed = true;
+                    hid_hal_keyboard_press(hid_keynote->hid, HID_KEYBOARD_SPACEBAR);
+                } else if(event->key == InputKeyBack) {
+                    model->back_pressed = true;
+                }
+            } else if(event->type == InputTypeRelease) {
+                if(event->key == InputKeyUp) {
+                    model->up_pressed = false;
+                    hid_hal_keyboard_release(hid_keynote->hid, HID_KEYBOARD_UP_ARROW);
+                } else if(event->key == InputKeyDown) {
+                    model->down_pressed = false;
+                    hid_hal_keyboard_release(hid_keynote->hid, HID_KEYBOARD_DOWN_ARROW);
+                } else if(event->key == InputKeyLeft) {
+                    model->left_pressed = false;
+                    hid_hal_keyboard_release(hid_keynote->hid, HID_KEYBOARD_LEFT_ARROW);
+                } else if(event->key == InputKeyRight) {
+                    model->right_pressed = false;
+                    hid_hal_keyboard_release(hid_keynote->hid, HID_KEYBOARD_RIGHT_ARROW);
+                } else if(event->key == InputKeyOk) {
+                    model->ok_pressed = false;
+                    hid_hal_keyboard_release(hid_keynote->hid, HID_KEYBOARD_SPACEBAR);
+                } else if(event->key == InputKeyBack) {
+                    model->back_pressed = false;
+                }
+            } else if(event->type == InputTypeShort) {
+                if(event->key == InputKeyBack) {
+                    hid_hal_keyboard_press(hid_keynote->hid, HID_KEYBOARD_DELETE);
+                    hid_hal_keyboard_release(hid_keynote->hid, HID_KEYBOARD_DELETE);
+                    hid_hal_consumer_key_press(hid_keynote->hid, HID_CONSUMER_AC_BACK);
+                    hid_hal_consumer_key_release(hid_keynote->hid, HID_CONSUMER_AC_BACK);
+                }
+            }
+        },
+        true);
+}
+
+static bool hid_keynote_input_callback(InputEvent* event, void* context) {
+    furi_assert(context);
+    HidKeynote* hid_keynote = context;
+    bool consumed = false;
+
+    if(event->type == InputTypeLong && event->key == InputKeyBack) {
+        hid_hal_keyboard_release_all(hid_keynote->hid);
+    } else {
+        hid_keynote_process(hid_keynote, event);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+HidKeynote* hid_keynote_alloc(Hid* hid) {
+    HidKeynote* hid_keynote = malloc(sizeof(HidKeynote));
+    hid_keynote->view = view_alloc();
+    hid_keynote->hid = hid;
+    view_set_context(hid_keynote->view, hid_keynote);
+    view_allocate_model(hid_keynote->view, ViewModelTypeLocking, sizeof(HidKeynoteModel));
+    view_set_draw_callback(hid_keynote->view, hid_keynote_draw_callback);
+    view_set_input_callback(hid_keynote->view, hid_keynote_input_callback);
+
+    with_view_model(
+        hid_keynote->view, HidKeynoteModel * model, { model->transport = hid->transport; }, true);
+
+    return hid_keynote;
+}
+
+void hid_keynote_free(HidKeynote* hid_keynote) {
+    furi_assert(hid_keynote);
+    view_free(hid_keynote->view);
+    free(hid_keynote);
+}
+
+View* hid_keynote_get_view(HidKeynote* hid_keynote) {
+    furi_assert(hid_keynote);
+    return hid_keynote->view;
+}
+
+void hid_keynote_set_connected_status(HidKeynote* hid_keynote, bool connected) {
+    furi_assert(hid_keynote);
+    with_view_model(
+        hid_keynote->view, HidKeynoteModel * model, { model->connected = connected; }, true);
+}
+
+void hid_keynote_set_orientation(HidKeynote* hid_keynote, bool vertical) {
+    furi_assert(hid_keynote);
+
+    if(vertical) {
+        view_set_draw_callback(hid_keynote->view, hid_keynote_draw_vertical_callback);
+        view_set_orientation(hid_keynote->view, ViewOrientationVerticalFlip);
+
+    } else {
+        view_set_draw_callback(hid_keynote->view, hid_keynote_draw_callback);
+        view_set_orientation(hid_keynote->view, ViewOrientationHorizontal);
+    }
+}

applications/system/hid_app/views/hid_keynote.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <gui/view.h>
+
+typedef struct Hid Hid;
+typedef struct HidKeynote HidKeynote;
+
+HidKeynote* hid_keynote_alloc(Hid* bt_hid);
+
+void hid_keynote_free(HidKeynote* hid_keynote);
+
+View* hid_keynote_get_view(HidKeynote* hid_keynote);
+
+void hid_keynote_set_connected_status(HidKeynote* hid_keynote, bool connected);
+
+void hid_keynote_set_orientation(HidKeynote* hid_keynote, bool vertical);

applications/system/hid_app/views/hid_media.c

@@ -0,0 +1,218 @@
+#include "hid_media.h"
+#include <furi.h>
+#include <furi_hal_bt_hid.h>
+#include <furi_hal_usb_hid.h>
+#include <gui/elements.h>
+#include "../hid.h"
+
+#include "hid_icons.h"
+
+#define TAG "HidMedia"
+
+struct HidMedia {
+    View* view;
+    Hid* hid;
+};
+
+typedef struct {
+    bool left_pressed;
+    bool up_pressed;
+    bool right_pressed;
+    bool down_pressed;
+    bool ok_pressed;
+    bool connected;
+    HidTransport transport;
+} HidMediaModel;
+
+static void hid_media_draw_arrow(Canvas* canvas, uint8_t x, uint8_t y, CanvasDirection dir) {
+    canvas_draw_triangle(canvas, x, y, 5, 3, dir);
+    if(dir == CanvasDirectionBottomToTop) {
+        canvas_draw_dot(canvas, x, y - 1);
+    } else if(dir == CanvasDirectionTopToBottom) {
+        canvas_draw_dot(canvas, x, y + 1);
+    } else if(dir == CanvasDirectionRightToLeft) {
+        canvas_draw_dot(canvas, x - 1, y);
+    } else if(dir == CanvasDirectionLeftToRight) {
+        canvas_draw_dot(canvas, x + 1, y);
+    }
+}
+
+static void hid_media_draw_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidMediaModel* model = context;
+
+    // Header
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
+    }
+
+    canvas_set_font(canvas, FontPrimary);
+    elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Media");
+    canvas_set_font(canvas, FontSecondary);
+
+    // Keypad circles
+    canvas_draw_icon(canvas, 76, 8, &I_Circles_47x47);
+
+    // Up
+    if(model->up_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 93, 9, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 96, 12, &I_Volup_8x6);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Down
+    if(model->down_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 93, 41, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 96, 45, &I_Voldwn_6x6);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Left
+    if(model->left_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 77, 25, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    hid_media_draw_arrow(canvas, 82, 31, CanvasDirectionRightToLeft);
+    hid_media_draw_arrow(canvas, 86, 31, CanvasDirectionRightToLeft);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Right
+    if(model->right_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 109, 25, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    hid_media_draw_arrow(canvas, 112, 31, CanvasDirectionLeftToRight);
+    hid_media_draw_arrow(canvas, 116, 31, CanvasDirectionLeftToRight);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Ok
+    if(model->ok_pressed) {
+        canvas_draw_icon(canvas, 93, 25, &I_Pressed_Button_13x13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    hid_media_draw_arrow(canvas, 96, 31, CanvasDirectionLeftToRight);
+    canvas_draw_line(canvas, 100, 29, 100, 33);
+    canvas_draw_line(canvas, 102, 29, 102, 33);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Exit
+    canvas_draw_icon(canvas, 0, 54, &I_Pin_back_arrow_10x8);
+    canvas_set_font(canvas, FontSecondary);
+    elements_multiline_text_aligned(canvas, 13, 62, AlignLeft, AlignBottom, "Hold to exit");
+}
+
+static void hid_media_process_press(HidMedia* hid_media, InputEvent* event) {
+    with_view_model(
+        hid_media->view,
+        HidMediaModel * model,
+        {
+            if(event->key == InputKeyUp) {
+                model->up_pressed = true;
+                hid_hal_consumer_key_press(hid_media->hid, HID_CONSUMER_VOLUME_INCREMENT);
+            } else if(event->key == InputKeyDown) {
+                model->down_pressed = true;
+                hid_hal_consumer_key_press(hid_media->hid, HID_CONSUMER_VOLUME_DECREMENT);
+            } else if(event->key == InputKeyLeft) {
+                model->left_pressed = true;
+                hid_hal_consumer_key_press(hid_media->hid, HID_CONSUMER_SCAN_PREVIOUS_TRACK);
+            } else if(event->key == InputKeyRight) {
+                model->right_pressed = true;
+                hid_hal_consumer_key_press(hid_media->hid, HID_CONSUMER_SCAN_NEXT_TRACK);
+            } else if(event->key == InputKeyOk) {
+                model->ok_pressed = true;
+                hid_hal_consumer_key_press(hid_media->hid, HID_CONSUMER_PLAY_PAUSE);
+            }
+        },
+        true);
+}
+
+static void hid_media_process_release(HidMedia* hid_media, InputEvent* event) {
+    with_view_model(
+        hid_media->view,
+        HidMediaModel * model,
+        {
+            if(event->key == InputKeyUp) {
+                model->up_pressed = false;
+                hid_hal_consumer_key_release(hid_media->hid, HID_CONSUMER_VOLUME_INCREMENT);
+            } else if(event->key == InputKeyDown) {
+                model->down_pressed = false;
+                hid_hal_consumer_key_release(hid_media->hid, HID_CONSUMER_VOLUME_DECREMENT);
+            } else if(event->key == InputKeyLeft) {
+                model->left_pressed = false;
+                hid_hal_consumer_key_release(hid_media->hid, HID_CONSUMER_SCAN_PREVIOUS_TRACK);
+            } else if(event->key == InputKeyRight) {
+                model->right_pressed = false;
+                hid_hal_consumer_key_release(hid_media->hid, HID_CONSUMER_SCAN_NEXT_TRACK);
+            } else if(event->key == InputKeyOk) {
+                model->ok_pressed = false;
+                hid_hal_consumer_key_release(hid_media->hid, HID_CONSUMER_PLAY_PAUSE);
+            }
+        },
+        true);
+}
+
+static bool hid_media_input_callback(InputEvent* event, void* context) {
+    furi_assert(context);
+    HidMedia* hid_media = context;
+    bool consumed = false;
+
+    if(event->type == InputTypePress) {
+        hid_media_process_press(hid_media, event);
+        consumed = true;
+    } else if(event->type == InputTypeRelease) {
+        hid_media_process_release(hid_media, event);
+        consumed = true;
+    } else if(event->type == InputTypeShort) {
+        if(event->key == InputKeyBack) {
+            hid_hal_consumer_key_release_all(hid_media->hid);
+        }
+    }
+
+    return consumed;
+}
+
+HidMedia* hid_media_alloc(Hid* hid) {
+    HidMedia* hid_media = malloc(sizeof(HidMedia));
+    hid_media->view = view_alloc();
+    hid_media->hid = hid;
+    view_set_context(hid_media->view, hid_media);
+    view_allocate_model(hid_media->view, ViewModelTypeLocking, sizeof(HidMediaModel));
+    view_set_draw_callback(hid_media->view, hid_media_draw_callback);
+    view_set_input_callback(hid_media->view, hid_media_input_callback);
+
+    with_view_model(
+        hid_media->view, HidMediaModel * model, { model->transport = hid->transport; }, true);
+
+    return hid_media;
+}
+
+void hid_media_free(HidMedia* hid_media) {
+    furi_assert(hid_media);
+    view_free(hid_media->view);
+    free(hid_media);
+}
+
+View* hid_media_get_view(HidMedia* hid_media) {
+    furi_assert(hid_media);
+    return hid_media->view;
+}
+
+void hid_media_set_connected_status(HidMedia* hid_media, bool connected) {
+    furi_assert(hid_media);
+    with_view_model(
+        hid_media->view, HidMediaModel * model, { model->connected = connected; }, true);
+}

applications/system/hid_app/views/hid_media.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <gui/view.h>
+
+typedef struct HidMedia HidMedia;
+
+HidMedia* hid_media_alloc();
+
+void hid_media_free(HidMedia* hid_media);
+
+View* hid_media_get_view(HidMedia* hid_media);
+
+void hid_media_set_connected_status(HidMedia* hid_media, bool connected);

applications/system/hid_app/views/hid_mouse.c

@@ -0,0 +1,226 @@
+#include "hid_mouse.h"
+#include <gui/elements.h>
+#include "../hid.h"
+
+#include "hid_icons.h"
+
+#define TAG "HidMouse"
+
+struct HidMouse {
+    View* view;
+    Hid* hid;
+};
+
+typedef struct {
+    bool left_pressed;
+    bool up_pressed;
+    bool right_pressed;
+    bool down_pressed;
+    bool left_mouse_pressed;
+    bool left_mouse_held;
+    bool right_mouse_pressed;
+    bool connected;
+    HidTransport transport;
+} HidMouseModel;
+
+static void hid_mouse_draw_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidMouseModel* model = context;
+
+    // Header
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
+    }
+
+    canvas_set_font(canvas, FontPrimary);
+    elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Mouse");
+    canvas_set_font(canvas, FontSecondary);
+
+    if(model->left_mouse_held == true) {
+        elements_multiline_text_aligned(canvas, 0, 62, AlignLeft, AlignBottom, "Selecting...");
+    } else {
+        canvas_draw_icon(canvas, 0, 54, &I_Pin_back_arrow_10x8);
+        canvas_set_font(canvas, FontSecondary);
+        elements_multiline_text_aligned(canvas, 13, 62, AlignLeft, AlignBottom, "Hold to exit");
+    }
+
+    // Keypad circles
+    canvas_draw_icon(canvas, 64, 8, &I_Circles_47x47);
+
+    // Up
+    if(model->up_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 81, 9, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 84, 10, &I_Pin_arrow_up_7x9);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Down
+    if(model->down_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 81, 41, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 84, 43, &I_Pin_arrow_down_7x9);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Left
+    if(model->left_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 65, 25, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 67, 28, &I_Pin_arrow_left_9x7);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Right
+    if(model->right_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 97, 25, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 99, 28, &I_Pin_arrow_right_9x7);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Ok
+    if(model->left_mouse_pressed) {
+        canvas_draw_icon(canvas, 81, 25, &I_Ok_btn_pressed_13x13);
+    } else {
+        canvas_draw_icon(canvas, 83, 27, &I_Left_mouse_icon_9x9);
+    }
+
+    // Back
+    if(model->right_mouse_pressed) {
+        canvas_draw_icon(canvas, 108, 48, &I_Ok_btn_pressed_13x13);
+    } else {
+        canvas_draw_icon(canvas, 110, 50, &I_Right_mouse_icon_9x9);
+    }
+}
+
+static void hid_mouse_process(HidMouse* hid_mouse, InputEvent* event) {
+    with_view_model(
+        hid_mouse->view,
+        HidMouseModel * model,
+        {
+            if(event->key == InputKeyBack) {
+                if(event->type == InputTypeShort) {
+                    hid_hal_mouse_press(hid_mouse->hid, HID_MOUSE_BTN_RIGHT);
+                    hid_hal_mouse_release(hid_mouse->hid, HID_MOUSE_BTN_RIGHT);
+                } else if(event->type == InputTypePress) {
+                    model->right_mouse_pressed = true;
+                } else if(event->type == InputTypeRelease) {
+                    model->right_mouse_pressed = false;
+                }
+            } else if(event->key == InputKeyOk) {
+                if(event->type == InputTypeShort) {
+                    // Just release if it was being held before
+                    if(!model->left_mouse_held)
+                        hid_hal_mouse_press(hid_mouse->hid, HID_MOUSE_BTN_LEFT);
+                    hid_hal_mouse_release(hid_mouse->hid, HID_MOUSE_BTN_LEFT);
+                    model->left_mouse_held = false;
+                } else if(event->type == InputTypeLong) {
+                    hid_hal_mouse_press(hid_mouse->hid, HID_MOUSE_BTN_LEFT);
+                    model->left_mouse_held = true;
+                    model->left_mouse_pressed = true;
+                } else if(event->type == InputTypePress) {
+                    model->left_mouse_pressed = true;
+                } else if(event->type == InputTypeRelease) {
+                    // Only release if it wasn't a long press
+                    if(!model->left_mouse_held) model->left_mouse_pressed = false;
+                }
+            } else if(event->key == InputKeyRight) {
+                if(event->type == InputTypePress) {
+                    model->right_pressed = true;
+                    hid_hal_mouse_move(hid_mouse->hid, MOUSE_MOVE_SHORT, 0);
+                } else if(event->type == InputTypeRepeat) {
+                    hid_hal_mouse_move(hid_mouse->hid, MOUSE_MOVE_LONG, 0);
+                } else if(event->type == InputTypeRelease) {
+                    model->right_pressed = false;
+                }
+            } else if(event->key == InputKeyLeft) {
+                if(event->type == InputTypePress) {
+                    model->left_pressed = true;
+                    hid_hal_mouse_move(hid_mouse->hid, -MOUSE_MOVE_SHORT, 0);
+                } else if(event->type == InputTypeRepeat) {
+                    hid_hal_mouse_move(hid_mouse->hid, -MOUSE_MOVE_LONG, 0);
+                } else if(event->type == InputTypeRelease) {
+                    model->left_pressed = false;
+                }
+            } else if(event->key == InputKeyDown) {
+                if(event->type == InputTypePress) {
+                    model->down_pressed = true;
+                    hid_hal_mouse_move(hid_mouse->hid, 0, MOUSE_MOVE_SHORT);
+                } else if(event->type == InputTypeRepeat) {
+                    hid_hal_mouse_move(hid_mouse->hid, 0, MOUSE_MOVE_LONG);
+                } else if(event->type == InputTypeRelease) {
+                    model->down_pressed = false;
+                }
+            } else if(event->key == InputKeyUp) {
+                if(event->type == InputTypePress) {
+                    model->up_pressed = true;
+                    hid_hal_mouse_move(hid_mouse->hid, 0, -MOUSE_MOVE_SHORT);
+                } else if(event->type == InputTypeRepeat) {
+                    hid_hal_mouse_move(hid_mouse->hid, 0, -MOUSE_MOVE_LONG);
+                } else if(event->type == InputTypeRelease) {
+                    model->up_pressed = false;
+                }
+            }
+        },
+        true);
+}
+
+static bool hid_mouse_input_callback(InputEvent* event, void* context) {
+    furi_assert(context);
+    HidMouse* hid_mouse = context;
+    bool consumed = false;
+
+    if(event->type == InputTypeLong && event->key == InputKeyBack) {
+        hid_hal_mouse_release_all(hid_mouse->hid);
+    } else {
+        hid_mouse_process(hid_mouse, event);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+HidMouse* hid_mouse_alloc(Hid* hid) {
+    HidMouse* hid_mouse = malloc(sizeof(HidMouse));
+    hid_mouse->view = view_alloc();
+    hid_mouse->hid = hid;
+    view_set_context(hid_mouse->view, hid_mouse);
+    view_allocate_model(hid_mouse->view, ViewModelTypeLocking, sizeof(HidMouseModel));
+    view_set_draw_callback(hid_mouse->view, hid_mouse_draw_callback);
+    view_set_input_callback(hid_mouse->view, hid_mouse_input_callback);
+
+    with_view_model(
+        hid_mouse->view, HidMouseModel * model, { model->transport = hid->transport; }, true);
+
+    return hid_mouse;
+}
+
+void hid_mouse_free(HidMouse* hid_mouse) {
+    furi_assert(hid_mouse);
+    view_free(hid_mouse->view);
+    free(hid_mouse);
+}
+
+View* hid_mouse_get_view(HidMouse* hid_mouse) {
+    furi_assert(hid_mouse);
+    return hid_mouse->view;
+}
+
+void hid_mouse_set_connected_status(HidMouse* hid_mouse, bool connected) {
+    furi_assert(hid_mouse);
+    with_view_model(
+        hid_mouse->view, HidMouseModel * model, { model->connected = connected; }, true);
+}

applications/system/hid_app/views/hid_mouse.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <gui/view.h>
+
+#define MOUSE_MOVE_SHORT 5
+#define MOUSE_MOVE_LONG 20
+
+typedef struct Hid Hid;
+typedef struct HidMouse HidMouse;
+
+HidMouse* hid_mouse_alloc(Hid* bt_hid);
+
+void hid_mouse_free(HidMouse* hid_mouse);
+
+View* hid_mouse_get_view(HidMouse* hid_mouse);
+
+void hid_mouse_set_connected_status(HidMouse* hid_mouse, bool connected);

applications/system/hid_app/views/hid_mouse_clicker.c

@@ -0,0 +1,214 @@
+#include "hid_mouse_clicker.h"
+#include <gui/elements.h>
+#include "../hid.h"
+
+#include "hid_icons.h"
+
+#define TAG "HidMouseClicker"
+#define DEFAULT_CLICK_RATE 1
+#define MAXIMUM_CLICK_RATE 60
+
+struct HidMouseClicker {
+    View* view;
+    Hid* hid;
+    FuriTimer* timer;
+};
+
+typedef struct {
+    bool connected;
+    bool running;
+    int rate;
+    HidTransport transport;
+} HidMouseClickerModel;
+
+static void hid_mouse_clicker_start_or_restart_timer(void* context) {
+    furi_assert(context);
+    HidMouseClicker* hid_mouse_clicker = context;
+
+    if(furi_timer_is_running(hid_mouse_clicker->timer)) {
+        furi_timer_stop(hid_mouse_clicker->timer);
+    }
+
+    with_view_model(
+        hid_mouse_clicker->view,
+        HidMouseClickerModel * model,
+        {
+            furi_timer_start(
+                hid_mouse_clicker->timer, furi_kernel_get_tick_frequency() / model->rate);
+        },
+        true);
+}
+
+static void hid_mouse_clicker_draw_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidMouseClickerModel* model = context;
+
+    // Header
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
+    }
+
+    canvas_set_font(canvas, FontPrimary);
+    elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Mouse Clicker");
+
+    // Ok
+    canvas_draw_icon(canvas, 63, 25, &I_Space_65x18);
+    if(model->running) {
+        canvas_set_font(canvas, FontPrimary);
+
+        FuriString* rate_label = furi_string_alloc();
+        furi_string_printf(rate_label, "%d clicks/s\n\nUp / Down", model->rate);
+        elements_multiline_text(canvas, AlignLeft, 35, furi_string_get_cstr(rate_label));
+        canvas_set_font(canvas, FontSecondary);
+        furi_string_free(rate_label);
+
+        elements_slightly_rounded_box(canvas, 66, 27, 60, 13);
+        canvas_set_color(canvas, ColorWhite);
+    } else {
+        canvas_set_font(canvas, FontPrimary);
+        elements_multiline_text(canvas, AlignLeft, 35, "Press Start\nto start\nclicking");
+        canvas_set_font(canvas, FontSecondary);
+    }
+    canvas_draw_icon(canvas, 74, 29, &I_Ok_btn_9x9);
+    if(model->running) {
+        elements_multiline_text_aligned(canvas, 91, 36, AlignLeft, AlignBottom, "Stop");
+    } else {
+        elements_multiline_text_aligned(canvas, 91, 36, AlignLeft, AlignBottom, "Start");
+    }
+    canvas_set_color(canvas, ColorBlack);
+
+    // Back
+    canvas_draw_icon(canvas, 74, 49, &I_Pin_back_arrow_10x8);
+    elements_multiline_text_aligned(canvas, 91, 57, AlignLeft, AlignBottom, "Quit");
+}
+
+static void hid_mouse_clicker_timer_callback(void* context) {
+    furi_assert(context);
+    HidMouseClicker* hid_mouse_clicker = context;
+    with_view_model(
+        hid_mouse_clicker->view,
+        HidMouseClickerModel * model,
+        {
+            if(model->running) {
+                hid_hal_mouse_press(hid_mouse_clicker->hid, HID_MOUSE_BTN_LEFT);
+                hid_hal_mouse_release(hid_mouse_clicker->hid, HID_MOUSE_BTN_LEFT);
+            }
+        },
+        false);
+}
+
+static void hid_mouse_clicker_enter_callback(void* context) {
+    hid_mouse_clicker_start_or_restart_timer(context);
+}
+
+static void hid_mouse_clicker_exit_callback(void* context) {
+    furi_assert(context);
+    HidMouseClicker* hid_mouse_clicker = context;
+    furi_timer_stop(hid_mouse_clicker->timer);
+}
+
+static bool hid_mouse_clicker_input_callback(InputEvent* event, void* context) {
+    furi_assert(context);
+    HidMouseClicker* hid_mouse_clicker = context;
+
+    bool consumed = false;
+    bool rate_changed = false;
+
+    if(event->type != InputTypeShort && event->type != InputTypeRepeat) {
+        return false;
+    }
+
+    with_view_model(
+        hid_mouse_clicker->view,
+        HidMouseClickerModel * model,
+        {
+            switch(event->key) {
+            case InputKeyOk:
+                model->running = !model->running;
+                consumed = true;
+                break;
+            case InputKeyUp:
+                if(model->rate < MAXIMUM_CLICK_RATE) {
+                    model->rate++;
+                }
+                rate_changed = true;
+                consumed = true;
+                break;
+            case InputKeyDown:
+                if(model->rate > 1) {
+                    model->rate--;
+                }
+                rate_changed = true;
+                consumed = true;
+                break;
+            default:
+                consumed = true;
+                break;
+            }
+        },
+        true);
+
+    if(rate_changed) {
+        hid_mouse_clicker_start_or_restart_timer(context);
+    }
+
+    return consumed;
+}
+
+HidMouseClicker* hid_mouse_clicker_alloc(Hid* hid) {
+    HidMouseClicker* hid_mouse_clicker = malloc(sizeof(HidMouseClicker));
+
+    hid_mouse_clicker->view = view_alloc();
+    view_set_context(hid_mouse_clicker->view, hid_mouse_clicker);
+    view_allocate_model(
+        hid_mouse_clicker->view, ViewModelTypeLocking, sizeof(HidMouseClickerModel));
+    view_set_draw_callback(hid_mouse_clicker->view, hid_mouse_clicker_draw_callback);
+    view_set_input_callback(hid_mouse_clicker->view, hid_mouse_clicker_input_callback);
+    view_set_enter_callback(hid_mouse_clicker->view, hid_mouse_clicker_enter_callback);
+    view_set_exit_callback(hid_mouse_clicker->view, hid_mouse_clicker_exit_callback);
+
+    hid_mouse_clicker->hid = hid;
+
+    hid_mouse_clicker->timer = furi_timer_alloc(
+        hid_mouse_clicker_timer_callback, FuriTimerTypePeriodic, hid_mouse_clicker);
+
+    with_view_model(
+        hid_mouse_clicker->view,
+        HidMouseClickerModel * model,
+        {
+            model->transport = hid->transport;
+            model->rate = DEFAULT_CLICK_RATE;
+        },
+        true);
+
+    return hid_mouse_clicker;
+}
+
+void hid_mouse_clicker_free(HidMouseClicker* hid_mouse_clicker) {
+    furi_assert(hid_mouse_clicker);
+
+    furi_timer_stop(hid_mouse_clicker->timer);
+    furi_timer_free(hid_mouse_clicker->timer);
+
+    view_free(hid_mouse_clicker->view);
+
+    free(hid_mouse_clicker);
+}
+
+View* hid_mouse_clicker_get_view(HidMouseClicker* hid_mouse_clicker) {
+    furi_assert(hid_mouse_clicker);
+    return hid_mouse_clicker->view;
+}
+
+void hid_mouse_clicker_set_connected_status(HidMouseClicker* hid_mouse_clicker, bool connected) {
+    furi_assert(hid_mouse_clicker);
+    with_view_model(
+        hid_mouse_clicker->view,
+        HidMouseClickerModel * model,
+        { model->connected = connected; },
+        true);
+}

applications/system/hid_app/views/hid_mouse_clicker.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <gui/view.h>
+
+typedef struct Hid Hid;
+typedef struct HidMouseClicker HidMouseClicker;
+
+HidMouseClicker* hid_mouse_clicker_alloc(Hid* bt_hid);
+
+void hid_mouse_clicker_free(HidMouseClicker* hid_mouse_clicker);
+
+View* hid_mouse_clicker_get_view(HidMouseClicker* hid_mouse_clicker);
+
+void hid_mouse_clicker_set_connected_status(HidMouseClicker* hid_mouse_clicker, bool connected);

applications/system/hid_app/views/hid_mouse_jiggler.c

@@ -0,0 +1,159 @@
+#include "hid_mouse_jiggler.h"
+#include <gui/elements.h>
+#include "../hid.h"
+
+#include "hid_icons.h"
+
+#define TAG "HidMouseJiggler"
+
+struct HidMouseJiggler {
+    View* view;
+    Hid* hid;
+    FuriTimer* timer;
+};
+
+typedef struct {
+    bool connected;
+    bool running;
+    uint8_t counter;
+    HidTransport transport;
+} HidMouseJigglerModel;
+
+static void hid_mouse_jiggler_draw_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidMouseJigglerModel* model = context;
+
+    // Header
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
+    }
+
+    canvas_set_font(canvas, FontPrimary);
+    elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Mouse Jiggler");
+
+    canvas_set_font(canvas, FontPrimary);
+    elements_multiline_text(canvas, AlignLeft, 35, "Press Start\nto jiggle");
+    canvas_set_font(canvas, FontSecondary);
+
+    // Ok
+    canvas_draw_icon(canvas, 63, 25, &I_Space_65x18);
+    if(model->running) {
+        elements_slightly_rounded_box(canvas, 66, 27, 60, 13);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 74, 29, &I_Ok_btn_9x9);
+    if(model->running) {
+        elements_multiline_text_aligned(canvas, 91, 36, AlignLeft, AlignBottom, "Stop");
+    } else {
+        elements_multiline_text_aligned(canvas, 91, 36, AlignLeft, AlignBottom, "Start");
+    }
+    canvas_set_color(canvas, ColorBlack);
+
+    // Back
+    canvas_draw_icon(canvas, 74, 49, &I_Pin_back_arrow_10x8);
+    elements_multiline_text_aligned(canvas, 91, 57, AlignLeft, AlignBottom, "Quit");
+}
+
+static void hid_mouse_jiggler_timer_callback(void* context) {
+    furi_assert(context);
+    HidMouseJiggler* hid_mouse_jiggler = context;
+    with_view_model(
+        hid_mouse_jiggler->view,
+        HidMouseJigglerModel * model,
+        {
+            if(model->running) {
+                model->counter++;
+                hid_hal_mouse_move(
+                    hid_mouse_jiggler->hid,
+                    (model->counter % 2 == 0) ? MOUSE_MOVE_SHORT : -MOUSE_MOVE_SHORT,
+                    0);
+            }
+        },
+        false);
+}
+
+static void hid_mouse_jiggler_enter_callback(void* context) {
+    furi_assert(context);
+    HidMouseJiggler* hid_mouse_jiggler = context;
+
+    furi_timer_start(hid_mouse_jiggler->timer, 500);
+}
+
+static void hid_mouse_jiggler_exit_callback(void* context) {
+    furi_assert(context);
+    HidMouseJiggler* hid_mouse_jiggler = context;
+    furi_timer_stop(hid_mouse_jiggler->timer);
+}
+
+static bool hid_mouse_jiggler_input_callback(InputEvent* event, void* context) {
+    furi_assert(context);
+    HidMouseJiggler* hid_mouse_jiggler = context;
+
+    bool consumed = false;
+
+    if(event->type == InputTypeShort && event->key == InputKeyOk) {
+        with_view_model(
+            hid_mouse_jiggler->view,
+            HidMouseJigglerModel * model,
+            { model->running = !model->running; },
+            true);
+        consumed = true;
+    }
+
+    return consumed;
+}
+
+HidMouseJiggler* hid_mouse_jiggler_alloc(Hid* hid) {
+    HidMouseJiggler* hid_mouse_jiggler = malloc(sizeof(HidMouseJiggler));
+
+    hid_mouse_jiggler->view = view_alloc();
+    view_set_context(hid_mouse_jiggler->view, hid_mouse_jiggler);
+    view_allocate_model(
+        hid_mouse_jiggler->view, ViewModelTypeLocking, sizeof(HidMouseJigglerModel));
+    view_set_draw_callback(hid_mouse_jiggler->view, hid_mouse_jiggler_draw_callback);
+    view_set_input_callback(hid_mouse_jiggler->view, hid_mouse_jiggler_input_callback);
+    view_set_enter_callback(hid_mouse_jiggler->view, hid_mouse_jiggler_enter_callback);
+    view_set_exit_callback(hid_mouse_jiggler->view, hid_mouse_jiggler_exit_callback);
+
+    hid_mouse_jiggler->hid = hid;
+
+    hid_mouse_jiggler->timer = furi_timer_alloc(
+        hid_mouse_jiggler_timer_callback, FuriTimerTypePeriodic, hid_mouse_jiggler);
+
+    with_view_model(
+        hid_mouse_jiggler->view,
+        HidMouseJigglerModel * model,
+        { model->transport = hid->transport; },
+        true);
+
+    return hid_mouse_jiggler;
+}
+
+void hid_mouse_jiggler_free(HidMouseJiggler* hid_mouse_jiggler) {
+    furi_assert(hid_mouse_jiggler);
+
+    furi_timer_stop(hid_mouse_jiggler->timer);
+    furi_timer_free(hid_mouse_jiggler->timer);
+
+    view_free(hid_mouse_jiggler->view);
+
+    free(hid_mouse_jiggler);
+}
+
+View* hid_mouse_jiggler_get_view(HidMouseJiggler* hid_mouse_jiggler) {
+    furi_assert(hid_mouse_jiggler);
+    return hid_mouse_jiggler->view;
+}
+
+void hid_mouse_jiggler_set_connected_status(HidMouseJiggler* hid_mouse_jiggler, bool connected) {
+    furi_assert(hid_mouse_jiggler);
+    with_view_model(
+        hid_mouse_jiggler->view,
+        HidMouseJigglerModel * model,
+        { model->connected = connected; },
+        true);
+}

applications/system/hid_app/views/hid_mouse_jiggler.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <gui/view.h>
+
+#define MOUSE_MOVE_SHORT 5
+#define MOUSE_MOVE_LONG 20
+
+typedef struct Hid Hid;
+typedef struct HidMouseJiggler HidMouseJiggler;
+
+HidMouseJiggler* hid_mouse_jiggler_alloc(Hid* bt_hid);
+
+void hid_mouse_jiggler_free(HidMouseJiggler* hid_mouse_jiggler);
+
+View* hid_mouse_jiggler_get_view(HidMouseJiggler* hid_mouse_jiggler);
+
+void hid_mouse_jiggler_set_connected_status(HidMouseJiggler* hid_mouse_jiggler, bool connected);

applications/system/hid_app/views/hid_tiktok.c

@@ -0,0 +1,241 @@
+#include "hid_tiktok.h"
+#include "../hid.h"
+#include <gui/elements.h>
+
+#include "hid_icons.h"
+
+#define TAG "HidTikTok"
+
+struct HidTikTok {
+    View* view;
+    Hid* hid;
+};
+
+typedef struct {
+    bool left_pressed;
+    bool up_pressed;
+    bool right_pressed;
+    bool down_pressed;
+    bool ok_pressed;
+    bool connected;
+    bool is_cursor_set;
+    HidTransport transport;
+} HidTikTokModel;
+
+static void hid_tiktok_draw_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidTikTokModel* model = context;
+
+    // Header
+    if(model->transport == HidTransportBle) {
+        if(model->connected) {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
+        } else {
+            canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
+        }
+    }
+
+    canvas_set_font(canvas, FontPrimary);
+    elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "TikTok");
+    canvas_set_font(canvas, FontSecondary);
+
+    // Keypad circles
+    canvas_draw_icon(canvas, 76, 8, &I_Circles_47x47);
+
+    // Up
+    if(model->up_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 93, 9, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 96, 11, &I_Arr_up_7x9);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Down
+    if(model->down_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 93, 41, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 96, 44, &I_Arr_dwn_7x9);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Left
+    if(model->left_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 77, 25, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 81, 29, &I_Voldwn_6x6);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Right
+    if(model->right_pressed) {
+        canvas_set_bitmap_mode(canvas, 1);
+        canvas_draw_icon(canvas, 109, 25, &I_Pressed_Button_13x13);
+        canvas_set_bitmap_mode(canvas, 0);
+        canvas_set_color(canvas, ColorWhite);
+    }
+    canvas_draw_icon(canvas, 111, 29, &I_Volup_8x6);
+    canvas_set_color(canvas, ColorBlack);
+
+    // Ok
+    if(model->ok_pressed) {
+        canvas_draw_icon(canvas, 91, 23, &I_Like_pressed_17x17);
+    } else {
+        canvas_draw_icon(canvas, 94, 27, &I_Like_def_11x9);
+    }
+    // Exit
+    canvas_draw_icon(canvas, 0, 54, &I_Pin_back_arrow_10x8);
+    canvas_set_font(canvas, FontSecondary);
+    elements_multiline_text_aligned(canvas, 13, 62, AlignLeft, AlignBottom, "Hold to exit");
+}
+
+static void hid_tiktok_reset_cursor(HidTikTok* hid_tiktok) {
+    // Set cursor to the phone's left up corner
+    // Delays to guarantee one packet per connection interval
+    for(size_t i = 0; i < 8; i++) {
+        hid_hal_mouse_move(hid_tiktok->hid, -127, -127);
+        furi_delay_ms(50);
+    }
+    // Move cursor from the corner
+    hid_hal_mouse_move(hid_tiktok->hid, 20, 120);
+    furi_delay_ms(50);
+}
+
+static void
+    hid_tiktok_process_press(HidTikTok* hid_tiktok, HidTikTokModel* model, InputEvent* event) {
+    if(event->key == InputKeyUp) {
+        model->up_pressed = true;
+    } else if(event->key == InputKeyDown) {
+        model->down_pressed = true;
+    } else if(event->key == InputKeyLeft) {
+        model->left_pressed = true;
+        hid_hal_consumer_key_press(hid_tiktok->hid, HID_CONSUMER_VOLUME_DECREMENT);
+    } else if(event->key == InputKeyRight) {
+        model->right_pressed = true;
+        hid_hal_consumer_key_press(hid_tiktok->hid, HID_CONSUMER_VOLUME_INCREMENT);
+    } else if(event->key == InputKeyOk) {
+        model->ok_pressed = true;
+    }
+}
+
+static void
+    hid_tiktok_process_release(HidTikTok* hid_tiktok, HidTikTokModel* model, InputEvent* event) {
+    if(event->key == InputKeyUp) {
+        model->up_pressed = false;
+    } else if(event->key == InputKeyDown) {
+        model->down_pressed = false;
+    } else if(event->key == InputKeyLeft) {
+        model->left_pressed = false;
+        hid_hal_consumer_key_release(hid_tiktok->hid, HID_CONSUMER_VOLUME_DECREMENT);
+    } else if(event->key == InputKeyRight) {
+        model->right_pressed = false;
+        hid_hal_consumer_key_release(hid_tiktok->hid, HID_CONSUMER_VOLUME_INCREMENT);
+    } else if(event->key == InputKeyOk) {
+        model->ok_pressed = false;
+    }
+}
+
+static bool hid_tiktok_input_callback(InputEvent* event, void* context) {
+    furi_assert(context);
+    HidTikTok* hid_tiktok = context;
+    bool consumed = false;
+
+    with_view_model(
+        hid_tiktok->view,
+        HidTikTokModel * model,
+        {
+            if(event->type == InputTypePress) {
+                hid_tiktok_process_press(hid_tiktok, model, event);
+                if(model->connected && !model->is_cursor_set) {
+                    hid_tiktok_reset_cursor(hid_tiktok);
+                    model->is_cursor_set = true;
+                }
+                consumed = true;
+            } else if(event->type == InputTypeRelease) {
+                hid_tiktok_process_release(hid_tiktok, model, event);
+                consumed = true;
+            } else if(event->type == InputTypeShort) {
+                if(event->key == InputKeyOk) {
+                    hid_hal_mouse_press(hid_tiktok->hid, HID_MOUSE_BTN_LEFT);
+                    furi_delay_ms(50);
+                    hid_hal_mouse_release(hid_tiktok->hid, HID_MOUSE_BTN_LEFT);
+                    furi_delay_ms(50);
+                    hid_hal_mouse_press(hid_tiktok->hid, HID_MOUSE_BTN_LEFT);
+                    furi_delay_ms(50);
+                    hid_hal_mouse_release(hid_tiktok->hid, HID_MOUSE_BTN_LEFT);
+                    consumed = true;
+                } else if(event->key == InputKeyUp) {
+                    // Emulate up swipe
+                    hid_hal_mouse_scroll(hid_tiktok->hid, -6);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, -12);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, -19);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, -12);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, -6);
+                    consumed = true;
+                } else if(event->key == InputKeyDown) {
+                    // Emulate down swipe
+                    hid_hal_mouse_scroll(hid_tiktok->hid, 6);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, 12);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, 19);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, 12);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, 6);
+                    consumed = true;
+                } else if(event->key == InputKeyBack) {
+                    hid_hal_consumer_key_release_all(hid_tiktok->hid);
+                    consumed = true;
+                }
+            } else if(event->type == InputTypeLong) {
+                if(event->key == InputKeyBack) {
+                    hid_hal_consumer_key_release_all(hid_tiktok->hid);
+                    model->is_cursor_set = false;
+                    consumed = false;
+                }
+            }
+        },
+        true);
+
+    return consumed;
+}
+
+HidTikTok* hid_tiktok_alloc(Hid* bt_hid) {
+    HidTikTok* hid_tiktok = malloc(sizeof(HidTikTok));
+    hid_tiktok->hid = bt_hid;
+    hid_tiktok->view = view_alloc();
+    view_set_context(hid_tiktok->view, hid_tiktok);
+    view_allocate_model(hid_tiktok->view, ViewModelTypeLocking, sizeof(HidTikTokModel));
+    view_set_draw_callback(hid_tiktok->view, hid_tiktok_draw_callback);
+    view_set_input_callback(hid_tiktok->view, hid_tiktok_input_callback);
+
+    with_view_model(
+        hid_tiktok->view, HidTikTokModel * model, { model->transport = bt_hid->transport; }, true);
+
+    return hid_tiktok;
+}
+
+void hid_tiktok_free(HidTikTok* hid_tiktok) {
+    furi_assert(hid_tiktok);
+    view_free(hid_tiktok->view);
+    free(hid_tiktok);
+}
+
+View* hid_tiktok_get_view(HidTikTok* hid_tiktok) {
+    furi_assert(hid_tiktok);
+    return hid_tiktok->view;
+}
+
+void hid_tiktok_set_connected_status(HidTikTok* hid_tiktok, bool connected) {
+    furi_assert(hid_tiktok);
+    with_view_model(
+        hid_tiktok->view,
+        HidTikTokModel * model,
+        {
+            model->connected = connected;
+            model->is_cursor_set = false;
+        },
+        true);
+}

applications/system/hid_app/views/hid_tiktok.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <gui/view.h>
+
+typedef struct Hid Hid;
+typedef struct HidTikTok HidTikTok;
+
+HidTikTok* hid_tiktok_alloc(Hid* bt_hid);
+
+void hid_tiktok_free(HidTikTok* hid_tiktok);
+
+View* hid_tiktok_get_view(HidTikTok* hid_tiktok);
+
+void hid_tiktok_set_connected_status(HidTikTok* hid_tiktok, bool connected);

applications/system/snake_game/application.fam

@@ -0,0 +1,13 @@
+App(
+    appid="snake_game",
+    name="Snake Game",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="snake_game_app",
+    requires=["gui"],
+    stack_size=1 * 1024,
+    targets=["f7"],
+    fap_version="1.0",
+    fap_description="Classic Snake Game",
+    fap_icon="snake_10px.png",
+    fap_category="Games",
+)

applications/system/snake_game/snake_game.c

@@ -0,0 +1,434 @@
+#include <furi.h>
+#include <gui/gui.h>
+#include <input/input.h>
+#include <stdlib.h>
+#include <dolphin/dolphin.h>
+#include <notification/notification.h>
+#include <notification/notification_messages.h>
+
+typedef struct {
+    //    +-----x
+    //    |
+    //    |
+    //    y
+    uint8_t x;
+    uint8_t y;
+} Point;
+
+typedef enum {
+    GameStateLife,
+
+    // https://melmagazine.com/en-us/story/snake-nokia-6110-oral-history-taneli-armanto
+    // Armanto: While testing the early versions of the game, I noticed it was hard
+    // to control the snake upon getting close to and edge but not crashing — especially
+    // in the highest speed levels. I wanted the highest level to be as fast as I could
+    // possibly make the device "run," but on the other hand, I wanted to be friendly
+    // and help the player manage that level. Otherwise it might not be fun to play. So
+    // I implemented a little delay. A few milliseconds of extra time right before
+    // the player crashes, during which she can still change the directions. And if
+    // she does, the game continues.
+    GameStateLastChance,
+
+    GameStateGameOver,
+} GameState;
+
+// Note: do not change without purpose. Current values are used in smart
+// orthogonality calculation in `snake_game_get_turn_snake`.
+typedef enum {
+    DirectionUp,
+    DirectionRight,
+    DirectionDown,
+    DirectionLeft,
+} Direction;
+
+#define MAX_SNAKE_LEN 253
+
+typedef struct {
+    Point points[MAX_SNAKE_LEN];
+    uint16_t len;
+    Direction currentMovement;
+    Direction nextMovement; // if backward of currentMovement, ignore
+    Point fruit;
+    GameState state;
+    FuriMutex* mutex;
+} SnakeState;
+
+typedef enum {
+    EventTypeTick,
+    EventTypeKey,
+} EventType;
+
+typedef struct {
+    EventType type;
+    InputEvent input;
+} SnakeEvent;
+
+const NotificationSequence sequence_fail = {
+    &message_vibro_on,
+
+    &message_note_ds4,
+    &message_delay_10,
+    &message_sound_off,
+    &message_delay_10,
+
+    &message_note_ds4,
+    &message_delay_10,
+    &message_sound_off,
+    &message_delay_10,
+
+    &message_note_ds4,
+    &message_delay_10,
+    &message_sound_off,
+    &message_delay_10,
+
+    &message_vibro_off,
+    NULL,
+};
+
+const NotificationSequence sequence_eat = {
+    &message_note_c7,
+    &message_delay_50,
+    &message_sound_off,
+    NULL,
+};
+
+static void snake_game_render_callback(Canvas* const canvas, void* ctx) {
+    furi_assert(ctx);
+    const SnakeState* snake_state = ctx;
+
+    furi_mutex_acquire(snake_state->mutex, FuriWaitForever);
+
+    // Frame
+    canvas_draw_frame(canvas, 0, 0, 128, 64);
+
+    // Fruit
+    Point f = snake_state->fruit;
+    f.x = f.x * 4 + 1;
+    f.y = f.y * 4 + 1;
+    canvas_draw_rframe(canvas, f.x, f.y, 6, 6, 2);
+
+    // Snake
+    for(uint16_t i = 0; i < snake_state->len; i++) {
+        Point p = snake_state->points[i];
+        p.x = p.x * 4 + 2;
+        p.y = p.y * 4 + 2;
+        canvas_draw_box(canvas, p.x, p.y, 4, 4);
+    }
+
+    // Game Over banner
+    if(snake_state->state == GameStateGameOver) {
+        // Screen is 128x64 px
+        canvas_set_color(canvas, ColorWhite);
+        canvas_draw_box(canvas, 34, 20, 62, 24);
+
+        canvas_set_color(canvas, ColorBlack);
+        canvas_draw_frame(canvas, 34, 20, 62, 24);
+
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str(canvas, 37, 31, "Game Over");
+
+        canvas_set_font(canvas, FontSecondary);
+        char buffer[12];
+        snprintf(buffer, sizeof(buffer), "Score: %u", snake_state->len - 7U);
+        canvas_draw_str_aligned(canvas, 64, 41, AlignCenter, AlignBottom, buffer);
+    }
+
+    furi_mutex_release(snake_state->mutex);
+}
+
+static void snake_game_input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
+    furi_assert(event_queue);
+
+    SnakeEvent event = {.type = EventTypeKey, .input = *input_event};
+    furi_message_queue_put(event_queue, &event, FuriWaitForever);
+}
+
+static void snake_game_update_timer_callback(FuriMessageQueue* event_queue) {
+    furi_assert(event_queue);
+
+    SnakeEvent event = {.type = EventTypeTick};
+    furi_message_queue_put(event_queue, &event, 0);
+}
+
+static void snake_game_init_game(SnakeState* const snake_state) {
+    Point p[] = {{8, 6}, {7, 6}, {6, 6}, {5, 6}, {4, 6}, {3, 6}, {2, 6}};
+    memcpy(snake_state->points, p, sizeof(p)); //-V1086
+
+    snake_state->len = 7;
+
+    snake_state->currentMovement = DirectionRight;
+
+    snake_state->nextMovement = DirectionRight;
+
+    Point f = {18, 6};
+    snake_state->fruit = f;
+
+    snake_state->state = GameStateLife;
+}
+
+static Point snake_game_get_new_fruit(SnakeState const* const snake_state) {
+    // 1 bit for each point on the playing field where the snake can turn
+    // and where the fruit can appear
+    uint16_t buffer[8];
+    memset(buffer, 0, sizeof(buffer));
+    uint8_t empty = 8 * 16;
+
+    for(uint16_t i = 0; i < snake_state->len; i++) {
+        Point p = snake_state->points[i];
+
+        if(p.x % 2 != 0 || p.y % 2 != 0) {
+            continue;
+        }
+        p.x /= 2;
+        p.y /= 2;
+
+        buffer[p.y] |= 1 << p.x;
+        empty--;
+    }
+    // Bit set if snake use that playing field
+
+    uint16_t newFruit = rand() % empty;
+
+    // Skip random number of _empty_ fields
+    for(uint8_t y = 0; y < 8; y++) {
+        for(uint16_t x = 0, mask = 1; x < 16; x += 1, mask <<= 1) {
+            if((buffer[y] & mask) == 0) {
+                if(newFruit == 0) {
+                    Point p = {
+                        .x = x * 2,
+                        .y = y * 2,
+                    };
+                    return p;
+                }
+                newFruit--;
+            }
+        }
+    }
+    // We will never be here
+    Point p = {0, 0};
+    return p;
+}
+
+static bool snake_game_collision_with_frame(Point const next_step) {
+    // if x == 0 && currentMovement == left then x - 1 == 255 ,
+    // so check only x > right border
+    return next_step.x > 30 || next_step.y > 14;
+}
+
+static bool
+    snake_game_collision_with_tail(SnakeState const* const snake_state, Point const next_step) {
+    for(uint16_t i = 0; i < snake_state->len; i++) {
+        Point p = snake_state->points[i];
+        if(p.x == next_step.x && p.y == next_step.y) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static Direction snake_game_get_turn_snake(SnakeState const* const snake_state) {
+    // Sum of two `Direction` lies between 0 and 6, odd values indicate orthogonality.
+    bool is_orthogonal = (snake_state->currentMovement + snake_state->nextMovement) % 2 == 1;
+    return is_orthogonal ? snake_state->nextMovement : snake_state->currentMovement;
+}
+
+static Point snake_game_get_next_step(SnakeState const* const snake_state) {
+    Point next_step = snake_state->points[0];
+    switch(snake_state->currentMovement) {
+    // +-----x
+    // |
+    // |
+    // y
+    case DirectionUp:
+        next_step.y--;
+        break;
+    case DirectionRight:
+        next_step.x++;
+        break;
+    case DirectionDown:
+        next_step.y++;
+        break;
+    case DirectionLeft:
+        next_step.x--;
+        break;
+    }
+    return next_step;
+}
+
+static void snake_game_move_snake(SnakeState* const snake_state, Point const next_step) {
+    memmove(snake_state->points + 1, snake_state->points, snake_state->len * sizeof(Point));
+    snake_state->points[0] = next_step;
+}
+
+static void
+    snake_game_process_game_step(SnakeState* const snake_state, NotificationApp* notification) {
+    if(snake_state->state == GameStateGameOver) {
+        return;
+    }
+
+    bool can_turn = (snake_state->points[0].x % 2 == 0) && (snake_state->points[0].y % 2 == 0);
+    if(can_turn) {
+        snake_state->currentMovement = snake_game_get_turn_snake(snake_state);
+    }
+
+    Point next_step = snake_game_get_next_step(snake_state);
+
+    bool crush = snake_game_collision_with_frame(next_step);
+    if(crush) {
+        if(snake_state->state == GameStateLife) {
+            snake_state->state = GameStateLastChance;
+            return;
+        } else if(snake_state->state == GameStateLastChance) {
+            snake_state->state = GameStateGameOver;
+            notification_message_block(notification, &sequence_fail);
+            return;
+        }
+    } else {
+        if(snake_state->state == GameStateLastChance) {
+            snake_state->state = GameStateLife;
+        }
+    }
+
+    crush = snake_game_collision_with_tail(snake_state, next_step);
+    if(crush) {
+        snake_state->state = GameStateGameOver;
+        notification_message_block(notification, &sequence_fail);
+        return;
+    }
+
+    bool eatFruit = (next_step.x == snake_state->fruit.x) && (next_step.y == snake_state->fruit.y);
+    if(eatFruit) {
+        snake_state->len++;
+        if(snake_state->len >= MAX_SNAKE_LEN) {
+            snake_state->state = GameStateGameOver;
+            notification_message_block(notification, &sequence_fail);
+            return;
+        }
+    }
+
+    snake_game_move_snake(snake_state, next_step);
+
+    if(eatFruit) {
+        snake_state->fruit = snake_game_get_new_fruit(snake_state);
+        notification_message(notification, &sequence_eat);
+    }
+}
+
+int32_t snake_game_app(void* p) {
+    UNUSED(p);
+
+    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(SnakeEvent));
+
+    SnakeState* snake_state = malloc(sizeof(SnakeState));
+    snake_game_init_game(snake_state);
+
+    snake_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+
+    if(!snake_state->mutex) {
+        FURI_LOG_E("SnakeGame", "cannot create mutex\r\n");
+        free(snake_state);
+        return 255;
+    }
+
+    ViewPort* view_port = view_port_alloc();
+    view_port_draw_callback_set(view_port, snake_game_render_callback, snake_state);
+    view_port_input_callback_set(view_port, snake_game_input_callback, event_queue);
+
+    FuriTimer* timer =
+        furi_timer_alloc(snake_game_update_timer_callback, FuriTimerTypePeriodic, event_queue);
+    furi_timer_start(timer, furi_kernel_get_tick_frequency() / 4);
+
+    // Open GUI and register view_port
+    Gui* gui = furi_record_open(RECORD_GUI);
+    gui_add_view_port(gui, view_port, GuiLayerFullscreen);
+    NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
+
+    notification_message_block(notification, &sequence_display_backlight_enforce_on);
+
+    dolphin_deed(DolphinDeedPluginGameStart);
+
+    SnakeEvent event;
+    for(bool processing = true; processing;) {
+        FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
+
+        furi_mutex_acquire(snake_state->mutex, FuriWaitForever);
+
+        if(event_status == FuriStatusOk) {
+            // press events
+            if(event.type == EventTypeKey) {
+                if(event.input.type == InputTypePress) {
+                    switch(event.input.key) {
+                    case InputKeyUp:
+                        snake_state->nextMovement = DirectionUp;
+                        break;
+                    case InputKeyDown:
+                        snake_state->nextMovement = DirectionDown;
+                        break;
+                    case InputKeyRight:
+                        snake_state->nextMovement = DirectionRight;
+                        break;
+                    case InputKeyLeft:
+                        snake_state->nextMovement = DirectionLeft;
+                        break;
+                    case InputKeyOk:
+                        if(snake_state->state == GameStateGameOver) {
+                            snake_game_init_game(snake_state);
+                        }
+                        break;
+                    case InputKeyBack:
+                        processing = false;
+                        break;
+                    default:
+                        break;
+                    }
+                }
+            } else if(event.type == EventTypeTick) {
+                snake_game_process_game_step(snake_state, notification);
+            }
+        } else {
+            // event timeout
+        }
+
+        view_port_update(view_port);
+        furi_mutex_release(snake_state->mutex);
+    }
+
+    // Return backlight to normal state
+    notification_message(notification, &sequence_display_backlight_enforce_auto);
+
+    furi_timer_free(timer);
+    view_port_enabled_set(view_port, false);
+    gui_remove_view_port(gui, view_port);
+    furi_record_close(RECORD_GUI);
+    furi_record_close(RECORD_NOTIFICATION);
+    view_port_free(view_port);
+    furi_message_queue_free(event_queue);
+    furi_mutex_free(snake_state->mutex);
+    free(snake_state);
+
+    return 0;
+}
+
+// Screen is 128x64 px
+// (4 + 4) * 16 - 4 + 2 + 2border == 128
+// (4 + 4) * 8 - 4 + 2 + 2border == 64
+// Game field from point{x:  0, y: 0} to point{x: 30, y: 14}.
+// The snake turns only in even cells - intersections.
+// ┌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┐
+// ╎ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ╎
+// ╎ ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪ ╎
+// ╎ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ╎
+// ╎ ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪ ╎
+// ╎ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ╎
+// ╎ ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪ ╎
+// ╎ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ╎
+// ╎ ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪ ╎
+// ╎ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ╎
+// ╎ ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪ ╎
+// ╎ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ╎
+// ╎ ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪ ╎
+// ╎ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ╎
+// ╎ ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪   ▪ ╎
+// ╎ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ▪ ╎
+// └╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┘

assets/resources/infrared/assets/tv.ir

@@ -267,12 +267,6 @@ command: 13 00 00 00
 #
 name: Power
 type: parsed
-protocol: Samsung32
-address: 0E 00 00 00
-command: 14 00 00 00
-#
-name: Power
-type: parsed
 protocol: NECext
 address: 80 7E 00 00
 command: 18 00 00 00
@@ -332,12 +326,6 @@ address: 00 00 00 00
 command: 01 00 00 00
 #
 name: Power
-type: parsed
-protocol: NEC
-address: 00 00 00 00
-command: 01 00 00 00
-#
-name: Power
 type: raw
 frequency: 38000
 duty_cycle: 0.330000
@@ -351,12 +339,6 @@ data: 525 1955 449 1999 476 4545 446 4544 478 2032 443 2006 469 2011 444 4577 44
 #
 name: Power
 type: parsed
-protocol: SIRC
-address: 01 00 00 00
-command: 15 00 00 00
-#
-name: Power
-type: parsed
 protocol: Kaseikyo
 address: 80 02 20 00
 command: D0 03 00 00
@@ -470,12 +452,6 @@ duty_cycle: 0.330000
 data: 533 1356 437 3474 427 3483 429 3455 436 1454 430 1459 405 28168 510 1379 434 3477 434 3476 425 3459 432 1457 427 1462 402
 #
 name: Power
-type: parsed
-protocol: RC5
-address: 00 00 00 00
-command: 0C 00 00 00
-#
-name: Power
 type: raw
 frequency: 38000
 duty_cycle: 0.330000
@@ -890,12 +866,6 @@ duty_cycle: 0.330000
 data: 8042 3979 513 510 508 541 487 1559 509 515 513 1560 508 515 513 510 508 541 477 3981 532 1568 510 1563 515 1558 510 1564 514 1559 509 514 514 535 483 540 488 24151 8042 3979 513 536 482 541 487 1560 508 541 488 1560 508 541 487 536 482 541 477 3980 533 1566 512 1561 507 1566 512 1562 516 1557 511 538 491 533 485 538 490
 #
 name: Power
-type: parsed
-protocol: NECext
-address: 83 7A 00 00
-command: 08 00 00 00
-#
-name: Power
 type: raw
 frequency: 38000
 duty_cycle: 0.330000
@@ -1064,36 +1034,18 @@ address: 86 02 00 00
 command: 49 00 00 00
 #
 name: Power
-type: parsed
-protocol: SIRC
-address: 01 00 00 00
-command: 15 00 00 00
-#
-name: Power
 type: raw
 frequency: 38000
 duty_cycle: 0.330000
 data: 178 7761 176 11308 546 957 540 1958 538 970 537 1955 541 962 545 1953 543 964 543 962 545 957 540 970 548 960 547 1945 541 1950 546 965 542 1953 543 962 545 1945 540 970 537 1958 538 7881 172 7744 172 11318 536 971 536 1956 540 963 534 1964 542 966 541 1951 535 968 539 971 536 971 536 969 538 964 533 1965 541 1954 542 963 534 1956 540 971 536 1959 537 968 539 1951 535
 #
 name: Power
-type: parsed
-protocol: Kaseikyo
-address: 80 02 20 00
-command: D0 03 00 00
-#
-name: Power
 type: raw
 frequency: 38000
 duty_cycle: 0.330000
 data: 278 1845 274 808 271 806 273 812 278 805 275 805 274 1840 279 1844 275 809 281 1836 272 806 274 812 278 805 274 1842 277 802 277 44956 279 1842 277 804 275 802 277 808 271 811 279 1838 281 798 271 814 276 1844 275 806 273 1841 278 1845 274 1846 273 808 271 1843 276 44959 275 1845 274 807 272 805 275 811 279 804 275 805 274 1839 280 1844 275 808 271 1845 274 805 274 811 279 804 275 1841 278 801 278 44955 280 1841 278 802 277 801 278 807 272 810 280 1837 271 807 272 813 277 1843 276 805 274 1839 280 1843 276 1845 274 807 272 1842 277
 #
 name: Power
-type: parsed
-protocol: RC5
-address: 00 00 00 00
-command: 0C 00 00 00
-#
-name: Power
 type: raw
 frequency: 38000
 duty_cycle: 0.330000
@@ -1208,12 +1160,6 @@ address: 00 00 00 00
 command: 26 00 00 00
 #
 name: Power
-type: parsed
-protocol: RC5
-address: 00 00 00 00
-command: 0C 00 00 00
-#
-name: Power
 type: raw
 frequency: 38000
 duty_cycle: 0.330000
@@ -1503,12 +1449,6 @@ data: 879 901 871 1796 1770 903 869 917 876 916 877 913 880 906 877 918 875 914
 #
 name: Power
 type: parsed
-protocol: RC5
-address: 00 00 00 00
-command: 0C 00 00 00
-#
-name: Power
-type: parsed
 protocol: Kaseikyo
 address: 90 02 20 00
 command: D0 03 00 00
@@ -1582,12 +1522,6 @@ data: 3429 3445 875 2555 868 875 867 871 871 2560 873 868 874 2551 872 874 868 8
 name: Power
 type: parsed
 protocol: NEC
-address: 71 00 00 00
-command: 08 00 00 00
-#
-name: Power
-type: parsed
-protocol: NEC
 address: 83 00 00 00
 command: FF 00 00 00
 #
@@ -1683,44 +1617,6 @@ frequency: 38000
 duty_cycle: 0.330000
 data: 3462 1592 490 332 513 1200 489 331 514 1201 489 355 490 1201 489 356 512 1178 489 356 512 1178 512 334 487 1202 488 1202 488 357 512 1178 512 334 486 1203 487 1202 488 1203 487 1204 486 383 461 1228 488 357 488 357 487 357 487 1203 486 1204 486 359 485 1205 485 360 485 361 484 360 485 360 485 361 484 361 484 361 484 1206 484 360 484 361 484 361 484 1206 484 361 484 361 484 361 484 1206 484 361 484 1206 484 361 484 71543 3434 1620 486 359 485 1205 485 360 485 1206 484 360 485 1206 484 360 485 1206 484 360 485 1206 484 360 485 1205 485 1206 484 360 485 1206 484 360 485 1206 484 1206 484 1206 484 1206 484 361 484 1206 484 360 485 360 485 361 484 1206 484 1206 484 360 484 1206 484 360 485 361 484 361 484 360 485 361 484 361 484 361 484 1206 484 361 484 361 484 361 484 1206 484 361 484 361 484 361 484 1207 483 361 484 1206 484 361 484 71543 3435 1619 486 358 486 1204 486 359 486 1205 485 360 485 1205 485 360 485 1205 485 360 485 1205 485 360 484 1205 485 1205 485 360 485 1205 485 360 485 1205 485 1205 485 1205 485 1206 484 360 485 1205 485 360 485 360 485 360 485 1205 485 1206 484 360 485 1206 484 360 485 360 485 360 485 360 485 360 485 360 485 360 485 1206 484 360 485 360 485 360 485 1206 484 360 485 360 485 360 485 1205 485 360 485 1206 484 360 485 71542 3436 1619 486 358 487 1204 486 359 485 1205 485 360 485 1205 485 360 485 1205 485 360 485 1205 485 360 485 1205 485 1205 485 360 485 1205 485 360 485 1206 484 1206 484 1206 484 1206 484 360 485 1206 484 360 485 360 485 361 484 1206 484 1206 484 361 484 1206 484 361 484 361 484 361 484 361 484 361 484 361 484 360 485 1206 484 361 484 361 484 361 484 1206 484 361 484 361 484 360 485 1206 484 361 484 1206 484 361 484 71542 3437 1618 487 358 486 1204 486 359 486 1205 485 360 485 1205 485 360 485 1205 485 360 485 1205 485 360 485 1205 485 1206 484 360 485 1205 485 360 485 1206 484 1205 485 1206 484 1205 485 360 485 1205 485 360 485 360 485 360 485 1205 485 1205 485 360 485 1205 485 360 485 360 485 360 485 360 485 360 485 360 485 360 485 1205 485 360 485 360 485 360 485 1205 485 360 485 360 485 360 485 1205 485 360 485 1205 485 360 485
 #
-# TCL
-#
-name: Power
-type: raw
-frequency: 38000
-duty_cycle: 0.330000
-data: 3977 3993 494 1994 495 1995 496 1997 494 1996 495 1004 496 1004 496 1995 496 1004 496 1997 494 1005 495 1995 495 1007 493 1006 494 1006 494 1005 495 1007 493 1997 494 1995 496 1004 496 1995 496 1005 495 1995 496 1003 497 1995 496 8467 3980 3993 494 1994 495 1996 495 1997 494 1995 496 1004 496 1006 494 1995 496 1004 496 1996 495 1004 496 1996 495 1005 495 1005 495 1004 496 1005 495 1005 495 1996 495 1995 496 1005 495 1996 495 1004 496 1995 496 1006 569 1920 571 8393 3980 3993 571 1918 572 1922 569 1920 571 1920 571 929 572 929 571 1920 571 929 571 1920 571 929 571 1921 570 930 570 929 571 929 571 929 571 928 572 1920 571 1921 570 930 571 1920 572 930 571 1921 571 929 571 1923 569 8396 3980 3994 570 1921 569 1923 569 1921 571 1920 572 929 572 930 571 1921 570 930 571 1922 570 930 571 1921 570 930 570 930 571 929 571 929 571 929 572 1922 570 1921 570 931 570 1922 570 930 571 1922 569 931 570 1921 570
-#
-name: Vol_up
-type: raw
-frequency: 38000
-duty_cycle: 0.330000
-data: 3979 3995 493 1994 496 1997 495 1999 492 1999 492 1006 495 1008 493 1998 493 1006 494 1997 495 1999 493 1997 494 1998 493 1006 495 1007 493 1005 495 1006 495 2025 467 1998 494 1006 494 1996 495 1006 494 1005 495 1006 494 1007 493 8468 3979 3995 492 1995 495 1999 492 1997 494 1997 494 1007 493 1006 494 1997 494 1006 494 1997 494 1996 571 1923 569 1921 570 930 570 929 571 931 569 931 575 1916 570 1920 571 930 570 1922 570 930 571 930 570 930 576 924 576
-#
-name: Vol_dn
-type: raw
-frequency: 38000
-duty_cycle: 0.330000
-data: 3951 3994 494 1997 493 1998 494 1998 493 1998 493 1005 496 1005 496 1996 495 1005 495 1997 495 1996 495 1996 495 1006 494 1005 495 1006 494 1005 495 1006 494 1996 495 1998 493 1005 495 1997 494 1008 492 1006 494 1006 494 1997 494 8471 3977 3996 493 1996 493 1997 494 1998 493 1997 494 1006 494 1007 493 1997 494 1009 492 1996 495 1996 495 1997 494 1006 494 1006 494 1006 494 1006 494 1006 494 1997 493 1997 494 1006 494 1996 494 1005 495 1004 495 1006 494 1996 494
-#
-name: Ch_next
-type: raw
-frequency: 38000
-duty_cycle: 0.330000
-data: 3978 3994 494 1995 495 1996 495 1996 495 1996 495 1006 494 1004 497 1997 494 1005 495 1997 520 1970 577 923 578 1914 577 924 576 924 576 925 575 924 576 1914 577 1915 576 924 576 1914 577 924 576 923 577 1915 576 926 574 8388 3978 3993 576 1913 576 1915 576 1915 576 1917 574 923 577 923 577 1943 548 925 575 1916 576 1915 575 924 576 1915 576 925 575 927 573 925 575 926 574 1916 574 1918 573 927 573 1918 573 928 572 927 573 1918 573 926 574 8389 4006 3966 572 1918 571 1919 572 1918 573 1920 570 929 571 929 571 1922 569 928 571 1920 571 1921 570 928 572 1919 572 929 571 929 571 929 571 929 571 1921 570 1921 521 980 569 1921 521 981 519 979 521 1971 520 979 521
-#
-name: Ch_prev
-type: raw
-frequency: 38000
-duty_cycle: 0.330000
-data: 3979 3994 494 1995 495 1997 494 1996 495 1998 493 1005 495 1006 494 1997 494 1005 495 1996 495 1995 496 1005 495 1005 495 1006 494 1005 495 1004 496 1005 495 1997 494 1997 494 1004 496 1996 495 1005 495 1005 495 1997 494 1996 495 8467 3976 3991 496 1995 495 1996 494 1994 496 1996 494 1005 495 1005 495 1996 495 1005 495 1995 495 1995 496 1006 494 1005 495 1006 494 1005 495 1004 496 1006 494 1994 496 1996 494 1005 495 1995 495 1004 496 1004 496 1995 495 1996 494
-#
-name: Mute
-type: raw
-frequency: 38000
-duty_cycle: 0.330000
-data: 3981 3992 495 1994 495 1995 496 1996 494 1996 495 1005 495 1006 494 1995 495 1997 494 1996 495 1996 494 1997 494 1996 495 1006 494 1005 495 1004 496 1005 495 1995 496 1994 496 1005 495 1004 496 1005 495 1006 494 1004 496 1006 494 8466 3978 3991 495 1994 495 1997 493 1994 496 1995 495 1004 496 1004 496 1996 494 1997 493 1996 494 1995 495 1995 495 1997 493 1004 495 1004 495 1006 494 1005 494 1998 491 1996 494 1006 494 1004 496 1006 494 1006 493 1005 495 1005 571
-#
 # Thomson RC3000E02
 #
 name: Power
@@ -1773,12 +1669,6 @@ protocol: NEC
 address: 40 00 00 00
 command: 13 00 00 00
 #
-name: Vol_dn
-type: parsed
-protocol: NEC
-address: 40 00 00 00
-command: 12 00 00 00
-#
 name: Mute
 type: parsed
 protocol: NEC

firmware/targets/f18/api_symbols.csv

@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,36.1,,
+Version,+,37.0,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/cli/cli.h,,
 Header,+,applications/services/cli/cli_vcp.h,,
@@ -827,8 +827,9 @@ Function,+,flipper_application_get_manifest,const FlipperApplicationManifest*,Fl
 Function,+,flipper_application_is_plugin,_Bool,FlipperApplication*
 Function,+,flipper_application_load_name_and_icon,_Bool,"FuriString*, Storage*, uint8_t**, FuriString*"
 Function,+,flipper_application_load_status_to_string,const char*,FlipperApplicationLoadStatus
-Function,+,flipper_application_manifest_is_compatible,_Bool,"const FlipperApplicationManifest*, const ElfApiInterface*"
 Function,+,flipper_application_manifest_is_target_compatible,_Bool,const FlipperApplicationManifest*
+Function,+,flipper_application_manifest_is_too_new,_Bool,"const FlipperApplicationManifest*, const ElfApiInterface*"
+Function,+,flipper_application_manifest_is_too_old,_Bool,"const FlipperApplicationManifest*, const ElfApiInterface*"
 Function,+,flipper_application_manifest_is_valid,_Bool,const FlipperApplicationManifest*
 Function,+,flipper_application_map_to_memory,FlipperApplicationLoadStatus,FlipperApplication*
 Function,+,flipper_application_plugin_get_descriptor,const FlipperAppPluginDescriptor*,FlipperApplication*

firmware/targets/f18/furi_hal/furi_hal_resources.c

@@ -136,6 +136,14 @@ static void furi_hal_resources_init_input_pins(GpioMode mode) {
     }
 }
 
+static void furi_hal_resources_init_gpio_pins(GpioMode mode) {
+    for(size_t i = 0; i < gpio_pins_count; i++) {
+        if(!gpio_pins[i].debug) {
+            furi_hal_gpio_init(gpio_pins[i].pin, mode, GpioPullNo, GpioSpeedLow);
+        }
+    }
+}
+
 void furi_hal_resources_init_early() {
     furi_hal_bus_enable(FuriHalBusGPIOA);
     furi_hal_bus_enable(FuriHalBusGPIOB);
@@ -179,14 +187,7 @@ void furi_hal_resources_init_early() {
     furi_hal_gpio_write(&gpio_usb_dp, 0);
 
     // External header pins
-    furi_hal_gpio_init(&gpio_ext_pc0, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pc1, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pc3, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pb2, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pb3, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pa4, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pa6, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pa7, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
+    furi_hal_resources_init_gpio_pins(GpioModeAnalog);
 }
 
 void furi_hal_resources_deinit_early() {

firmware/targets/f7/api_symbols.csv

@@ -1,5 +1,5 @@
 entry,status,name,type,params
-Version,+,36.1,,
+Version,+,37.0,,
 Header,+,applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h,,
 Header,+,applications/services/bt/bt_service/bt.h,,
 Header,+,applications/services/cli/cli.h,,
@@ -898,8 +898,9 @@ Function,+,flipper_application_get_manifest,const FlipperApplicationManifest*,Fl
 Function,+,flipper_application_is_plugin,_Bool,FlipperApplication*
 Function,+,flipper_application_load_name_and_icon,_Bool,"FuriString*, Storage*, uint8_t**, FuriString*"
 Function,+,flipper_application_load_status_to_string,const char*,FlipperApplicationLoadStatus
-Function,+,flipper_application_manifest_is_compatible,_Bool,"const FlipperApplicationManifest*, const ElfApiInterface*"
 Function,+,flipper_application_manifest_is_target_compatible,_Bool,const FlipperApplicationManifest*
+Function,+,flipper_application_manifest_is_too_new,_Bool,"const FlipperApplicationManifest*, const ElfApiInterface*"
+Function,+,flipper_application_manifest_is_too_old,_Bool,"const FlipperApplicationManifest*, const ElfApiInterface*"
 Function,+,flipper_application_manifest_is_valid,_Bool,const FlipperApplicationManifest*
 Function,+,flipper_application_map_to_memory,FlipperApplicationLoadStatus,FlipperApplication*
 Function,+,flipper_application_plugin_get_descriptor,const FlipperAppPluginDescriptor*,FlipperApplication*

firmware/targets/f7/furi_hal/furi_hal_resources.c

@@ -117,6 +117,14 @@ static void furi_hal_resources_init_input_pins(GpioMode mode) {
     }
 }
 
+static void furi_hal_resources_init_gpio_pins(GpioMode mode) {
+    for(size_t i = 0; i < gpio_pins_count; i++) {
+        if(!gpio_pins[i].debug) {
+            furi_hal_gpio_init(gpio_pins[i].pin, mode, GpioPullNo, GpioSpeedLow);
+        }
+    }
+}
+
 void furi_hal_resources_init_early() {
     furi_hal_bus_enable(FuriHalBusGPIOA);
     furi_hal_bus_enable(FuriHalBusGPIOB);
@@ -161,14 +169,7 @@ void furi_hal_resources_init_early() {
     furi_hal_gpio_write(&gpio_usb_dp, 0);
 
     // External header pins
-    furi_hal_gpio_init(&gpio_ext_pc0, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pc1, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pc3, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pb2, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pb3, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pa4, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pa6, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(&gpio_ext_pa7, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
+    furi_hal_resources_init_gpio_pins(GpioModeAnalog);
 }
 
 void furi_hal_resources_deinit_early() {

lib/flipper_application/application_manifest.c

@@ -11,10 +11,21 @@ bool flipper_application_manifest_is_valid(const FlipperApplicationManifest* man
     return true;
 }
 
-bool flipper_application_manifest_is_compatible(
+bool flipper_application_manifest_is_too_old(
     const FlipperApplicationManifest* manifest,
     const ElfApiInterface* api_interface) {
-    if(manifest->base.api_version.major != api_interface->api_version_major /* ||
+    if(manifest->base.api_version.major < api_interface->api_version_major /* ||
+       manifest->base.api_version.minor > app->api_interface->api_version_minor */) {
+        return false;
+    }
+
+    return true;
+}
+
+bool flipper_application_manifest_is_too_new(
+    const FlipperApplicationManifest* manifest,
+    const ElfApiInterface* api_interface) {
+    if(manifest->base.api_version.major > api_interface->api_version_major /* ||
        manifest->base.api_version.minor > app->api_interface->api_version_minor */) {
         return false;
     }

lib/flipper_application/application_manifest.h

@@ -54,14 +54,25 @@ typedef FlipperApplicationManifestV1 FlipperApplicationManifest;
  */
 bool flipper_application_manifest_is_valid(const FlipperApplicationManifest* manifest);
 
-/**
- * @brief Check if manifest is compatible with current ELF API interface
- * 
- * @param manifest 
- * @param api_interface 
- * @return bool 
+/** Check if API Version declared in manifest is older than firmware ELF API interface
+ *
+ * @param      manifest       The manifest
+ * @param      api_interface  The api interface
+ *
+ * @return     bool
  */
-bool flipper_application_manifest_is_compatible(
+bool flipper_application_manifest_is_too_old(
+    const FlipperApplicationManifest* manifest,
+    const ElfApiInterface* api_interface);
+
+/** Check if API Version declared in manifest is newer than firmware ELF API interface
+ *
+ * @param      manifest       The manifest
+ * @param      api_interface  The api interface
+ *
+ * @return     bool
+ */
+bool flipper_application_manifest_is_too_new(
     const FlipperApplicationManifest* manifest,
     const ElfApiInterface* api_interface);
 

lib/flipper_application/flipper_application.c

@@ -101,9 +101,14 @@ static FlipperApplicationPreloadStatus
         return FlipperApplicationPreloadStatusTargetMismatch;
     }
 
-    if(!flipper_application_manifest_is_compatible(
+    if(!flipper_application_manifest_is_too_old(
            &app->manifest, elf_file_get_api_interface(app->elf))) {
-        return FlipperApplicationPreloadStatusApiMismatch;
+        return FlipperApplicationPreloadStatusApiTooOld;
+    }
+
+    if(!flipper_application_manifest_is_too_new(
+           &app->manifest, elf_file_get_api_interface(app->elf))) {
+        return FlipperApplicationPreloadStatusApiTooNew;
     }
 
     return FlipperApplicationPreloadStatusSuccess;
@@ -257,7 +262,8 @@ static const char* preload_status_strings[] = {
     [FlipperApplicationPreloadStatusUnspecifiedError] = "Unknown error",
     [FlipperApplicationPreloadStatusInvalidFile] = "Invalid file",
     [FlipperApplicationPreloadStatusInvalidManifest] = "Invalid file manifest",
-    [FlipperApplicationPreloadStatusApiMismatch] = "API version mismatch",
+    [FlipperApplicationPreloadStatusApiTooOld] = "Update Application to use with this Firmware (ApiTooOld)",
+    [FlipperApplicationPreloadStatusApiTooNew] = "Update Firmware to use with this Application (ApiTooNew)",
     [FlipperApplicationPreloadStatusTargetMismatch] = "Hardware target mismatch",
 };
 
@@ -265,7 +271,7 @@ static const char* load_status_strings[] = {
     [FlipperApplicationLoadStatusSuccess] = "Success",
     [FlipperApplicationLoadStatusUnspecifiedError] = "Unknown error",
     [FlipperApplicationLoadStatusNoFreeMemory] = "Out of memory",
-    [FlipperApplicationLoadStatusMissingImports] = "Found unsatisfied imports",
+    [FlipperApplicationLoadStatusMissingImports] = "Update Firmware to use with this Application (MissingImports)",
 };
 
 const char* flipper_application_preload_status_to_string(FlipperApplicationPreloadStatus status) {

lib/flipper_application/flipper_application.h

@@ -21,7 +21,8 @@ typedef enum {
     FlipperApplicationPreloadStatusUnspecifiedError,
     FlipperApplicationPreloadStatusInvalidFile,
     FlipperApplicationPreloadStatusInvalidManifest,
-    FlipperApplicationPreloadStatusApiMismatch,
+    FlipperApplicationPreloadStatusApiTooOld,
+    FlipperApplicationPreloadStatusApiTooNew,
     FlipperApplicationPreloadStatusTargetMismatch,
 } FlipperApplicationPreloadStatus;
 

lib/u8g2/u8g2_glue.c

@@ -3,7 +3,7 @@
 #include <furi_hal.h>
 
 #define CONTRAST_ERC 31
-#define CONTRAST_MGG 31
+#define CONTRAST_MGG 27
 
 uint8_t u8g2_gpio_and_delay_stm32(u8x8_t* u8x8, uint8_t msg, uint8_t arg_int, void* arg_ptr) {
     UNUSED(u8x8);

scripts/flipper/utils/fff.py

@@ -67,7 +67,10 @@ class FlipperFormatFile:
         self.writeLine("")
 
     def writeComment(self, text: str):
-        self.writeLine(f"# {text}")
+        if text:
+            self.writeLine(f"# {text}")
+        else:
+            self.writeLine("#")
 
     def getHeader(self):
         if self.cursor != 0 and len(self.lines) == 0:

scripts/infrared.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+
+from os import path
+
+from flipper.app import App
+from flipper.utils.fff import *
+
+
+class Main(App):
+    def init(self):
+        # Subparsers
+        self.subparsers = self.parser.add_subparsers(help="sub-command help")
+
+        self.parser_cleanup = self.subparsers.add_parser(
+            "cleanup", help="Cleanup duplicate remotes"
+        )
+        self.parser_cleanup.add_argument("filename", type=str)
+        self.parser_cleanup.set_defaults(func=self.cleanup)
+
+    def cleanup(self):
+        f = FlipperFormatFile()
+        f.load(self.args.filename)
+
+        filetype, version = f.getHeader()
+        if filetype != "IR library file" or version != 1:
+            self.logger.error(f"Incorrect file type({filetype}) or version({version})")
+            return 1
+
+        data = []
+        unique = {}
+        while True:
+            try:
+                d = {}
+                d["name"] = f.readKey("name")
+                d["type"] = f.readKey("type")
+                key = None
+                if d["type"] == "parsed":
+                    d["protocol"] = f.readKey("protocol")
+                    d["address"] = f.readKey("address")
+                    d["command"] = f.readKey("command")
+                    key = f'{d["protocol"]}{d["address"]}{d["command"]}'
+                elif d["type"] == "raw":
+                    d["frequency"] = f.readKey("frequency")
+                    d["duty_cycle"] = f.readKey("duty_cycle")
+                    d["data"] = f.readKey("data")
+                    key = f'{d["frequency"]}{d["duty_cycle"]}{d["data"]}'
+                else:
+                    raise Exception(f'Unknown type: {d["type"]}')
+                if not key in unique:
+                    unique[key] = d
+                    data.append(d)
+                else:
+                    self.logger.warn(f"Duplicate key: {key}")
+            except EOFError:
+                break
+        # Form new file
+        f = FlipperFormatFile()
+        f.setHeader(filetype, version)
+        for i in data:
+            f.writeComment(None)
+            f.writeKey("name", i["name"])
+            f.writeKey("type", i["type"])
+            if i["type"] == "parsed":
+                f.writeKey("protocol", i["protocol"])
+                f.writeKey("address", i["address"])
+                f.writeKey("command", i["command"])
+            elif i["type"] == "raw":
+                f.writeKey("frequency", i["frequency"])
+                f.writeKey("duty_cycle", i["duty_cycle"])
+                f.writeKey("data", i["data"])
+            else:
+                raise Exception(f'Unknown type: {i["type"]}')
+        f.save(self.args.filename)
+
+        return 0
+
+
+if __name__ == "__main__":
+    Main()()

scripts/ob.py

@@ -22,7 +22,8 @@ class Main(App):
         self.parser_set = self.subparsers.add_parser("set", help="Set Option Bytes")
         self._add_args(self.parser_set)
         self.parser_set.set_defaults(func=self.set)
-        # Set command
+
+        # Recover command
         self.parser_recover = self.subparsers.add_parser(
             "recover", help="Recover Option Bytes"
         )