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 "fl/stl/compiler_control.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_NO_EXCEPT;

    static ChannelManager& registry() FL_NO_EXCEPT;

    ChannelManager() FL_NO_EXCEPT;

    ~ChannelManager() FL_NO_EXCEPT override;

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

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

    void clearAllDrivers() FL_NO_EXCEPT;

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

    template<fl::Bus B, fl::u8 Which = 0>
    void setExclusiveDriver() FL_NO_EXCEPT;

    bool setExclusiveDriver(Bus bus, fl::u8 which = 0) FL_NO_EXCEPT;

    bool setExclusiveDriverByName(const char* name) FL_NO_EXCEPT;

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

    bool isDriverEnabled(const char* name) const FL_NO_EXCEPT;

    bool isDriverEnabled(const IChannelDriver& driver) const FL_NO_EXCEPT;

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

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

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

    fl::size getDriverCount() const FL_NO_EXCEPT;

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

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

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

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

    IChannelDriver::DriverState poll() FL_NO_EXCEPT;

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

    void onBeginFrame() FL_NO_EXCEPT override;

    void onEndFrame() FL_NO_EXCEPT override;

    void reset() FL_NO_EXCEPT;
 
private:
    enum class AddDriverSlowReason : u8 {
        NULL_DRIVER,
        EMPTY_NAME,
        DUPLICATE_NAME,
    };

    FL_NO_INLINE FL_COLD bool addDriverSlow(
        int priority,
        const fl::shared_ptr<IChannelDriver>& driver,
        const fl::string* engineName,
        AddDriverSlowReason reason) FL_NO_EXCEPT;

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

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

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

    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_NO_EXCEPT = delete;
    ChannelManager& operator=(const ChannelManager&) FL_NO_EXCEPT = delete;
    ChannelManager(ChannelManager&&) FL_NO_EXCEPT = delete;
    ChannelManager& operator=(ChannelManager&&) FL_NO_EXCEPT = delete;
};

ChannelManager& channelManager() FL_NO_EXCEPT;
 
// 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, fl::u8 Which>
inline void ChannelManager::setExclusiveDriver() FL_NO_EXCEPT {
    // 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;
    fl::detail::enable_clockless<fl::BusTraits<B, Which>>();  // #4793
    addDriver(kExclusivePriority, fl::BusTraits<B, Which>::instancePtr());
}
 
} // namespace fl