Events for modular UI and other listeners

lib/scan/scan.cpp

@@ -66,8 +66,8 @@ uint16_t Scan::rssiMethod(size_t samples, uint16_t *result, size_t res_size)
     return max_signal;
 }
 
-size_t Scan::detect(uint16_t *result, bool *filtered_result, size_t result_size,
-                    int samples)
+Event Scan::detect(uint16_t *result, bool *filtered_result, size_t result_size,
+                   int samples)
 {
     size_t max_rssi_x = result_size;
 
@@ -122,7 +122,46 @@ size_t Scan::detect(uint16_t *result, bool *filtered_result, size_t result_size,
         }
     }
 
-    return max_rssi_x;
+    Event event(*this, EventType::DETECTED, 0);
+    event.epoch = epoch;
+    event.detected.detected = max_rssi_x < result_size;
+    event.detected.freq = current_frequency;
+    event.detected.rssi =
+        event.detected.detected ? -(float)result[max_rssi_x] : LO_RSSI_THRESHOLD;
+    event.detected.detected_at = max_rssi_x;
+    event.detected.trigger =
+        event.detected.detected && event.detected.rssi >= trigger_level;
+    detection_count++;
+
+    return event;
+}
+
+size_t Scan::addEventListener(EventType t, Listener &l)
+{
+    size_t c = listener_count[(size_t)t];
+    Listener **new_list = new Listener *[c + 1];
+    new_list[c] = &l;
+    listener_count[(size_t)t] = c + 1;
+
+    if (c > 0)
+    {
+        Listener **old_list = eventListeners[(size_t)t];
+        memcpy(new_list, old_list, c * sizeof(Listener *));
+        delete[] old_list;
+    }
+
+    eventListeners[(size_t)t] = new_list;
+    return c;
+}
+
+void Scan::fireEvent(Event &event)
+{
+    Listener **list = eventListeners[(size_t)event.type];
+    size_t c = listener_count[(size_t)event.type];
+    for (int i = 0; i < c; i++)
+    {
+        list[i]->onEvent(event);
+    }
 }
 
 #endif

lib/scan/scan.h

@@ -1,4 +1,5 @@
 #include <cstdint>
+#include <events.h>
 #include <stdlib.h>
 
 #ifndef LORASA_CORE_H
@@ -41,11 +42,18 @@ struct Scan
     bool sound_on;
     bool led_flag;
     uint64_t detection_count;
+    bool animated;
+    float trigger_level;
+
+    Listener **eventListeners[(size_t)EventType::_MAX_EVENT_TYPE];
+    size_t listener_count[(size_t)EventType::_MAX_EVENT_TYPE];
 
     Scan()
         : epoch(0), current_frequency(0), fr_begin(0), fr_end(0),
-          drone_detection_level(0), sound_on(false), led_flag(false),
-          detection_count(0) {};
+          drone_detection_level(0), sound_on(false), led_flag(false), detection_count(0),
+          animated(false), trigger_level(0), listener_count{
+                                                 0,
+                                             } {};
 
     virtual float getRSSI() = 0;
 
@@ -57,8 +65,11 @@ struct Scan
     // those values that represent a detection event.
     // It returns index that represents strongest signal at which a detection event
     // occurred.
-    static size_t detect(uint16_t *result, bool *filtered_result, size_t result_size,
-                         int samples);
+    Event detect(uint16_t *result, bool *filtered_result, size_t result_size,
+                 int samples);
+
+    size_t addEventListener(EventType t, Listener &l);
+    void fireEvent(Event &e);
 };
 
 // Remove reading without neighbors