JablotronDeviceManager.h

#pragma once

#include <list>
#include <set>

#include <Poco/Mutex.h>

#include "commands/DeviceAcceptCommand.h"
#include "commands/DeviceSetValueCommand.h"
#include "commands/DeviceUnpairCommand.h"
#include "commands/GatewayListenCommand.h"
#include "core/DeviceManager.h"
#include "hotplug/HotplugListener.h"
#include "jablotron/JablotronController.h"
#include "jablotron/JablotronGadget.h"
#include "jablotron/JablotronReport.h"
#include "model/ModuleType.h"
#include "model/RefreshTime.h"
#include "util/BackOff.h"

namespace BeeeOn {

class JablotronDeviceManager : public DeviceManager, public HotplugListener {
public:
        JablotronDeviceManager();

        void setUnpairErasesSlot(bool erase);

        void setTxBackOffFactory(BackOffFactory::Ptr factory);

        void setPGYEnrollGap(const Poco::Timespan &gap);

        void setEraseAllOnProbe(bool erase);

        void setRegisterOnProbe(const std::list<std::string> &addresses);

        void setMaxProbeAttempts(int count);

        void setProbeTimeout(const Poco::Timespan &timeout);

        void setIOJoinTimeout(const Poco::Timespan &timeout);

        void setIOReadTimeout(const Poco::Timespan &timeout);

        void setIOErrorSleep(const Poco::Timespan &delay);

        void onAdd(const HotplugEvent &e) override;
        void onRemove(const HotplugEvent &e) override;

        void run() override;
        void stop() override;

        void handleRemoteStatus(
                const DevicePrefix &prefix,
                const std::set<DeviceID> &devices,
                const DeviceStatusHandler::DeviceValues &values) override;

protected:
        void handleAccept(const DeviceAcceptCommand::Ptr cmd) override;

        AsyncWork<>::Ptr startDiscovery(const Poco::Timespan &timeout) override;

        AsyncWork<>::Ptr startSearch(
                        const Poco::Timespan &timeout,
                        const uint64_t serialNumber) override;

        AsyncWork<std::set<DeviceID>>::Ptr startUnpair(
                        const DeviceID &id,
                        const Poco::Timespan &timeout) override;

        AsyncWork<double>::Ptr startSetValue(
                        const DeviceID &id,
                        const ModuleID &module,
                        const double value,
                        const Poco::Timespan &timeout) override;

        std::string hotplugMatch(const HotplugEvent &e);

        void newDevice(
                const DeviceID &id,
                const std::string &name,
                const std::list<ModuleType> &types,
                const RefreshTime &refreshTime);

        void acceptGadget(const DeviceID &id);

        void enrollTX();

        void registerGadget(
                std::set<unsigned int> &freeSlots,
                const uint32_t address,
                const Poco::Timespan &timeout);

        void unregisterGadget(const DeviceID &id, const Poco::Timespan &timeout);

        void shipReport(const JablotronReport &report);

        std::vector<JablotronGadget> readGadgets(const Poco::Timespan &timeout);

        void scanSlots(
                std::set<uint32_t> &registered,
                std::set<unsigned int> &freeSlots,
                std::set<unsigned int> &unknownSlots);

        void initDongle();

        void syncSlots();

        static DeviceID buildID(uint32_t address);

        static uint32_t extractAddress(const DeviceID &id);

        static DeviceID pgxID();
        static DeviceID pgyID();
        static DeviceID sirenID();

        static void sleep(const Poco::Timespan &delay);

private:
        bool m_unpairErasesSlot;
        BackOffFactory::Ptr m_txBackOffFactory;
        Poco::Timespan m_pgyEnrollGap;
        bool m_eraseAllOnProbe;
        std::list<uint32_t> m_registerOnProbe;
        JablotronController m_controller;
        bool m_pgx;
        bool m_pgy;
        bool m_alarm;
        JablotronController::Beep m_beep;
        Poco::FastMutex m_lock;
};

}