IOControl/include/IO/Controller.h

Go to the documentation of this file.

#pragma once

#include "Device.h"
#include <WVector.h>

namespace IO
{
using DeviceFactoryList = Vector<const Device::Factory*>;

enum class Direction {
    Incoming,
    Outgoing,
    Idle,
};

class Controller : public LinkedObjectTemplate<Controller>
{
    friend class Device;
    friend class DeviceManager;

public:
    using List = LinkedObjectListTemplate<Controller>;

    Controller(uint8_t instance) : instance(instance)
    {
    }

    virtual ~Controller()
    {
    }

    static void registerDeviceClass(const Device::Factory& factory)
    {
        deviceClasses.addElement(&factory);
        debug_i("Device class '%s' registered", String(factory.deviceClass()).c_str());
    }

    uint8_t getInstance() const
    {
        return instance;
    }

    Device::OwnedList& getDevices()
    {
        return devices;
    }

    void freeDevices();

    ErrorCode createDevice(const char* id, JsonObjectConst config, Device*& device);

    template <class DeviceClass>
    ErrorCode createDevice(const char* id, const typename DeviceClass::Config& config, DeviceClass*& device);

    Device* findDevice(const String& id);

    virtual const FlashString& classname() const = 0;

    virtual void start()
    {
        startDevices();
    }

    virtual void stop()
    {
        stopDevices();
    }

    virtual bool canStop() const
    {
        return queue.isEmpty();
    }

    const CString& getId() const
    {
        return id;
    }

    bool operator==(const String& id) const
    {
        return this->id == id;
    }

protected:
    virtual void handleEvent(Request* request, Event event);

    void submit(Request* request);

    void startTimer();
    void stopTimer();

private:
    ErrorCode constructDevice(const Device::Factory& factory, const char* id, Device*& device);

    void executeNext();

    void deviceError(Device& device);

    void startDevices();
    void stopDevices();

    const Device::Factory* findDeviceClass(const String& className);

    Device::OwnedList devices;
    Request::OwnedList queue;
    static DeviceFactoryList deviceClasses;
    std::unique_ptr<SimpleTimer> deviceCheckTimer;
    CString id;
    uint8_t instance;
};

template <class DeviceClass>
ErrorCode Controller::createDevice(const char* id, const typename DeviceClass::Config& config, DeviceClass*& device)
{
    auto& factory = DeviceClass::factory;
    Device* dev;
    auto err = constructDevice(factory, id, dev);
    if(err) {
        return err;
    }

    device = static_cast<DeviceClass*>(device);
    err = device->init(config);
    if(err) {
        delete device;
        device = nullptr;
        debug_err(err, String(factory.deviceClass()));
        return err;
    }

    devices.add(device);
    debug_d("Device %s created, class %s", device->caption().c_str(), String(factory.deviceClass()).c_str());

    return err;
}

} // namespace IO