manager.h

Go to the documentation of this file.

 
#pragma once
 
#include "fl/channels/driver.h"
#include "fl/channels/data.h"
#include "fl/channels/bus.h"
#include "fl/channels/bus_traits.h"
#include "fl/system/engine_events.h"
#include "fl/stl/vector.h"
#include "fl/stl/shared_ptr.h"
#include "fl/stl/noexcept.h"
#include "platforms/channel_poll_signal.h"
 
namespace fl {

struct DriverInfo {
    fl::string name;  
    int priority;     
    bool enabled;     
};

class ChannelManager : public EngineEvents::Listener {
public:
    static ChannelManager& instance() FL_NOEXCEPT;

    ChannelManager() FL_NOEXCEPT;

    ~ChannelManager() FL_NOEXCEPT override;

    void addDriver(int priority, fl::shared_ptr<IChannelDriver> driver) FL_NOEXCEPT;

    bool removeDriver(fl::shared_ptr<IChannelDriver> driver) FL_NOEXCEPT;

    void clearAllDrivers() FL_NOEXCEPT;

    void setDriverEnabled(const char* name, bool enabled) FL_NOEXCEPT;

    template<fl::Bus B>
    void setExclusiveDriver() FL_NOEXCEPT;

    bool setExclusiveDriver(Bus bus) FL_NOEXCEPT;

    bool setExclusiveDriverByName(const char* name) FL_NOEXCEPT;

    bool setDriverPriority(const fl::string& name, int priority) FL_NOEXCEPT;

    bool isDriverEnabled(const char* name) const FL_NOEXCEPT;

    enum class DriverStatus {
        NOT_REGISTERED,    
        STATUS_DISABLED,   
        STATUS_ENABLED,    
    };

    DriverStatus driverStatus(const fl::string& name) const FL_NOEXCEPT;

    const fl::string& exclusiveDriverName() const FL_NOEXCEPT { return mExclusiveDriver; }

    fl::size getDriverCount() const FL_NOEXCEPT;

    fl::span<const DriverInfo> getDriverInfos() const FL_NOEXCEPT;

    fl::shared_ptr<IChannelDriver> getDriverByName(const fl::string& name) const FL_NOEXCEPT;

    fl::shared_ptr<IChannelDriver> findDriverByName(const fl::string& name) const FL_NOEXCEPT;

    fl::shared_ptr<IChannelDriver> selectDriverForChannel(const ChannelDataPtr& data, const fl::string& affinity) FL_NOEXCEPT;

    IChannelDriver::DriverState poll() FL_NOEXCEPT;

    bool waitForReady(u32 timeoutMs = 1000) FL_NOEXCEPT;
    bool waitForReadyOrDraining(u32 timeoutMs = 1000) FL_NOEXCEPT;

    void onBeginFrame() FL_NOEXCEPT override;

    void onEndFrame() FL_NOEXCEPT override;

    void reset() FL_NOEXCEPT;
 
private:
    template<typename Condition>
    bool waitForCondition(Condition condition, u32 timeoutMs = 1000) FL_NOEXCEPT;
 
    void notifyPollNeeded() FL_NOEXCEPT;
    bool waitForPollNeededSignal(u32 timeoutMs) FL_NOEXCEPT;
    u32 pollNeededWaitSliceMs(u32 startTime, u32 timeoutMs) const FL_NOEXCEPT;
    static void notifyPollNeededThunk(void* context) FL_NOEXCEPT;
 
private:
    struct EngineEntry {
        int priority;
        fl::shared_ptr<IChannelDriver> driver;
        fl::string name;  
        bool enabled;     

        bool operator<(const EngineEntry& other) const FL_NOEXCEPT {
            return priority > other.priority;  // Sort descending: higher values first
        }
    };

    IChannelDriver* selectDriver(const ChannelDataPtr& data = nullptr) FL_NOEXCEPT;

    fl::vector<EngineEntry> mDrivers;

    mutable fl::vector<DriverInfo> mCachedDriverInfo;

    fl::string mExclusiveDriver;

    IChannelDriver::PollNeededCallback mPollNeededCallback;

    platforms::ChannelPollSignal mPollNeededSignal;
 
    // Non-copyable, non-movable
    ChannelManager(const ChannelManager&) FL_NOEXCEPT = delete;
    ChannelManager& operator=(const ChannelManager&) FL_NOEXCEPT = delete;
    ChannelManager(ChannelManager&&) FL_NOEXCEPT = delete;
    ChannelManager& operator=(ChannelManager&&) FL_NOEXCEPT = delete;
};

ChannelManager& channelManager() FL_NOEXCEPT;
 
// Inline template definition for ChannelManager::setExclusiveDriver<B>().
// Defined here so the ODR-use of `BusTraits<B>::instancePtr()` happens in the
// caller's TU, which links the driver translation unit. The caller must have
// the per-driver `bus_traits.h` (which provides `BusTraits<B>::instancePtr`)
// visible at the call site.
template<fl::Bus B>
inline void ChannelManager::setExclusiveDriver() FL_NOEXCEPT {
    // Priority above any platform default — see `bus_priorities.h` for the
    // default-priority constants (highest there is ~10 for native LCD/I2S SPI).
    constexpr int kExclusivePriority = 10000;
    addDriver(kExclusivePriority, fl::BusTraits<B>::instancePtr());
}
 
} // namespace fl