[FL-3846] Event Loop Timers (#3721)

* Implement POC event loop tmers (not all edge cases are handled)
* Use a separate ready list to allow for (re)starting and stopping of timers from callback
* Improve the test application
* Improve timer API and test application
* Improve timeout calculation logic
* Improve timer API, update documentation
* Fix API usage error
* Update doxygen comments
* Revert the old (correct) check
* Improve function naming
* Check whether a timer was on the expired list before processing it
* Implement tick callback
* Add critical sections to improve timer consistency
* Simplify event loop timer API
* Remove redundant search
* Refactor timer logic, use message queue
* Simplify FuriEventLoopTimer API
* Improve event loop timer logic
* Update the f18 target
* Remove superfluous clears
* Correct f18 api symbols
* Fix doxygen comments
* Update .pvsconfig
* Use a double push list instead of deque
* Update .pvsconfig
* Add pending callback functionality
* Restore unprocessed flags when applicable
* Refactor Dolphin app to use FuriEventLoop
* Improve naming
* Update naming some more
* Fix a typo Co-authored-by: Silent <CookiePLMonster@users.noreply.github.com>
* Fix wait time in example
* Bump API version
* Debug: multiple of 25 timings in event loop blink test
* Separate FuriEventLoopTimer to its own set of files
* Improve start time calculation for periodic timers
* Do not use dynamic allocations for timer requests
* Split the tick functionality in separate files, rearrange code
* Improve timer queue handling
* Properly reset GPIO pins in the test app
* Properly initialise GPIO pins in the test app too
* Furi: variable naming in event loop
* Furi: fix spelling in event loop

Co-authored-by: あく <alleteam@gmail.com>
Co-authored-by: Silent <CookiePLMonster@users.noreply.github.com>

furi/core/event_loop_i.h

@@ -1,35 +1,97 @@
 #pragma once
 
 #include "event_loop.h"
+#include "event_loop_link_i.h"
+#include "event_loop_timer_i.h"
+#include "event_loop_tick_i.h"
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#include <m-list.h>
+#include <m-bptree.h>
+#include <m-i-list.h>
 
-typedef struct FuriEventLoopItem FuriEventLoopItem;
+#include "thread.h"
 
-/* Link between Event Loop  */
+struct FuriEventLoopItem {
+    // Source
+    FuriEventLoop* owner;
+
+    // Tracking item
+    const FuriEventLoopContract* contract;
+    void* object;
+    FuriEventLoopEvent event;
+
+    // Callback and context
+    FuriEventLoopMessageQueueCallback callback;
+    void* callback_context;
+
+    // Waiting list
+    ILIST_INTERFACE(WaitingList, struct FuriEventLoopItem);
+};
+
+ILIST_DEF(WaitingList, FuriEventLoopItem, M_POD_OPLIST)
+
+/* Event Loop RB tree */
+#define FURI_EVENT_LOOP_TREE_RANK (4)
+
+BPTREE_DEF2( // NOLINT
+    FuriEventLoopTree,
+    FURI_EVENT_LOOP_TREE_RANK,
+    void*, /* pointer to object we track */
+    M_PTR_OPLIST,
+    FuriEventLoopItem*, /* pointer to the FuriEventLoopItem */
+    M_PTR_OPLIST)
+
+#define M_OPL_FuriEventLoopTree_t() BPTREE_OPLIST(FuriEventLoopTree, M_POD_OPLIST)
+
+#define FURI_EVENT_LOOP_FLAG_NOTIFY_INDEX (2)
+
+typedef enum {
+    FuriEventLoopFlagEvent = (1 << 0),
+    FuriEventLoopFlagStop = (1 << 1),
+    FuriEventLoopFlagTimer = (1 << 2),
+    FuriEventLoopFlagPending = (1 << 3),
+} FuriEventLoopFlag;
+
+#define FuriEventLoopFlagAll                                                   \
+    (FuriEventLoopFlagEvent | FuriEventLoopFlagStop | FuriEventLoopFlagTimer | \
+     FuriEventLoopFlagPending)
+
+typedef enum {
+    FuriEventLoopProcessStatusComplete,
+    FuriEventLoopProcessStatusIncomplete,
+    FuriEventLoopProcessStatusAgain,
+} FuriEventLoopProcessStatus;
+
+typedef enum {
+    FuriEventLoopStateStopped,
+    FuriEventLoopStateIdle,
+    FuriEventLoopStateProcessing,
+} FuriEventLoopState;
 
 typedef struct {
-    FuriEventLoopItem* item_in;
-    FuriEventLoopItem* item_out;
-} FuriEventLoopLink;
+    FuriEventLoopPendingCallback callback;
+    void* context;
+} FuriEventLoopPendingQueueItem;
 
-void furi_event_loop_link_notify(FuriEventLoopLink* instance, FuriEventLoopEvent event);
+LIST_DUAL_PUSH_DEF(PendingQueue, FuriEventLoopPendingQueueItem, M_POD_OPLIST)
 
-/* Contract between event loop and an object */
+struct FuriEventLoop {
+    // Only works if all operations are done from the same thread
+    FuriThreadId thread_id;
 
-typedef FuriEventLoopLink* (*FuriEventLoopContractGetLink)(void* object);
+    // Poller state
+    volatile FuriEventLoopState state;
 
-typedef uint32_t (*FuriEventLoopContractGetLevel)(void* object, FuriEventLoopEvent event);
+    // Event handling
+    FuriEventLoopTree_t tree;
+    WaitingList_t waiting_list;
 
-typedef struct {
-    const FuriEventLoopContractGetLink get_link;
-    const FuriEventLoopContractGetLevel get_level;
-} FuriEventLoopContract;
-
-bool furi_event_loop_signal_callback(uint32_t signal, void* arg, void* context);
-
-#ifdef __cplusplus
-}
-#endif
+    // Active timer list
+    TimerList_t timer_list;
+    // Timer request queue
+    TimerQueue_t timer_queue;
+    // Pending callback queue
+    PendingQueue_t pending_queue;
+    // Tick event
+    FuriEventLoopTick tick;
+};