feat(NetworkEvents lib) reuse ESP IDF's event bus notifications

ESP IDF has very similar implementation of event bus ti propagate messages to subscribers,
it consists of same set of componets - a queue and a task to execute subscriber's callbacks.
Reusing it for Arduino networking events could give some benefits:

 - a unified event exchange bus between arduino and IDF components
 - save resources for extra Task stack and Queue to handle Arduino's own event bus

Author: vortigont

Diff for: libraries/Network/src/NetworkEvents.cpp

@@ -3,39 +3,24 @@
  *
  * SPDX-License-Identifier: Apache-2.0
  */
+#include <algorithm>
 #include "NetworkEvents.h"
-#include "NetworkManager.h"
-#include "esp_task.h"
 #include "esp32-hal.h"
 
-#ifndef ARDUINO_NETWORK_EVENT_TASK_STACK_SIZE
-#define ARDUINO_NETWORK_EVENT_TASK_STACK_SIZE 4096
-#endif
-
-NetworkEvents::NetworkEvents() : _arduino_event_group(NULL), _arduino_event_queue(NULL), _arduino_event_task_handle(NULL) {}
+ESP_EVENT_DEFINE_BASE(ARDUINO_EVENTS);
 
 NetworkEvents::~NetworkEvents() {
-  if (_arduino_event_task_handle != NULL) {
-    vTaskDelete(_arduino_event_task_handle);
-    _arduino_event_task_handle = NULL;
-  }
   if (_arduino_event_group != NULL) {
     vEventGroupDelete(_arduino_event_group);
     _arduino_event_group = NULL;
   }
-  if (_arduino_event_queue != NULL) {
-    arduino_event_t *event = NULL;
-    // consume queue
-    while (xQueueReceive(_arduino_event_queue, &event, 0) == pdTRUE) {
-      delete event;
-    }
-    vQueueDelete(_arduino_event_queue);
-    _arduino_event_queue = NULL;
+  // unregister event bus handler
+  if (_evt_handler){
+    esp_event_handler_instance_unregister(ARDUINO_EVENTS, ESP_EVENT_ANY_ID, _evt_handler);
+    _evt_handler = nullptr;
   }
 }
 
-static uint32_t _initial_bits = 0;
-
 bool NetworkEvents::initNetworkEvents() {
   if (!_arduino_event_group) {
     _arduino_event_group = xEventGroupCreate();
@@ -46,108 +31,63 @@ bool NetworkEvents::initNetworkEvents() {
     xEventGroupSetBits(_arduino_event_group, _initial_bits);
   }
 
-  if (!_arduino_event_queue) {
-    _arduino_event_queue = xQueueCreate(32, sizeof(arduino_event_t *));
-    if (!_arduino_event_queue) {
-      log_e("Network Event Queue Create Failed!");
-      return false;
-    }
-  }
-
+  // create default ESP event loop
   esp_err_t err = esp_event_loop_create_default();
   if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) {
     log_e("esp_event_loop_create_default failed!");
-    return err;
+    return false;
   }
 
-  if (!_arduino_event_task_handle) {
-    xTaskCreateUniversal(
-      [](void *self) {
-        static_cast<NetworkEvents *>(self)->_checkForEvent();
-      },
-      "arduino_events",                       // label
-      ARDUINO_NETWORK_EVENT_TASK_STACK_SIZE,  // event task's stack size
-      this, ESP_TASKD_EVENT_PRIO - 1, &_arduino_event_task_handle, ARDUINO_EVENT_RUNNING_CORE
+  // subscribe to default ESP event bus
+  if (!_evt_handler){
+    ESP_ERROR_CHECK(
+      esp_event_handler_instance_register(
+        ARDUINO_EVENTS, ESP_EVENT_ANY_ID,
+        [](void* self, esp_event_base_t base, int32_t id, void* data) { static_cast<NetworkEvents*>(self)->_evt_picker(id, reinterpret_cast<arduino_event_info_t*>(data)); },
+        this,
+        &_evt_handler
+      )
     );
-    if (!_arduino_event_task_handle) {
-      log_e("Network Event Task Start Failed!");
-      return false;
-    }
   }
-
   return true;
 }
 
-bool NetworkEvents::postEvent(const arduino_event_t *data) {
-  if (data == NULL || _arduino_event_queue == NULL) {
-    return false;
-  }
-  arduino_event_t *event = new arduino_event_t();
-  if (event == NULL) {
-    log_e("Arduino Event Malloc Failed!");
-    return false;
-  }
+bool NetworkEvents::postEvent(const arduino_event_t *data, TickType_t timeout) {
+  if (!data) return false;
+  esp_err_t err = esp_event_post(ARDUINO_EVENTS, static_cast<int32_t>(data->event_id), &data->event_info, sizeof(data->event_info), timeout);
+  if (err == pdTRUE)
+    return true;
 
-  memcpy(event, data, sizeof(arduino_event_t));
-  if (xQueueSend(_arduino_event_queue, &event, portMAX_DELAY) != pdPASS) {
-    log_e("Arduino Event Send Failed!");
-    delete event;  // release mem on error
-    return false;
-  }
-  return true;
+  log_e("Arduino Event Send Failed!");
+  return false;
 }
 
-void NetworkEvents::_checkForEvent() {
-  // this task can't run without the queue
-  if (_arduino_event_queue == NULL) {
-    _arduino_event_task_handle = NULL;
-    vTaskDelete(NULL);
-    return;
-  }
-
-  for (;;) {
-    arduino_event_t *event = NULL;
-    // wait for an event on a queue
-    if (xQueueReceive(_arduino_event_queue, &event, portMAX_DELAY) != pdTRUE) {
-      continue;
-    }
-    if (event == NULL) {
-      continue;
-    }
-    log_v("Network Event: %d - %s", event->event_id, eventName(event->event_id));
-
+void NetworkEvents::_evt_picker(int32_t id, arduino_event_info_t *info){
 #if defined NETWORK_EVENTS_MUTEX && SOC_CPU_CORES_NUM > 1
-    std::unique_lock<std::mutex> lock(_mtx);
+  std::lock_guard<std::mutex> lock(_mtx);
 #endif  // defined NETWORK_EVENTS_MUTEX &&  SOC_CPU_CORES_NUM > 1
 
-    // iterate over registered callbacks
-    for (auto &i : _cbEventList) {
-      if (i.cb || i.fcb || i.scb) {
-        if (i.event == (arduino_event_id_t)event->event_id || i.event == ARDUINO_EVENT_MAX) {
-          if (i.cb) {
-            i.cb((arduino_event_id_t)event->event_id);
-            continue;
-          }
-
-          if (i.fcb) {
-            i.fcb((arduino_event_id_t)event->event_id, (arduino_event_info_t)event->event_info);
-            continue;
-          }
-
-          i.scb(event);
-        }
+  // iterate over registered callbacks
+  for (auto &i : _cbEventList) {
+    if (i.event == static_cast<arduino_event_id_t>(id) || i.event == ARDUINO_EVENT_ANY) {
+      if (i.cb) {
+        i.cb(static_cast<arduino_event_id_t>(id));
+        continue;
       }
-    }
 
-#if defined NETWORK_EVENTS_MUTEX && SOC_CPU_CORES_NUM > 1
-    lock.unlock();
-#endif  // defined NETWORK_EVENTS_MUTEX &&  SOC_CPU_CORES_NUM > 1
+      if (i.fcb) {
+        i.fcb(static_cast<arduino_event_id_t>(id), *info);
+        continue;
+      }
 
-    // release the event object's memory
-    delete event;
+      if (i.scb && info){
+        // system event callback needs a ptr to struct
+        arduino_event_t event{static_cast<arduino_event_id_t>(id), {}};
+        memcpy(&event.event_info, info, sizeof(arduino_event_info_t));
+        i.scb(&event);
+      }
+    }
   }
-
-  vTaskDelete(NULL);
 }
 
 template<typename T, typename... U> static size_t getStdFunctionAddress(std::function<T(U...)> f) {
@@ -354,7 +294,6 @@ int NetworkEvents::waitStatusBits(int bits, uint32_t timeout_ms) {
  * @brief Convert arduino_event_id_t to a C string.
  * @param [in] id The event id to be converted.
  * @return A string representation of the event id.
- * @note: arduino_event_id_t values as of Mar 2023 (arduino-esp32 r2.0.7) are: 0-39 (ARDUINO_EVENT_MAX=40) and are defined in WiFiGeneric.h.
  */
 const char *NetworkEvents::eventName(arduino_event_id_t id) {
   switch (id) {

Diff for: libraries/Network/src/NetworkEvents.h

@@ -15,9 +15,6 @@
 #endif
 #include <functional>
 #include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "freertos/queue.h"
-#include "freertos/semphr.h"
 #include "freertos/event_groups.h"
 #if defined NETWORK_EVENTS_MUTEX && SOC_CPU_CORES_NUM > 1
 #include <mutex>
@@ -39,8 +36,11 @@ constexpr int WIFI_SCAN_DONE_BIT = BIT1;
 #define NET_HAS_IP6_GLOBAL_BIT 0
 
 ESP_EVENT_DECLARE_BASE(ARDUINO_EVENTS);
+// backward compatibility
+#define ARDUINO_EVENT_MAX ARDUINO_EVENT_ANY
 
 typedef enum {
+  ARDUINO_EVENT_ANY = ESP_EVENT_ANY_ID, // make all ARDUINO events compatibile with ANY ESP_EVENT
   ARDUINO_EVENT_NONE = 0,
   ARDUINO_EVENT_ETH_START,
   ARDUINO_EVENT_ETH_STOP,
@@ -93,9 +93,9 @@ typedef enum {
   ARDUINO_EVENT_PPP_GOT_IP,
   ARDUINO_EVENT_PPP_LOST_IP,
   ARDUINO_EVENT_PPP_GOT_IP6,
-  ARDUINO_EVENT_MAX
 } arduino_event_id_t;
 
+
 typedef union {
   ip_event_ap_staipassigned_t wifi_ap_staipassigned;
   ip_event_got_ip_t got_ip;
@@ -148,7 +148,7 @@ using network_event_handle_t = size_t;
  */
 class NetworkEvents {
 public:
-  NetworkEvents();
+  NetworkEvents(){};
   ~NetworkEvents();
 
   /**
@@ -159,7 +159,7 @@ class NetworkEvents {
    * @param event event to process, any event by default
    * @return network_event_handle_t
    */
-  network_event_handle_t onEvent(NetworkEventCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX);
+  network_event_handle_t onEvent(NetworkEventCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_ANY);
 
   /**
    * @brief register functional callback to be executed on arduino event(s)
@@ -170,7 +170,7 @@ class NetworkEvents {
    * @param event event to process, any event by default
    * @return network_event_handle_t
    */
-  network_event_handle_t onEvent(NetworkEventFuncCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX);
+  network_event_handle_t onEvent(NetworkEventFuncCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_ANY);
 
   /**
    * @brief register static system callback to be executed on arduino event(s)
@@ -182,7 +182,7 @@ class NetworkEvents {
    * @param event event to process, any event by default
    * @return network_event_handle_t
    */
-  network_event_handle_t onEvent(NetworkEventSysCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX);
+  network_event_handle_t onEvent(NetworkEventSysCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_ANY);
 
   /**
    * @brief unregister static function callback
@@ -191,7 +191,7 @@ class NetworkEvents {
    * @param cbEvent static callback function
    * @param event event to process, any event by default
    */
-  void removeEvent(NetworkEventCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX);
+  void removeEvent(NetworkEventCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_ANY);
 
   /**
    * @brief unregister functional callback
@@ -201,7 +201,7 @@ class NetworkEvents {
    * @param cbEvent functional callback
    * @param event event to process, any event by default
    */
-  void removeEvent(NetworkEventFuncCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX)
+  void removeEvent(NetworkEventFuncCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_ANY)
     __attribute__((deprecated("removing functional callbacks via pointer is deprecated, use removeEvent(network_event_handle_t) instead")));
 
   /**
@@ -211,21 +211,19 @@ class NetworkEvents {
    * @param cbEvent static callback function
    * @param event event to process, any event by default
    */
-  void removeEvent(NetworkEventSysCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX);
+  void removeEvent(NetworkEventSysCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_ANY);
 
   /**
    * @brief unregister event callback via handler
    *
-   * @param cbEvent static callback function
-   * @param event event to process, any event by default
+   * @param event_handle a handler to remove
    */
   void removeEvent(network_event_handle_t event_handle);
 
   /**
    * @brief get a human-readable name of an event by it's id
    *
    * @param id event id code
-   * @return const char* event name string
    */
   static const char *eventName(arduino_event_id_t id);
 
@@ -238,7 +236,7 @@ class NetworkEvents {
    * @return true if event was queued susccessfuly
    * @return false on memrory allocation error or queue is full
    */
-  bool postEvent(const arduino_event_t *event);
+  bool postEvent(const arduino_event_t *event, TickType_t timeout = portMAX_DELAY);
 
   int getStatusBits() const;
   int waitStatusBits(int bits, uint32_t timeout_ms);
@@ -257,11 +255,11 @@ class NetworkEvents {
 protected:
   bool initNetworkEvents();
   // same as onEvent() but places newly added handler at the beginning of registered events list
-  network_event_handle_t onSysEvent(NetworkEventCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX);
+  network_event_handle_t onSysEvent(NetworkEventCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_ANY);
   // same as onEvent() but places newly added handler at the beginning of registered events list
-  network_event_handle_t onSysEvent(NetworkEventFuncCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX);
+  network_event_handle_t onSysEvent(NetworkEventFuncCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_ANY);
   // same as onEvent() but places newly added handler at the beginning of registered events list
-  network_event_handle_t onSysEvent(NetworkEventSysCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_MAX);
+  network_event_handle_t onSysEvent(NetworkEventSysCb cbEvent, arduino_event_id_t event = ARDUINO_EVENT_ANY);
 
 private:
   /**
@@ -280,17 +278,20 @@ class NetworkEvents {
 
     explicit NetworkEventCbList_t(
       network_event_handle_t id, NetworkEventCb cb = nullptr, NetworkEventFuncCb fcb = nullptr, NetworkEventSysCb scb = nullptr,
-      arduino_event_id_t event = ARDUINO_EVENT_MAX
+      arduino_event_id_t event = ARDUINO_EVENT_ANY
     )
       : id(id), cb(cb), fcb(fcb), scb(scb), event(event) {}
   };
 
   // define initial id's value
   network_event_handle_t _current_id{0};
+  // EventGroup i.c.
+  uint32_t _initial_bits{0};
+
+  // ESP event bus handler
+  esp_event_handler_instance_t _evt_handler{nullptr};
 
-  EventGroupHandle_t _arduino_event_group;
-  QueueHandle_t _arduino_event_queue;
-  TaskHandle_t _arduino_event_task_handle;
+  EventGroupHandle_t _arduino_event_group{nullptr};
 
   // registered events callbacks container
   std::vector<NetworkEventCbList_t> _cbEventList;
@@ -300,9 +301,6 @@ class NetworkEvents {
   std::mutex _mtx;
 #endif  // defined NETWORK_EVENTS_MUTEX &&  SOC_CPU_CORES_NUM > 1
 
-  /**
-   * @brief task function that picks events from an event queue and calls registered callbacks
-   *
-   */
-  void _checkForEvent();
+  // ESP event bus callback function, picks events from an event queue and calls registered callbacks
+  void _evt_picker(int32_t id, arduino_event_info_t *info);
 };

Diff for: libraries/WiFi/src/WiFiGeneric.cpp

@@ -56,8 +56,6 @@ extern "C" {
 #include <vector>
 #include "sdkconfig.h"
 
-ESP_EVENT_DEFINE_BASE(ARDUINO_EVENTS);
-
 static esp_netif_t *esp_netifs[ESP_IF_MAX] = {NULL, NULL, NULL};
 
 esp_netif_t *get_esp_interface_netif(esp_interface_t interface) {