BLESmartDeviceManager.h

#pragma once

#include <map>
#include <vector>

#include <Poco/Mutex.h>
#include <Poco/Thread.h>
#include <Poco/Timespan.h>
#include <Poco/UUID.h>

#include "bluetooth/BLESmartDevice.h"
#include "bluetooth/HciInterface.h"
#include "commands/DeviceAcceptCommand.h"
#include "commands/DeviceSetValueCommand.h"
#include "core/AbstractSeeker.h"
#include "core/DongleDeviceManager.h"
#include "core/PollingKeeper.h"
#include "loop/StopControl.h"
#include "model/DeviceID.h"
#include "model/RefreshTime.h"
#include "net/MACAddress.h"
#include "util/AsyncWork.h"

namespace BeeeOn {

class BLESmartDeviceManager : public DongleDeviceManager {
public:
        static const Poco::UUID CHAR_MODEL_NUMBER;

        class BLESmartSeeker : public AbstractSeeker {
        public:
                typedef Poco::SharedPtr<BLESmartSeeker> Ptr;

                BLESmartSeeker(
                        BLESmartDeviceManager& parent,
                        const Poco::Timespan& duration);

        protected:
                void seekLoop(StopControl &control) override;

        private:
                BLESmartDeviceManager& m_parent;
        };

        BLESmartDeviceManager();

        void dongleAvailable() override;

        std::string dongleMatch(const HotplugEvent &e) override;

        void dongleFailed(const FailDetector &dongleStatus) override;

        bool dongleMissing() override;
        void stop() override;

        void setDevicePoller(DevicePoller::Ptr poller);
        void setScanTimeout(const Poco::Timespan &timeout);
        void setDeviceTimeout(const Poco::Timespan &timeout);
        void setRefresh(const Poco::Timespan &refresh);
        void setNumberOfExaminationThreads(const int numberOfExaminationThreads);
        void setHciManager(HciInterfaceManager::Ptr manager);

protected:
        void notifyDongleRemoved() override;
        void handleAccept(const DeviceAcceptCommand::Ptr cmd) override;
        AsyncWork<>::Ptr startDiscovery(const Poco::Timespan &timeout) 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;

        void eraseAllDevices();

        void processAsyncData(
                const MACAddress& address,
                std::vector<unsigned char> &data);

        void seekPairedDevices();

        void seekDevices(
                std::vector<BLESmartDevice::Ptr>& foundDevices,
                const StopControl& stop);

        void threadedExaminationOfDevices(
                const std::map<MACAddress, std::string>& devices,
                Poco::FastMutex& foundDevicesMutex,
                std::vector<BLESmartDevice::Ptr>& foundDevices,
                const StopControl& stop);

        void examineBatchOfDevices(
                const std::map<MACAddress, std::string>& devices,
                Poco::FastMutex& foundDevicesMutex,
                std::vector<BLESmartDevice::Ptr>& foundDevices,
                const StopControl& stop);

        BLESmartDevice::Ptr createDevice(const MACAddress& address) const;

        void processNewDevice(BLESmartDevice::Ptr newDevice);

private:
        Poco::FastMutex m_devicesMutex;
        std::map<DeviceID, BLESmartDevice::Ptr> m_devices;
        Poco::SharedPtr<HciInterface::WatchCallback> m_watchCallback;

        PollingKeeper m_pollingKeeper;
        Poco::Timespan m_scanTimeout;
        Poco::Timespan m_deviceTimeout;
        RefreshTime m_refresh;
        uint32_t m_numberOfExaminationThreads;
        HciInterfaceManager::Ptr m_hciManager;
        HciInterface::Ptr m_hci;
};

}