Merge branch '420' of https://github.com/RogueMaster/flipperzero-firmware-wPlugins into Dev

applications/plugins/doom/doom_music_player_worker.c

@@ -47,47 +47,51 @@ static int32_t music_player_worker_thread_callback(void* context) {
 
     NoteBlockArray_it_t it;
     NoteBlockArray_it(it, instance->notes);
+    if(furi_hal_speaker_acquire(1000)) {
+        while(instance->should_work) {
+            if(NoteBlockArray_end_p(it)) {
+                NoteBlockArray_it(it, instance->notes);
+                furi_delay_ms(10);
+            } else {
+                NoteBlock* note_block = NoteBlockArray_ref(it);
 
-    while(instance->should_work) {
-        if(NoteBlockArray_end_p(it)) {
-            NoteBlockArray_it(it, instance->notes);
-            furi_delay_ms(10);
-        } else {
-            NoteBlock* note_block = NoteBlockArray_ref(it);
+                float note_from_a4 = (float)note_block->semitone - NOTE_C4_SEMITONE;
+                float frequency = NOTE_C4 * powf(TWO_POW_TWELTH_ROOT, note_from_a4);
+                float duration = 60.0 * furi_kernel_get_tick_frequency() * 4 / instance->bpm /
+                                 note_block->duration;
+                uint32_t dots = note_block->dots;
+                while(dots > 0) {
+                    duration += duration / 2;
+                    dots--;
+                }
+                uint32_t next_tick = furi_get_tick() + duration;
+                float volume = instance->volume;
 
-            float note_from_a4 = (float)note_block->semitone - NOTE_C4_SEMITONE;
-            float frequency = NOTE_C4 * powf(TWO_POW_TWELTH_ROOT, note_from_a4);
-            float duration =
-                60.0 * furi_kernel_get_tick_frequency() * 4 / instance->bpm / note_block->duration;
-            uint32_t dots = note_block->dots;
-            while(dots > 0) {
-                duration += duration / 2;
-                dots--;
+                if(instance->callback) {
+                    instance->callback(
+                        note_block->semitone,
+                        note_block->dots,
+                        note_block->duration,
+                        0.0,
+                        instance->callback_context);
+                }
+
+                furi_hal_speaker_stop();
+                furi_hal_speaker_start(frequency, volume);
+                while(instance->should_work && furi_get_tick() < next_tick) {
+                    volume *= 0.9945679;
+                    furi_hal_speaker_set_volume(volume);
+                    furi_delay_ms(2);
+                }
+                NoteBlockArray_next(it);
             }
-            uint32_t next_tick = furi_get_tick() + duration;
-            float volume = instance->volume;
-
-            if(instance->callback) {
-                instance->callback(
-                    note_block->semitone,
-                    note_block->dots,
-                    note_block->duration,
-                    0.0,
-                    instance->callback_context);
-            }
-
-            furi_hal_speaker_stop();
-            furi_hal_speaker_start(frequency, volume);
-            while(instance->should_work && furi_get_tick() < next_tick) {
-                volume *= 0.9945679;
-                furi_hal_speaker_set_volume(volume);
-                furi_delay_ms(2);
-            }
-            NoteBlockArray_next(it);
         }
-    }
 
-    furi_hal_speaker_stop();
+        furi_hal_speaker_stop();
+        furi_hal_speaker_release();
+    } else {
+        FURI_LOG_E(TAG, "Speaker system is busy with another process.");
+    }
 
     return 0;
 }

applications/plugins/usbkeyboard/usb_hid.c

@@ -10,6 +10,7 @@ enum UsbDebugSubmenuIndex {
     UsbHidSubmenuIndexKeyboard,
     UsbHidSubmenuIndexMedia,
     UsbHidSubmenuIndexMouse,
+    UsbHidSubmenuIndexMouseJiggler,
 };
 
 void usb_hid_submenu_callback(void* context, uint32_t index) {
@@ -27,6 +28,9 @@ void usb_hid_submenu_callback(void* context, uint32_t index) {
     } else if(index == UsbHidSubmenuIndexMouse) {
         app->view_id = UsbHidViewMouse;
         view_dispatcher_switch_to_view(app->view_dispatcher, UsbHidViewMouse);
+    } else if(index == UsbHidSubmenuIndexMouseJiggler) {
+        app->view_id = UsbHidViewMouseJiggler;
+        view_dispatcher_switch_to_view(app->view_dispatcher, UsbHidViewMouseJiggler);
     }
 }
 
@@ -76,6 +80,12 @@ UsbHid* usb_hid_app_alloc() {
         app->submenu, "Media", UsbHidSubmenuIndexMedia, usb_hid_submenu_callback, app);
     submenu_add_item(
         app->submenu, "Mouse", UsbHidSubmenuIndexMouse, usb_hid_submenu_callback, app);
+    submenu_add_item(
+        app->submenu,
+        "Mouse Jiggler",
+        UsbHidSubmenuIndexMouseJiggler,
+        usb_hid_submenu_callback,
+        app);
     view_set_previous_callback(submenu_get_view(app->submenu), usb_hid_exit);
     view_dispatcher_add_view(
         app->view_dispatcher, UsbHidViewSubmenu, submenu_get_view(app->submenu));
@@ -121,6 +131,15 @@ UsbHid* usb_hid_app_alloc() {
     view_dispatcher_add_view(
         app->view_dispatcher, UsbHidViewMouse, usb_hid_mouse_get_view(app->usb_hid_mouse));
 
+    // 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), usb_hid_exit_confirm_view);
+    view_dispatcher_add_view(
+        app->view_dispatcher,
+        UsbHidViewMouseJiggler,
+        hid_mouse_jiggler_get_view(app->hid_mouse_jiggler));
+
     // TODO switch to menu after Media is done
     app->view_id = UsbHidViewSubmenu;
     view_dispatcher_switch_to_view(app->view_dispatcher, app->view_id);
@@ -147,6 +166,8 @@ void usb_hid_app_free(UsbHid* app) {
     usb_hid_media_free(app->usb_hid_media);
     view_dispatcher_remove_view(app->view_dispatcher, UsbHidViewMouse);
     usb_hid_mouse_free(app->usb_hid_mouse);
+    view_dispatcher_remove_view(app->view_dispatcher, UsbHidViewMouseJiggler);
+    hid_mouse_jiggler_free(app->hid_mouse_jiggler);
     view_dispatcher_free(app->view_dispatcher);
     // Close records
     furi_record_close(RECORD_GUI);

applications/plugins/usbkeyboard/usb_hid.h

@@ -12,6 +12,7 @@
 #include "views/usb_hid_keyboard.h"
 #include "views/usb_hid_media.h"
 #include "views/usb_hid_mouse.h"
+#include "views/usb_hid_mouse_jiggler.h"
 
 typedef struct {
     Gui* gui;
@@ -23,6 +24,7 @@ typedef struct {
     UsbHidKeyboard* usb_hid_keyboard;
     UsbHidMedia* usb_hid_media;
     UsbHidMouse* usb_hid_mouse;
+    HidMouseJiggler* hid_mouse_jiggler;
     uint32_t view_id;
 } UsbHid;
 
@@ -32,5 +34,6 @@ typedef enum {
     UsbHidViewKeyboard,
     UsbHidViewMedia,
     UsbHidViewMouse,
+    UsbHidViewMouseJiggler,
     UsbHidViewExitConfirm,
 } UsbHidView;

applications/plugins/usbkeyboard/views/usb_hid_mouse_jiggler.c

@@ -0,0 +1,130 @@
+#include "usb_hid_mouse_jiggler.h"
+#include <furi.h>
+#include <furi_hal_usb_hid.h>
+#include <gui/elements.h>
+
+#include <USB_Keyboard_icons.h>
+
+#define TAG "HidMouseJiggler"
+
+struct HidMouseJiggler {
+    View* view;
+    FuriTimer* timer;
+};
+
+typedef struct {
+    bool running;
+    uint8_t counter;
+} HidMouseJigglerModel;
+
+static void hid_mouse_jiggler_draw_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidMouseJigglerModel* model = context;
+
+    // Header
+    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++;
+                furi_hal_hid_mouse_move(
+                    (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->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() {
+    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->timer = furi_timer_alloc(
+        hid_mouse_jiggler_timer_callback, FuriTimerTypePeriodic, hid_mouse_jiggler);
+
+    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;
+}

applications/plugins/usbkeyboard/views/usb_hid_mouse_jiggler.h

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