Merge branch 'fz-dev' into dev

.vscode/example/tasks.json

@@ -128,6 +128,38 @@
             "group": "build",
             "type": "shell",
             "command": "./fbt COMPACT=1 DEBUG=0 launch_app APPSRC=${relativeFileDirname}"
+        },
+        {
+            "label": "[Debug] Launch App on Flipper with Serial Console",
+            "dependsOrder": "sequence",
+            "group": "build",
+            "dependsOn": [
+                "[Debug] Launch App on Flipper",
+                "Serial Console"
+            ]
+        },
+        {
+            // Press Ctrl+] to quit
+            "label": "Serial Console",
+            "type": "shell",
+            "command": "./fbt cli",
+            "group": "none",
+            "isBackground": true,
+			"options": {
+                "env": {
+                    "FBT_NO_SYNC": "0"
+                }
+            },
+            "presentation": {
+                "reveal": "always",
+                "revealProblems": "never",
+                "showReuseMessage": false,
+                "panel": "dedicated",
+                "focus": true,
+                "echo": true,
+                "close": true,
+                "group": "Logger"
+            }
         }
     ]
-}
+}

applications/plugins/hid_app/hid.c

@@ -9,10 +9,10 @@ enum HidDebugSubmenuIndex {
     HidSubmenuIndexKeynote,
     HidSubmenuIndexKeyboard,
     HidSubmenuIndexMedia,
-    BtHidSubmenuIndexTikTok,
+    HidSubmenuIndexTikTok,
     HidSubmenuIndexMouse,
+    HidSubmenuIndexMouseJiggler,
 };
-typedef enum { ConnTypeSubmenuIndexBluetooth, ConnTypeSubmenuIndexUsb } ConnTypeDebugSubmenuIndex;
 
 static void hid_submenu_callback(void* context, uint32_t index) {
     furi_assert(context);
@@ -29,9 +29,12 @@ 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 == BtHidSubmenuIndexTikTok) {
+    } else if(index == HidSubmenuIndexTikTok) {
         app->view_id = BtHidViewTikTok;
         view_dispatcher_switch_to_view(app->view_dispatcher, BtHidViewTikTok);
+    } else if(index == HidSubmenuIndexMouseJiggler) {
+        app->view_id = HidViewMouseJiggler;
+        view_dispatcher_switch_to_view(app->view_dispatcher, HidViewMouseJiggler);
     }
 }
 
@@ -48,6 +51,7 @@ static void bt_hid_connection_status_changed_callback(BtStatus status, void* con
     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_jiggler_set_connected_status(hid->hid_mouse_jiggler, connected);
     hid_tiktok_set_connected_status(hid->hid_tiktok, connected);
 }
 
@@ -104,10 +108,16 @@ Hid* hid_alloc(HidTransport transport) {
         submenu_add_item(
             app->device_type_submenu,
             "TikTok Controller",
-            BtHidSubmenuIndexTikTok,
+            HidSubmenuIndexTikTok,
             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));
@@ -160,6 +170,15 @@ Hid* hid_app_alloc_view(void* context) {
     view_dispatcher_add_view(
         app->view_dispatcher, HidViewMouse, hid_mouse_get_view(app->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), hid_exit_confirm_view);
+    view_dispatcher_add_view(
+        app->view_dispatcher,
+        HidViewMouseJiggler,
+        hid_mouse_jiggler_get_view(app->hid_mouse_jiggler));
+
     return app;
 }
 
@@ -182,6 +201,8 @@ void hid_free(Hid* app) {
     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, 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);

applications/plugins/hid_app/hid.h

@@ -19,6 +19,7 @@
 #include "views/hid_keyboard.h"
 #include "views/hid_media.h"
 #include "views/hid_mouse.h"
+#include "views/hid_mouse_jiggler.h"
 #include "views/hid_tiktok.h"
 
 typedef enum {
@@ -39,6 +40,7 @@ struct Hid {
     HidKeyboard* hid_keyboard;
     HidMedia* hid_media;
     HidMouse* hid_mouse;
+    HidMouseJiggler* hid_mouse_jiggler;
     HidTikTok* hid_tiktok;
 
     HidTransport transport;

applications/plugins/hid_app/views.h

@@ -4,6 +4,7 @@ typedef enum {
     HidViewKeyboard,
     HidViewMedia,
     HidViewMouse,
+    HidViewMouseJiggler,
     BtHidViewTikTok,
     HidViewExitConfirm,
 } HidView;

applications/plugins/hid_app/views/hid_mouse_jiggler.c

@@ -0,0 +1,149 @@
+#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;
+} HidMouseJigglerModel;
+
+static void hid_mouse_jiggler_draw_callback(Canvas* canvas, void* context) {
+    furi_assert(context);
+    HidMouseJigglerModel* model = context;
+
+    // Header
+    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->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);
+
+    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/plugins/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/plugins/weather_station/helpers/weather_station_types.h

@@ -3,7 +3,7 @@
 #include <furi.h>
 #include <furi_hal.h>
 
-#define WS_VERSION_APP "0.5"
+#define WS_VERSION_APP "0.6"
 #define WS_DEVELOPED "SkorP"
 #define WS_GITHUB "https://github.com/flipperdevices/flipperzero-firmware"
 

applications/plugins/weather_station/protocols/nexus_th.c

@@ -135,6 +135,10 @@ static void ws_protocol_nexus_th_remote_controller(WSBlockGeneric* instance) {
     }
 
     instance->humidity = instance->data & 0xFF;
+    if(instance->humidity > 95)
+        instance->humidity = 95;
+    else if(instance->humidity < 20)
+        instance->humidity = 20;
 }
 
 void ws_protocol_decoder_nexus_th_feed(void* context, bool level, uint32_t duration) {

applications/plugins/weather_station/protocols/oregon_v1.c

@@ -0,0 +1,331 @@
+#include "oregon_v1.h"
+#include <lib/toolbox/manchester_decoder.h>
+
+#define TAG "WSProtocolOregon_V1"
+
+/*
+ * Help
+ * https://github.dev/merbanan/rtl_433/blob/bb1be7f186ac0fdb7dc5d77693847d96fb95281e/src/devices/oregon_scientific_v1.c
+ * 
+ * OSv1 protocol.
+ * 
+ * MC with nominal bit width of 2930 us.
+ * Pulses are somewhat longer than nominal half-bit width, 1748 us / 3216 us,
+ * Gaps are somewhat shorter than nominal half-bit width, 1176 us / 2640 us.
+ * After 12 preamble bits there is 4200 us gap, 5780 us pulse, 5200 us gap.
+ * And next 32 bit data
+ * 
+ * Care must be taken with the gap after the sync pulse since it
+ * is outside of the normal clocking.  Because of this a data stream
+ * beginning with a 0 will have data in this gap.   
+ * 
+ * 
+ * Data is in reverse order of bits
+ *      RevBit(data32bit)=> tib23atad
+ * 
+ *      tib23atad => xxxxxxxx | busuTTTT | ttttzzzz | ccuuiiii 
+ *
+ *      - i: ID
+ *      - x: CRC;
+ *      - u: unknown;
+ *      - b: battery low; flag to indicate low battery voltage
+ *      - s: temperature sign
+ *      - T: BCD, Temperature; in °C * 10
+ *      - t: BCD, Temperature; in °C * 1
+ *      - z: BCD, Temperature; in °C * 0.1
+ *      - c: Channel 00=CH1, 01=CH2, 10=CH3
+ * 
+ */
+
+#define OREGON_V1_HEADER_OK 0xFF
+
+static const SubGhzBlockConst ws_protocol_oregon_v1_const = {
+    .te_short = 1465,
+    .te_long = 2930,
+    .te_delta = 350,
+    .min_count_bit_for_found = 32,
+};
+
+struct WSProtocolDecoderOregon_V1 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    WSBlockGeneric generic;
+    ManchesterState manchester_state;
+    uint16_t header_count;
+    uint8_t first_bit;
+};
+
+struct WSProtocolEncoderOregon_V1 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    WSBlockGeneric generic;
+};
+
+typedef enum {
+    Oregon_V1DecoderStepReset = 0,
+    Oregon_V1DecoderStepFoundPreamble,
+    Oregon_V1DecoderStepParse,
+} Oregon_V1DecoderStep;
+
+const SubGhzProtocolDecoder ws_protocol_oregon_v1_decoder = {
+    .alloc = ws_protocol_decoder_oregon_v1_alloc,
+    .free = ws_protocol_decoder_oregon_v1_free,
+
+    .feed = ws_protocol_decoder_oregon_v1_feed,
+    .reset = ws_protocol_decoder_oregon_v1_reset,
+
+    .get_hash_data = ws_protocol_decoder_oregon_v1_get_hash_data,
+    .serialize = ws_protocol_decoder_oregon_v1_serialize,
+    .deserialize = ws_protocol_decoder_oregon_v1_deserialize,
+    .get_string = ws_protocol_decoder_oregon_v1_get_string,
+};
+
+const SubGhzProtocolEncoder ws_protocol_oregon_v1_encoder = {
+    .alloc = NULL,
+    .free = NULL,
+
+    .deserialize = NULL,
+    .stop = NULL,
+    .yield = NULL,
+};
+
+const SubGhzProtocol ws_protocol_oregon_v1 = {
+    .name = WS_PROTOCOL_OREGON_V1_NAME,
+    .type = SubGhzProtocolWeatherStation,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_868 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable,
+
+    .decoder = &ws_protocol_oregon_v1_decoder,
+    .encoder = &ws_protocol_oregon_v1_encoder,
+};
+
+void* ws_protocol_decoder_oregon_v1_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    WSProtocolDecoderOregon_V1* instance = malloc(sizeof(WSProtocolDecoderOregon_V1));
+    instance->base.protocol = &ws_protocol_oregon_v1;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void ws_protocol_decoder_oregon_v1_free(void* context) {
+    furi_assert(context);
+    WSProtocolDecoderOregon_V1* instance = context;
+    free(instance);
+}
+
+void ws_protocol_decoder_oregon_v1_reset(void* context) {
+    furi_assert(context);
+    WSProtocolDecoderOregon_V1* instance = context;
+    instance->decoder.parser_step = Oregon_V1DecoderStepReset;
+}
+
+static bool ws_protocol_oregon_v1_check(WSProtocolDecoderOregon_V1* instance) {
+    if(!instance->decoder.decode_data) return false;
+    uint64_t data = subghz_protocol_blocks_reverse_key(instance->decoder.decode_data, 32);
+    uint16_t crc = (data & 0xff) + ((data >> 8) & 0xff) + ((data >> 16) & 0xff);
+    crc = (crc & 0xff) + ((crc >> 8) & 0xff);
+    return (crc == ((data >> 24) & 0xFF));
+}
+
+/**
+ * Analysis of received data
+ * @param instance Pointer to a WSBlockGeneric* instance
+ */
+static void ws_protocol_oregon_v1_remote_controller(WSBlockGeneric* instance) {
+    uint64_t data = subghz_protocol_blocks_reverse_key(instance->data, 32);
+
+    instance->id = data & 0xFF;
+    instance->channel = ((data >> 6) & 0x03) + 1;
+
+    float temp_raw =
+        ((data >> 8) & 0x0F) * 0.1f + ((data >> 12) & 0x0F) + ((data >> 16) & 0x0F) * 10.0f;
+    if(!((data >> 21) & 1)) {
+        instance->temp = temp_raw;
+    } else {
+        instance->temp = -temp_raw;
+    }
+
+    instance->battery_low = !(instance->data >> 23) & 1;
+
+    instance->btn = WS_NO_BTN;
+    instance->humidity = WS_NO_HUMIDITY;
+}
+
+void ws_protocol_decoder_oregon_v1_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    WSProtocolDecoderOregon_V1* instance = context;
+    ManchesterEvent event = ManchesterEventReset;
+    switch(instance->decoder.parser_step) {
+    case Oregon_V1DecoderStepReset:
+        if((level) && (DURATION_DIFF(duration, ws_protocol_oregon_v1_const.te_short) <
+                       ws_protocol_oregon_v1_const.te_delta)) {
+            instance->decoder.parser_step = Oregon_V1DecoderStepFoundPreamble;
+            instance->decoder.te_last = duration;
+            instance->header_count = 0;
+        }
+        break;
+    case Oregon_V1DecoderStepFoundPreamble:
+        if(level) {
+            //keep high levels, if they suit our durations
+            if((DURATION_DIFF(duration, ws_protocol_oregon_v1_const.te_short) <
+                ws_protocol_oregon_v1_const.te_delta) ||
+               (DURATION_DIFF(duration, ws_protocol_oregon_v1_const.te_short * 4) <
+                ws_protocol_oregon_v1_const.te_delta)) {
+                instance->decoder.te_last = duration;
+            } else {
+                instance->decoder.parser_step = Oregon_V1DecoderStepReset;
+            }
+        } else if(
+            //checking low levels
+            (DURATION_DIFF(duration, ws_protocol_oregon_v1_const.te_short) <
+             ws_protocol_oregon_v1_const.te_delta) &&
+            (DURATION_DIFF(instance->decoder.te_last, ws_protocol_oregon_v1_const.te_short) <
+             ws_protocol_oregon_v1_const.te_delta)) {
+            // Found header
+            instance->header_count++;
+        } else if(
+            (DURATION_DIFF(duration, ws_protocol_oregon_v1_const.te_short * 3) <
+             ws_protocol_oregon_v1_const.te_delta) &&
+            (DURATION_DIFF(instance->decoder.te_last, ws_protocol_oregon_v1_const.te_short) <
+             ws_protocol_oregon_v1_const.te_delta)) {
+            // check header
+            if(instance->header_count > 7) {
+                instance->header_count = OREGON_V1_HEADER_OK;
+            }
+        } else if(
+            (instance->header_count == OREGON_V1_HEADER_OK) &&
+            (DURATION_DIFF(instance->decoder.te_last, ws_protocol_oregon_v1_const.te_short * 4) <
+             ws_protocol_oregon_v1_const.te_delta)) {
+            //found all the necessary patterns
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 1;
+            manchester_advance(
+                instance->manchester_state,
+                ManchesterEventReset,
+                &instance->manchester_state,
+                NULL);
+            instance->decoder.parser_step = Oregon_V1DecoderStepParse;
+            if(duration < ws_protocol_oregon_v1_const.te_short * 4) {
+                instance->first_bit = 1;
+            } else {
+                instance->first_bit = 0;
+            }
+        } else {
+            instance->decoder.parser_step = Oregon_V1DecoderStepReset;
+        }
+        break;
+    case Oregon_V1DecoderStepParse:
+        if(level) {
+            if(DURATION_DIFF(duration, ws_protocol_oregon_v1_const.te_short) <
+               ws_protocol_oregon_v1_const.te_delta) {
+                event = ManchesterEventShortHigh;
+            } else if(
+                DURATION_DIFF(duration, ws_protocol_oregon_v1_const.te_long) <
+                ws_protocol_oregon_v1_const.te_delta) {
+                event = ManchesterEventLongHigh;
+            } else {
+                instance->decoder.parser_step = Oregon_V1DecoderStepReset;
+            }
+        } else {
+            if(DURATION_DIFF(duration, ws_protocol_oregon_v1_const.te_short) <
+               ws_protocol_oregon_v1_const.te_delta) {
+                event = ManchesterEventShortLow;
+            } else if(
+                DURATION_DIFF(duration, ws_protocol_oregon_v1_const.te_long) <
+                ws_protocol_oregon_v1_const.te_delta) {
+                event = ManchesterEventLongLow;
+            } else if(duration >= ((uint32_t)ws_protocol_oregon_v1_const.te_long * 2)) {
+                if(instance->decoder.decode_count_bit ==
+                   ws_protocol_oregon_v1_const.min_count_bit_for_found) {
+                    if(instance->first_bit) {
+                        instance->decoder.decode_data = ~instance->decoder.decode_data | (1 << 31);
+                    }
+                    if(ws_protocol_oregon_v1_check(instance)) {
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                        ws_protocol_oregon_v1_remote_controller(&instance->generic);
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                manchester_advance(
+                    instance->manchester_state,
+                    ManchesterEventReset,
+                    &instance->manchester_state,
+                    NULL);
+            } else {
+                instance->decoder.parser_step = Oregon_V1DecoderStepReset;
+            }
+        }
+        if(event != ManchesterEventReset) {
+            bool data;
+            bool data_ok = manchester_advance(
+                instance->manchester_state, event, &instance->manchester_state, &data);
+
+            if(data_ok) {
+                instance->decoder.decode_data = (instance->decoder.decode_data << 1) | !data;
+                instance->decoder.decode_count_bit++;
+            }
+        }
+
+        break;
+    }
+}
+
+uint8_t ws_protocol_decoder_oregon_v1_get_hash_data(void* context) {
+    furi_assert(context);
+    WSProtocolDecoderOregon_V1* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+bool ws_protocol_decoder_oregon_v1_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    WSProtocolDecoderOregon_V1* instance = context;
+    return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+bool ws_protocol_decoder_oregon_v1_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    WSProtocolDecoderOregon_V1* instance = context;
+    bool ret = false;
+    do {
+        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
+            break;
+        }
+        if(instance->generic.data_count_bit !=
+           ws_protocol_oregon_v1_const.min_count_bit_for_found) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            break;
+        }
+        ret = true;
+    } while(false);
+    return ret;
+}
+
+void ws_protocol_decoder_oregon_v1_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    WSProtocolDecoderOregon_V1* instance = context;
+    furi_string_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Sn:0x%lX Ch:%d  Bat:%d\r\n"
+        "Temp:%3.1f C Hum:%d%%",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)(instance->generic.data),
+        instance->generic.id,
+        instance->generic.channel,
+        instance->generic.battery_low,
+        (double)instance->generic.temp,
+        instance->generic.humidity);
+}

applications/plugins/weather_station/protocols/oregon_v1.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <lib/subghz/protocols/base.h>
+
+#include <lib/subghz/blocks/const.h>
+#include <lib/subghz/blocks/decoder.h>
+#include <lib/subghz/blocks/encoder.h>
+#include "ws_generic.h"
+#include <lib/subghz/blocks/math.h>
+
+#define WS_PROTOCOL_OREGON_V1_NAME "Oregon-v1"
+
+typedef struct WSProtocolDecoderOregon_V1 WSProtocolDecoderOregon_V1;
+typedef struct WSProtocolEncoderOregon_V1 WSProtocolEncoderOregon_V1;
+
+extern const SubGhzProtocolDecoder ws_protocol_oregon_v1_decoder;
+extern const SubGhzProtocolEncoder ws_protocol_oregon_v1_encoder;
+extern const SubGhzProtocol ws_protocol_oregon_v1;
+
+/**
+ * Allocate WSProtocolDecoderOregon_V1.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return WSProtocolDecoderOregon_V1* pointer to a WSProtocolDecoderOregon_V1 instance
+ */
+void* ws_protocol_decoder_oregon_v1_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free WSProtocolDecoderOregon_V1.
+ * @param context Pointer to a WSProtocolDecoderOregon_V1 instance
+ */
+void ws_protocol_decoder_oregon_v1_free(void* context);
+
+/**
+ * Reset decoder WSProtocolDecoderOregon_V1.
+ * @param context Pointer to a WSProtocolDecoderOregon_V1 instance
+ */
+void ws_protocol_decoder_oregon_v1_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a WSProtocolDecoderOregon_V1 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void ws_protocol_decoder_oregon_v1_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a WSProtocolDecoderOregon_V1 instance
+ * @return hash Hash sum
+ */
+uint8_t ws_protocol_decoder_oregon_v1_get_hash_data(void* context);
+
+/**
+ * Serialize data WSProtocolDecoderOregon_V1.
+ * @param context Pointer to a WSProtocolDecoderOregon_V1 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return true On success
+ */
+bool ws_protocol_decoder_oregon_v1_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data WSProtocolDecoderOregon_V1.
+ * @param context Pointer to a WSProtocolDecoderOregon_V1 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+bool ws_protocol_decoder_oregon_v1_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a WSProtocolDecoderOregon_V1 instance
+ * @param output Resulting text
+ */
+void ws_protocol_decoder_oregon_v1_get_string(void* context, FuriString* output);

applications/plugins/weather_station/protocols/protocol_items.c

@@ -13,6 +13,8 @@ const SubGhzProtocol* weather_station_protocol_registry_items[] = {
     &ws_protocol_acurite_592txr,
     &ws_protocol_ambient_weather,
     &ws_protocol_auriol_th,
+    &ws_protocol_oregon_v1,
+    &ws_protocol_tx_8300,
 };
 
 const SubGhzProtocolRegistry weather_station_protocol_registry = {

applications/plugins/weather_station/protocols/protocol_items.h

@@ -13,5 +13,7 @@
 #include "acurite_592txr.h"
 #include "ambient_weather.h"
 #include "auriol_hg0601a.h"
+#include "oregon_v1.h"
+#include "tx_8300.h"
 
 extern const SubGhzProtocolRegistry weather_station_protocol_registry;

applications/plugins/weather_station/protocols/tx_8300.c

@@ -0,0 +1,293 @@
+#include "tx_8300.h"
+
+#define TAG "WSProtocolTX_8300"
+
+/*
+ * Help
+ * https://github.com/merbanan/rtl_433/blob/master/src/devices/ambientweather_tx8300.c
+ *
+ * Ambient Weather TX-8300 (also sold as TFA 30.3211.02).
+ * 1970us pulse with variable gap (third pulse 3920 us).
+ * Above 79% humidity, gap after third pulse is 5848 us.
+ * - Bit 1 : 1970us pulse with 3888 us gap
+ * - Bit 0 : 1970us pulse with 1936 us gap
+ * 74 bit (2 bit preamble and 72 bit data => 9 bytes => 18 nibbles)
+ * The preamble seems to be a repeat counter (00, and 01 seen),
+ * the first 4 bytes are data,
+ * the second 4 bytes the same data inverted,
+ * the last byte is a checksum.
+ * Preamble format (2 bits):
+ *     [1 bit (0)] [1 bit rolling count]
+ * Payload format (32 bits):
+ *     HHHHhhhh ??CCNIII IIIITTTT ttttuuuu
+ * - H = First BCD digit humidity (the MSB might be distorted by the demod)
+ * - h = Second BCD digit humidity, invalid humidity seems to be 0x0e
+ * - ? = Likely battery flag, 2 bits
+ * - C = Channel, 2 bits
+ * - N = Negative temperature sign bit
+ * - I = ID, 7-bit
+ * - T = First BCD digit temperature
+ * - t = Second BCD digit temperature
+ * - u = Third BCD digit temperature
+ * The Checksum seems to covers the 4 data bytes and is something like Fletcher-8.
+ **/
+
+#define TX_8300_PACKAGE_SIZE 32
+
+static const SubGhzBlockConst ws_protocol_tx_8300_const = {
+    .te_short = 1940,
+    .te_long = 3880,
+    .te_delta = 250,
+    .min_count_bit_for_found = 72,
+};
+
+struct WSProtocolDecoderTX_8300 {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    WSBlockGeneric generic;
+    uint32_t package_1;
+    uint32_t package_2;
+};
+
+struct WSProtocolEncoderTX_8300 {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    WSBlockGeneric generic;
+};
+
+typedef enum {
+    TX_8300DecoderStepReset = 0,
+    TX_8300DecoderStepCheckPreambule,
+    TX_8300DecoderStepSaveDuration,
+    TX_8300DecoderStepCheckDuration,
+} TX_8300DecoderStep;
+
+const SubGhzProtocolDecoder ws_protocol_tx_8300_decoder = {
+    .alloc = ws_protocol_decoder_tx_8300_alloc,
+    .free = ws_protocol_decoder_tx_8300_free,
+
+    .feed = ws_protocol_decoder_tx_8300_feed,
+    .reset = ws_protocol_decoder_tx_8300_reset,
+
+    .get_hash_data = ws_protocol_decoder_tx_8300_get_hash_data,
+    .serialize = ws_protocol_decoder_tx_8300_serialize,
+    .deserialize = ws_protocol_decoder_tx_8300_deserialize,
+    .get_string = ws_protocol_decoder_tx_8300_get_string,
+};
+
+const SubGhzProtocolEncoder ws_protocol_tx_8300_encoder = {
+    .alloc = NULL,
+    .free = NULL,
+
+    .deserialize = NULL,
+    .stop = NULL,
+    .yield = NULL,
+};
+
+const SubGhzProtocol ws_protocol_tx_8300 = {
+    .name = WS_PROTOCOL_TX_8300_NAME,
+    .type = SubGhzProtocolWeatherStation,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_868 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable,
+
+    .decoder = &ws_protocol_tx_8300_decoder,
+    .encoder = &ws_protocol_tx_8300_encoder,
+};
+
+void* ws_protocol_decoder_tx_8300_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    WSProtocolDecoderTX_8300* instance = malloc(sizeof(WSProtocolDecoderTX_8300));
+    instance->base.protocol = &ws_protocol_tx_8300;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void ws_protocol_decoder_tx_8300_free(void* context) {
+    furi_assert(context);
+    WSProtocolDecoderTX_8300* instance = context;
+    free(instance);
+}
+
+void ws_protocol_decoder_tx_8300_reset(void* context) {
+    furi_assert(context);
+    WSProtocolDecoderTX_8300* instance = context;
+    instance->decoder.parser_step = TX_8300DecoderStepReset;
+}
+
+static bool ws_protocol_tx_8300_check_crc(WSProtocolDecoderTX_8300* instance) {
+    if(!instance->package_2) return false;
+    if(instance->package_1 != ~instance->package_2) return false;
+
+    uint16_t x = 0;
+    uint16_t y = 0;
+    for(int i = 0; i < 32; i += 4) {
+        x += (instance->package_1 >> i) & 0x0F;
+        y += (instance->package_1 >> i) & 0x05;
+    }
+    uint8_t crc = (~x & 0xF) << 4 | (~y & 0xF);
+    return (crc == ((instance->decoder.decode_data) & 0xFF));
+}
+
+/**
+ * Analysis of received data
+ * @param instance Pointer to a WSBlockGeneric* instance
+ */
+static void ws_protocol_tx_8300_remote_controller(WSBlockGeneric* instance) {
+    instance->humidity = (((instance->data >> 28) & 0x0F) * 10) + ((instance->data >> 24) & 0x0F);
+    instance->btn = WS_NO_BTN;
+    if(!((instance->data >> 22) & 0x03))
+        instance->battery_low = 0;
+    else
+        instance->battery_low = 1;
+    instance->channel = (instance->data >> 20) & 0x03;
+    instance->id = (instance->data >> 12) & 0x7F;
+
+    float temp_raw = ((instance->data >> 8) & 0x0F) * 10.0f + ((instance->data >> 4) & 0x0F) +
+                     (instance->data & 0x0F) * 0.1f;
+    if(!((instance->data >> 19) & 1)) {
+        instance->temp = temp_raw;
+    } else {
+        instance->temp = -temp_raw;
+    }
+}
+
+void ws_protocol_decoder_tx_8300_feed(void* context, bool level, uint32_t duration) {
+    furi_assert(context);
+    WSProtocolDecoderTX_8300* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case TX_8300DecoderStepReset:
+        if((level) && (DURATION_DIFF(duration, ws_protocol_tx_8300_const.te_short * 2) <
+                       ws_protocol_tx_8300_const.te_delta)) {
+            instance->decoder.parser_step = TX_8300DecoderStepCheckPreambule;
+        }
+        break;
+
+    case TX_8300DecoderStepCheckPreambule:
+        if((!level) && ((DURATION_DIFF(duration, ws_protocol_tx_8300_const.te_short * 2) <
+                         ws_protocol_tx_8300_const.te_delta) ||
+                        (DURATION_DIFF(duration, ws_protocol_tx_8300_const.te_short * 3) <
+                         ws_protocol_tx_8300_const.te_delta))) {
+            instance->decoder.parser_step = TX_8300DecoderStepSaveDuration;
+            instance->decoder.decode_data = 0;
+            instance->decoder.decode_count_bit = 1;
+            instance->package_1 = 0;
+            instance->package_2 = 0;
+        } else {
+            instance->decoder.parser_step = TX_8300DecoderStepReset;
+        }
+        break;
+
+    case TX_8300DecoderStepSaveDuration:
+        if(level) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = TX_8300DecoderStepCheckDuration;
+        } else {
+            instance->decoder.parser_step = TX_8300DecoderStepReset;
+        }
+        break;
+
+    case TX_8300DecoderStepCheckDuration:
+        if(!level) {
+            if(duration >= ((uint32_t)ws_protocol_tx_8300_const.te_short * 5)) {
+                //Found syncPostfix
+                if((instance->decoder.decode_count_bit ==
+                    ws_protocol_tx_8300_const.min_count_bit_for_found) &&
+                   ws_protocol_tx_8300_check_crc(instance)) {
+                    instance->generic.data = instance->package_1;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    ws_protocol_tx_8300_remote_controller(&instance->generic);
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 1;
+                instance->decoder.parser_step = TX_8300DecoderStepReset;
+                break;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, ws_protocol_tx_8300_const.te_short) <
+                 ws_protocol_tx_8300_const.te_delta) &&
+                (DURATION_DIFF(duration, ws_protocol_tx_8300_const.te_long) <
+                 ws_protocol_tx_8300_const.te_delta * 2)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = TX_8300DecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, ws_protocol_tx_8300_const.te_short) <
+                 ws_protocol_tx_8300_const.te_delta) &&
+                (DURATION_DIFF(duration, ws_protocol_tx_8300_const.te_short) <
+                 ws_protocol_tx_8300_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = TX_8300DecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = TX_8300DecoderStepReset;
+            }
+
+            if(instance->decoder.decode_count_bit == TX_8300_PACKAGE_SIZE) {
+                instance->package_1 = instance->decoder.decode_data;
+                instance->decoder.decode_data = 0;
+            } else if(instance->decoder.decode_count_bit == TX_8300_PACKAGE_SIZE * 2) {
+                instance->package_2 = instance->decoder.decode_data;
+                instance->decoder.decode_data = 0;
+            }
+
+        } else {
+            instance->decoder.parser_step = TX_8300DecoderStepReset;
+        }
+        break;
+    }
+}
+
+uint8_t ws_protocol_decoder_tx_8300_get_hash_data(void* context) {
+    furi_assert(context);
+    WSProtocolDecoderTX_8300* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+bool ws_protocol_decoder_tx_8300_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(context);
+    WSProtocolDecoderTX_8300* instance = context;
+    return ws_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+bool ws_protocol_decoder_tx_8300_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_assert(context);
+    WSProtocolDecoderTX_8300* instance = context;
+    bool ret = false;
+    do {
+        if(!ws_block_generic_deserialize(&instance->generic, flipper_format)) {
+            break;
+        }
+        if(instance->generic.data_count_bit != ws_protocol_tx_8300_const.min_count_bit_for_found) {
+            FURI_LOG_E(TAG, "Wrong number of bits in key");
+            break;
+        }
+        ret = true;
+    } while(false);
+    return ret;
+}
+
+void ws_protocol_decoder_tx_8300_get_string(void* context, FuriString* output) {
+    furi_assert(context);
+    WSProtocolDecoderTX_8300* instance = context;
+    furi_string_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Sn:0x%lX Ch:%d  Bat:%d\r\n"
+        "Temp:%3.1f C Hum:%d%%",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)(instance->generic.data),
+        instance->generic.id,
+        instance->generic.channel,
+        instance->generic.battery_low,
+        (double)instance->generic.temp,
+        instance->generic.humidity);
+}

applications/plugins/weather_station/protocols/tx_8300.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <lib/subghz/protocols/base.h>
+
+#include <lib/subghz/blocks/const.h>
+#include <lib/subghz/blocks/decoder.h>
+#include <lib/subghz/blocks/encoder.h>
+#include "ws_generic.h"
+#include <lib/subghz/blocks/math.h>
+
+#define WS_PROTOCOL_TX_8300_NAME "TX8300"
+
+typedef struct WSProtocolDecoderTX_8300 WSProtocolDecoderTX_8300;
+typedef struct WSProtocolEncoderTX_8300 WSProtocolEncoderTX_8300;
+
+extern const SubGhzProtocolDecoder ws_protocol_tx_8300_decoder;
+extern const SubGhzProtocolEncoder ws_protocol_tx_8300_encoder;
+extern const SubGhzProtocol ws_protocol_tx_8300;
+
+/**
+ * Allocate WSProtocolDecoderTX_8300.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return WSProtocolDecoderTX_8300* pointer to a WSProtocolDecoderTX_8300 instance
+ */
+void* ws_protocol_decoder_tx_8300_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free WSProtocolDecoderTX_8300.
+ * @param context Pointer to a WSProtocolDecoderTX_8300 instance
+ */
+void ws_protocol_decoder_tx_8300_free(void* context);
+
+/**
+ * Reset decoder WSProtocolDecoderTX_8300.
+ * @param context Pointer to a WSProtocolDecoderTX_8300 instance
+ */
+void ws_protocol_decoder_tx_8300_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a WSProtocolDecoderTX_8300 instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void ws_protocol_decoder_tx_8300_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a WSProtocolDecoderTX_8300 instance
+ * @return hash Hash sum
+ */
+uint8_t ws_protocol_decoder_tx_8300_get_hash_data(void* context);
+
+/**
+ * Serialize data WSProtocolDecoderTX_8300.
+ * @param context Pointer to a WSProtocolDecoderTX_8300 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return true On success
+ */
+bool ws_protocol_decoder_tx_8300_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data WSProtocolDecoderTX_8300.
+ * @param context Pointer to a WSProtocolDecoderTX_8300 instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+bool ws_protocol_decoder_tx_8300_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a WSProtocolDecoderTX_8300 instance
+ * @param output Resulting text
+ */
+void ws_protocol_decoder_tx_8300_get_string(void* context, FuriString* output);

applications/services/desktop/animations/animation_manager.c

@@ -52,6 +52,7 @@ struct AnimationManager {
     FuriString* freezed_animation_name;
     int32_t freezed_animation_time_left;
     ViewStack* view_stack;
+    bool dummy_mode;
 };
 
 static StorageAnimation*
@@ -93,6 +94,12 @@ void animation_manager_set_interact_callback(
     animation_manager->interact_callback = callback;
 }
 
+void animation_manager_set_dummy_mode_state(AnimationManager* animation_manager, bool enabled) {
+    furi_assert(animation_manager);
+    animation_manager->dummy_mode = enabled;
+    animation_manager_start_new_idle(animation_manager);
+}
+
 static void animation_manager_check_blocking_callback(const void* message, void* context) {
     const StorageEvent* storage_event = message;
 
@@ -363,7 +370,9 @@ static bool animation_manager_is_valid_idle_animation(
 
 static StorageAnimation*
     animation_manager_select_idle_animation(AnimationManager* animation_manager) {
-    UNUSED(animation_manager);
+    if(animation_manager->dummy_mode) {
+        return animation_storage_find_animation(HARDCODED_ANIMATION_NAME);
+    }
     StorageAnimationList_t animation_list;
     StorageAnimationList_init(animation_list);
     animation_storage_fill_animation_list(&animation_list);

applications/services/desktop/animations/animation_manager.h

@@ -157,3 +157,11 @@ void animation_manager_unload_and_stall_animation(AnimationManager* animation_ma
  * @animation_manager   instance
  */
 void animation_manager_load_and_continue_animation(AnimationManager* animation_manager);
+
+/**
+ * Enable or disable dummy mode backgrounds of animation manager.
+ *
+ * @animation_manager    instance
+ * @enabled              bool
+ */
+void animation_manager_set_dummy_mode_state(AnimationManager* animation_manager, bool enabled);

applications/services/desktop/desktop.c

@@ -144,6 +144,7 @@ void desktop_unlock(Desktop* desktop) {
 void desktop_set_dummy_mode_state(Desktop* desktop, bool enabled) {
     view_port_enabled_set(desktop->dummy_mode_icon_viewport, enabled);
     desktop_main_set_dummy_mode_state(desktop->main_view, enabled);
+    animation_manager_set_dummy_mode_state(desktop->animation_manager, enabled);
     desktop->settings.dummy_mode = enabled;
     DESKTOP_SETTINGS_SAVE(&desktop->settings);
 }
@@ -330,6 +331,8 @@ int32_t desktop_srv(void* p) {
 
     view_port_enabled_set(desktop->dummy_mode_icon_viewport, desktop->settings.dummy_mode);
     desktop_main_set_dummy_mode_state(desktop->main_view, desktop->settings.dummy_mode);
+    animation_manager_set_dummy_mode_state(
+        desktop->animation_manager, desktop->settings.dummy_mode);
 
     scene_manager_next_scene(desktop->scene_manager, DesktopSceneMain);