Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-04-24 03:29:57 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'dev' of https://github.com/DarkFlippers/unleashed-firmware into mntm-dev --nobuild

Browse Source
This commit is contained in:
Willy-JL
2024-05-16 05:03:33 +01:00
parent c2b7b9c60f 0ae78dfcdd
commit b628af1060
18 changed files with 350 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
applications/services/gui/modules/submenu.h
View File

@@ -53,14 +53,6 @@ void submenu_add_item(
SubmenuItemCallback callback,
void* callback_context);
/** Change label of an existing item
*
* @param submenu Submenu instance
* @param index The index of the item
* @param label The new label
*/
void submenu_change_item_label(Submenu* submenu, uint32_t index, const char* label);
/** Add lockable item to submenu
*
* @param submenu Submenu instance
@@ -81,6 +73,14 @@ void submenu_add_lockable_item(
bool locked,
const char* locked_message);
/** Change label of an existing item
*
* @param submenu Submenu instance
* @param index The index of the item
* @param label The new label
*/
void submenu_change_item_label(Submenu* submenu, uint32_t index, const char* label);
/** Remove all items from submenu
*
* @param submenu Submenu instance

11
applications/system/hid_app/hid.c
View File

@@ -48,6 +48,7 @@ static void bt_hid_connection_status_changed_callback(BtStatus status, void* con
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_mouse_jiggler_stealth_set_connected_status(hid->hid_mouse_jiggler_stealth, connected);
hid_ptt_set_connected_status(hid->hid_ptt, connected);
hid_tiktok_set_connected_status(hid->hid_tiktok, connected);
}
@@ -57,7 +58,7 @@ static uint32_t hid_ptt_menu_view(void* context) {
return HidViewPushToTalkMenu;
}
Hid* hid_alloc() {
Hid* hid_alloc(void) {
Hid* app = malloc(sizeof(Hid));
// Gui
@@ -146,6 +147,12 @@ Hid* hid_alloc() {
app->view_dispatcher,
HidViewMouseJiggler,
hid_mouse_jiggler_get_view(app->hid_mouse_jiggler));
// Mouse jiggler stealth view
app->hid_mouse_jiggler_stealth = hid_mouse_jiggler_stealth_alloc(app);
view_dispatcher_add_view(
app->view_dispatcher,
HidViewMouseJigglerStealth,
hid_mouse_jiggler_stealth_get_view(app->hid_mouse_jiggler_stealth));
// PushToTalk view
app->hid_ptt_menu = hid_ptt_menu_alloc(app);
@@ -191,6 +198,8 @@ void hid_free(Hid* app) {
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, HidViewMouseJigglerStealth);
hid_mouse_jiggler_stealth_free(app->hid_mouse_jiggler_stealth);
view_dispatcher_remove_view(app->view_dispatcher, HidViewPushToTalkMenu);
hid_ptt_menu_free(app->hid_ptt_menu);
view_dispatcher_remove_view(app->view_dispatcher, HidViewPushToTalk);

2
applications/system/hid_app/hid.h
View File

@@ -27,6 +27,7 @@
#include "views/hid_mouse.h"
#include "views/hid_mouse_clicker.h"
#include "views/hid_mouse_jiggler.h"
#include "views/hid_mouse_jiggler_stealth.h"
#include "views/hid_tiktok.h"
#include "views/hid_ptt.h"
#include "views/hid_ptt_menu.h"
@@ -56,6 +57,7 @@ struct Hid {
HidMouse* hid_mouse;
HidMouseClicker* hid_mouse_clicker;
HidMouseJiggler* hid_mouse_jiggler;
HidMouseJigglerStealth* hid_mouse_jiggler_stealth;
HidTikTok* hid_tiktok;
HidPushToTalk* hid_ptt;
HidPushToTalkMenu* hid_ptt_menu;

2
applications/system/hid_app/scenes/hid_scene_config.h
View File

@@ -1,3 +1,3 @@
ADD_SCENE(hid, start, Start)
ADD_SCENE(hid, main, Main)
ADD_SCENE(hid, unpair, Unpair)
ADD_SCENE(hid, unpair, Unpair)

1
applications/system/hid_app/scenes/hid_scene_main.c
View File

@@ -3,6 +3,7 @@
void hid_scene_main_on_enter(void* context) {
Hid* app = context;
view_dispatcher_switch_to_view(
app->view_dispatcher, scene_manager_get_scene_state(app->scene_manager, HidSceneMain));
}

10
applications/system/hid_app/scenes/hid_scene_start.c
View File

@@ -13,6 +13,7 @@ enum HidSubmenuIndex {
HidSubmenuIndexMouse,
HidSubmenuIndexMouseClicker,
HidSubmenuIndexMouseJiggler,
HidSubmenuIndexMouseJigglerStealth,
HidSubmenuIndexPushToTalk,
HidSubmenuIndexRemovePairing,
};
@@ -67,6 +68,12 @@ void hid_scene_start_on_enter(void* context) {
HidSubmenuIndexMouseJiggler,
hid_scene_start_submenu_callback,
app);
submenu_add_item(
app->submenu,
"Mouse Jiggler Stealth",
HidSubmenuIndexMouseJigglerStealth,
hid_scene_start_submenu_callback,
app);
submenu_add_item(
app->submenu,
"PushToTalk",
@@ -133,6 +140,9 @@ bool hid_scene_start_on_event(void* context, SceneManagerEvent event) {
case HidSubmenuIndexMouseJiggler:
view_id = HidViewMouseJiggler;
break;
case HidSubmenuIndexMouseJigglerStealth:
view_id = HidViewMouseJigglerStealth;
break;
case HidSubmenuIndexPushToTalk:
view_id = HidViewPushToTalkMenu;
break;

1
applications/system/hid_app/views.h
View File

@@ -9,6 +9,7 @@ typedef enum {
HidViewMouse,
HidViewMouseClicker,
HidViewMouseJiggler,
HidViewMouseJigglerStealth,
BtHidViewTikTok,
HidViewPushToTalk,
HidViewPushToTalkMenu,

5
applications/system/hid_app/views/hid_keyboard.c
View File

@@ -228,7 +228,7 @@ static void hid_keyboard_draw_callback(Canvas* canvas, void* context) {
furi_assert(context);
HidKeyboardModel* model = context;
// Header
// Header
#ifdef HID_TRANSPORT_BLE
if(!model->connected) {
canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
@@ -400,8 +400,7 @@ HidKeyboard* hid_keyboard_alloc(Hid* bt_hid) {
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->y = 1; }, true);
with_view_model(hid_keyboard->view, HidKeyboardModel * model, { model->y = 1; }, true);
return hid_keyboard;
}

5
applications/system/hid_app/views/hid_keynote.c
View File

@@ -38,7 +38,7 @@ static void hid_keynote_draw_callback(Canvas* canvas, void* context) {
furi_assert(context);
HidKeynoteModel* model = context;
// Header
// Header
#ifdef HID_TRANSPORT_BLE
if(model->connected) {
canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -114,7 +114,7 @@ static void hid_keynote_draw_vertical_callback(Canvas* canvas, void* context) {
furi_assert(context);
HidKeynoteModel* model = context;
// Header
// Header
#ifdef HID_TRANSPORT_BLE
if(model->connected) {
canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -273,6 +273,7 @@ HidKeynote* hid_keynote_alloc(Hid* hid) {
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);
return hid_keynote;
}

3
applications/system/hid_app/views/hid_media.c
View File

@@ -41,7 +41,7 @@ static void hid_media_draw_callback(Canvas* canvas, void* context) {
furi_assert(context);
HidMediaModel* model = context;
// Header
// Header
#ifdef HID_TRANSPORT_BLE
if(model->connected) {
canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -208,6 +208,7 @@ HidMedia* hid_media_alloc(Hid* hid) {
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);
return hid_media;
}

3
applications/system/hid_app/views/hid_mouse.c
View File

@@ -27,7 +27,7 @@ static void hid_mouse_draw_callback(Canvas* canvas, void* context) {
furi_assert(context);
HidMouseModel* model = context;
// Header
// Header
#ifdef HID_TRANSPORT_BLE
if(model->connected) {
canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -226,6 +226,7 @@ HidMouse* hid_mouse_alloc(Hid* hid) {
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);
return hid_mouse;
}

46
applications/system/hid_app/views/hid_mouse_clicker.c
View File

@@ -42,7 +42,7 @@ static void hid_mouse_clicker_draw_callback(Canvas* canvas, void* context) {
furi_assert(context);
HidMouseClickerModel* model = context;
// Header
// Header
#ifdef HID_TRANSPORT_BLE
if(model->connected) {
canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -52,37 +52,37 @@ static void hid_mouse_clicker_draw_callback(Canvas* canvas, void* context) {
#endif
canvas_set_font(canvas, FontPrimary);
elements_multiline_text_aligned(canvas, 17, 3, AlignLeft, AlignTop, "Mouse Clicker");
canvas_set_font(canvas, FontSecondary);
elements_multiline_text_aligned(canvas, 27, 3, AlignLeft, AlignTop, "Mouse Clicker");
// Ok
canvas_draw_icon(canvas, 58, 25, &I_Space_65x18);
canvas_draw_icon(canvas, 63, 25, &I_Space_65x18);
if(model->running) {
elements_slightly_rounded_box(canvas, 61, 27, 60, 13);
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);
}
canvas_draw_icon(canvas, 69, 29, &I_Ok_btn_9x9);
if(model->running) {
elements_multiline_text_aligned(canvas, 86, 37, AlignLeft, AlignBottom, "Stop");
} else {
elements_multiline_text_aligned(canvas, 86, 37, AlignLeft, AlignBottom, "Start");
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);
// Clicks/s
char label[20];
snprintf(label, sizeof(label), "%d clicks/s", model->rate);
elements_multiline_text_aligned(canvas, 28, 37, AlignCenter, AlignBottom, label);
canvas_draw_icon(canvas, 25, 20, &I_ButtonUp_7x4);
canvas_draw_icon(canvas, 25, 44, &I_ButtonDown_7x4);
// Back
canvas_draw_icon(canvas, 0, 54, &I_Pin_back_arrow_10x8);
elements_multiline_text_aligned(canvas, 13, 62, AlignLeft, AlignBottom, "Exit");
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) {

126
applications/system/hid_app/views/hid_mouse_jiggler.c
View File

@@ -15,15 +15,17 @@ struct HidMouseJiggler {
typedef struct {
bool connected;
bool running;
int min_interval; // Minimum interval for random range
int max_interval; // Maximum interval for random range
int interval_idx;
uint8_t counter;
} HidMouseJigglerModel;
const int intervals[6] = {500, 2000, 5000, 10000, 30000, 60000};
static void hid_mouse_jiggler_draw_callback(Canvas* canvas, void* context) {
furi_assert(context);
HidMouseJigglerModel* model = context;
// Header
// Header
#ifdef HID_TRANSPORT_BLE
if(model->connected) {
canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
@@ -32,26 +34,22 @@ static void hid_mouse_jiggler_draw_callback(Canvas* canvas, void* context) {
}
#endif
// Title "Mouse Jiggler"
canvas_set_font(canvas, FontPrimary);
elements_multiline_text_aligned(canvas, 17, 2, AlignLeft, AlignTop, "Mouse Jiggler");
elements_multiline_text_aligned(canvas, 27, 2, AlignLeft, AlignTop, "Mouse Jiggler");
// Display the current min interval in minutes
canvas_set_font(canvas, FontSecondary); // Assuming there's a smaller font available
FuriString* min_interval_str = furi_string_alloc_printf("Min: %d min", model->min_interval);
elements_multiline_text_aligned(
canvas, 0, 16, AlignLeft, AlignTop, furi_string_get_cstr(min_interval_str));
furi_string_free(min_interval_str);
// Timeout
elements_multiline_text(canvas, AlignLeft, 26, "Interval (ms):");
canvas_set_font(canvas, FontSecondary);
if(model->interval_idx != 0) canvas_draw_icon(canvas, 74, 19, &I_ButtonLeft_4x7);
if(model->interval_idx != (int)COUNT_OF(intervals) - 1)
canvas_draw_icon(canvas, 80, 19, &I_ButtonRight_4x7);
FuriString* interval_str = furi_string_alloc_printf("%d", intervals[model->interval_idx]);
elements_multiline_text(canvas, 91, 26, furi_string_get_cstr(interval_str));
furi_string_free(interval_str);
// Display the current max interval in minutes
FuriString* max_interval_str = furi_string_alloc_printf("Max: %d min", model->max_interval);
elements_multiline_text_aligned(
canvas, 0, 28, AlignLeft, AlignTop, furi_string_get_cstr(max_interval_str));
furi_string_free(max_interval_str);
// "Press Start to jiggle"
canvas_set_font(canvas, FontPrimary);
elements_multiline_text(canvas, AlignLeft, 50, "Press Start\nto jiggle");
elements_multiline_text(canvas, AlignLeft, 40, "Press Start\nto jiggle");
canvas_set_font(canvas, FontSecondary);
// Ok
canvas_draw_icon(canvas, 63, 30, &I_Space_65x18);
@@ -80,20 +78,11 @@ static void hid_mouse_jiggler_timer_callback(void* context) {
HidMouseJigglerModel * model,
{
if(model->running) {
// Generate a random interval in minutes and convert to milliseconds
int randomIntervalMinutes =
model->min_interval + rand() % (model->max_interval - model->min_interval + 1);
// Randomize the mouse movement distance and direction
int move_x = (rand() % 2001) - 1000; // Randomly between -1000 and 1000
int move_y = (rand() % 2001) - 1000; // Randomly between -1000 and 1000
// Perform the mouse move with the randomized values
hid_hal_mouse_move(hid_mouse_jiggler->hid, move_x, move_y);
// Restart timer with the new random interval
furi_timer_stop(hid_mouse_jiggler->timer);
furi_timer_start(hid_mouse_jiggler->timer, randomIntervalMinutes * 60000);
model->counter++;
hid_hal_mouse_move(
hid_mouse_jiggler->hid,
(model->counter % 2 == 0) ? MOUSE_MOVE_SHORT : -MOUSE_MOVE_SHORT,
0);
}
},
false);
@@ -115,51 +104,23 @@ static bool hid_mouse_jiggler_input_callback(InputEvent* event, void* context) {
hid_mouse_jiggler->view,
HidMouseJigglerModel * model,
{
if(event->type == InputTypePress) {
switch(event->key) {
case InputKeyOk:
model->running = !model->running;
if(model->running) {
furi_timer_stop(hid_mouse_jiggler->timer);
int randomIntervalMinutes =
model->min_interval +
rand() % (model->max_interval - model->min_interval + 1);
furi_timer_start(hid_mouse_jiggler->timer, randomIntervalMinutes * 60000);
}
consumed = true;
break;
case InputKeyUp:
if(!model->running && model->min_interval < model->max_interval) {
model->min_interval++; // Increment min interval by 1 minute
}
consumed = true;
break;
case InputKeyDown:
if(!model->running && model->min_interval > 1) { // Minimum 1 minute
model->min_interval--; // Decrement min interval by 1 minute
}
consumed = true;
break;
case InputKeyRight:
if(!model->running && model->max_interval < 30) { // Maximum 30 minutes
model->max_interval++; // Increment max interval by 1 minute
}
consumed = true;
break;
case InputKeyLeft:
if(!model->running && model->max_interval > model->min_interval + 1) {
model->max_interval--; // Decrement max interval by 1 minute
}
consumed = true;
break;
default:
break;
}
if(event->type == InputTypePress && event->key == InputKeyOk) {
model->running = !model->running;
if(model->running) {
furi_timer_stop(hid_mouse_jiggler->timer);
furi_timer_start(hid_mouse_jiggler->timer, intervals[model->interval_idx]);
};
consumed = true;
}
if(event->type == InputTypePress && event->key == InputKeyRight && !model->running &&
model->interval_idx < (int)COUNT_OF(intervals) - 1) {
model->interval_idx++;
consumed = true;
}
if(event->type == InputTypePress && event->key == InputKeyLeft && !model->running &&
model->interval_idx > 0) {
model->interval_idx--;
consumed = true;
}
},
true);
@@ -184,14 +145,7 @@ HidMouseJiggler* hid_mouse_jiggler_alloc(Hid* hid) {
hid_mouse_jiggler_timer_callback, FuriTimerTypePeriodic, hid_mouse_jiggler);
with_view_model(
hid_mouse_jiggler->view,
HidMouseJigglerModel * model,
{
// Initialize the min and max interval values
model->min_interval = 2; // 2 minutes
model->max_interval = 15; // 15 minutes
},
true);
hid_mouse_jiggler->view, HidMouseJigglerModel * model, { model->interval_idx = 2; }, true);
return hid_mouse_jiggler;
}

2
applications/system/hid_app/views/hid_mouse_jiggler.h
View File

@@ -2,6 +2,8 @@
#include <gui/view.h>
#define MOUSE_MOVE_SHORT 5
typedef struct Hid Hid;
typedef struct HidMouseJiggler HidMouseJiggler;

224
applications/system/hid_app/views/hid_mouse_jiggler_stealth.c Normal file
View File

@@ -0,0 +1,224 @@
#include "hid_mouse_jiggler_stealth.h"
#include <gui/elements.h>
#include "../hid.h"
#include "hid_icons.h"
#define TAG "HidMouseJigglerStealth"
struct HidMouseJigglerStealth {
View* view;
Hid* hid;
FuriTimer* timer;
};
typedef struct {
bool connected;
bool running;
int min_interval; // Minimum interval for random range
int max_interval; // Maximum interval for random range
} HidMouseJigglerStealthModel;
static void hid_mouse_jiggler_stealth_draw_callback(Canvas* canvas, void* context) {
furi_assert(context);
HidMouseJigglerStealthModel* model = context;
// Header
#ifdef HID_TRANSPORT_BLE
if(model->connected) {
canvas_draw_icon(canvas, 0, 0, &I_Ble_connected_15x15);
} else {
canvas_draw_icon(canvas, 0, 0, &I_Ble_disconnected_15x15);
}
#endif
// Title "Mouse Jiggler"
canvas_set_font(canvas, FontPrimary);
elements_multiline_text_aligned(canvas, 10, 2, AlignLeft, AlignTop, "Mouse Jiggler Stealth");
// Display the current min interval in minutes
canvas_set_font(canvas, FontSecondary); // Assuming there's a smaller font available
FuriString* min_interval_str = furi_string_alloc_printf("Min: %d min", model->min_interval);
elements_multiline_text_aligned(
canvas, 0, 16, AlignLeft, AlignTop, furi_string_get_cstr(min_interval_str));
furi_string_free(min_interval_str);
// Display the current max interval in minutes
FuriString* max_interval_str = furi_string_alloc_printf("Max: %d min", model->max_interval);
elements_multiline_text_aligned(
canvas, 0, 28, AlignLeft, AlignTop, furi_string_get_cstr(max_interval_str));
furi_string_free(max_interval_str);
// "Press Start to jiggle"
canvas_set_font(canvas, FontPrimary);
elements_multiline_text(canvas, AlignLeft, 50, "Press Start\nto jiggle");
// Ok
canvas_draw_icon(canvas, 63, 30, &I_Space_65x18);
if(model->running) {
elements_slightly_rounded_box(canvas, 66, 32, 60, 13);
canvas_set_color(canvas, ColorWhite);
}
canvas_draw_icon(canvas, 74, 34, &I_Ok_btn_9x9);
if(model->running) {
elements_multiline_text_aligned(canvas, 91, 41, AlignLeft, AlignBottom, "Stop");
} else {
elements_multiline_text_aligned(canvas, 91, 41, AlignLeft, AlignBottom, "Start");
}
canvas_set_color(canvas, ColorBlack);
// Back
canvas_draw_icon(canvas, 74, 54, &I_Pin_back_arrow_10x8);
elements_multiline_text_aligned(canvas, 91, 62, AlignLeft, AlignBottom, "Quit");
}
static void hid_mouse_jiggler_stealth_timer_callback(void* context) {
furi_assert(context);
HidMouseJigglerStealth* hid_mouse_jiggler = context;
with_view_model(
hid_mouse_jiggler->view,
HidMouseJigglerStealthModel * model,
{
if(model->running) {
// Generate a random interval in minutes and convert to milliseconds
int randomIntervalMinutes =
model->min_interval + rand() % (model->max_interval - model->min_interval + 1);
// Randomize the mouse movement distance and direction
int move_x = (rand() % 2001) - 1000; // Randomly between -1000 and 1000
int move_y = (rand() % 2001) - 1000; // Randomly between -1000 and 1000
// Perform the mouse move with the randomized values
hid_hal_mouse_move(hid_mouse_jiggler->hid, move_x, move_y);
// Restart timer with the new random interval
furi_timer_stop(hid_mouse_jiggler->timer);
furi_timer_start(hid_mouse_jiggler->timer, randomIntervalMinutes * 60000);
}
},
false);
}
static void hid_mouse_jiggler_stealth_exit_callback(void* context) {
furi_assert(context);
HidMouseJigglerStealth* hid_mouse_jiggler = context;
furi_timer_stop(hid_mouse_jiggler->timer);
}
static bool hid_mouse_jiggler_stealth_input_callback(InputEvent* event, void* context) {
furi_assert(context);
HidMouseJigglerStealth* hid_mouse_jiggler = context;
bool consumed = false;
with_view_model(
hid_mouse_jiggler->view,
HidMouseJigglerStealthModel * model,
{
if(event->type == InputTypePress) {
switch(event->key) {
case InputKeyOk:
model->running = !model->running;
if(model->running) {
furi_timer_stop(hid_mouse_jiggler->timer);
int randomIntervalMinutes =
model->min_interval +
rand() % (model->max_interval - model->min_interval + 1);
furi_timer_start(hid_mouse_jiggler->timer, randomIntervalMinutes * 60000);
}
consumed = true;
break;
case InputKeyUp:
if(!model->running && model->min_interval < model->max_interval) {
model->min_interval++; // Increment min interval by 1 minute
}
consumed = true;
break;
case InputKeyDown:
if(!model->running && model->min_interval > 1) { // Minimum 1 minute
model->min_interval--; // Decrement min interval by 1 minute
}
consumed = true;
break;
case InputKeyRight:
if(!model->running && model->max_interval < 30) { // Maximum 30 minutes
model->max_interval++; // Increment max interval by 1 minute
}
consumed = true;
break;
case InputKeyLeft:
if(!model->running && model->max_interval > model->min_interval + 1) {
model->max_interval--; // Decrement max interval by 1 minute
}
consumed = true;
break;
default:
break;
}
}
},
true);
return consumed;
}
HidMouseJigglerStealth* hid_mouse_jiggler_stealth_alloc(Hid* hid) {
HidMouseJigglerStealth* hid_mouse_jiggler = malloc(sizeof(HidMouseJigglerStealth));
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(HidMouseJigglerStealthModel));
view_set_draw_callback(hid_mouse_jiggler->view, hid_mouse_jiggler_stealth_draw_callback);
view_set_input_callback(hid_mouse_jiggler->view, hid_mouse_jiggler_stealth_input_callback);
view_set_exit_callback(hid_mouse_jiggler->view, hid_mouse_jiggler_stealth_exit_callback);
hid_mouse_jiggler->hid = hid;
hid_mouse_jiggler->timer = furi_timer_alloc(
hid_mouse_jiggler_stealth_timer_callback, FuriTimerTypePeriodic, hid_mouse_jiggler);
with_view_model(
hid_mouse_jiggler->view,
HidMouseJigglerStealthModel * model,
{
// Initialize the min and max interval values
model->min_interval = 1; // 1 minutes
model->max_interval = 4; // 4 minutes
},
true);
return hid_mouse_jiggler;
}
void hid_mouse_jiggler_stealth_free(HidMouseJigglerStealth* 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_stealth_get_view(HidMouseJigglerStealth* hid_mouse_jiggler) {
furi_assert(hid_mouse_jiggler);
return hid_mouse_jiggler->view;
}
void hid_mouse_jiggler_stealth_set_connected_status(
HidMouseJigglerStealth* hid_mouse_jiggler,
bool connected) {
furi_assert(hid_mouse_jiggler);
with_view_model(
hid_mouse_jiggler->view,
HidMouseJigglerStealthModel * model,
{ model->connected = connected; },
true);
}

16
applications/system/hid_app/views/hid_mouse_jiggler_stealth.h Normal file
View File

@@ -0,0 +1,16 @@
#pragma once
#include <gui/view.h>
typedef struct Hid Hid;
typedef struct HidMouseJigglerStealth HidMouseJigglerStealth;
HidMouseJigglerStealth* hid_mouse_jiggler_stealth_alloc(Hid* bt_hid);
void hid_mouse_jiggler_stealth_free(HidMouseJigglerStealth* hid_mouse_jiggler);
View* hid_mouse_jiggler_stealth_get_view(HidMouseJigglerStealth* hid_mouse_jiggler);
void hid_mouse_jiggler_stealth_set_connected_status(
HidMouseJigglerStealth* hid_mouse_jiggler,
bool connected);

1
applications/system/hid_app/views/hid_numpad.c
View File

@@ -143,6 +143,7 @@ static void hid_numpad_draw_callback(Canvas* canvas, void* context) {
canvas, 7, 60, AlignLeft, AlignBottom, "Waiting for\nConnection...");
}
elements_multiline_text_aligned(canvas, 20, 3, AlignLeft, AlignTop, "Numpad");
#else
elements_multiline_text_aligned(canvas, 12, 3, AlignLeft, AlignTop, "Numpad");
#endif

4
lib/subghz/devices/registry.c
View File

@@ -23,8 +23,8 @@ void subghz_device_registry_init(void) {
firmware_api_interface);
//TODO FL-3556: fix path to plugins
if(plugin_manager_load_all(subghz_device->manager, "/any/apps_data/subghz/plugins") !=
//if(plugin_manager_load_all(subghz_device->manager, APP_DATA_PATH("plugins")) !=
//if(plugin_manager_load_all(subghz_device->manager, APP_DATA_PATH("plugins")) !=
if(plugin_manager_load_all(subghz_device->manager, "/ext/apps_data/subghz/plugins") !=
PluginManagerErrorNone) {
FURI_LOG_E(TAG, "Failed to load all libs");
}