EventBus.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <cstddef>
 
namespace cdc::core {

enum class EventType : uint8_t {
    // Input events
    KEY_PRESSED,
    KEY_RELEASED,
    KEY_LONG_PRESS,
 
    // Power events
    POWER_USB_CONNECTED,
    POWER_USB_DISCONNECTED,
    POWER_CHARGING,
    POWER_BATTERY_LOW,
    POWER_BATTERY_CRITICAL,
 
    // System events
    SYSTEM_UNLOCK,
    SYSTEM_LOCK,
    SYSTEM_SLEEP,
    SYSTEM_WAKE,
    SYSTEM_SLEEP_INCOMING,
 
    // Bluetooth events
    BLE_CONNECTED,
    BLE_DISCONNECTED,
    BLE_PAIRING_REQUEST,
    BLE_CONSENT_REQUEST,
    BLE_EXCHANGE_COMPLETE,
 
    // Timer
    TIMER_TICK,
 
    // Custom module events (use data.value for sub-type)
    MODULE_EVENT,
 
    // Module error (data.ptr = module name, data.value = index)
    MODULE_ERROR,
 
    EVENT_COUNT
};

struct Event {
    EventType type;
    uint32_t timestamp;  // millis since boot
    union {
        char key;        // For KEY_* events
        uint8_t value;   // Generic value
        void* ptr;       // Pointer to extended data
    } data;
};

using EventHandler = void(*)(const Event&);

class EventBus {
public:
    static constexpr size_t MAX_HANDLERS = 16;
    static constexpr size_t DEFAULT_QUEUE_SIZE = 32;

    static EventBus& instance();

    bool init(size_t queueSize = DEFAULT_QUEUE_SIZE);

    uint8_t subscribe(EventHandler handler, uint32_t mask = 0);

    void unsubscribe(uint8_t id);

    bool publish(const Event& event, bool fromISR = false);

    bool publish(EventType type, uint8_t value = 0);

    void process();

    static constexpr uint32_t eventMask(EventType type) {
        return 1u << static_cast<uint8_t>(type);
    }
 
private:
    EventBus() = default;
    EventBus(const EventBus&) = delete;
    EventBus& operator=(const EventBus&) = delete;
 
    struct Subscription {
        EventHandler handler;
        uint32_t mask;
        bool active;
    };
 
    Subscription handlers_[MAX_HANDLERS] = {};
    void* queue_ = nullptr;  // FreeRTOS QueueHandle_t
    bool initialized_ = false;
};
 
} // namespace cdc::core