kallisto_impl.hpp

Go to the documentation of this file.

#ifndef KALLISTO_IMPL_HPP
#define KALLISTO_IMPL_HPP

#include <string>
#include <vector>
#include <map>
#include <thread>
#include <mutex>
#include <atomic>

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

#include "kallisto.hpp"
#include "kallisto_event_listener.hpp"
#include "hal/synchronization/time_synchronizer.hpp"
#include "hal/synchronization/time_adjust_synchronizer.hpp"
#include "hal/sensors/sensor_impl.hpp"
#include "hal/sensors/sensor_factory.hpp"
#include "hal/sensors/sensor_event_listener.hpp"
#include "../bluetooth/adapter/bluetooth_adapter.hpp"
#include "../bluetooth/device/bluetooth_device.hpp"
#include "../bluetooth/device/bluetooth_dispatcher.hpp"

namespace kallisto {
namespace hardware {

class KallistoImpl : public Kallisto, public bluetooth::BluetoothDispatcher {
private:
    static const std::string DIS_SERVICE_UUID; //Device information service UUID
    static const std::string SW_VERSION_UUID; //Software Version Characteristic UUID
    static const std::string FW_VERSION_UUID; //Firmware Version Characteristic UUID
    static const std::string HW_VERSION_UUID; //Hardware Version Characteristic UUID
    static const std::string MANUFACTURER_UUID; //Manufacturer Characteristic UUID

    std::atomic_bool m_valid {false}; //Signals if this object is valid
    bluetooth::BluetoothDevice* m_bluetooth_device; //The native bluetooth device
    std::atomic_bool m_discovered {false}; //Signals if already got the metadata from the device
    std::atomic_bool m_stay_connected {false}; //Signals if we should keep a connection to the device

    //Link Loss variables
    std::atomic_bool m_link_loss {false}; //Signals if we are in link loss
    std::atomic_bool m_link_removed {false}; //Signals if we are in removal procedure
    std::thread m_link_loss_worker; //Link loss timeout thread
    std::mutex m_link_loss_worker_mutex; //Link loss mutex for the condition variable
    std::condition_variable m_link_loss_cv; //Link loss condition variable to wait for a timeout

    std::map<std::string, std::vector<uint8_t>> m_service_data;
    std::map<uint16_t, std::vector<uint8_t>> m_manufacturer_data;
    std::list<KallistoEventListener*> m_listeners; //Holds the event listeners.
    std::unique_ptr<TimeSynchronizer> m_synchronizer = nullptr;

    SensorFactory& m_sensor_factory; //The sensor builder
    std::vector<std::unique_ptr<SensorImpl> > m_sensors; //The sensor list
    util::Executor& m_event_dispatcher; //The event dispatcher
    std::mutex m_mutex; //Used to sync the object

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

    void closeInternal();

    error::KallistoDetailedResult connect();

    void onConnection();

    error::KallistoDetailedResult discover();

    error::KallistoDetailedResult disconnect();

    void onDisconnection();

    bool getConnected();

    bool getBeingUsedInternal();

public:
    KallistoImpl(kallisto::bluetooth::BluetoothDevice& bluetooth_device, const bluetooth::BluetoothAdapter::ScanListener::ScanRecord& record, bool legacy_discovery,
              util::Executor& event_dispatcher, SensorFactory& sensor_factory);

    virtual ~KallistoImpl();

    void close();

    /*************************************************************
     * Kallisto methods.
    *************************************************************/

    bool getBeingUsed();

    bool getLinkLoss();

    /*************************************************************
     * Public API
    *************************************************************/
    error::KallistoDetailedResult registerListener(KallistoEventListener& listener);

    error::KallistoDetailedResult unregisterListener(KallistoEventListener& listener);

    error::KallistoDetailedResult stayConnected(bool enable);

    std::vector<Sensor*> getSensors();

    Sensor* getSensor(unsigned int handle);

    error::KallistoDetailedResult registerSensorListener(Sensor& sensor, std::map<std::string, const void*> parameters, SensorEventListener& listener);

    error::KallistoDetailedResult unregisterSensorListener(Sensor& sensor, SensorEventListener& listener);

    error::KallistoDetailedResult onBluetoothDeviceRecovered(kallisto::bluetooth::BluetoothDevice& bluetooth_device);

    /*************************************************************
     * BluetoothDispatcher methods.
     * @see BluetoothDispatcher
    *************************************************************/
    error::KallistoDetailedResult getRssi(int& buffer);
    std::vector<std::string> getServices();
    std::vector<std::string> getCharacteristics(std::string service_uuid);
    error::KallistoDetailedResult readCharacteristic(std::string service_uuid, std::string characteristic_uuid, std::vector<unsigned char>& buffer);
    error::KallistoDetailedResult writeCharacteristic(std::string service_uuid, std::string characteristic_uuid, std::vector<unsigned char>& buffer);
    error::KallistoDetailedResult enableNotification(std::string service_uuid, std::string characteristic_uuid, BluetoothDispatcher::NotificationListener& listener);
    error::KallistoDetailedResult disableNotification(std::string service_uuid, std::string characteristic_uuid, BluetoothDispatcher::NotificationListener& listener);
};

} /* namespace hardware */
} /* namespace kallisto */

#endif // KALLISTO_IMPL_HPP