[FL-3841] FuriEventLoop Pt.2

applications/debug/event_loop_blink_test/event_loop_blink_test.c

@@ -82,7 +82,8 @@ static void view_port_input_callback(InputEvent* input_event, void* context) {
     furi_message_queue_put(app->input_queue, input_event, 0);
 }
 
-static bool input_queue_callback(FuriMessageQueue* queue, void* context) {
+static bool input_queue_callback(FuriEventLoopObject* object, void* context) {
+    FuriMessageQueue* queue = object;
     EventLoopBlinkTestApp* app = context;
 
     InputEvent event;
@@ -144,7 +145,7 @@ int32_t event_loop_blink_test_app(void* arg) {
     gui_add_view_port(gui, view_port, GuiLayerFullscreen);
 
     furi_event_loop_tick_set(app.event_loop, 500, event_loop_tick_callback, &app);
-    furi_event_loop_message_queue_subscribe(
+    furi_event_loop_subscribe_message_queue(
         app.event_loop, app.input_queue, FuriEventLoopEventIn, input_queue_callback, &app);
 
     furi_event_loop_run(app.event_loop);
@@ -154,7 +155,7 @@ int32_t event_loop_blink_test_app(void* arg) {
 
     furi_record_close(RECORD_GUI);
 
-    furi_event_loop_message_queue_unsubscribe(app.event_loop, app.input_queue);
+    furi_event_loop_unsubscribe(app.event_loop, app.input_queue);
     furi_message_queue_free(app.input_queue);
 
     for(size_t i = 0; i < TIMER_COUNT; ++i) {

applications/debug/unit_tests/tests/furi/furi_event_loop.c

@@ -19,25 +19,24 @@ typedef struct {
     uint32_t consumer_counter;
 } TestFuriData;
 
-bool test_furi_event_loop_producer_mq_callback(FuriMessageQueue* queue, void* context) {
+bool test_furi_event_loop_producer_mq_callback(FuriEventLoopObject* object, void* context) {
     furi_check(context);
 
     TestFuriData* data = context;
-    furi_check(data->mq == queue, "Invalid queue");
+    furi_check(data->mq == object, "Invalid queue");
 
     FURI_LOG_I(
         TAG, "producer_mq_callback: %lu %lu", data->producer_counter, data->consumer_counter);
 
-    // Remove and add should not cause crash
-    // if(data->producer_counter == EVENT_LOOP_EVENT_COUNT/2) {
-    //     furi_event_loop_message_queue_remove(data->producer_event_loop, data->mq);
-    //     furi_event_loop_message_queue_add(
-    //     data->producer_event_loop,
-    //     data->mq,
-    //     FuriEventLoopEventOut,
-    //     test_furi_event_loop_producer_mq_callback,
-    //     data);
-    // }
+    if(data->producer_counter == EVENT_LOOP_EVENT_COUNT / 2) {
+        furi_event_loop_unsubscribe(data->producer_event_loop, data->mq);
+        furi_event_loop_subscribe_message_queue(
+            data->producer_event_loop,
+            data->mq,
+            FuriEventLoopEventOut,
+            test_furi_event_loop_producer_mq_callback,
+            data);
+    }
 
     if(data->producer_counter == EVENT_LOOP_EVENT_COUNT) {
         furi_event_loop_stop(data->producer_event_loop);
@@ -61,7 +60,7 @@ int32_t test_furi_event_loop_producer(void* p) {
     FURI_LOG_I(TAG, "producer start 1st run");
 
     data->producer_event_loop = furi_event_loop_alloc();
-    furi_event_loop_message_queue_subscribe(
+    furi_event_loop_subscribe_message_queue(
         data->producer_event_loop,
         data->mq,
         FuriEventLoopEventOut,
@@ -73,15 +72,15 @@ int32_t test_furi_event_loop_producer(void* p) {
     // 2 EventLoop index, 0xFFFFFFFF - all possible flags, emulate uncleared flags
     xTaskNotifyIndexed(xTaskGetCurrentTaskHandle(), 2, 0xFFFFFFFF, eSetBits);
 
-    furi_event_loop_message_queue_unsubscribe(data->producer_event_loop, data->mq);
+    furi_event_loop_unsubscribe(data->producer_event_loop, data->mq);
     furi_event_loop_free(data->producer_event_loop);
 
     FURI_LOG_I(TAG, "producer start 2nd run");
 
     data->producer_counter = 0;
     data->producer_event_loop = furi_event_loop_alloc();
 
-    furi_event_loop_message_queue_subscribe(
+    furi_event_loop_subscribe_message_queue(
         data->producer_event_loop,
         data->mq,
         FuriEventLoopEventOut,
@@ -90,36 +89,35 @@ int32_t test_furi_event_loop_producer(void* p) {
 
     furi_event_loop_run(data->producer_event_loop);
 
-    furi_event_loop_message_queue_unsubscribe(data->producer_event_loop, data->mq);
+    furi_event_loop_unsubscribe(data->producer_event_loop, data->mq);
     furi_event_loop_free(data->producer_event_loop);
 
     FURI_LOG_I(TAG, "producer end");
 
     return 0;
 }
 
-bool test_furi_event_loop_consumer_mq_callback(FuriMessageQueue* queue, void* context) {
+bool test_furi_event_loop_consumer_mq_callback(FuriEventLoopObject* object, void* context) {
     furi_check(context);
 
     TestFuriData* data = context;
-    furi_check(data->mq == queue);
+    furi_check(data->mq == object);
 
     furi_delay_us(furi_hal_random_get() % 1000);
     furi_check(furi_message_queue_get(data->mq, &data->consumer_counter, 0) == FuriStatusOk);
 
     FURI_LOG_I(
         TAG, "consumer_mq_callback: %lu %lu", data->producer_counter, data->consumer_counter);
 
-    // Remove and add should not cause crash
-    // if(data->producer_counter == EVENT_LOOP_EVENT_COUNT/2) {
-    //     furi_event_loop_message_queue_remove(data->consumer_event_loop, data->mq);
-    //     furi_event_loop_message_queue_add(
-    //     data->consumer_event_loop,
-    //     data->mq,
-    //     FuriEventLoopEventIn,
-    //     test_furi_event_loop_producer_mq_callback,
-    //     data);
-    // }
+    if(data->consumer_counter == EVENT_LOOP_EVENT_COUNT / 2) {
+        furi_event_loop_unsubscribe(data->consumer_event_loop, data->mq);
+        furi_event_loop_subscribe_message_queue(
+            data->consumer_event_loop,
+            data->mq,
+            FuriEventLoopEventIn,
+            test_furi_event_loop_consumer_mq_callback,
+            data);
+    }
 
     if(data->consumer_counter == EVENT_LOOP_EVENT_COUNT) {
         furi_event_loop_stop(data->consumer_event_loop);
@@ -137,7 +135,7 @@ int32_t test_furi_event_loop_consumer(void* p) {
     FURI_LOG_I(TAG, "consumer start 1st run");
 
     data->consumer_event_loop = furi_event_loop_alloc();
-    furi_event_loop_message_queue_subscribe(
+    furi_event_loop_subscribe_message_queue(
         data->consumer_event_loop,
         data->mq,
         FuriEventLoopEventIn,
@@ -149,14 +147,14 @@ int32_t test_furi_event_loop_consumer(void* p) {
     // 2 EventLoop index, 0xFFFFFFFF - all possible flags, emulate uncleared flags
     xTaskNotifyIndexed(xTaskGetCurrentTaskHandle(), 2, 0xFFFFFFFF, eSetBits);
 
-    furi_event_loop_message_queue_unsubscribe(data->consumer_event_loop, data->mq);
+    furi_event_loop_unsubscribe(data->consumer_event_loop, data->mq);
     furi_event_loop_free(data->consumer_event_loop);
 
     FURI_LOG_I(TAG, "consumer start 2nd run");
 
     data->consumer_counter = 0;
     data->consumer_event_loop = furi_event_loop_alloc();
-    furi_event_loop_message_queue_subscribe(
+    furi_event_loop_subscribe_message_queue(
         data->consumer_event_loop,
         data->mq,
         FuriEventLoopEventIn,
@@ -165,7 +163,7 @@ int32_t test_furi_event_loop_consumer(void* p) {
 
     furi_event_loop_run(data->consumer_event_loop);
 
-    furi_event_loop_message_queue_unsubscribe(data->consumer_event_loop, data->mq);
+    furi_event_loop_unsubscribe(data->consumer_event_loop, data->mq);
     furi_event_loop_free(data->consumer_event_loop);
 
     FURI_LOG_I(TAG, "consumer end");

applications/debug/unit_tests/tests/rpc/rpc_test.c

@@ -127,6 +127,8 @@ static void test_rpc_teardown(void) {
     furi_check(
         furi_semaphore_acquire(rpc_session[0].terminate_semaphore, FuriWaitForever) ==
         FuriStatusOk);
+    // Temporary workaround: do not delete the semaphore immediately after taking it
+    furi_delay_ms(1);
     furi_record_close(RECORD_RPC);
     furi_stream_buffer_free(rpc_session[0].output_stream);
     furi_semaphore_free(rpc_session[0].close_session_semaphore);
@@ -145,6 +147,8 @@ static void test_rpc_teardown_second_session(void) {
     furi_check(
         furi_semaphore_acquire(rpc_session[1].terminate_semaphore, FuriWaitForever) ==
         FuriStatusOk);
+    // Temporary workaround: do not delete the semaphore immediately after taking it
+    furi_delay_ms(1);
     furi_stream_buffer_free(rpc_session[1].output_stream);
     furi_semaphore_free(rpc_session[1].close_session_semaphore);
     furi_semaphore_free(rpc_session[1].terminate_semaphore);

applications/debug/unit_tests/unit_test_api_table_i.h

@@ -36,14 +36,10 @@ static constexpr auto unit_tests_api_table = sort(create_array_t<sym_entry>(
     API_METHOD(furi_event_loop_alloc, FuriEventLoop*, (void)),
     API_METHOD(furi_event_loop_free, void, (FuriEventLoop*)),
     API_METHOD(
-        furi_event_loop_message_queue_subscribe,
+        furi_event_loop_subscribe_message_queue,
         void,
-        (FuriEventLoop*,
-         FuriMessageQueue*,
-         FuriEventLoopEvent,
-         FuriEventLoopMessageQueueCallback,
-         void*)),
-    API_METHOD(furi_event_loop_message_queue_unsubscribe, void, (FuriEventLoop*, FuriMessageQueue*)),
+        (FuriEventLoop*, FuriMessageQueue*, FuriEventLoopEvent, FuriEventLoopEventCallback, void*)),
+    API_METHOD(furi_event_loop_unsubscribe, void, (FuriEventLoop*, FuriEventLoopObject*)),
     API_METHOD(furi_event_loop_run, void, (FuriEventLoop*)),
     API_METHOD(furi_event_loop_stop, void, (FuriEventLoop*)),
     API_VARIABLE(PB_Main_msg, PB_Main_msg_t)));

applications/examples/example_event_loop/application.fam

@@ -0,0 +1,7 @@
+App(
+    appid="example_event_loop_timer",
+    name="Example: Event Loop Timer",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="example_event_loop_timer_app",
+    fap_category="Examples",
+)

applications/examples/example_event_loop/example_event_loop_timer.c

@@ -0,0 +1,87 @@
+/**
+ * @file example_event_loop_timer.c
+ * @brief Example application that demonstrates FuriEventLoop's software timer capability.
+ *
+ * This application prints a countdown from 10 to 0 to the debug output and then exits.
+ * Despite only one timer being used in this example for clarity, an event loop instance can have
+ * an arbitrary number of independent timers of any type (periodic or one-shot).
+ *
+ */
+#include <furi.h>
+
+#define TAG "ExampleEventLoopTimer"
+
+#define COUNTDOWN_START_VALUE (10)
+#define COUNTDOWN_INTERVAL_MS (1000)
+
+typedef struct {
+    FuriEventLoop* event_loop;
+    FuriEventLoopTimer* timer;
+    uint32_t countdown_value;
+} EventLoopTimerApp;
+
+// This function is called each time the timer expires (i.e. once per 1000 ms (1s) in this example)
+static void event_loop_timer_callback(void* context) {
+    furi_assert(context);
+    EventLoopTimerApp* app = context;
+
+    // Print the countdown value
+    FURI_LOG_I(TAG, "T-00:00:%02lu", app->countdown_value);
+
+    if(app->countdown_value == 0) {
+        // If the countdown reached 0, print the final line and stop the event loop
+        FURI_LOG_I(TAG, "Blast off to adventure!");
+        // After this call, the control will be returned back to event_loop_timers_app_run()
+        furi_event_loop_stop(app->event_loop);
+
+    } else {
+        // Decrement the countdown value
+        app->countdown_value -= 1;
+    }
+}
+
+static EventLoopTimerApp* event_loop_timer_app_alloc(void) {
+    EventLoopTimerApp* app = malloc(sizeof(EventLoopTimerApp));
+
+    // Create an event loop instance.
+    app->event_loop = furi_event_loop_alloc();
+    // Create a software timer instance.
+    // The timer is bound to the event loop instance and will execute in its context.
+    // Here, the timer type is periodic, i.e. it will restart automatically after expiring.
+    app->timer = furi_event_loop_timer_alloc(
+        app->event_loop, event_loop_timer_callback, FuriEventLoopTimerTypePeriodic, app);
+    // The countdown value will be tracked in this variable.
+    app->countdown_value = COUNTDOWN_START_VALUE;
+
+    return app;
+}
+
+static void event_loop_timer_app_free(EventLoopTimerApp* app) {
+    // IMPORTANT: All event loop timers MUST be deleted BEFORE deleting the event loop itself.
+    // Failure to do so will result in a crash.
+    furi_event_loop_timer_free(app->timer);
+    // With all timers deleted, it's safe to delete the event loop.
+    furi_event_loop_free(app->event_loop);
+    free(app);
+}
+
+static void event_loop_timer_app_run(EventLoopTimerApp* app) {
+    FURI_LOG_I(TAG, "All systems go! Prepare for countdown!");
+
+    // Timers can be started either before the event loop is run, or in any
+    // callback function called by a running event loop.
+    furi_event_loop_timer_start(app->timer, COUNTDOWN_INTERVAL_MS);
+    // This call will block until furi_event_loop_stop() is called.
+    furi_event_loop_run(app->event_loop);
+}
+
+// The application's entry point - referenced in application.fam
+int32_t example_event_loop_timer_app(void* arg) {
+    UNUSED(arg);
+
+    EventLoopTimerApp* app = event_loop_timer_app_alloc();
+    event_loop_timer_app_run(app);
+    event_loop_timer_app_free(app);
+
+    return 0;
+}

applications/services/dolphin/dolphin.c

@@ -191,8 +191,8 @@ static void dolphin_update_clear_limits_timer_period(void* context) {
     FURI_LOG_D(TAG, "Daily limits reset in %lu ms", time_to_clear_limits);
 }
 
-static bool dolphin_process_event(FuriMessageQueue* queue, void* context) {
-    UNUSED(queue);
+static bool dolphin_process_event(FuriEventLoopObject* object, void* context) {
+    UNUSED(object);
 
     Dolphin* dolphin = context;
     DolphinEvent event;
@@ -249,7 +249,7 @@ int32_t dolphin_srv(void* p) {
 
     dolphin_state_load(dolphin->state);
 
-    furi_event_loop_message_queue_subscribe(
+    furi_event_loop_subscribe_message_queue(
         dolphin->event_loop,
         dolphin->event_queue,
         FuriEventLoopEventIn,

applications/services/gui/view_dispatcher.c

@@ -30,13 +30,11 @@ void view_dispatcher_free(ViewDispatcher* view_dispatcher) {
     view_port_free(view_dispatcher->view_port);
     // Free internal queue
     if(view_dispatcher->input_queue) {
-        furi_event_loop_message_queue_unsubscribe(
-            view_dispatcher->event_loop, view_dispatcher->input_queue);
+        furi_event_loop_unsubscribe(view_dispatcher->event_loop, view_dispatcher->input_queue);
         furi_message_queue_free(view_dispatcher->input_queue);
     }
     if(view_dispatcher->event_queue) {
-        furi_event_loop_message_queue_unsubscribe(
-            view_dispatcher->event_loop, view_dispatcher->event_queue);
+        furi_event_loop_unsubscribe(view_dispatcher->event_loop, view_dispatcher->event_queue);
         furi_message_queue_free(view_dispatcher->event_queue);
     }
     if(view_dispatcher->event_loop) {
@@ -53,15 +51,15 @@ void view_dispatcher_enable_queue(ViewDispatcher* view_dispatcher) {
     view_dispatcher->event_loop = furi_event_loop_alloc();
 
     view_dispatcher->input_queue = furi_message_queue_alloc(16, sizeof(InputEvent));
-    furi_event_loop_message_queue_subscribe(
+    furi_event_loop_subscribe_message_queue(
         view_dispatcher->event_loop,
         view_dispatcher->input_queue,
         FuriEventLoopEventIn,
         view_dispatcher_run_input_callback,
         view_dispatcher);
 
     view_dispatcher->event_queue = furi_message_queue_alloc(16, sizeof(uint32_t));
-    furi_event_loop_message_queue_subscribe(
+    furi_event_loop_subscribe_message_queue(
         view_dispatcher->event_loop,
         view_dispatcher->event_queue,
         FuriEventLoopEventIn,
@@ -381,10 +379,10 @@ void view_dispatcher_update(View* view, void* context) {
     }
 }
 
-bool view_dispatcher_run_event_callback(FuriMessageQueue* queue, void* context) {
+bool view_dispatcher_run_event_callback(FuriEventLoopObject* object, void* context) {
     furi_assert(context);
     ViewDispatcher* instance = context;
-    furi_assert(instance->event_queue == queue);
+    furi_assert(instance->event_queue == object);
 
     uint32_t event;
     furi_check(furi_message_queue_get(instance->event_queue, &event, 0) == FuriStatusOk);
@@ -393,10 +391,10 @@ bool view_dispatcher_run_event_callback(FuriMessageQueue* queue, void* context)
     return true;
 }
 
-bool view_dispatcher_run_input_callback(FuriMessageQueue* queue, void* context) {
+bool view_dispatcher_run_input_callback(FuriEventLoopObject* object, void* context) {
     furi_assert(context);
     ViewDispatcher* instance = context;
-    furi_assert(instance->input_queue == queue);
+    furi_assert(instance->input_queue == object);
 
     InputEvent input;
     furi_check(furi_message_queue_get(instance->input_queue, &input, 0) == FuriStatusOk);

applications/services/gui/view_dispatcher_i.h

@@ -56,7 +56,7 @@ void view_dispatcher_set_current_view(ViewDispatcher* view_dispatcher, View* vie
 void view_dispatcher_update(View* view, void* context);
 
 /** ViewDispatcher run event loop event callback */
-bool view_dispatcher_run_event_callback(FuriMessageQueue* queue, void* context);
+bool view_dispatcher_run_event_callback(FuriEventLoopObject* object, void* context);
 
 /** ViewDispatcher run event loop input callback */
-bool view_dispatcher_run_input_callback(FuriMessageQueue* queue, void* context);
+bool view_dispatcher_run_input_callback(FuriEventLoopObject* object, void* context);