add buggy extra config UI for bad usb (for implementing BLE and UART)

applications/main/bad_usb/bad_usb_app.c

@@ -5,8 +5,14 @@
 #include <storage/storage.h>
 #include <lib/toolbox/path.h>
 
+// ble hid
+#include <bt/bt_service/bt.h>
+#include <applications/plugins/hid_app/hid.h>
+
 #define BAD_USB_SETTINGS_PATH BAD_USB_APP_BASE_FOLDER "/" BAD_USB_SETTINGS_FILE_NAME
 
+#define BAD_USB_LOGFILE_PATH BAD_USB_APP_BASE_FOLDER "/debug.log"
+
 static bool bad_usb_app_custom_event_callback(void* context, uint32_t event) {
     furi_assert(context);
     BadUsbApp* app = context;
@@ -54,6 +60,16 @@ static void bad_usb_save_settings(BadUsbApp* app) {
 BadUsbApp* bad_usb_app_alloc(char* arg) {
     BadUsbApp* app = malloc(sizeof(BadUsbApp));
 
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+    File* file = storage_file_alloc(storage);
+    if(!storage_file_open(file, BAD_USB_LOGFILE_PATH, FSAM_WRITE, FSOM_OPEN_APPEND)) {
+        FURI_LOG_E("BadUsbApp", "Can't open debug log file");
+        storage_file_close(file);
+        app->debug_file = NULL;
+    } else {
+        app->debug_file = file;
+    }
+
     app->bad_usb_script = NULL;
 
     app->file_path = furi_string_alloc();
@@ -86,9 +102,19 @@ BadUsbApp* bad_usb_app_alloc(char* arg) {
     view_dispatcher_add_view(
         app->view_dispatcher, BadUsbAppViewError, widget_get_view(app->widget));
 
-    app->submenu = submenu_alloc();
+    // app->submenu = submenu_alloc();
+    // view_dispatcher_add_view(
+    //     app->view_dispatcher, BadUsbAppViewConfig, submenu_get_view(app->submenu));
+
+    app->variable_item_list = variable_item_list_alloc();
     view_dispatcher_add_view(
-        app->view_dispatcher, BadUsbAppViewConfig, submenu_get_view(app->submenu));
+        app->view_dispatcher,
+        BadUsbAppViewConfig,
+        variable_item_list_get_view(app->variable_item_list));
+    app->menu_idx = 0;
+    for(int i = 0; i < NUM_CONF_OPT; i++) {
+        app->menu_opt_idx[i] = 0;
+    }
 
     app->bad_usb_view = bad_usb_alloc();
     view_dispatcher_add_view(
@@ -96,6 +122,10 @@ BadUsbApp* bad_usb_app_alloc(char* arg) {
 
     view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
 
+    // default injection mode is USB
+    app->mode = BadUsbModeUSB;
+    F_DEBUG(app, "Starting BadUSB app\r\n");
+
     if(furi_hal_usb_is_locked()) {
         app->error = BadUsbAppErrorCloseRpc;
         scene_manager_next_scene(app->scene_manager, BadUsbSceneError);
@@ -121,6 +151,10 @@ void bad_usb_app_free(BadUsbApp* app) {
         app->bad_usb_script = NULL;
     }
 
+    // BLE HID
+    F_DEBUG(app, "Stopping BLE HID");
+    furi_hal_bt_hid_stop();
+
     // Views
     view_dispatcher_remove_view(app->view_dispatcher, BadUsbAppViewWork);
     bad_usb_free(app->bad_usb_view);
@@ -130,8 +164,12 @@ void bad_usb_app_free(BadUsbApp* app) {
     widget_free(app->widget);
 
     // Submenu
+    // view_dispatcher_remove_view(app->view_dispatcher, BadUsbAppViewConfig);
+    // submenu_free(app->submenu);
+
+    // Variable Item List
     view_dispatcher_remove_view(app->view_dispatcher, BadUsbAppViewConfig);
-    submenu_free(app->submenu);
+    variable_item_list_free(app->variable_item_list);
 
     // View dispatcher
     view_dispatcher_free(app->view_dispatcher);
@@ -147,6 +185,12 @@ void bad_usb_app_free(BadUsbApp* app) {
     furi_string_free(app->file_path);
     furi_string_free(app->keyboard_layout);
 
+    if(app->debug_file) {
+        storage_file_close(app->debug_file);
+        storage_file_free(app->debug_file);
+    }
+    furi_record_close(RECORD_STORAGE);
+
     free(app);
 }
 

applications/main/bad_usb/bad_usb_app_i.h

@@ -3,6 +3,10 @@
 #include "bad_usb_app.h"
 #include "scenes/bad_usb_scene.h"
 #include "bad_usb_script.h"
+#include "bad_usb_custom_event.h"
+#include "bad_usb_script.h"
+
+#include <storage/storage.h>
 
 #include <gui/gui.h>
 #include <bad_usb_icons.h>
@@ -20,11 +24,16 @@
 #define BAD_USB_APP_SCRIPT_EXTENSION ".txt"
 #define BAD_USB_APP_LAYOUT_EXTENSION ".kl"
 
+#define NUM_CONF_ITEM 3 // modify here if you add new item in config menu
+#define NUM_CONF_OPT BadUsbModeNb // for now, scaled on hid mode (ble or usb)
+
 typedef enum {
     BadUsbAppErrorNoFiles,
     BadUsbAppErrorCloseRpc,
 } BadUsbAppError;
 
+#define F_DEBUG(app, s) do { if(app->debug_file) { storage_file_write(app->debug_file, s, strlen(s)); } } while(0)
+
 struct BadUsbApp {
     Gui* gui;
     ViewDispatcher* view_dispatcher;
@@ -32,17 +41,26 @@ struct BadUsbApp {
     NotificationApp* notifications;
     DialogsApp* dialogs;
     Widget* widget;
-    Submenu* submenu;
+
+    //Submenu* submenu;
+    VariableItemList* variable_item_list;
+    uint8_t menu_idx;
+    uint8_t menu_opt_idx[NUM_CONF_OPT];
 
     BadUsbAppError error;
     FuriString* file_path;
     FuriString* keyboard_layout;
     BadUsb* bad_usb_view;
     BadUsbScript* bad_usb_script;
+    BadUsbMode mode;
+
+    File *debug_file;
 };
 
 typedef enum {
     BadUsbAppViewError,
     BadUsbAppViewWork,
     BadUsbAppViewConfig,
+    // for ble hid related information
+    BadUsbAppViewConfigBle
 } BadUsbAppView;

applications/main/bad_usb/bad_usb_custom_event.h

@@ -0,0 +1,11 @@
+#pragma once
+
+typedef enum {
+    BadUsbCustomEventKeyboardLayout,
+    BadUsbCustomEventModeUSB,
+    BadUsbCustomEventModeBLE,
+    BadUsbCustomEventModeUART,
+    BadUsbCustomEventConfigBle,
+    BadUsbCustomEventErrorBack,
+    BadUsbCustomEventNb,
+} BadUsbCustomEvent;

applications/main/bad_usb/bad_usb_script.c

@@ -8,6 +8,10 @@
 #include "bad_usb_script.h"
 #include <dolphin/dolphin.h>
 
+
+#include <furi_hal_bt_hid.h>
+#include <furi_hal_bt.h>
+
 #define TAG "BadUSB"
 #define WORKER_TAG TAG "Worker"
 #define FILE_BUFFER_LEN 16
@@ -720,7 +724,7 @@ void bad_usb_script_set_keyboard_layout(BadUsbScript* bad_usb, FuriString* layou
     storage_file_free(layout_file);
 }
 
-void bad_usb_script_toggle(BadUsbScript* bad_usb) {
+void bad_usb_script_toggle(BadUsbScript* bad_usb, BadUsbMode mode) {
     furi_assert(bad_usb);
     furi_thread_flags_set(furi_thread_get_id(bad_usb->thread), WorkerEvtToggle);
 }

applications/main/bad_usb/bad_usb_script.h

@@ -29,6 +29,8 @@ typedef struct {
     char error[64];
 } BadUsbState;
 
+typedef enum { BadUsbModeUSB, BadUsbModeBLE, BadUsbModeUART, BadUsbModeNb } BadUsbMode;
+
 BadUsbScript* bad_usb_script_open(FuriString* file_path);
 
 void bad_usb_script_close(BadUsbScript* bad_usb);
@@ -39,9 +41,7 @@ void bad_usb_script_start(BadUsbScript* bad_usb);
 
 void bad_usb_script_stop(BadUsbScript* bad_usb);
 
-void bad_usb_script_toggle(BadUsbScript* bad_usb);
+void bad_usb_script_toggle(BadUsbScript* bad_usb, BadUsbMode mode);
-
-BadUsbState* bad_usb_script_get_state(BadUsbScript* bad_usb);
 
 #ifdef __cplusplus
 }

applications/main/bad_usb/scenes/bad_usb_scene_config.c

@@ -1,53 +1,219 @@
 #include "../bad_usb_app_i.h"
 #include "furi_hal_power.h"
 #include "furi_hal_usb.h"
+#include "../bad_usb_script.h"
 
-enum SubmenuIndex {
+// enum SubmenuIndex {
-    SubmenuIndexKeyboardLayout,
+//     SubmenuIndexKeyboardLayout,
+//     SubmenuIndexInjectionMode,
+//     SubmenuIndexBleConfig
+// };
+
+enum VariableListIndex {
+    VariableListIndexKeyboardLayout,
+    VariableListIndexInjectionMode,
+    VariableListIndexBleConfig
 };
 
-void bad_usb_scene_config_submenu_callback(void* context, uint32_t index) {
+typedef struct BadUsbConfigItem {
+    const char* name;
+    uint8_t num_options_menu;
+    const char* options_menu[NUM_CONF_OPT];
+} BadUsbConfigItem;
+
+const BadUsbCustomEvent bad_usb_custom_events_mode[NUM_CONF_OPT] = {
+    BadUsbCustomEventModeUSB,
+    BadUsbCustomEventModeBLE,
+    BadUsbCustomEventModeUART
+};
+
+#define NUM_BAD_USB_CONFIG_ITEMS 3
+const BadUsbConfigItem bad_usb_config_items[NUM_BAD_USB_CONFIG_ITEMS] = {
+    {"Keyboard layout", 1, {""}},
+    {"Injection mode", 3, {"USB", "BLE", "UART"}},
+    {"BLE Config", 1, {""}},
+};
+
+// void bad_usb_scene_config_submenu_callback(void* context, uint32_t index) {
+//     BadUsbApp* bad_usb = context;
+//     view_dispatcher_send_custom_event(bad_usb->view_dispatcher, index);
+// }
+
+void bad_usb_scene_config_var_list_callback(void* context, uint32_t index) {
     BadUsbApp* bad_usb = context;
     view_dispatcher_send_custom_event(bad_usb->view_dispatcher, index);
 }
 
+void bad_usb_scene_config_var_list_enter_callback(void* context, uint32_t index) {
+    BadUsbApp* bad_usb = context;
+
+    F_DEBUG(bad_usb, "[+] bad_usb_scene_config_var_list_enter_callback\r\n");
+
+    if (index == VariableListIndexKeyboardLayout) {
+        view_dispatcher_send_custom_event(bad_usb->view_dispatcher, BadUsbCustomEventKeyboardLayout);
+    } else if (index == VariableListIndexInjectionMode) {
+        int menu_opt_idx = bad_usb->menu_opt_idx[index]; 
+        view_dispatcher_send_custom_event(bad_usb->view_dispatcher, bad_usb_custom_events_mode[menu_opt_idx]);
+    } else if (index == VariableListIndexBleConfig) {
+        view_dispatcher_send_custom_event(bad_usb->view_dispatcher, BadUsbCustomEventConfigBle);
+    }
+
+    F_DEBUG(bad_usb, "[-] bad_usb_scene_config_var_list_enter_callback\r\n");
+}
+
+void bad_usb_scene_config_var_list_change_callback(VariableItem *item) {
+    furi_assert(item);
+    BadUsbApp* bad_usb = variable_item_get_context(item);
+    furi_assert(bad_usb);
+
+    F_DEBUG(bad_usb, "[+] bad_usb_scene_config_var_list_change_callback\r\n");
+    BadUsbConfigItem *menu_item = &bad_usb_config_items[bad_usb->menu_idx];
+    uint8_t item_index = variable_item_get_current_value_index(item); 
+    furi_assert(item_index < menu_item->num_options_menu);
+    variable_item_set_current_value_text(item, menu_item->options_menu[item_index]);
+    bad_usb->menu_opt_idx[bad_usb->menu_idx] = item_index;
+    F_DEBUG(bad_usb, "[-] bad_usb_scene_config_var_list_change_callback\r\n");
+}
+
 void bad_usb_scene_config_on_enter(void* context) {
     BadUsbApp* bad_usb = context;
-    Submenu* submenu = bad_usb->submenu;
+    //Submenu* submenu = bad_usb->submenu;
+    char toggle_label[32];
+    VariableItemList *item_list = bad_usb->variable_item_list;
+    VariableItem *item = NULL;
 
-    submenu_add_item(
+    char debug_buf[256];
-        submenu,
-        "Keyboard layout",
-        SubmenuIndexKeyboardLayout,
-        bad_usb_scene_config_submenu_callback,
-        bad_usb);
 
-    submenu_set_selected_item(
+    F_DEBUG(bad_usb, "[+] BadUsbSceneConfig on_enter\r\n");
-        submenu, scene_manager_get_scene_state(bad_usb->scene_manager, BadUsbSceneConfig));
+
+    F_DEBUG(bad_usb, "Setting up variable item list\r\n");
+    variable_item_list_set_enter_callback(
+        item_list, bad_usb_scene_config_var_list_enter_callback, bad_usb);
+
+    for (int i=0; i<NUM_BAD_USB_CONFIG_ITEMS; i++) {
+        item = variable_item_list_add(
+            item_list,
+            bad_usb_config_items[i].name,
+            bad_usb_config_items[i].num_options_menu,
+            bad_usb_scene_config_var_list_change_callback,
+            bad_usb
+        );
+        variable_item_set_current_value_index(item, bad_usb->menu_opt_idx[i]);
+        variable_item_set_current_value_text(
+            item, bad_usb_config_items[i].options_menu[bad_usb->menu_opt_idx[i]]);
+
+        snprintf(debug_buf, sizeof(debug_buf), "Added item %s, index %d, opt_idx %d\r\n",
+            bad_usb_config_items[i].name, i, bad_usb->menu_opt_idx[i]);
+        F_DEBUG(bad_usb, debug_buf);
+    }
+
+    variable_item_list_set_selected_item(
+        item_list, scene_manager_get_scene_state(bad_usb->scene_manager, BadUsbSceneConfig));
+
+
+    // submenu_add_item(
+    //     submenu,        "Keyboard layout",
+    //     SubmenuIndexKeyboardLayout,
+    //     bad_usb_scene_config_submenu_callback,
+    //     bad_usb);
+
+    // furi_assert(bad_usb->bad_usb_script);
+    // // switch for choising Bad-USB or Bad-BLE
+    // BadUsbScriptMode hid_mode = bad_usb_script_get_hid_mode(bad_usb->bad_usb_script);
+    // furi_assert(hid_mode < BadUsbScriptModeNb);
+    // snprintf(toggle_label, sizeof(toggle_label), "Toggle Mode: %s", ducky_mode_names[hid_mode]);
+    // submenu_add_item(
+    //     submenu,
+    //     toggle_label,
+    //     SubmenuIndexInjectionMode,
+    //     bad_usb_scene_config_submenu_callback,
+    //     bad_usb);
+
+    // submenu_add_item(
+    //     submenu,        "BLE Config",
+    //     SubmenuIndexBleConfig,
+    //     bad_usb_scene_config_submenu_callback,
+    //     bad_usb);
+
+    // submenu_set_selected_item(
+    //     submenu, scene_manager_get_scene_state(bad_usb->scene_manager, BadUsbSceneConfig));
 
     view_dispatcher_switch_to_view(bad_usb->view_dispatcher, BadUsbAppViewConfig);
+    
+    F_DEBUG(bad_usb, "[-] BadUsbSceneConfig on_enter\r\n");
 }
 
 bool bad_usb_scene_config_on_event(void* context, SceneManagerEvent event) {
+    // BadUsbApp* bad_usb = context;
+    // bool consumed = false;
+
+    // if(event.type == SceneManagerEventTypeCustom) {
+    //     scene_manager_set_scene_state(bad_usb->scene_manager, BadUsbSceneConfig, event.event);
+    //     consumed = true;
+    //     if(event.event == SubmenuIndexKeyboardLayout) {
+    //         scene_manager_next_scene(bad_usb->scene_manager, BadUsbSceneConfigLayout);
+    //     } else if (event.event == SubmenuIndexInjectionMode) {
+    //         BadUsbScriptMode hid_mode = bad_usb_script_get_hid_mode(bad_usb->bad_usb_script);
+    //         if (hid_mode == BadUsbScriptModeUSB) {
+    //             bad_usb_script_set_hid_mode(bad_usb->bad_usb_script, BadUsbScriptModeBLE);
+    //         } else {
+    //             bad_usb_script_set_hid_mode(bad_usb->bad_usb_script, BadUsbScriptModeUSB);
+    //         }
+    //         scene_manager_next_scene(bad_usb->scene_manager, BadUsbSceneConfig);
+    //     } else if (event.event == SubmenuIndexBleConfig) {
+    //         //scene_manager_next_scene(bad_usb->scene_manager, BadUsbSceneConfigBleHid);
+    //     } else {
+    //         furi_crash("Unknown key type");
+    //     }
+    // }
+
+    // return consumed;
+    furi_assert(context);
     BadUsbApp* bad_usb = context;
     bool consumed = false;
+    char debug_buf[256];
 
+    F_DEBUG(bad_usb, "[+] BadUsbSceneConfig on_event\r\n");
     if(event.type == SceneManagerEventTypeCustom) {
-        scene_manager_set_scene_state(bad_usb->scene_manager, BadUsbSceneConfig, event.event);
         consumed = true;
-        if(event.event == SubmenuIndexKeyboardLayout) {
+        if(event.event == BadUsbCustomEventKeyboardLayout) {
+            scene_manager_set_scene_state(bad_usb->scene_manager, BadUsbSceneConfig, bad_usb->menu_idx);
             scene_manager_next_scene(bad_usb->scene_manager, BadUsbSceneConfigLayout);
+        } else if(event.event == BadUsbCustomEventModeUSB) {
+            F_DEBUG(bad_usb, "mode usb triggered !\r\n");
+            scene_manager_set_scene_state(bad_usb->scene_manager, BadUsbSceneConfig, bad_usb->menu_idx);
+            bad_usb->mode = BadUsbModeUSB;
+        } else if (event.event == BadUsbCustomEventModeBLE) {
+            F_DEBUG(bad_usb, "mode ble triggered !\r\n");
+            scene_manager_set_scene_state(bad_usb->scene_manager, BadUsbSceneConfig, bad_usb->menu_idx);
+            bad_usb->mode = BadUsbModeBLE;
+        } else if (event.event == BadUsbCustomEventModeUART) {
+            F_DEBUG(bad_usb, "mode uart triggered !\r\n");
+            scene_manager_set_scene_state(bad_usb->scene_manager, BadUsbSceneConfig, bad_usb->menu_idx);
+            bad_usb->mode = BadUsbModeUART;
+        } else if (event.event == BadUsbCustomEventConfigBle) {
+            //scene_manager_next_scene(bad_usb->scene_manager, BadUsbSceneConfigBleHid);
         } else {
             furi_crash("Unknown key type");
         }
+    } else if(event.type == SceneManagerEventTypeTick) {
+        bad_usb->menu_idx = variable_item_list_get_selected_item_index(bad_usb->variable_item_list);
+        snprintf(debug_buf, sizeof(debug_buf), "menu_idx: %d\r\n", bad_usb->menu_idx);
+        F_DEBUG(bad_usb, debug_buf);
+        consumed = true;
     }
 
+    F_DEBUG(bad_usb, "[-] BadUsbSceneConfig on_event\r\n");
     return consumed;
 }
 
 void bad_usb_scene_config_on_exit(void* context) {
     BadUsbApp* bad_usb = context;
-    Submenu* submenu = bad_usb->submenu;
+    //Submenu* submenu = bad_usb->submenu;
+
+    //submenu_reset(submenu);
+
+    VariableItemList *item_list = bad_usb->variable_item_list;
+    variable_item_list_reset(item_list);
 
-    submenu_reset(submenu);
 }

applications/main/bad_usb/scenes/bad_usb_scene_config.h

@@ -3,3 +3,5 @@ ADD_SCENE(bad_usb, work, Work)
 ADD_SCENE(bad_usb, error, Error)
 ADD_SCENE(bad_usb, config, Config)
 ADD_SCENE(bad_usb, config_layout, ConfigLayout)
+// BLE HID config
+// ADD_SCENE(bad_usb, config_ble_hid, ConfigBleHid)

applications/main/bad_usb/scenes/bad_usb_scene_error.c

@@ -1,8 +1,8 @@
 #include "../bad_usb_app_i.h"
 
-typedef enum {
+// typedef enum {
-    BadUsbCustomEventErrorBack,
+//     BadUsbCustomEventErrorBack,
-} BadUsbCustomEvent;
+// } BadUsbCustomEvent;
 
 static void
     bad_usb_scene_error_event_callback(GuiButtonType result, InputType type, void* context) {

applications/main/bad_usb/scenes/bad_usb_scene_work.c

@@ -19,7 +19,7 @@ bool bad_usb_scene_work_on_event(void* context, SceneManagerEvent event) {
             scene_manager_next_scene(app->scene_manager, BadUsbSceneConfig);
             consumed = true;
         } else if(event.event == InputKeyOk) {
-            bad_usb_script_toggle(app->bad_usb_script);
+            bad_usb_script_toggle(app->bad_usb_script, app->mode);
             consumed = true;
         }
     } else if(event.type == SceneManagerEventTypeTick) {

applications/main/gpio/scenes/gpio_scene_start.c

@@ -1,3 +1,6 @@
+#ifndef __GPIO_SCENE_START_H__
+#define __GPIO_SCENE_START_H__
+
 #include "../gpio_app_i.h"
 #include "furi_hal_power.h"
 #include "furi_hal_usb.h"
@@ -35,7 +38,8 @@ static void gpio_scene_start_var_list_enter_callback(void* context, uint32_t ind
     }
 }
 
-static void gpio_scene_start_var_list_change_callback(VariableItem* item) {
+static void 
+gpio_scene_start_var_list_change_callback(VariableItem* item) {
     GpioApp* app = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
 
@@ -117,3 +121,5 @@ void gpio_scene_start_on_exit(void* context) {
     GpioApp* app = context;
     variable_item_list_reset(app->var_item_list);
 }
+
+#endif // __GPIO_SCENE_START_H__

firmware/targets/f7/ble_glue/gap.c

@@ -313,7 +313,7 @@ static void gap_init_svc(Gap* gap) {
     // Initialize GATT interface
     aci_gatt_init();
     // Initialize GAP interface
-    // Skip fist symbol AD_TYPE_COMPLETE_LOCAL_NAME
+    // Skip first symbol AD_TYPE_COMPLETE_LOCAL_NAME
     char* name = gap->service.adv_name + 1;
     aci_gap_init(
         GAP_PERIPHERAL_ROLE,

firmware/targets/f7/furi_hal/furi_hal_bt.c

@@ -73,7 +73,7 @@ FuriHalBtProfileConfig profile_config[FuriHalBtProfileNumber] = {
                             .supervisor_timeout = 0,
                         },
                 },
-        },
+        }
 };
 FuriHalBtProfileConfig* current_profile = NULL;
 

firmware/targets/f7/furi_hal/furi_hal_bt_hid.c

@@ -139,9 +139,24 @@ void furi_hal_bt_hid_start() {
         hid_svc_start();
     }
     // Configure HID Keyboard
+    //
+    // this will also be called by Bad-usb now, so we need to prevent memory leak
+    // I dont know for now, how apps and mains interacts together, so lets add some 
+    // protection in case a crash in one doesn't affect the other
+    if(kb_report)
+        memset(kb_report, 0, sizeof(FuriHalBtHidKbReport));
+    else
         kb_report = malloc(sizeof(FuriHalBtHidKbReport));
+
+    if(mouse_report)
+        memset(mouse_report, 0, sizeof(FuriHalBtHidMouseReport));
+    else
         mouse_report = malloc(sizeof(FuriHalBtHidMouseReport));
+    if(consumer_report)
+        memset(consumer_report, 0, sizeof(FuriHalBtHidConsumerReport));
+    else
         consumer_report = malloc(sizeof(FuriHalBtHidConsumerReport));
+
     // Configure Report Map characteristic
     hid_svc_update_report_map(
         furi_hal_bt_hid_report_map_data, sizeof(furi_hal_bt_hid_report_map_data));