@stoprocent/noble 1.9.2-16

package/lib/win/src/peripheral_winrt.cc

@@ -0,0 +1,296 @@
+#include "peripheral_winrt.h"
+#include "winrt_cpp.h"
+
+#include <winrt/Windows.Storage.Streams.h>
+using namespace winrt::Windows::Storage::Streams;
+
+using winrt::Windows::Devices::Bluetooth::BluetoothCacheMode;
+using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattCharacteristicsResult;
+using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattDescriptorsResult;
+using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattDeviceServicesResult;
+using winrt::Windows::Foundation::AsyncStatus;
+using winrt::Windows::Foundation::IAsyncOperation;
+
+PeripheralWinrt::PeripheralWinrt(uint64_t bluetoothAddress,
+                                 BluetoothLEAdvertisementType advertismentType, const int rssiValue,
+                                 const BluetoothLEAdvertisement& advertisment)
+{
+    this->bluetoothAddress = bluetoothAddress;
+    address = formatBluetoothAddress(bluetoothAddress);
+    // Random addresses have the two most-significant bits set of the 48-bit address.
+    addressType = (bluetoothAddress >= 211106232532992) ? RANDOM : PUBLIC;
+    Update(rssiValue, advertisment, advertismentType);
+}
+
+PeripheralWinrt::~PeripheralWinrt()
+{
+    if (device.has_value() && connectionToken)
+    {
+        device->ConnectionStatusChanged(connectionToken);
+    }
+}
+
+void PeripheralWinrt::Update(const int rssiValue, const BluetoothLEAdvertisement& advertisment,
+                             const BluetoothLEAdvertisementType& advertismentType)
+{
+    std::string localName = ws2s(advertisment.LocalName().c_str());
+    if (!localName.empty())
+    {
+        name = localName;
+    }
+
+    connectable = advertismentType == BluetoothLEAdvertisementType::ConnectableUndirected ||
+        advertismentType == BluetoothLEAdvertisementType::ConnectableDirected;
+
+    manufacturerData.clear();
+    for (auto ds : advertisment.DataSections())
+    {
+        if (ds.DataType() == BluetoothLEAdvertisementDataTypes::TxPowerLevel())
+        {
+            auto d = ds.Data();
+            auto dr = DataReader::FromBuffer(d);
+            txPowerLevel = dr.ReadByte();
+            if (txPowerLevel >= 128)
+                txPowerLevel -= 256;
+            dr.Close();
+        }
+        if (ds.DataType() == BluetoothLEAdvertisementDataTypes::ManufacturerSpecificData())
+        {
+            auto d = ds.Data();
+            auto dr = DataReader::FromBuffer(d);
+            manufacturerData.resize(d.Length());
+            dr.ReadBytes(manufacturerData);
+            dr.Close();
+        }
+    }
+
+    serviceUuids.clear();
+    for (auto uuid : advertisment.ServiceUuids())
+    {
+        serviceUuids.push_back(toStr(uuid));
+    }
+
+    rssi = rssiValue;
+}
+
+void PeripheralWinrt::Disconnect()
+{
+    cachedServices.clear();
+    if (device.has_value() && connectionToken)
+    {
+        device->ConnectionStatusChanged(connectionToken);
+    }
+    device = std::nullopt;
+}
+
+void PeripheralWinrt::GetServiceFromDevice(
+    winrt::guid serviceUuid, std::function<void(std::optional<GattDeviceService>)> callback)
+{
+    if (device.has_value())
+    {
+        device->GetGattServicesForUuidAsync(serviceUuid, BluetoothCacheMode::Cached)
+            .Completed([=](IAsyncOperation<GattDeviceServicesResult> result, auto& status) {
+                if (status == AsyncStatus::Completed)
+                {
+                    auto services = result.GetResults();
+                    auto service = services.Services().First();
+                    if (service.HasCurrent())
+                    {
+                        GattDeviceService s = service.Current();
+                        cachedServices.insert(std::make_pair(serviceUuid, CachedService(s)));
+                        callback(s);
+                    }
+                    else
+                    {
+                        printf("GetGattServicesForUuidAsync: no service with given id\n");
+                        callback(std::nullopt);
+                    }
+                }
+                else
+                {
+                    printf("GetGattServicesForUuidAsync: failed with status: %d\n", status);
+                    callback(std::nullopt);
+                }
+            });
+    }
+    else
+    {
+        printf("GetGattServicesForUuidAsync: no device currently connected\n");
+        callback(std::nullopt);
+    }
+}
+
+void PeripheralWinrt::GetService(winrt::guid serviceUuid,
+                                 std::function<void(std::optional<GattDeviceService>)> callback)
+{
+    auto it = cachedServices.find(serviceUuid);
+    if (it != cachedServices.end())
+    {
+        callback(it->second.service);
+    }
+    else
+    {
+        GetServiceFromDevice(serviceUuid, callback);
+    }
+}
+
+void PeripheralWinrt::GetCharacteristicFromService(
+    GattDeviceService service, winrt::guid characteristicUuid,
+    std::function<void(std::optional<GattCharacteristic>)> callback)
+{
+    service.GetCharacteristicsForUuidAsync(characteristicUuid, BluetoothCacheMode::Cached)
+        .Completed([=](IAsyncOperation<GattCharacteristicsResult> result, auto& status) {
+            if (status == AsyncStatus::Completed)
+            {
+                auto characteristics = result.GetResults();
+                auto characteristic = characteristics.Characteristics().First();
+                if (characteristic.HasCurrent())
+                {
+                    winrt::guid serviceUuid = service.Uuid();
+                    CachedService& cachedService = cachedServices[serviceUuid];
+                    GattCharacteristic c = characteristic.Current();
+                    cachedService.characterisitics.insert(
+                        std::make_pair(c.Uuid(), CachedCharacteristic(c)));
+                    callback(c);
+                }
+                else
+                {
+                    printf("GetCharacteristicsForUuidAsync: no characteristic with given id\n");
+                    callback(std::nullopt);
+                }
+            }
+            else
+            {
+                printf("GetCharacteristicsForUuidAsync: failed with status: %d\n", status);
+                callback(std::nullopt);
+            }
+        });
+}
+
+void PeripheralWinrt::GetCharacteristic(
+    winrt::guid serviceUuid, winrt::guid characteristicUuid,
+    std::function<void(std::optional<GattCharacteristic>)> callback)
+{
+    auto it = cachedServices.find(serviceUuid);
+    if (it != cachedServices.end())
+    {
+        auto& cachedService = it->second;
+        auto cit = cachedService.characterisitics.find(characteristicUuid);
+        if (cit != cachedService.characterisitics.end())
+        {
+            callback(cit->second.characteristic);
+        }
+        else
+        {
+            GetCharacteristicFromService(cachedService.service, characteristicUuid, callback);
+        }
+    }
+    else
+    {
+        GetServiceFromDevice(serviceUuid, [=](std::optional<GattDeviceService> service) {
+            if (service)
+            {
+                GetCharacteristicFromService(*service, characteristicUuid, callback);
+            }
+            else
+            {
+                printf("GetCharacteristic: get service failed\n");
+                callback(nullptr);
+            }
+        });
+    }
+}
+
+void PeripheralWinrt::GetDescriptorFromCharacteristic(
+    GattCharacteristic characteristic, winrt::guid descriptorUuid,
+    std::function<void(std::optional<GattDescriptor>)> callback)
+{
+    characteristic.GetDescriptorsForUuidAsync(descriptorUuid, BluetoothCacheMode::Cached)
+        .Completed([=](IAsyncOperation<GattDescriptorsResult> result, auto& status) {
+            if (status == AsyncStatus::Completed)
+            {
+                auto descriptors = result.GetResults();
+                auto descriptor = descriptors.Descriptors().First();
+                if (descriptor.HasCurrent())
+                {
+                    GattDescriptor d = descriptor.Current();
+                    winrt::guid characteristicUuid = characteristic.Uuid();
+                    winrt::guid descriptorUuid = d.Uuid();
+                    winrt::guid serviceUuid = characteristic.Service().Uuid();
+                    CachedService& cachedService = cachedServices[serviceUuid];
+                    CachedCharacteristic& c = cachedService.characterisitics[characteristicUuid];
+                    c.descriptors.insert(std::make_pair(descriptorUuid, d));
+                    callback(d);
+                }
+                else
+                {
+                    printf("GetDescriptorsForUuidAsync: no characteristic with given id\n");
+                    callback(std::nullopt);
+                }
+            }
+            else
+            {
+                printf("GetDescriptorsForUuidAsync: failed with status: %d\n", status);
+                callback(std::nullopt);
+            }
+        });
+}
+
+void PeripheralWinrt::GetDescriptor(winrt::guid serviceUuid, winrt::guid characteristicUuid,
+                                    winrt::guid descriptorUuid,
+                                    std::function<void(std::optional<GattDescriptor>)> callback)
+{
+    auto it = cachedServices.find(serviceUuid);
+    if (it != cachedServices.end())
+    {
+        auto& cachedService = it->second;
+        auto cit = cachedService.characterisitics.find(characteristicUuid);
+        if (cit != cachedService.characterisitics.end())
+        {
+            GetDescriptorFromCharacteristic(cit->second.characteristic, descriptorUuid, callback);
+        }
+        else
+        {
+            GetCharacteristicFromService(
+                cachedService.service, characteristicUuid,
+                [=](std::optional<GattCharacteristic> characteristic) {
+                    if (characteristic)
+                    {
+                        GetDescriptorFromCharacteristic(*characteristic, descriptorUuid, callback);
+                    }
+                    else
+                    {
+                        printf("GetDescriptor: get characteristic failed 1\n");
+                        callback(nullptr);
+                    }
+                });
+        }
+    }
+    else
+    {
+        GetServiceFromDevice(serviceUuid, [=](std::optional<GattDeviceService> service) {
+            if (service)
+            {
+                GetCharacteristicFromService(
+                    *service, characteristicUuid,
+                    [=](std::optional<GattCharacteristic> characteristic) {
+                        if (characteristic)
+                        {
+                            GetDescriptorFromCharacteristic(*characteristic, descriptorUuid,
+                                                            callback);
+                        }
+                        else
+                        {
+                            printf("GetDescriptor: get characteristic failed 2\n");
+                            callback(nullptr);
+                        }
+                    });
+            }
+            else
+            {
+                printf("GetDescriptor: get service failed\n");
+                callback(nullptr);
+            }
+        });
+    }
+}

package/lib/win/src/peripheral_winrt.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <napi.h>
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <winrt/Windows.Devices.Bluetooth.Advertisement.h>
+
+using namespace winrt::Windows::Devices::Bluetooth::Advertisement;
+using winrt::Windows::Devices::Bluetooth::BluetoothLEDevice;
+using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattCharacteristic;
+using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattDescriptor;
+using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattDeviceService;
+
+#include "winrt/Windows.Devices.Bluetooth.h"
+
+#include <string>
+#include <optional>
+
+#include "peripheral.h"
+#include "winrt_guid.h"
+
+class CachedCharacteristic
+{
+public:
+    CachedCharacteristic() = default;
+    CachedCharacteristic(GattCharacteristic& c) : characteristic(c)
+    {
+    }
+
+    GattCharacteristic characteristic = nullptr;
+    std::unordered_map<winrt::guid, GattDescriptor> descriptors;
+};
+
+class CachedService
+{
+public:
+    CachedService() = default;
+    CachedService(GattDeviceService& s) : service(s)
+    {
+    }
+
+    GattDeviceService service = nullptr;
+    std::unordered_map<winrt::guid, CachedCharacteristic> characterisitics;
+};
+
+class PeripheralWinrt : public Peripheral
+{
+public:
+    PeripheralWinrt() = default;
+    PeripheralWinrt(uint64_t bluetoothAddress, BluetoothLEAdvertisementType advertismentType,
+                    int rssiValue, const BluetoothLEAdvertisement& advertisment);
+    ~PeripheralWinrt();
+
+    void Update(int rssiValue, const BluetoothLEAdvertisement& advertisment,
+                const BluetoothLEAdvertisementType& advertismentType);
+
+    void Disconnect();
+
+    void GetService(winrt::guid serviceUuid,
+                    std::function<void(std::optional<GattDeviceService>)> callback);
+    void GetCharacteristic(winrt::guid serviceUuid, winrt::guid characteristicUuid,
+                           std::function<void(std::optional<GattCharacteristic>)> callback);
+    void GetDescriptor(winrt::guid serviceUuid, winrt::guid characteristicUuid,
+                       winrt::guid descriptorUuid,
+                       std::function<void(std::optional<GattDescriptor>)> callback);
+
+    int rssi;
+    uint64_t bluetoothAddress;
+    std::optional<BluetoothLEDevice> device;
+    winrt::event_token connectionToken;
+
+private:
+    void GetServiceFromDevice(winrt::guid serviceUuid,
+                              std::function<void(std::optional<GattDeviceService>)> callback);
+    void
+    GetCharacteristicFromService(GattDeviceService service, winrt::guid characteristicUuid,
+                                 std::function<void(std::optional<GattCharacteristic>)> callback);
+    void
+    GetDescriptorFromCharacteristic(GattCharacteristic characteristic, winrt::guid descriptorUuid,
+                                    std::function<void(std::optional<GattDescriptor>)> callback);
+    std::unordered_map<winrt::guid, CachedService> cachedServices;
+};

package/lib/win/src/radio_watcher.cc

@@ -0,0 +1,125 @@
+//
+//  radio_watcher.cc
+//  noble-winrt-native
+//
+//  Created by Georg Vienna on 07.09.18.
+//
+
+#pragma once
+
+#include "radio_watcher.h"
+#include "winrt_cpp.h"
+
+using winrt::Windows::Devices::Radios::RadioKind;
+using winrt::Windows::Foundation::AsyncStatus;
+
+template <typename O, typename M, class... Types> auto bind2(O* object, M method, Types&... args)
+{
+    return std::bind(method, object, std::placeholders::_1, std::placeholders::_2, args...);
+}
+
+#define RADIO_INTERFACE_CLASS_GUID \
+    L"System.Devices.InterfaceClassGuid:=\"{A8804298-2D5F-42E3-9531-9C8C39EB29CE}\""
+
+RadioWatcher::RadioWatcher()
+    : mRadio(nullptr), watcher(DeviceInformation::CreateWatcher(RADIO_INTERFACE_CLASS_GUID))
+{
+    mAddedRevoker = watcher.Added(winrt::auto_revoke, bind2(this, &RadioWatcher::OnAdded));
+    mUpdatedRevoker = watcher.Updated(winrt::auto_revoke, bind2(this, &RadioWatcher::OnUpdated));
+    mRemovedRevoker = watcher.Removed(winrt::auto_revoke, bind2(this, &RadioWatcher::OnRemoved));
+    auto completed = bind2(this, &RadioWatcher::OnCompleted);
+    mCompletedRevoker = watcher.EnumerationCompleted(winrt::auto_revoke, completed);
+}
+
+void RadioWatcher::Start(std::function<void(Radio& radio)> on)
+{
+    radioStateChanged = on;
+    inEnumeration = true;
+    initialDone = false;
+    initialCount = 0;
+    watcher.Start();
+}
+
+IAsyncOperation<Radio> RadioWatcher::GetRadios(std::set<winrt::hstring> ids)
+{
+    Radio bluetooth = nullptr;
+    for (auto id : ids)
+    {
+        try
+        {
+            auto radio = co_await Radio::FromIdAsync(id);
+            if (radio && radio.Kind() == RadioKind::Bluetooth)
+            {
+                auto state = radio.State();
+                // we only get state changes for turned on/off adapter but not for disabled adapter
+                if (state == RadioState::On || state == RadioState::Off)
+                {
+                    bluetooth = radio;
+                }
+            }
+        }
+        catch (...)
+        {
+            // Radio::RadioFromAsync throws if the device is not available (unplugged)
+        }
+    }
+    co_return bluetooth;
+}
+
+void RadioWatcher::OnRadioChanged()
+{
+    GetRadios(radioIds).Completed([=](auto&& asyncOp, auto&& status) {
+        if (status == AsyncStatus::Completed)
+        {
+            Radio radio = asyncOp.GetResults();
+            // !radio: to handle if there is no radio
+            if (!radio || radio != mRadio)
+            {
+                if (radio)
+                {
+                    mRadioStateChangedRevoker.revoke();
+                    mRadioStateChangedRevoker = radio.StateChanged(
+                        winrt::auto_revoke, [=](Radio radio, auto&&) { radioStateChanged(radio); });
+                }
+                else
+                {
+                    mRadioStateChangedRevoker.revoke();
+                }
+                radioStateChanged(radio);
+                mRadio = radio;
+            }
+        }
+        else
+        {
+            mRadio = nullptr;
+            mRadioStateChangedRevoker.revoke();
+            radioStateChanged(mRadio);
+        }
+    });
+}
+
+void RadioWatcher::OnAdded(DeviceWatcher watcher, DeviceInformation info)
+{
+    radioIds.insert(info.Id());
+    if (!inEnumeration)
+    {
+        OnRadioChanged();
+    }
+}
+
+void RadioWatcher::OnUpdated(DeviceWatcher watcher, DeviceInformationUpdate info)
+{
+    OnRadioChanged();
+}
+
+void RadioWatcher::OnRemoved(DeviceWatcher watcher, DeviceInformationUpdate info)
+{
+    radioIds.erase(info.Id());
+    OnRadioChanged();
+}
+
+void RadioWatcher::OnCompleted(DeviceWatcher watcher, IInspectable info)
+{
+    inEnumeration = false;
+    OnRadioChanged();
+}

package/lib/win/src/radio_watcher.h

@@ -0,0 +1,61 @@
+//
+//  radio_watcher.h
+//  noble-winrt-native
+//
+//  Created by Georg Vienna on 07.09.18.
+//
+
+#pragma once
+
+#include <functional>
+#include <set>
+#include <winrt/Windows.Devices.Enumeration.h>
+#include <winrt/Windows.Devices.Radios.h>
+
+using namespace winrt::Windows::Devices::Enumeration;
+
+using winrt::Windows::Devices::Radios::IRadio;
+using winrt::Windows::Devices::Radios::Radio;
+using winrt::Windows::Devices::Radios::RadioState;
+using winrt::Windows::Foundation::IAsyncOperation;
+using winrt::Windows::Foundation::IInspectable;
+
+enum class AdapterState : int32_t
+{
+    Initial = -2,
+    Unsupported = -1,
+    Unknown = (int32_t)RadioState::Unknown,
+    On = (int32_t)RadioState::On,
+    Off = (int32_t)RadioState::Off,
+    Disabled = (int32_t)RadioState::Disabled,
+};
+
+class RadioWatcher
+{
+public:
+    RadioWatcher();
+
+    void Start(std::function<void(Radio& radio)> on);
+
+private:
+    IAsyncOperation<Radio> GetRadios(std::set<winrt::hstring> ids);
+
+    void OnRadioChanged();
+    void OnAdded(DeviceWatcher watcher, DeviceInformation info);
+    void OnUpdated(DeviceWatcher watcher, DeviceInformationUpdate info);
+    void OnRemoved(DeviceWatcher watcher, DeviceInformationUpdate info);
+    void OnCompleted(DeviceWatcher watcher, IInspectable info);
+
+    DeviceWatcher watcher;
+    winrt::event_revoker<IDeviceWatcher> mAddedRevoker;
+    winrt::event_revoker<IDeviceWatcher> mUpdatedRevoker;
+    winrt::event_revoker<IDeviceWatcher> mRemovedRevoker;
+    winrt::event_revoker<IDeviceWatcher> mCompletedRevoker;
+    bool inEnumeration;
+    bool initialDone;
+    int initialCount;
+    std::set<winrt::hstring> radioIds;
+    Radio mRadio;
+    winrt::event_revoker<IRadio> mRadioStateChangedRevoker;
+    std::function<void(Radio& radio)> radioStateChanged;
+};

package/lib/win/src/winrt_cpp.cc

@@ -0,0 +1,82 @@
+#include "winrt_cpp.h"
+
+#include <sstream>
+#include <iomanip>
+
+#include <winrt\Windows.Devices.Bluetooth.h>
+
+std::string ws2s(const wchar_t* wstr)
+{
+    return winrt::to_string(wstr);
+}
+
+std::string formatBluetoothAddress(unsigned long long BluetoothAddress)
+{
+    std::ostringstream ret;
+    ret << std::hex << std::setfill('0') << std::setw(2) << ((BluetoothAddress >> (5 * 8)) & 0xff)
+        << ":" << std::setw(2) << ((BluetoothAddress >> (4 * 8)) & 0xff) << ":" << std::setw(2)
+        << ((BluetoothAddress >> (3 * 8)) & 0xff) << ":" << std::setw(2)
+        << ((BluetoothAddress >> (2 * 8)) & 0xff) << ":" << std::setw(2)
+        << ((BluetoothAddress >> (1 * 8)) & 0xff) << ":" << std::setw(2)
+        << ((BluetoothAddress >> (0 * 8)) & 0xff);
+    return ret.str();
+}
+
+std::string formatBluetoothUuid(unsigned long long BluetoothAddress)
+{
+    std::ostringstream ret;
+    ret << std::hex << std::setfill('0') << std::setw(2) << ((BluetoothAddress >> (5 * 8)) & 0xff)
+        << std::setw(2) << ((BluetoothAddress >> (4 * 8)) & 0xff) << std::setw(2)
+        << ((BluetoothAddress >> (3 * 8)) & 0xff) << std::setw(2)
+        << ((BluetoothAddress >> (2 * 8)) & 0xff) << std::setw(2)
+        << ((BluetoothAddress >> (1 * 8)) & 0xff) << std::setw(2)
+        << ((BluetoothAddress >> (0 * 8)) & 0xff);
+    return ret.str();
+}
+
+std::string toStr(winrt::guid uuid)
+{
+    try
+    {
+        auto ref = winrt::Windows::Devices::Bluetooth::BluetoothUuidHelper::TryGetShortId(uuid);
+        if (ref)
+        {
+            auto i = ref.Value();
+            std::ostringstream ret;
+            ret << std::hex << i;
+            return ret.str();
+        }
+    }
+    catch (...)
+    {
+    }
+
+    // taken from winrt/base.h
+    char buffer[38];
+    // 00000000-0000-0000-0000-000000000000
+    sprintf_s(buffer, "%08x-%04hx-%04hx-%02hhx%02hhx-%02hhx%02hhx%02hhx%02hhx%02hhx%02hhx",
+              uuid.Data1, uuid.Data2, uuid.Data3, uuid.Data4[0], uuid.Data4[1], uuid.Data4[2],
+              uuid.Data4[3], uuid.Data4[4], uuid.Data4[5], uuid.Data4[6], uuid.Data4[7]);
+    return std::string(buffer);
+}
+
+#define SET_VAL(prop, val, str) \
+    if ((prop & val) == val)    \
+    {                           \
+        arr.push_back(str);     \
+    }
+
+std::vector<std::string> toPropertyArray(GattCharacteristicProperties& properties)
+{
+    std::vector<std::string> arr;
+    SET_VAL(properties, GattCharacteristicProperties::Broadcast, "broadcast")
+    SET_VAL(properties, GattCharacteristicProperties::Read, "read")
+    SET_VAL(properties, GattCharacteristicProperties::WriteWithoutResponse, "writeWithoutResponse")
+    SET_VAL(properties, GattCharacteristicProperties::Write, "write")
+    SET_VAL(properties, GattCharacteristicProperties::Notify, "notify")
+    SET_VAL(properties, GattCharacteristicProperties::Indicate, "indicate")
+    SET_VAL(properties, GattCharacteristicProperties::AuthenticatedSignedWrites,
+            "authenticatedSignedWrites")
+    SET_VAL(properties, GattCharacteristicProperties::ExtendedProperties, "extendedProperties")
+    return arr;
+}

package/lib/win/src/winrt_cpp.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h>
+
+using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattCharacteristicProperties;
+
+std::string ws2s(const wchar_t* wstr);
+std::string formatBluetoothAddress(unsigned long long BluetoothAddress);
+std::string formatBluetoothUuid(unsigned long long BluetoothAddress);
+std::string toStr(winrt::guid uuid);
+std::vector<std::string> toPropertyArray(GattCharacteristicProperties& properties);

package/lib/win/src/winrt_guid.cc

@@ -0,0 +1,12 @@
+#include "winrt_guid.h"
+
+#if _MSC_VER < 1920
+namespace std
+{
+    std::size_t hash<winrt::guid>::operator()(const winrt::guid& k) const
+    {
+        auto str = winrt::to_hstring(k).c_str();
+        return std::hash<std::wstring>()(str);
+    }
+}
+#endif

package/lib/win/src/winrt_guid.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <winrt/base.h>
+
+#if _MSC_VER < 1920
+namespace std
+{
+    template <> struct hash<winrt::guid>
+    {
+        std::size_t operator()(const winrt::guid& k) const;
+    };
+}
+#endif