Peripheral.h

Go to the documentation of this file.

 
#pragma once
 
#include "BleTypes.h"
 
namespace Systemic::BluetoothLE
{
    class Service;
 
    enum class ConnectionEvent
    {
        Connecting,
 
        Connected,
 
        FailedToConnect,
 
        Ready,
 
        Disconnecting,
 
        Disconnected,
    };
 
    enum class ConnectionEventReason
    {
        Unknown = -1,
 
        Success = 0,
 
        Canceled,
 
        NotSupported,
 
        Timeout,
 
        LinkLoss,
 
        AdpaterOff,
 
        Peripheral,
    };
 
    class Peripheral : public std::enable_shared_from_this<Peripheral>
    {
        using BluetoothLEDevice = winrt::Windows::Devices::Bluetooth::BluetoothLEDevice;
        using GattSession = winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattSession;
 
        // The Bluetooth address
        const bluetooth_address_t _address{};
 
        // The user callback for connection events
        const std::function<void(ConnectionEvent, ConnectionEventReason)> _onConnectionEvent{};
 
        // Device and session
        BluetoothLEDevice _device{ nullptr };
        GattSession _session{ nullptr };
        winrt::event_token _connectionStatusChangedToken{};
 
        // Services
        std::unordered_map<winrt::guid, std::shared_ptr<Service>> _services{};
 
        // The ready state
        volatile bool _isReady{};
 
        // Connection
        mutable std::recursive_mutex _connectOpMtx{};   // Connection mutex
        volatile size_t _connectCounter{};              // Incremented every time connect or disconnect is called
        volatile bool _connecting{};                    // Whether we are trying to connect
 
        // Queue of connection events to notify to user
        std::vector<std::tuple<ConnectionEvent, ConnectionEventReason>> _connectionEventsQueue{};
 
        Peripheral(bluetooth_address_t bluetoothAddress, const std::function<void(ConnectionEvent, ConnectionEventReason)>& onConnectionEvent)
            : _address{ bluetoothAddress }, _onConnectionEvent{ onConnectionEvent }
        {
            assert(bluetoothAddress); // TODO check arguments
            assert(onConnectionEvent);
            _connectionEventsQueue.reserve(16);
        }
 
    public:
 
        static std::shared_ptr<Peripheral> create(
            bluetooth_address_t bluetoothAddress,
            const std::function<void(ConnectionEvent, ConnectionEventReason)>& onConnectionEvent)
        {
            return std::shared_ptr<Peripheral>{ new Peripheral(bluetoothAddress, onConnectionEvent) };
        }
 
        ~Peripheral()
        {
            disconnect();
        }
 
 
        std::future<BleRequestStatus> connectAsync(
            std::vector<winrt::guid> requiredServices = std::vector<winrt::guid>{},
            bool maintainConnection = false);
 
        void disconnect()
        {
            internalDisconnect(ConnectionEventReason::Success);
            notifyQueuedConnectionEvents(); // TODO not getting those events!
        }
 
 
        bluetooth_address_t address() const
        {
            return _address;
        }
 
        bool isConnected() const
        {
            using namespace winrt::Windows::Devices::Bluetooth;
 
            auto dev = safeGetDevice();
            return dev ? (dev.ConnectionStatus() == BluetoothConnectionStatus::Connected) : false;
        }
 
        bool isReady() const
        {
            return _isReady;
        }
 
 
        const winrt::hstring deviceId() const
        {
            auto dev = safeGetDevice();
            return dev ? dev.DeviceId() : winrt::hstring{};
        }
 
        const winrt::hstring name() const
        {
            auto dev = safeGetDevice();
            return dev ? dev.Name() : winrt::hstring{};
        }
 
        uint16_t mtu() const
        {
            // TODO is the lock needed?
            std::lock_guard lock{ _connectOpMtx };
            return _session ? _session.MaxPduSize() : 0;
        }
 
 
        std::shared_ptr<Service> getDiscoveredService(const winrt::guid& uuid) const
        {
            std::lock_guard lock{ _connectOpMtx };
            auto it = _services.find(uuid);
            return it != _services.end() ? it->second : nullptr;
        }
 
        void copyDiscoveredServices(std::vector<std::shared_ptr<Service>>& outServices) const
        {
            std::lock_guard lock{ _connectOpMtx };
            outServices.reserve(outServices.size() + _services.size());
            for (auto& [_, s] : _services)
            {
                outServices.emplace_back(s);
            }
        }
 
 
    private:
        // Get the device object in a thread safe manner
        BluetoothLEDevice safeGetDevice() const
        {
            // TODO is the lock needed?
            std::lock_guard lock{ _connectOpMtx };
            return _device;
        }
 
        // Take the lock and release device and session, be sure to call notifyQueuedConnectionEvents() afterwards
        void internalDisconnect(ConnectionEventReason reason, bool fromDevice = false);
 
        // Notify user code with pending connection event
        void notifyQueuedConnectionEvents()
        {
            // TODO optimize for case with 1 or 2 elements in queue
            decltype(_connectionEventsQueue) queue{};
            {
                std::lock_guard lock{ _connectOpMtx };
                queue = _connectionEventsQueue;
                _connectionEventsQueue.clear();
            }
            if (_onConnectionEvent)
            {
                for (auto& [ev, reason] : queue)
                {
                    _onConnectionEvent(ev, reason);
                }
            }
        }
 
        // Called by the device when the connection status changes
        void onDeviceConnectionStatusChanged(BluetoothLEDevice device, winrt::Windows::Foundation::IInspectable _)
        {
            using namespace winrt::Windows::Devices::Bluetooth;
 
            if (device.ConnectionStatus() == BluetoothConnectionStatus::Disconnected)
            {
                bool linkLoss = (_session != nullptr) && _session.MaintainConnection();
                internalDisconnect(linkLoss ? ConnectionEventReason::LinkLoss : ConnectionEventReason::Timeout, true);
                notifyQueuedConnectionEvents();
            }
            else
            {
                // Connected event is raised in connectAsync() after it has successfully retrieved the services
            }
        }
    };
}