Hid app refactor to match ofw

applications/system/hid_app/hid.c

@@ -4,6 +4,7 @@
 #include "views.h"
 #include <notification/notification_messages.h>
 #include <dolphin/dolphin.h>
+#include "hid_icons.h"
 
 #define TAG "HidApp"
 
@@ -15,7 +16,7 @@ enum HidDebugSubmenuIndex {
     HidSubmenuIndexMedia,
     HidSubmenuIndexMusicMacOs,
     HidSubmenuIndexMovie,
-    HidSubmenuIndexTikShorts,
+    HidSubmenuIndexTikTok,
     HidSubmenuIndexMouse,
     HidSubmenuIndexMouseClicker,
     HidSubmenuIndexMouseJiggler,
@@ -23,7 +24,22 @@ enum HidDebugSubmenuIndex {
     HidSubmenuIndexRemovePairing,
 };
 
-static void bt_hid_remove_pairing(Bt* bt) {
+bool hid_custom_event_callback(void* context, uint32_t event) {
+    furi_assert(context);
+    Hid* app = context;
+    return scene_manager_handle_custom_event(app->scene_manager, event);
+}
+
+bool hid_back_event_callback(void* context) {
+    furi_assert(context);
+    Hid* app = context;
+    FURI_LOG_D("HID", "Back event");
+    scene_manager_next_scene(app->scene_manager, HidSceneExitConfirm);
+    return true;
+}
+
+void bt_hid_remove_pairing(Hid* app) {
+    Bt* bt = app->bt;
     bt_disconnect(bt);
 
     // Wait 2nd core to update nvm storage
@@ -65,9 +81,9 @@ static void hid_submenu_callback(void* context, uint32_t index) {
     } else if(index == HidSubmenuIndexMouse) {
         app->view_id = HidViewMouse;
         view_dispatcher_switch_to_view(app->view_dispatcher, HidViewMouse);
-    } else if(index == HidSubmenuIndexTikShorts) {
-        app->view_id = BtHidViewTikShorts;
-        view_dispatcher_switch_to_view(app->view_dispatcher, BtHidViewTikShorts);
+    } 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);
@@ -78,7 +94,7 @@ static void hid_submenu_callback(void* context, uint32_t index) {
         app->view_id = HidViewPushToTalkMenu;
         view_dispatcher_switch_to_view(app->view_dispatcher, HidViewPushToTalkMenu);
     } else if(index == HidSubmenuIndexRemovePairing) {
-        bt_hid_remove_pairing(app->bt);
+        scene_manager_next_scene(app->scene_manager, HidSceneUnpair);
     }
 }
 
@@ -103,12 +119,7 @@ static void bt_hid_connection_status_changed_callback(BtStatus status, void* con
     hid_mouse_clicker_set_connected_status(hid->hid_mouse_clicker, connected);
     hid_mouse_jiggler_set_connected_status(hid->hid_mouse_jiggler, connected);
     hid_ptt_set_connected_status(hid->hid_ptt, connected);
-    hid_tikshorts_set_connected_status(hid->hid_tikshorts, connected);
-}
-
-static uint32_t hid_menu_view(void* context) {
-    UNUSED(context);
-    return HidViewSubmenu;
+    hid_tiktok_set_connected_status(hid->hid_tiktok, connected);
 }
 
 static uint32_t hid_exit(void* context) {
@@ -137,6 +148,12 @@ Hid* hid_alloc() {
     app->view_dispatcher = view_dispatcher_alloc();
     view_dispatcher_enable_queue(app->view_dispatcher);
     view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
+    view_dispatcher_set_navigation_event_callback(app->view_dispatcher, hid_back_event_callback);
+    view_dispatcher_set_event_callback_context(app->view_dispatcher, app);
+
+    // Scene Manager
+    app->scene_manager = scene_manager_alloc(&hid_scene_handlers, app);
+
     // Device Type Submenu view
     app->device_type_submenu = submenu_alloc();
     submenu_add_item(
@@ -166,7 +183,7 @@ Hid* hid_alloc() {
     submenu_add_item(
         app->device_type_submenu,
         "TikTok / YT Shorts",
-        HidSubmenuIndexTikShorts,
+        HidSubmenuIndexTikTok,
         hid_submenu_callback,
         app);
     submenu_add_item(
@@ -199,7 +216,6 @@ Hid* hid_alloc() {
     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;
 }
 
@@ -207,57 +223,56 @@ Hid* hid_app_alloc_view(void* context) {
     furi_assert(context);
     Hid* app = context;
 
+    // Dialog view
+    app->dialog = dialog_ex_alloc();
+    view_dispatcher_add_view(app->view_dispatcher, HidViewDialog, dialog_ex_get_view(app->dialog));
+
+    // Popup view
+    app->popup = popup_alloc();
+    view_dispatcher_add_view(app->view_dispatcher, HidViewPopup, popup_get_view(app->popup));
+
     // Keynote view
     app->hid_keynote = hid_keynote_alloc(app);
-    view_set_previous_callback(hid_keynote_get_view(app->hid_keynote), hid_menu_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_menu_view);
     view_dispatcher_add_view(
         app->view_dispatcher, HidViewKeyboard, hid_keyboard_get_view(app->hid_keyboard));
 
     //Numpad keyboard view
     app->hid_numpad = hid_numpad_alloc(app);
-    view_set_previous_callback(hid_numpad_get_view(app->hid_numpad), hid_menu_view);
     view_dispatcher_add_view(
         app->view_dispatcher, HidViewNumpad, hid_numpad_get_view(app->hid_numpad));
 
     // Media view
     app->hid_media = hid_media_alloc(app);
-    view_set_previous_callback(hid_media_get_view(app->hid_media), hid_menu_view);
     view_dispatcher_add_view(
         app->view_dispatcher, HidViewMedia, hid_media_get_view(app->hid_media));
 
     // Music MacOs view
     app->hid_music_macos = hid_music_macos_alloc(app);
-    view_set_previous_callback(hid_music_macos_get_view(app->hid_music_macos), hid_menu_view);
     view_dispatcher_add_view(
         app->view_dispatcher, HidViewMusicMacOs, hid_music_macos_get_view(app->hid_music_macos));
 
     // Movie view
     app->hid_movie = hid_movie_alloc(app);
-    view_set_previous_callback(hid_movie_get_view(app->hid_movie), hid_menu_view);
     view_dispatcher_add_view(
         app->view_dispatcher, HidViewMovie, hid_movie_get_view(app->hid_movie));
 
-    // TikTok / YT Shorts view
-    app->hid_tikshorts = hid_tikshorts_alloc(app);
-    view_set_previous_callback(hid_tikshorts_get_view(app->hid_tikshorts), hid_menu_view);
+    // TikTok view
+    app->hid_tiktok = hid_tiktok_alloc(app);
     view_dispatcher_add_view(
-        app->view_dispatcher, BtHidViewTikShorts, hid_tikshorts_get_view(app->hid_tikshorts));
+        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_menu_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_menu_view);
     view_dispatcher_add_view(
         app->view_dispatcher,
         HidViewMouseClicker,
@@ -265,7 +280,6 @@ Hid* hid_app_alloc_view(void* context) {
 
     // 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_menu_view);
     view_dispatcher_add_view(
         app->view_dispatcher,
         HidViewMouseJiggler,
@@ -273,7 +287,6 @@ Hid* hid_app_alloc_view(void* context) {
 
     // PushToTalk view
     app->hid_ptt_menu = hid_ptt_menu_alloc(app);
-    view_set_previous_callback(hid_ptt_menu_get_view(app->hid_ptt_menu), hid_menu_view);
     view_dispatcher_add_view(
         app->view_dispatcher, HidViewPushToTalkMenu, hid_ptt_menu_get_view(app->hid_ptt_menu));
     app->hid_ptt = hid_ptt_alloc(app);
@@ -294,6 +307,10 @@ void hid_free(Hid* app) {
     // Free views
     view_dispatcher_remove_view(app->view_dispatcher, HidViewSubmenu);
     submenu_free(app->device_type_submenu);
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewDialog);
+    dialog_ex_free(app->dialog);
+    view_dispatcher_remove_view(app->view_dispatcher, HidViewPopup);
+    popup_free(app->popup);
     view_dispatcher_remove_view(app->view_dispatcher, HidViewKeynote);
     hid_keynote_free(app->hid_keynote);
     view_dispatcher_remove_view(app->view_dispatcher, HidViewKeyboard);
@@ -316,8 +333,9 @@ void hid_free(Hid* app) {
     hid_ptt_menu_free(app->hid_ptt_menu);
     view_dispatcher_remove_view(app->view_dispatcher, HidViewPushToTalk);
     hid_ptt_free(app->hid_ptt);
-    view_dispatcher_remove_view(app->view_dispatcher, BtHidViewTikShorts);
-    hid_tikshorts_free(app->hid_tikshorts);
+    view_dispatcher_remove_view(app->view_dispatcher, BtHidViewTikTok);
+    hid_tiktok_free(app->hid_tiktok);
+    scene_manager_free(app->scene_manager);
     view_dispatcher_free(app->view_dispatcher);
 
     // Close records
@@ -336,6 +354,8 @@ int32_t hid_usb_app(void* p) {
     UNUSED(p);
     Hid* app = hid_alloc();
     app = hid_app_alloc_view(app);
+    FURI_LOG_D("HID", "Starting as USB 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);
@@ -344,6 +364,8 @@ int32_t hid_usb_app(void* p) {
 
     dolphin_deed(DolphinDeedPluginStart);
 
+    scene_manager_next_scene(app->scene_manager, HidSceneMain);
+
     view_dispatcher_run(app->view_dispatcher);
 
     furi_hal_usb_set_config(usb_mode_prev, NULL);
@@ -358,6 +380,8 @@ int32_t hid_ble_app(void* p) {
     Hid* app = hid_alloc();
     app = hid_app_alloc_view(app);
 
+    FURI_LOG_D("HID", "Starting as BLE app");
+
     bt_disconnect(app->bt);
 
     // Wait 2nd core to update nvm storage
@@ -384,6 +408,8 @@ int32_t hid_ble_app(void* p) {
 
     dolphin_deed(DolphinDeedPluginStart);
 
+    scene_manager_next_scene(app->scene_manager, HidSceneMain);
+
     view_dispatcher_run(app->view_dispatcher);
 
     bt_set_status_changed_callback(app->bt, NULL, NULL);

applications/system/hid_app/hid.h

@@ -11,10 +11,12 @@
 #include <gui/gui.h>
 #include <gui/view.h>
 #include <gui/view_dispatcher.h>
+#include <gui/scene_manager.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"
@@ -25,11 +27,11 @@
 #include "views/hid_mouse.h"
 #include "views/hid_mouse_clicker.h"
 #include "views/hid_mouse_jiggler.h"
-#include "views/hid_tikshorts.h"
+#include "views/hid_tiktok.h"
 #include "views/hid_ptt.h"
 #include "views/hid_ptt_menu.h"
 
-#include <assets_icons.h>
+#include "scenes/hid_scene.h"
 
 #define HID_BT_KEYS_STORAGE_NAME ".bt_hid.keys"
 
@@ -46,7 +48,10 @@ struct Hid {
     Gui* gui;
     NotificationApp* notifications;
     ViewDispatcher* view_dispatcher;
+    SceneManager* scene_manager;
     Submenu* device_type_submenu;
+    DialogEx* dialog;
+    Popup* popup;
     HidKeynote* hid_keynote;
     HidKeyboard* hid_keyboard;
     HidNumpad* hid_numpad;
@@ -56,13 +61,14 @@ struct Hid {
     HidMouse* hid_mouse;
     HidMouseClicker* hid_mouse_clicker;
     HidMouseJiggler* hid_mouse_jiggler;
-    HidTikShorts* hid_tikshorts;
+    HidTikTok* hid_tiktok;
     HidPushToTalk* hid_ptt;
     HidPushToTalkMenu* hid_ptt_menu;
 
     HidTransport transport;
     uint32_t view_id;
 };
+void bt_hid_remove_pairing(Hid* app);
 
 void hid_hal_keyboard_press(Hid* instance, uint16_t event);
 void hid_hal_keyboard_release(Hid* instance, uint16_t event);
@@ -76,4 +82,4 @@ 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);
+void hid_hal_mouse_release_all(Hid* instance);

applications/system/hid_app/scenes/hid_scene.c

@@ -0,0 +1,30 @@
+#include "hid_scene.h"
+
+// Generate scene on_enter handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_enter,
+void (*const hid_on_enter_handlers[])(void*) = {
+#include "hid_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_event handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_event,
+bool (*const hid_on_event_handlers[])(void* context, SceneManagerEvent event) = {
+#include "hid_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers array
+#define ADD_SCENE(prefix, name, id) prefix##_scene_##name##_on_exit,
+void (*const hid_on_exit_handlers[])(void* context) = {
+#include "hid_scene_config.h"
+};
+#undef ADD_SCENE
+
+// Initialize scene handlers configuration structure
+const SceneManagerHandlers hid_scene_handlers = {
+    .on_enter_handlers = hid_on_enter_handlers,
+    .on_event_handlers = hid_on_event_handlers,
+    .on_exit_handlers = hid_on_exit_handlers,
+    .scene_num = HidSceneNum,
+};

applications/system/hid_app/scenes/hid_scene.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <gui/scene_manager.h>
+
+// Generate scene id and total number
+#define ADD_SCENE(prefix, name, id) HidScene##id,
+typedef enum {
+#include "hid_scene_config.h"
+    HidSceneNum,
+} HidScene;
+#undef ADD_SCENE
+
+extern const SceneManagerHandlers hid_scene_handlers;
+
+// Generate scene on_enter handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_enter(void*);
+#include "hid_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_event handlers declaration
+#define ADD_SCENE(prefix, name, id) \
+    bool prefix##_scene_##name##_on_event(void* context, SceneManagerEvent event);
+#include "hid_scene_config.h"
+#undef ADD_SCENE
+
+// Generate scene on_exit handlers declaration
+#define ADD_SCENE(prefix, name, id) void prefix##_scene_##name##_on_exit(void* context);
+#include "hid_scene_config.h"
+#undef ADD_SCENE

applications/system/hid_app/scenes/hid_scene_config.h

@@ -0,0 +1,3 @@
+ADD_SCENE(hid, main, Main)
+ADD_SCENE(hid, unpair, Unpair)
+ADD_SCENE(hid, exit_confirm, ExitConfirm)

applications/system/hid_app/scenes/hid_scene_exit_confirm.c

@@ -0,0 +1,45 @@
+#include "../hid.h"
+#include "../views.h"
+
+static void hid_scene_exit_confirm_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) {
+        scene_manager_previous_scene(app->scene_manager);
+    } else if(result == DialogExResultCenter) {
+        scene_manager_search_and_switch_to_previous_scene(app->scene_manager, HidSceneMain);
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewSubmenu);
+    }
+}
+
+void hid_scene_exit_confirm_on_enter(void* context) {
+    Hid* app = context;
+
+    // Exit dialog view
+    dialog_ex_reset(app->dialog);
+    dialog_ex_set_result_callback(app->dialog, hid_scene_exit_confirm_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_switch_to_view(app->view_dispatcher, HidViewDialog);
+}
+
+bool hid_scene_exit_confirm_on_event(void* context, SceneManagerEvent event) {
+    Hid* app = context;
+    bool consumed = false;
+    UNUSED(app);
+    UNUSED(event);
+
+    return consumed;
+}
+
+void hid_scene_exit_confirm_on_exit(void* context) {
+    Hid* app = context;
+
+    dialog_ex_reset(app->dialog);
+}

applications/system/hid_app/scenes/hid_scene_main.c

@@ -0,0 +1,22 @@
+#include "../hid.h"
+#include "../views.h"
+
+void hid_scene_main_on_enter(void* context) {
+    Hid* app = context;
+
+    view_dispatcher_switch_to_view(app->view_dispatcher, app->view_id);
+}
+
+bool hid_scene_main_on_event(void* context, SceneManagerEvent event) {
+    Hid* app = context;
+    bool consumed = false;
+    UNUSED(app);
+    UNUSED(event);
+
+    return consumed;
+}
+
+void hid_scene_main_on_exit(void* context) {
+    Hid* app = context;
+    UNUSED(app);
+}

applications/system/hid_app/scenes/hid_scene_unpair.c

@@ -0,0 +1,63 @@
+#include "../hid.h"
+#include "../views.h"
+#include "hid_icons.h"
+
+static void hid_scene_unpair_dialog_callback(DialogExResult result, void* context) {
+    Hid* app = context;
+
+    if(result == DialogExResultRight) {
+        // Unpair all devices
+        bt_hid_remove_pairing(app);
+
+        // Show popup
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewPopup);
+    } else if(result == DialogExResultLeft) {
+        scene_manager_previous_scene(app->scene_manager);
+    }
+}
+
+void hid_scene_unpair_popup_callback(void* context) {
+    Hid* app = context;
+
+    scene_manager_previous_scene(app->scene_manager);
+}
+
+void hid_scene_unpair_on_enter(void* context) {
+    Hid* app = context;
+
+    // Un-pair dialog view
+    dialog_ex_reset(app->dialog);
+    dialog_ex_set_result_callback(app->dialog, hid_scene_unpair_dialog_callback);
+    dialog_ex_set_context(app->dialog, app);
+    dialog_ex_set_header(app->dialog, "Unpair All Devices?", 64, 3, AlignCenter, AlignTop);
+    dialog_ex_set_text(
+        app->dialog, "All previous pairings\nwill be lost!", 64, 22, AlignCenter, AlignTop);
+    dialog_ex_set_left_button_text(app->dialog, "Back");
+    dialog_ex_set_right_button_text(app->dialog, "Unpair");
+
+    // Un-pair success popup view
+    popup_set_icon(app->popup, 48, 6, &I_DolphinDone_80x58);
+    popup_set_header(app->popup, "Done", 14, 15, AlignLeft, AlignTop);
+    popup_set_timeout(app->popup, 1500);
+    popup_set_context(app->popup, app);
+    popup_set_callback(app->popup, hid_scene_unpair_popup_callback);
+    popup_enable_timeout(app->popup);
+
+    view_dispatcher_switch_to_view(app->view_dispatcher, HidViewDialog);
+}
+
+bool hid_scene_unpair_on_event(void* context, SceneManagerEvent event) {
+    Hid* app = context;
+    bool consumed = false;
+    UNUSED(app);
+    UNUSED(event);
+
+    return consumed;
+}
+
+void hid_scene_unpair_on_exit(void* context) {
+    Hid* app = context;
+
+    dialog_ex_reset(app->dialog);
+    popup_reset(app->popup);
+}

applications/system/hid_app/views.h

@@ -9,8 +9,10 @@ typedef enum {
     HidViewMouse,
     HidViewMouseClicker,
     HidViewMouseJiggler,
-    BtHidViewTikShorts,
+    BtHidViewTikTok,
     HidViewPushToTalk,
     HidViewPushToTalkMenu,
     HidViewPushToTalkHelp,
-} HidView;
+    HidViewDialog,
+    HidViewPopup,
+} HidView;

applications/system/hid_app/views/hid_keynote.c

@@ -116,16 +116,16 @@ static void hid_keynote_draw_vertical_callback(Canvas* canvas, void* context) {
     HidKeynoteModel* model = context;
 
     // Header
-    canvas_set_font(canvas, FontPrimary);
     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");
     }
 

applications/system/hid_app/views/hid_mouse_jiggler.h

@@ -3,6 +3,7 @@
 #include <gui/view.h>
 
 #define MOUSE_MOVE_SHORT 5
+#define MOUSE_MOVE_LONG 20
 
 typedef struct Hid Hid;
 typedef struct HidMouseJiggler HidMouseJiggler;

applications/system/hid_app/views/hid_tikshorts.h

@@ -1,14 +0,0 @@
-#pragma once
-
-#include <gui/view.h>
-
-typedef struct Hid Hid;
-typedef struct HidTikShorts HidTikShorts;
-
-HidTikShorts* hid_tikshorts_alloc(Hid* bt_hid);
-
-void hid_tikshorts_free(HidTikShorts* hid_tikshorts);
-
-View* hid_tikshorts_get_view(HidTikShorts* hid_tikshorts);
-
-void hid_tikshorts_set_connected_status(HidTikShorts* hid_tikshorts, bool connected);

applications/system/hid_app/views/hid_tiktok.c

@@ -1,12 +1,12 @@
-#include "hid_tikshorts.h"
+#include "hid_tiktok.h"
 #include "../hid.h"
 #include <gui/elements.h>
 
 #include "hid_icons.h"
 
-#define TAG "HidTikShorts"
+#define TAG "HidTikTok"
 
-struct HidTikShorts {
+struct HidTikTok {
     View* view;
     Hid* hid;
 };
@@ -21,11 +21,11 @@ typedef struct {
     bool is_cursor_set;
     bool back_mouse_pressed;
     HidTransport transport;
-} HidTikShortsModel;
+} HidTikTokModel;
 
-static void hid_tikshorts_draw_callback(Canvas* canvas, void* context) {
+static void hid_tiktok_draw_callback(Canvas* canvas, void* context) {
     furi_assert(context);
-    HidTikShortsModel* model = context;
+    HidTikTokModel* model = context;
 
     // Header
     if(model->transport == HidTransportBle) {
@@ -110,32 +110,30 @@ static void hid_tikshorts_draw_callback(Canvas* canvas, void* context) {
     elements_multiline_text_aligned(canvas, 13, 62, AlignLeft, AlignBottom, "Hold to exit");
 }
 
-static void hid_tikshorts_reset_cursor(HidTikShorts* hid_tikshorts) {
+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_tikshorts->hid, -127, -127);
+        hid_hal_mouse_move(hid_tiktok->hid, -127, -127);
         furi_delay_ms(50);
     }
     // Move cursor from the corner
-    hid_hal_mouse_move(hid_tikshorts->hid, 20, 120);
+    hid_hal_mouse_move(hid_tiktok->hid, 20, 120);
     furi_delay_ms(50);
 }
 
-static void hid_tikshorts_process_press(
-    HidTikShorts* hid_tikshorts,
-    HidTikShortsModel* model,
-    InputEvent* event) {
+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_tikshorts->hid, HID_CONSUMER_VOLUME_DECREMENT);
+        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_tikshorts->hid, HID_CONSUMER_VOLUME_INCREMENT);
+        hid_hal_consumer_key_press(hid_tiktok->hid, HID_CONSUMER_VOLUME_INCREMENT);
     } else if(event->key == InputKeyOk) {
         model->ok_pressed = true;
     } else if(event->key == InputKeyBack) {
@@ -143,20 +141,18 @@ static void hid_tikshorts_process_press(
     }
 }
 
-static void hid_tikshorts_process_release(
-    HidTikShorts* hid_tikshorts,
-    HidTikShortsModel* model,
-    InputEvent* event) {
+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_tikshorts->hid, HID_CONSUMER_VOLUME_DECREMENT);
+        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_tikshorts->hid, HID_CONSUMER_VOLUME_INCREMENT);
+        hid_hal_consumer_key_release(hid_tiktok->hid, HID_CONSUMER_VOLUME_INCREMENT);
     } else if(event->key == InputKeyOk) {
         model->ok_pressed = false;
     } else if(event->key == InputKeyBack) {
@@ -164,61 +160,61 @@ static void hid_tikshorts_process_release(
     }
 }
 
-static bool hid_tikshorts_input_callback(InputEvent* event, void* context) {
+static bool hid_tiktok_input_callback(InputEvent* event, void* context) {
     furi_assert(context);
-    HidTikShorts* hid_tikshorts = context;
+    HidTikTok* hid_tiktok = context;
     bool consumed = false;
 
     with_view_model(
-        hid_tikshorts->view,
-        HidTikShortsModel * model,
+        hid_tiktok->view,
+        HidTikTokModel * model,
         {
             if(event->type == InputTypePress) {
-                hid_tikshorts_process_press(hid_tikshorts, model, event);
+                hid_tiktok_process_press(hid_tiktok, model, event);
                 if(model->connected && !model->is_cursor_set) {
-                    hid_tikshorts_reset_cursor(hid_tikshorts);
+                    hid_tiktok_reset_cursor(hid_tiktok);
                     model->is_cursor_set = true;
                 }
                 consumed = true;
             } else if(event->type == InputTypeRelease) {
-                hid_tikshorts_process_release(hid_tikshorts, model, event);
+                hid_tiktok_process_release(hid_tiktok, model, event);
                 consumed = true;
             } else if(event->type == InputTypeShort) {
                 if(event->key == InputKeyOk) {
-                    hid_hal_mouse_press(hid_tikshorts->hid, HID_MOUSE_BTN_LEFT);
+                    hid_hal_mouse_press(hid_tiktok->hid, HID_MOUSE_BTN_LEFT);
                     furi_delay_ms(25);
-                    hid_hal_mouse_release(hid_tikshorts->hid, HID_MOUSE_BTN_LEFT);
+                    hid_hal_mouse_release(hid_tiktok->hid, HID_MOUSE_BTN_LEFT);
                     furi_delay_ms(100);
-                    hid_hal_mouse_press(hid_tikshorts->hid, HID_MOUSE_BTN_LEFT);
+                    hid_hal_mouse_press(hid_tiktok->hid, HID_MOUSE_BTN_LEFT);
                     furi_delay_ms(25);
-                    hid_hal_mouse_release(hid_tikshorts->hid, HID_MOUSE_BTN_LEFT);
-                    consumed = true;
-                } else if(event->key == InputKeyDown) {
-                    // Swipe to next video
-                    hid_hal_mouse_scroll(hid_tikshorts->hid, 6);
-                    hid_hal_mouse_scroll(hid_tikshorts->hid, 8);
-                    hid_hal_mouse_scroll(hid_tikshorts->hid, 10);
-                    hid_hal_mouse_scroll(hid_tikshorts->hid, 8);
-                    hid_hal_mouse_scroll(hid_tikshorts->hid, 6);
+                    hid_hal_mouse_release(hid_tiktok->hid, HID_MOUSE_BTN_LEFT);
                     consumed = true;
                 } else if(event->key == InputKeyUp) {
                     // Swipe to previous video
-                    hid_hal_mouse_scroll(hid_tikshorts->hid, -6);
-                    hid_hal_mouse_scroll(hid_tikshorts->hid, -8);
-                    hid_hal_mouse_scroll(hid_tikshorts->hid, -10);
-                    hid_hal_mouse_scroll(hid_tikshorts->hid, -8);
-                    hid_hal_mouse_scroll(hid_tikshorts->hid, -6);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, -6);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, -8);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, -10);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, -8);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, -6);
+                    consumed = true;
+                } else if(event->key == InputKeyDown) {
+                    // Swipe to next video
+                    hid_hal_mouse_scroll(hid_tiktok->hid, 6);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, 8);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, 10);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, 8);
+                    hid_hal_mouse_scroll(hid_tiktok->hid, 6);
                     consumed = true;
                 } else if(event->key == InputKeyBack) {
                     // Pause
-                    hid_hal_mouse_press(hid_tikshorts->hid, HID_MOUSE_BTN_LEFT);
+                    hid_hal_mouse_press(hid_tiktok->hid, HID_MOUSE_BTN_LEFT);
                     furi_delay_ms(50);
-                    hid_hal_mouse_release(hid_tikshorts->hid, HID_MOUSE_BTN_LEFT);
+                    hid_hal_mouse_release(hid_tiktok->hid, HID_MOUSE_BTN_LEFT);
                     consumed = true;
                 }
             } else if(event->type == InputTypeLong) {
                 if(event->key == InputKeyBack) {
-                    hid_hal_consumer_key_release_all(hid_tikshorts->hid);
+                    hid_hal_consumer_key_release_all(hid_tiktok->hid);
                     model->is_cursor_set = false;
                     consumed = false;
                 }
@@ -229,40 +225,37 @@ static bool hid_tikshorts_input_callback(InputEvent* event, void* context) {
     return consumed;
 }
 
-HidTikShorts* hid_tikshorts_alloc(Hid* bt_hid) {
-    HidTikShorts* hid_tikshorts = malloc(sizeof(HidTikShorts));
-    hid_tikshorts->hid = bt_hid;
-    hid_tikshorts->view = view_alloc();
-    view_set_context(hid_tikshorts->view, hid_tikshorts);
-    view_allocate_model(hid_tikshorts->view, ViewModelTypeLocking, sizeof(HidTikShortsModel));
-    view_set_draw_callback(hid_tikshorts->view, hid_tikshorts_draw_callback);
-    view_set_input_callback(hid_tikshorts->view, hid_tikshorts_input_callback);
+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_tikshorts->view,
-        HidTikShortsModel * model,
-        { model->transport = bt_hid->transport; },
-        true);
+        hid_tiktok->view, HidTikTokModel * model, { model->transport = bt_hid->transport; }, true);
 
-    return hid_tikshorts;
+    return hid_tiktok;
 }
 
-void hid_tikshorts_free(HidTikShorts* hid_tikshorts) {
-    furi_assert(hid_tikshorts);
-    view_free(hid_tikshorts->view);
-    free(hid_tikshorts);
+void hid_tiktok_free(HidTikTok* hid_tiktok) {
+    furi_assert(hid_tiktok);
+    view_free(hid_tiktok->view);
+    free(hid_tiktok);
 }
 
-View* hid_tikshorts_get_view(HidTikShorts* hid_tikshorts) {
-    furi_assert(hid_tikshorts);
-    return hid_tikshorts->view;
+View* hid_tiktok_get_view(HidTikTok* hid_tiktok) {
+    furi_assert(hid_tiktok);
+    return hid_tiktok->view;
 }
 
-void hid_tikshorts_set_connected_status(HidTikShorts* hid_tikshorts, bool connected) {
-    furi_assert(hid_tikshorts);
+void hid_tiktok_set_connected_status(HidTikTok* hid_tiktok, bool connected) {
+    furi_assert(hid_tiktok);
     with_view_model(
-        hid_tikshorts->view,
-        HidTikShortsModel * model,
+        hid_tiktok->view,
+        HidTikTokModel * model,
         {
             model->connected = connected;
             model->is_cursor_set = false;

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