DBusHciInterface.h

#pragma once

#include <glib.h>
#include <gio/gio.h>

#include <functional>
#include <map>
#include <string>
#include <vector>

#include <Poco/Condition.h>
#include <Poco/Mutex.h>
#include <Poco/RunnableAdapter.h>
#include <Poco/SharedPtr.h>
#include <Poco/Thread.h>
#include <Poco/Timespan.h>
#include <Poco/Timestamp.h>

#include "bluetooth/HciInfo.h"
#include "bluetooth/HciInterface.h"
#include "bluetooth/GlibPtr.h"
#include "bluetooth/org-bluez-adapter1.h"
#include "bluetooth/org-bluez-device1.h"
#include "bluetooth/org-bluez-gattcharacteristic1.h"
#include "net/MACAddress.h"
#include "util/Loggable.h"
#include "util/WaitCondition.h"

namespace BeeeOn {

class DBusHciInterface : public HciInterface, Loggable {
public:
        class Device;
        friend class DBusHciConnection;

        typedef Poco::SharedPtr<DBusHciInterface> Ptr;
        typedef std::function<bool(const std::string& path)> PathFilter;
        typedef std::pair<Poco::FastMutex, std::map<MACAddress, Device>> ThreadSafeDevices;

        class Device {
        public:
                Device(
                        const GlibPtr<OrgBluezDevice1> device,
                        const uint64_t rssiHandle);

                GlibPtr<OrgBluezDevice1> device() const
                {
                        return m_device;
                }

                uint64_t rssiHandle() const
                {
                        return m_rssiHandle;
                }

                void updateLastSeen()
                {
                        m_lastSeen = Poco::Timestamp();
                }

                Poco::Timestamp lastSeen() const
                {
                        return m_lastSeen;
                }

                uint64_t watchHandle() const
                {
                        return m_watchHandle;
                }

                void watch(
                        uint64_t watchHandle,
                        Poco::SharedPtr<WatchCallback> callBack)
                {
                        m_watchHandle = watchHandle;
                        m_callBack = callBack;
                }

                void unwatch()
                {
                        m_watchHandle = 0;
                        m_callBack = nullptr;
                }

                bool isWatched() const
                {
                        return !m_callBack.isNull();
                }

                std::string name();
                MACAddress macAddress();
                int16_t rssi();

        private:
                GlibPtr<OrgBluezDevice1> m_device;
                Poco::Timestamp m_lastSeen;
                uint64_t m_rssiHandle;
                uint64_t m_watchHandle;
                Poco::SharedPtr<WatchCallback> m_callBack;
        };


        DBusHciInterface(
                const std::string& name,
                const Poco::Timespan& leMaxAgeRssi,
                const Poco::Timespan& leMaxUnavailabilityTime,
                const Poco::Timespan& classicArtificialAvaibilityTimeout);
        ~DBusHciInterface();

        void down() const;

        void up() const override;
        void reset() const override;

        bool detect(const MACAddress &address) const override;

        std::map<MACAddress, std::string> scan() const override;

        std::map<MACAddress, std::string> lescan(
                const Poco::Timespan &timeout) const override;

        HciInfo info() const override;

        HciConnection::Ptr connect(
                const MACAddress& address,
                const Poco::Timespan& timeout) const override;

        void watch(
                const MACAddress& address,
                Poco::SharedPtr<WatchCallback> callBack) override;
        void unwatch(const MACAddress& address) override;

protected:
        static gboolean onStopLoop(gpointer loop);

        static void onDBusObjectAdded(
                GDBusObjectManager* objectManager,
                GDBusObject* object,
                gpointer userData);

        static gboolean onDeviceRSSIChanged(
                OrgBluezDevice1* device,
                GVariant* properties,
                const gchar* const* invalidatedProperties,
                gpointer userData);

        static gboolean onDeviceManufacturerDataRecieved(
                OrgBluezDevice1* device,
                GVariant* properties,
                const gchar* const* invalidatedProperties,
                gpointer userData);

        static void processManufacturerData(
                OrgBluezDevice1* device,
                GVariant* value,
                gpointer userData);

private:
        void waitUntilPoweredChange(GlibPtr<OrgBluezAdapter1> adapter, const bool powered) const;

        void startDiscovery(
                GlibPtr<OrgBluezAdapter1> adapter,
                const std::string& trasport) const;

        void stopDiscovery(GlibPtr<OrgBluezAdapter1> adapter) const;

        void initDiscoveryFilter(
                GlibPtr<OrgBluezAdapter1> adapter,
                const std::string& trasport) const;

        std::vector<GlibPtr<OrgBluezDevice1>> processKnownDevices(
                GlibPtr<GDBusObjectManager> objectManager) const;

        void removeUnvailableDevices() const;

        void runLoop();

        static std::vector<std::string> retrievePathsOfBluezObjects(
                GlibPtr<GDBusObjectManager> objectManager,
                PathFilter pathFilter,
                const std::string& objectFilter);

        static const std::string createAdapterPath(const std::string& name);

        static const std::string createDevicePath(
                const std::string& name,
                const MACAddress& address);

        static GlibPtr<GDBusObjectManager> createBluezObjectManager();

        static GlibPtr<OrgBluezAdapter1> retrieveBluezAdapter(const std::string& path);

        static GlibPtr<OrgBluezDevice1> retrieveBluezDevice(const std::string& path);

private:
        std::string m_name;
        mutable WaitCondition m_resetCondition;

        GlibPtr<GMainLoop> m_loop;
        Poco::RunnableAdapter<DBusHciInterface> m_loopThread;
        Poco::Thread m_thread;
        GlibPtr<GDBusObjectManager> m_objectManager;
        uint64_t m_objectManagerHandle;
        mutable ThreadSafeDevices m_devices;
        mutable GlibPtr<OrgBluezAdapter1> m_adapter;
        Poco::Timespan m_leMaxAgeRssi;
        Poco::Timespan m_leMaxUnavailabilityTime;

        mutable std::map<MACAddress, Poco::Timestamp> m_seenClassicDevices;
        Poco::Timespan m_classicArtificialAvaibilityTimeout;
        mutable Poco::FastMutex m_classicMutex;

        mutable Poco::Condition m_condition;
        mutable Poco::FastMutex m_statusMutex;
        mutable Poco::FastMutex m_discoveringMutex;
};

class DBusHciInterfaceManager : public HciInterfaceManager {
public:
        DBusHciInterfaceManager();

        void setLeMaxAgeRssi(const Poco::Timespan& time);
        void setLeMaxUnavailabilityTime(const Poco::Timespan& time);

        void setClassicArtificialAvaibilityTimeout(const Poco::Timespan& time);

        HciInterface::Ptr lookup(const std::string &name) override;

private:
        Poco::FastMutex m_mutex;
        std::map<std::string, DBusHciInterface::Ptr> m_interfaces;
        Poco::Timespan m_leMaxAgeRssi;
        Poco::Timespan m_leMaxUnavailabilityTime;
        Poco::Timespan m_classicArtificialAvaibilityTimeout;
};

}