Merge pull request #159 from CookiePLMonster/fix-view-dispatcher-apps

Fix apps using the View Dispatcher without running it

apps_source_code/musictracker/application.fam

@@ -12,6 +12,6 @@ App(
     fap_category="Media",
     fap_author="@DrZlo13",
     fap_weburl="https://github.com/DrZlo13/flipper-zero-music-tracker",
-    fap_version="1.3",
+    fap_version="1.4",
     fap_description="App plays hardcoded tracker song",
 )

apps_source_code/musictracker/tracker_engine/tracker.c

@@ -154,25 +154,25 @@ typedef struct {
 
 static void tracker_send_position_message(Tracker* tracker) {
     if(tracker->callback != NULL) {
-        tracker->callback(
-            (TrackerMessage){
-                .type = TrackerPositionChanged,
-                .data =
-                    {
-                        .position =
-                            {
-                                .order_list_index = tracker->song_state.order_list_index,
-                                .row = tracker->song_state.row_index,
-                            },
-                    },
-            },
-            tracker->context);
+        const TrackerMessage message = {
+            .type = TrackerPositionChanged,
+            .data =
+                {
+                    .position =
+                        {
+                            .order_list_index = tracker->song_state.order_list_index,
+                            .row = tracker->song_state.row_index,
+                        },
+                },
+        };
+        tracker->callback(&message, tracker->context);
     }
 }
 
 static void tracker_send_end_message(Tracker* tracker) {
     if(tracker->callback != NULL) {
-        tracker->callback((TrackerMessage){.type = TrackerEndOfSong}, tracker->context);
+        const TrackerMessage message = {.type = TrackerEndOfSong};
+        tracker->callback(&message, tracker->context);
     }
 }
 
@@ -438,4 +438,4 @@ void tracker_stop(Tracker* tracker) {
     tracker_debug_deinit();
 
     tracker->playing = false;
-}
+}

apps_source_code/musictracker/tracker_engine/tracker.h

@@ -5,6 +5,7 @@
 typedef enum {
     TrackerPositionChanged,
     TrackerEndOfSong,
+    TrackerShutDown,
 } TrackerMessageType;
 
 typedef struct {
@@ -17,7 +18,7 @@ typedef struct {
     } data;
 } TrackerMessage;
 
-typedef void (*TrackerMessageCallback)(TrackerMessage message, void* context);
+typedef void (*TrackerMessageCallback)(const TrackerMessage* message, void* context);
 
 typedef struct Tracker Tracker;
 

apps_source_code/musictracker/view/tracker_view.c

@@ -10,8 +10,6 @@ typedef struct {
 
 struct TrackerView {
     View* view;
-    void* back_context;
-    TrackerViewCallback back_callback;
 };
 
 static Channel* get_current_channel(TrackerViewModel* model) {
@@ -126,25 +124,12 @@ static void tracker_view_draw_callback(Canvas* canvas, void* _model) {
     furi_string_free(buffer);
 }
 
-static bool tracker_view_input_callback(InputEvent* event, void* context) {
-    TrackerView* tracker_view = context;
-
-    if(tracker_view->back_callback) {
-        if(event->type == InputTypeShort && event->key == InputKeyBack) {
-            tracker_view->back_callback(tracker_view->back_context);
-            return true;
-        }
-    }
-    return false;
-}
-
 TrackerView* tracker_view_alloc() {
     TrackerView* tracker_view = malloc(sizeof(TrackerView));
     tracker_view->view = view_alloc();
     view_allocate_model(tracker_view->view, ViewModelTypeLocking, sizeof(TrackerViewModel));
     view_set_context(tracker_view->view, tracker_view);
-    view_set_draw_callback(tracker_view->view, (ViewDrawCallback)tracker_view_draw_callback);
-    view_set_input_callback(tracker_view->view, (ViewInputCallback)tracker_view_input_callback);
+    view_set_draw_callback(tracker_view->view, tracker_view_draw_callback);
     return tracker_view;
 }
 
@@ -157,14 +142,6 @@ View* tracker_view_get_view(TrackerView* tracker_view) {
     return tracker_view->view;
 }
 
-void tracker_view_set_back_callback(
-    TrackerView* tracker_view,
-    TrackerViewCallback callback,
-    void* context) {
-    tracker_view->back_callback = callback;
-    tracker_view->back_context = context;
-}
-
 void tracker_view_set_song(TrackerView* tracker_view, const Song* song) {
     with_view_model(
         tracker_view->view, TrackerViewModel * model, { model->song = song; }, true);

apps_source_code/musictracker/view/tracker_view.h

@@ -13,13 +13,6 @@ void tracker_view_free(TrackerView* tracker_view);
 
 View* tracker_view_get_view(TrackerView* tracker_view);
 
-typedef void (*TrackerViewCallback)(void* context);
-
-void tracker_view_set_back_callback(
-    TrackerView* tracker_view,
-    TrackerViewCallback callback,
-    void* context);
-
 void tracker_view_set_song(TrackerView* tracker_view, const Song* song);
 
 void tracker_view_set_position(TrackerView* tracker_view, uint8_t order_list_index, uint8_t row);

apps_source_code/musictracker/zero_tracker.c

@@ -1,6 +1,6 @@
 #include <furi.h>
 #include <gui/gui.h>
-#include <gui/view_dispatcher.h>
+#include <gui/view_holder.h>
 #include <notification/notification_messages.h>
 #include "zero_tracker.h"
 #include "tracker_engine/tracker.h"
@@ -474,10 +474,26 @@ Song song = {
     .ticks_per_second = 60,
 };
 
-void tracker_message(TrackerMessage message, void* context) {
+void tracker_message(const TrackerMessage* message, void* context) {
     FuriMessageQueue* queue = context;
     furi_assert(queue);
-    furi_message_queue_put(queue, &message, 0);
+    furi_message_queue_put(queue, message, 0);
+}
+
+static void exit_callback(void* context) {
+    FuriMessageQueue* queue = context;
+
+    const TrackerMessage message = {.type = TrackerShutDown};
+    furi_message_queue_put(queue, &message, FuriWaitForever);
+}
+
+static bool thread_exit_signal_callback(uint32_t signal, void* arg, void* ctx) {
+    UNUSED(arg);
+    if(signal == FuriSignalExit) {
+        exit_callback(ctx);
+        return true;
+    }
+    return false;
 }
 
 int32_t zero_tracker_app(void* p) {
@@ -486,51 +502,55 @@ int32_t zero_tracker_app(void* p) {
     NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
     notification_message(notification, &sequence_display_backlight_enforce_on);
 
+    FuriMessageQueue* queue = furi_message_queue_alloc(8, sizeof(TrackerMessage));
+
     Gui* gui = furi_record_open(RECORD_GUI);
-    ViewDispatcher* view_dispatcher = view_dispatcher_alloc();
+    ViewHolder* view_holder = view_holder_alloc();
     TrackerView* tracker_view = tracker_view_alloc();
     tracker_view_set_song(tracker_view, &song);
-    view_dispatcher_add_view(view_dispatcher, 0, tracker_view_get_view(tracker_view));
-    view_dispatcher_attach_to_gui(view_dispatcher, gui, ViewDispatcherTypeFullscreen);
-    view_dispatcher_switch_to_view(view_dispatcher, 0);
 
-    FuriMessageQueue* queue = furi_message_queue_alloc(8, sizeof(TrackerMessage));
+    view_holder_set_back_callback(view_holder, exit_callback, queue);
+    view_holder_attach_to_gui(view_holder, gui);
+    view_holder_set_view(view_holder, tracker_view_get_view(tracker_view));
+    view_holder_send_to_front(view_holder);
+
     Tracker* tracker = tracker_alloc();
     tracker_set_message_callback(tracker, tracker_message, queue);
     tracker_set_song(tracker, &song);
     tracker_start(tracker);
 
+    furi_thread_set_signal_callback(furi_thread_get_current(), thread_exit_signal_callback, queue);
+
     while(1) {
         TrackerMessage message;
-        FuriStatus status = furi_message_queue_get(queue, &message, FuriWaitForever);
-        if(status == FuriStatusOk) {
-            if(message.type == TrackerPositionChanged) {
-                uint8_t order_list_index = message.data.position.order_list_index;
-                uint8_t row = message.data.position.row;
-                uint8_t pattern = song.order_list[order_list_index];
-                tracker_view_set_position(tracker_view, order_list_index, row);
-                FURI_LOG_I("Tracker", "O:%d P:%d R:%d", order_list_index, pattern, row);
-            } else if(message.type == TrackerEndOfSong) {
-                FURI_LOG_I("Tracker", "End of song");
-                break;
-            }
+        furi_check(furi_message_queue_get(queue, &message, FuriWaitForever) == FuriStatusOk);
+        if(message.type == TrackerPositionChanged) {
+            uint8_t order_list_index = message.data.position.order_list_index;
+            uint8_t row = message.data.position.row;
+            uint8_t pattern = song.order_list[order_list_index];
+            tracker_view_set_position(tracker_view, order_list_index, row);
+            FURI_LOG_I("Tracker", "O:%d P:%d R:%d", order_list_index, pattern, row);
+        } else if(message.type == TrackerEndOfSong) {
+            FURI_LOG_I("Tracker", "End of song");
+            break;
+        } else if(message.type == TrackerShutDown) {
+            break;
         }
     }
 
     tracker_stop(tracker);
     tracker_free(tracker);
-    furi_message_queue_free(queue);
-
-    furi_delay_ms(500);
 
-    view_dispatcher_remove_view(view_dispatcher, 0);
+    view_holder_set_view(view_holder, NULL);
+    view_holder_free(view_holder);
     tracker_view_free(tracker_view);
-    view_dispatcher_free(view_dispatcher);
 
-    notification_message(notification, &sequence_display_backlight_enforce_auto);
+    furi_record_close(RECORD_GUI);
 
+    furi_message_queue_free(queue);
+
+    notification_message(notification, &sequence_display_backlight_enforce_auto);
     furi_record_close(RECORD_NOTIFICATION);
-    furi_record_close(RECORD_GUI);
 
     return 0;
-}
+}

base_pack/wav_player/application.fam

@@ -9,6 +9,6 @@ App(
     fap_category="Media",
     fap_icon_assets="images",
     fap_author="@DrZlo13 & (ported, fixed by @xMasterX), (improved by @LTVA1)",
-    fap_version="1.2",
+    fap_version="1.3",
     fap_description="Audio player for WAV files, recommended to convert files to unsigned 8-bit PCM stereo, but it may work with others too",
 )

base_pack/wav_player/wav_parser.h

@@ -3,12 +3,10 @@
 
 #include <furi.h>
 #include <furi_hal.h>
-#include <cli/cli.h>
 #include <gui/gui.h>
-#include <stm32wbxx_ll_dma.h>
 #include <dialogs/dialogs.h>
 #include <notification/notification_messages.h>
-#include <gui/view_dispatcher.h>
+#include <gui/view_holder.h>
 #include <toolbox/stream/file_stream.h>
 
 #include "wav_player_view.h"
@@ -67,7 +65,7 @@ typedef struct {
     bool play;
 
     WavPlayerView* view;
-    ViewDispatcher* view_dispatcher;
+    ViewHolder* view_holder;
     Gui* gui;
     NotificationApp* notification;
 } WavPlayerApp;

base_pack/wav_player/wav_player.c

@@ -1,12 +1,7 @@
 #include <furi.h>
 #include <furi_hal.h>
-#include <cli/cli.h>
 #include <gui/gui.h>
 #include <stm32wbxx_ll_dma.h>
-#include <dialogs/dialogs.h>
-#include <notification/notification_messages.h>
-#include <gui/view_dispatcher.h>
-#include <toolbox/stream/file_stream.h>
 #include "wav_player_hal.h"
 #include "wav_parser.h"
 #include "wav_player_view.h"
@@ -79,6 +74,23 @@ static void wav_player_dma_isr(void* ctx) {
     }
 }
 
+static void exit_callback(void* ctx) {
+    FuriMessageQueue* event_queue = ctx;
+
+    WavPlayerEvent event;
+    event.type = WavPlayerEventCtrlBack;
+    furi_message_queue_put(event_queue, &event, 0);
+}
+
+static bool thread_exit_signal_callback(uint32_t signal, void* arg, void* ctx) {
+    UNUSED(arg);
+    if(signal == FuriSignalExit) {
+        exit_callback(ctx);
+        return true;
+    }
+    return false;
+}
+
 static WavPlayerApp* app_alloc() {
     WavPlayerApp* app = malloc(sizeof(WavPlayerApp));
     app->samples_count_half = 1024 * 4;
@@ -94,22 +106,26 @@ static WavPlayerApp* app_alloc() {
     app->play = true;
 
     app->gui = furi_record_open(RECORD_GUI);
-    app->view_dispatcher = view_dispatcher_alloc();
+    app->view_holder = view_holder_alloc();
     app->view = wav_player_view_alloc();
 
-    view_dispatcher_add_view(app->view_dispatcher, 0, wav_player_view_get_view(app->view));
-    view_dispatcher_attach_to_gui(app->view_dispatcher, app->gui, ViewDispatcherTypeFullscreen);
-    view_dispatcher_switch_to_view(app->view_dispatcher, 0);
+    view_holder_set_back_callback(app->view_holder, exit_callback, app->queue);
+    view_holder_attach_to_gui(app->view_holder, app->gui);
+    view_holder_set_view(app->view_holder, wav_player_view_get_view(app->view));
+    view_holder_send_to_front(app->view_holder);
 
     app->notification = furi_record_open(RECORD_NOTIFICATION);
     notification_message(app->notification, &sequence_display_backlight_enforce_on);
 
+    furi_thread_set_signal_callback(
+        furi_thread_get_current(), thread_exit_signal_callback, app->queue);
+
     return app;
 }
 
 static void app_free(WavPlayerApp* app) {
-    view_dispatcher_remove_view(app->view_dispatcher, 0);
-    view_dispatcher_free(app->view_dispatcher);
+    view_holder_set_view(app->view_holder, NULL);
+    view_holder_free(app->view_holder);
     wav_player_view_free(app->view);
     furi_record_close(RECORD_GUI);
 
@@ -332,10 +348,6 @@ static void ctrl_callback(WavPlayerCtrl ctrl, void* ctx) {
         event.type = WavPlayerEventCtrlOk;
         furi_message_queue_put(event_queue, &event, 0);
         break;
-    case WavPlayerCtrlBack:
-        event.type = WavPlayerEventCtrlBack;
-        furi_message_queue_put(event_queue, &event, 0);
-        break;
     default:
         break;
     }

base_pack/wav_player/wav_player_view.c

@@ -100,9 +100,6 @@ static bool wav_player_view_input_callback(InputEvent* event, void* context) {
             } else if(event->key == InputKeyOk) {
                 wav_player_view->callback(WavPlayerCtrlOk, wav_player_view->context);
                 consumed = true;
-            } else if(event->key == InputKeyBack) {
-                wav_player_view->callback(WavPlayerCtrlBack, wav_player_view->context);
-                consumed = true;
             }
         }
     }
@@ -134,20 +131,17 @@ View* wav_player_view_get_view(WavPlayerView* wav_view) {
 
 void wav_player_view_set_volume(WavPlayerView* wav_view, float volume) {
     furi_assert(wav_view);
-    with_view_model(
-        wav_view->view, WavPlayerViewModel * model, { model->volume = volume; }, true);
+    with_view_model(wav_view->view, WavPlayerViewModel * model, { model->volume = volume; }, true);
 }
 
 void wav_player_view_set_start(WavPlayerView* wav_view, size_t start) {
     furi_assert(wav_view);
-    with_view_model(
-        wav_view->view, WavPlayerViewModel * model, { model->start = start; }, true);
+    with_view_model(wav_view->view, WavPlayerViewModel * model, { model->start = start; }, true);
 }
 
 void wav_player_view_set_end(WavPlayerView* wav_view, size_t end) {
     furi_assert(wav_view);
-    with_view_model(
-        wav_view->view, WavPlayerViewModel * model, { model->end = end; }, true);
+    with_view_model(wav_view->view, WavPlayerViewModel * model, { model->end = end; }, true);
 }
 
 void wav_player_view_set_current(WavPlayerView* wav_view, size_t current) {
@@ -158,8 +152,7 @@ void wav_player_view_set_current(WavPlayerView* wav_view, size_t current) {
 
 void wav_player_view_set_play(WavPlayerView* wav_view, bool play) {
     furi_assert(wav_view);
-    with_view_model(
-        wav_view->view, WavPlayerViewModel * model, { model->play = play; }, true);
+    with_view_model(wav_view->view, WavPlayerViewModel * model, { model->play = play; }, true);
 }
 
 void wav_player_view_set_chans(WavPlayerView* wav_view, uint16_t chn) {

base_pack/wav_player/wav_player_view.h

@@ -3,13 +3,7 @@
 
 #include <furi.h>
 #include <furi_hal.h>
-#include <cli/cli.h>
-#include <gui/gui.h>
-#include <stm32wbxx_ll_dma.h>
-#include <dialogs/dialogs.h>
-#include <notification/notification_messages.h>
-#include <gui/view_dispatcher.h>
-#include <toolbox/stream/file_stream.h>
+#include <gui/view.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -23,7 +17,6 @@ typedef enum {
     WavPlayerCtrlMoveL,
     WavPlayerCtrlMoveR,
     WavPlayerCtrlOk,
-    WavPlayerCtrlBack,
 } WavPlayerCtrl;
 
 typedef void (*WavPlayerCtrlCallback)(WavPlayerCtrl ctrl, void* context);