bluetooth_adapter.hpp

Go to the documentation of this file.

#ifndef BLUETOOTH_ADAPTER_HPP_
#define BLUETOOTH_ADAPTER_HPP_

#include <map>
#include <vector>
#include <memory>
#include <chrono>

#include "../../util/error/kallisto_error.hpp"
#include "../device/bluetooth_device.hpp"

namespace kallisto {
namespace bluetooth {

class BluetoothAdapterNative; //Forward declaration of the native implementation

class BluetoothAdapter {
public:
    class Listener {
    protected:
        virtual ~Listener(){}

    public:
        enum class Error {
            USER_REJECTED,
            STACK_ERROR,
            ALREADY_ENABLED
        };

        virtual void onAdapterEnabled(BluetoothAdapter& adapter) = 0;

        virtual void onAdapterEnableFailed(BluetoothAdapter& adapter, BluetoothAdapter::Listener::Error error) = 0;

        virtual void onAdapterDisabled(BluetoothAdapter& adapter) = 0;
    };

    class ScanListener {
    protected:
        virtual ~ScanListener(){}

    public:
        class ScanRecord {
        public:
            const std::chrono::nanoseconds timestamp;

            const std::map<std::string, std::vector<uint8_t>> service_data;

            const std::map<uint16_t, std::vector<uint8_t>> manufacturer_data;

            const int rssi;

            ScanRecord() : timestamp(std::chrono::nanoseconds(0)), rssi(0) {}

            ScanRecord(std::chrono::nanoseconds _timestamp, std::map<std::string, std::vector<uint8_t>> _service_data, std::map<uint16_t, std::vector<uint8_t>> _manufacturer_data, int _rssi):
                timestamp(_timestamp), service_data(_service_data), manufacturer_data(_manufacturer_data), rssi(_rssi){}
        };

        virtual void onScanStart() = 0;

        virtual void onScanStartFailed() = 0;

        virtual void onScanStop(std::vector<BluetoothDevice*> devices_found) = 0;

        virtual void onScan(BluetoothDevice& device, const ScanRecord record) = 0;
    };

private:
    //Holds the native implementation
    std::unique_ptr<BluetoothAdapterNative> m_native_implementation;

    //Adapter ID
    std::string m_id;

public:
    BluetoothAdapter(std::string id);

    ~BluetoothAdapter();

    BluetoothAdapter(BluetoothAdapter const&) = delete;
    void operator=(BluetoothAdapter const&) = delete;

    BluetoothAdapter(BluetoothAdapter&& other);

    BluetoothAdapter& operator= (BluetoothAdapter&& other);

    std::string getId() const {
        return m_id;
    }

    error::KallistoDetailedResult enable();

    error::KallistoDetailedResult disable();

    bool isEnabled();

    const std::vector<BluetoothDevice*> getDevices();

    BluetoothDevice* getDevice(std::string address);

    error::KallistoDetailedResult registerListener(BluetoothAdapter::Listener& listener);

    void unregisterListener();

    bool isScanning();

    error::KallistoDetailedResult startScan(BluetoothAdapter::ScanListener& listener);

    error::KallistoDetailedResult stopScan();

    bool operator== (const BluetoothAdapter &other) const {
       return (this->getId() == other.getId());
    }

    bool operator!= (const BluetoothAdapter &other) const {
        return !(*this == other);
    }
};

} /* namespace bluetooth */
} /* namespace kallisto */

#endif /* BLUETOOTH_ADAPTER_HPP_ */