ScannedPeripheral.h

Go to the documentation of this file.

 
#pragma once
 
namespace Systemic::BluetoothLE
{
    class Scanner;
 
    class ManufacturerData
    {
        uint16_t _companyId{};
        std::vector<uint8_t> _data{};
 
    public:
        uint16_t companyId() const { return _companyId; }
 
        const std::vector<uint8_t>& data() const { return _data; }
 
    private:
        friend Scanner;
 
        // Initializes a new instance of ManufacturerData with the company id and a WinRT data buffer
        ManufacturerData(uint16_t companyId, winrt::Windows::Storage::Streams::IBuffer data)
            : _companyId{ companyId }, _data{ Internal::dataBufferToBytesVector(data) } {}
    };
 
    class ServiceData
    {
        uint16_t _shortUuid{};
        std::vector<uint8_t> _data{};
 
    public:
        uint16_t shortUuid() const { return _shortUuid; }
 
        const std::vector<uint8_t>& data() const { return _data; }
 
    private:
        friend Scanner;
 
        // Initializes a new instance of ServiceData with a WinRT data buffer first containing the service short UUID
        ServiceData(winrt::Windows::Storage::Streams::IBuffer data)
            : _shortUuid(0), _data{ Internal::dataBufferToBytesVector(data) }
        {
            if (_data.size() >= 2)
            {
                _shortUuid = _data[0] | ((uint16_t)_data[1] << 8);
                _data.erase(_data.begin(), _data.begin() + 2);
            }
        }
    };
 
    class AdvertisementData
    {
        uint8_t _dataType{};
        std::vector<uint8_t> _data{};
 
    public:
        uint8_t dataType() const { return _dataType; }
 
        const std::vector<uint8_t>& data() const { return _data; }
 
    private:
        friend Scanner;
 
        // Initializes a new instance of AdvertisementData with the advertisement data type and a WinRT data buffer
        AdvertisementData(uint8_t dataType, winrt::Windows::Storage::Streams::IBuffer data)
            : _dataType{ dataType }, _data{ Internal::dataBufferToBytesVector(data) } {}
    };
 
    class ScannedPeripheral
    {
        using DateTime = winrt::Windows::Foundation::DateTime;
 
        DateTime _timestamp{};
        bluetooth_address_t _address{};
        std::wstring _name{};
        bool _isConnectable{};
        int _rssi{};
        int _txPowerLevel{};
        std::vector<winrt::guid> _services{};
        std::vector<ManufacturerData> _manufacturersData{};
        std::vector<ServiceData> _servicesData{};
        std::vector<AdvertisementData> _advertisingData{};
 
    public:
        const DateTime& timestamp() const { return _timestamp; }
 
        bluetooth_address_t address() const{ return _address; }
 
        const std::wstring& name() const { return _name; }
 
        bool isConnectable() const { return _isConnectable; }
 
        int rssi() const { return _rssi; }
 
        int txPowerLevel() const { return _txPowerLevel; }
 
        const std::vector<winrt::guid>& services() const { return _services; }
 
        const std::vector<ManufacturerData>& manufacturersData() const { return _manufacturersData; }
 
        const std::vector<ServiceData>& servicesData() const { return _servicesData; }
 
        const std::vector<AdvertisementData>& advertisingData() const { return _advertisingData; }
 
    private:
        friend Scanner;
 
        ScannedPeripheral(
            const DateTime& timestamp,
            bluetooth_address_t address,
            const std::wstring& name,
            bool isConnectable,
            int rssi,
            int txPowerLevel,
            const std::vector<winrt::guid>& services,
            const std::vector<ManufacturerData>& manufacturersData,
            const std::vector<ServiceData>& servicesData,
            const std::vector<AdvertisementData>& advertisingData)
            :
            _timestamp{ timestamp },
            _address{ address },
            _name{ name },
            _isConnectable{ isConnectable },
            _rssi{ rssi },
            _txPowerLevel{ txPowerLevel },
            _services{ services },
            _manufacturersData{ manufacturersData },
            _servicesData{ servicesData },
            _advertisingData{ advertisingData } {}
 
        ScannedPeripheral(
            const DateTime& timestamp,
            const ScannedPeripheral& peripheral,
            std::wstring& name,
            int rssi,
            int txPowerLevel,
            const std::vector<winrt::guid>& services,
            const std::vector<ManufacturerData>& manufacturersData,
            const std::vector<ServiceData>& servicesData,
            const std::vector<AdvertisementData>& advertisingData)
            :
            _timestamp{ timestamp },
            _address{ peripheral.address() },
            _name{ name.empty() ? peripheral._name : name },
            _isConnectable{ peripheral.isConnectable() },
            _rssi{ rssi },
            _txPowerLevel{ txPowerLevel },
            _services{ concat(peripheral._services, services) },
            _manufacturersData{ concat(peripheral._manufacturersData, manufacturersData) },
            _servicesData{ concat(peripheral._servicesData, servicesData) },
            _advertisingData{ concat(peripheral._advertisingData, advertisingData) } {}
 
        template <typename T>
        std::vector<T> concat(const std::vector<T> a, const std::vector<T>& b)
        {
            std::vector<T> out{ a };
            out.insert(out.end(), b.begin(), b.end());
            return out;
        }
    };
}