kallisto_core_impl.hpp

Go to the documentation of this file.

#ifndef KALLISTO_CORE_IMPL_HPP_
#define KALLISTO_CORE_IMPL_HPP_

#include <mutex>
#include <list>
#include <memory>

#include "core/kallisto_core.hpp"

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

#include "../bluetooth/adapter/bluetooth_adapter_manager.hpp"
#include "../bluetooth/scanner/bluetooth_scanner.hpp"
#include "../bluetooth/bluetooth_adapter_event_listener.hpp"
#include "../bluetooth/bluetooth_scan_event_listener.hpp"

#include "../hardware/kallisto_factory.hpp"
#include "../hardware/kallisto_impl.hpp"
#include "../hardware/kallisto_helper.hpp"
#include "../hardware/kallisto_event_listener.hpp"
#include "../hardware/hal/sensors/sensor_factory.hpp"
#include "../hardware/hal/sensors/sensor.hpp"
#include "../hardware/hal/sensors/sensor_event_listener.hpp"

namespace kallisto {
namespace core {

class KallistoCoreImpl : public KallistoCore, bluetooth::BluetoothAdapterManager::Listener, bluetooth::BluetoothAdapter::Listener,
        bluetooth::BluetoothAdapter::ScanListener, hardware::KallistoEventListener {

private:
    //Event dispatcher
    util::Executor m_event_dispatcher{"CoreEventDispatcher", 1};

    //Holds our Bluetooth adapter
    std::unique_ptr<bluetooth::BluetoothAdapterManager> m_adapter_manager = nullptr;
    bluetooth::BluetoothAdapter* m_adapter = nullptr;

    //Holds our Bluetooth scanner variables
    std::unique_ptr<bluetooth::BluetoothScanner> m_scanner = nullptr;
    bluetooth::BluetoothScannerConfiguration m_scanner_configuration;
    bluetooth::BluetoothScannerFilter m_scanner_filter;

    //Event listeners variables
    enum class AdapterEventType {
        ADAPTER_ENABLED, ADAPTER_DISABLED, ADAPTER_IRRECUPERABLE
    };
    enum class ScanEventType {
        DEVICE_FOUND, DEVICE_LOST, DEVICE_REPORT
    };
    enum class KallistoEventType {
        LINK_LOSS, LINK_RECOVERED, LINK_REMOVED
    };
    std::mutex m_listener_list_mutex;
    std::list<bluetooth::BluetoothAdapterEventListener*> m_adapter_listeners;
    std::list<bluetooth::BluetoothScanEventListener*> m_scan_listeners;

    //Link Loss flags
    enum class LinkLossScanStatus {
        SCANNING, STOPPING, STOPPED
    };
    std::atomic<LinkLossScanStatus> m_link_loss_scan_status {LinkLossScanStatus::STOPPED};

    //Device factories
    hardware::SensorFactory m_sensor_factory;
    hardware::KallistoFactory m_device_factory{m_sensor_factory};

    //Device list variables
    std::mutex m_device_list_mutex;
    std::list<std::unique_ptr<hardware::KallistoImpl> > m_device_list;
    std::list<std::unique_ptr<hardware::KallistoImpl> > m_device_to_remove_list;

    void start();

    void stop();

    void removeDevice(hardware::Kallisto& kallisto);

    void stopScanningForLinkLoss();

    void onLinkLossScanStop();

    void onNormalScanStop(std::vector<kallisto::bluetooth::BluetoothDevice*> devices_found);

    void onScanBuildDevice(bluetooth::BluetoothDevice& device, const bluetooth::BluetoothAdapter::ScanListener::ScanRecord record);

    void onScanRecoverDevice(bluetooth::BluetoothDevice& device);


public:
    KallistoCoreImpl(kallisto::bluetooth::BluetoothScannerConfiguration& scanner_configuration, kallisto::bluetooth::BluetoothScannerFilter& scanner_filter);

    ~KallistoCoreImpl();

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

    /*********************************************************************
     *  System Manager API
     ********************************************************************/
    error::KallistoDetailedResult registerBluetoothAdapterEventListener(bluetooth::BluetoothAdapterEventListener& listener);

    error::KallistoDetailedResult unregisterBluetoothAdapterEventListener(bluetooth::BluetoothAdapterEventListener& listener);

    error::KallistoDetailedResult setScannerConfiguration(bluetooth::BluetoothScannerConfiguration& configuration);

    const bluetooth::BluetoothScannerConfiguration* getScannerConfiguration();

    error::KallistoDetailedResult setScannerFilter(bluetooth::BluetoothScannerFilter& filter);

    const bluetooth::BluetoothScannerFilter* getScannerFilter();

    error::KallistoDetailedResult registerBluetoothScanEventListener(bluetooth::BluetoothScanEventListener& listener);

    error::KallistoDetailedResult unregisterBluetoothScanEventListener(bluetooth::BluetoothScanEventListener& listener);

    /*********************************************************************
     *  Kallisto Manager API
     ********************************************************************/
    std::vector<hardware::KallistoImpl*> getDevices();

    error::KallistoDetailedResult registerListener(hardware::KallistoEventListener& listener, hardware::Kallisto& kallisto);

    error::KallistoDetailedResult unregisterListener(hardware::KallistoEventListener& listener, hardware::Kallisto& kallisto);

    error::KallistoDetailedResult stayConnected(hardware::Kallisto& kallisto, bool enable);

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

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

    /*********************************************************************
     *  Bluetooth adapter callbacks
     ********************************************************************/
    void onAdapterConnected(bluetooth::BluetoothAdapter& adapter);
    void onAdapterDisconnected(bluetooth::BluetoothAdapter& adapter);

    void onAdapterEnabled(bluetooth::BluetoothAdapter& adapter);

    void onAdapterEnableFailed(bluetooth::BluetoothAdapter& adapter, bluetooth::BluetoothAdapter::Listener::Error error);

    void onAdapterDisabled(bluetooth::BluetoothAdapter& adapter);

    void sendAdapterEvent(AdapterEventType type);

    /*********************************************************************
     *  Bluetooth scanner callbacks
     ********************************************************************/
    void onScanStart();

    void onScanStartFailed();

    void onScanStop(std::vector<kallisto::bluetooth::BluetoothDevice*> devices_found);

    void onScan(bluetooth::BluetoothDevice& device, const bluetooth::BluetoothAdapter::ScanListener::ScanRecord record);

    void sendScanEvent(ScanEventType type, hardware::Kallisto& device, const bluetooth::BluetoothAdapter::ScanListener::ScanRecord record);

    /*********************************************************************
     *  Kallisto callbacks
     ********************************************************************/
    void onLinkLoss(std::chrono::nanoseconds timestamp, hardware::Kallisto& device);

    void onLinkRecovered(std::chrono::nanoseconds timestamp, hardware::Kallisto& device);

    void onLinkRemoved(std::chrono::nanoseconds /*timestamp*/, hardware::Kallisto& device);

    void sendKallistoEvent(KallistoEventType type);
};

} /* namespace core */
} /* namespace kallisto */

#endif /* KALLISTO_CORE_IMPL_HPP_ */