@stoprocent/noble 1.9.2-16

package/lib/win/src/ble_manager.h

@@ -0,0 +1,77 @@
+//
+//  ble_manager.h
+//  noble-winrt-native
+//
+//  Created by Georg Vienna on 03.09.18.
+//
+
+#pragma once
+
+#include <winrt/Windows.Devices.Bluetooth.Advertisement.h>
+#include <winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h>
+
+#include "callbacks.h"
+#include "peripheral_winrt.h"
+#include "radio_watcher.h"
+#include "notify_map.h"
+
+using namespace winrt::Windows::Devices::Bluetooth::GenericAttributeProfile;
+using namespace winrt::Windows::Devices::Bluetooth::Advertisement;
+using winrt::Windows::Foundation::AsyncStatus;
+
+class BLEManager
+{
+public:
+    // clang-format off
+    BLEManager(const Napi::Value& receiver, const Napi::Function& callback);
+    void Scan(const std::vector<winrt::guid>& serviceUUIDs, bool allowDuplicates);
+    void StopScan();
+    bool Connect(const std::string& uuid);
+    bool Disconnect(const std::string& uuid);
+    bool UpdateRSSI(const std::string& uuid);
+    bool DiscoverServices(const std::string& uuid, const std::vector<winrt::guid>& serviceUUIDs);
+    bool DiscoverIncludedServices(const std::string& uuid, const winrt::guid& serviceUuid, const std::vector<winrt::guid>& serviceUUIDs);
+    bool DiscoverCharacteristics(const std::string& uuid, const winrt::guid& service, const std::vector<winrt::guid>& characteristicUUIDs);
+    bool Read(const std::string& uuid, const winrt::guid& serviceUuid, const winrt::guid& characteristicUuid);
+    bool Write(const std::string& uuid, const winrt::guid& serviceUuid, const winrt::guid& characteristicUuid, const Data& data, bool withoutResponse);
+    bool Notify(const std::string& uuid, const winrt::guid& serviceUuid, const winrt::guid& characteristicUuid, bool on);
+    bool DiscoverDescriptors(const std::string& uuid, const winrt::guid& serviceUuid, const winrt::guid& characteristicUuid);
+    bool ReadValue(const std::string& uuid, const winrt::guid& serviceUuid, const winrt::guid& characteristicUuid, const winrt::guid& descriptorUuid);
+    bool WriteValue(const std::string& uuid, const winrt::guid& serviceUuid, const winrt::guid& characteristicUuid, const winrt::guid& descriptorUuid, const Data& data);
+    bool ReadHandle(const std::string& uuid, int handle);
+    bool WriteHandle(const std::string& uuid, int handle, Data data);
+    // clang-format on
+
+private:
+    // clang-format off
+    void OnRadio(Radio& radio);
+    void OnScanResult(BluetoothLEAdvertisementWatcher watcher, const BluetoothLEAdvertisementReceivedEventArgs& args);
+    void OnScanStopped(BluetoothLEAdvertisementWatcher watcher, const BluetoothLEAdvertisementWatcherStoppedEventArgs& args);
+    void OnConnected(IAsyncOperation<BluetoothLEDevice> asyncOp, AsyncStatus& status, std::string uuid);
+    void OnConnectionStatusChanged(BluetoothLEDevice device, winrt::Windows::Foundation::IInspectable inspectable);
+    void OnServicesDiscovered(IAsyncOperation<GattDeviceServicesResult> asyncOp, AsyncStatus status, std::string uuid, std::vector<winrt::guid> serviceUUIDs);
+    void OnIncludedServicesDiscovered(IAsyncOperation<GattDeviceServicesResult> asyncOp, AsyncStatus status, std::string uuid, std::string serviceId, std::vector<winrt::guid> serviceUUIDs);
+    void OnCharacteristicsDiscovered(IAsyncOperation<GattCharacteristicsResult> asyncOp, AsyncStatus status, std::string uuid, std::string serviceId, std::vector<winrt::guid> characteristicUUIDs);
+    void OnRead(IAsyncOperation<GattReadResult> asyncOp, AsyncStatus status, std::string uuid, std::string serviceId, std::string characteristicId);
+    void OnWrite(IAsyncOperation<GattWriteResult> asyncOp, AsyncStatus status, std::string uuid, std::string serviceId, std::string characteristicId);
+    void OnNotify(IAsyncOperation<GattWriteResult> asyncOp, AsyncStatus status,  GattCharacteristic characteristic, std::string uuid, std::string serviceId, std::string characteristicId, bool state);
+    void OnValueChanged(GattCharacteristic chracteristic, const GattValueChangedEventArgs& args, std::string uuid);
+    void OnDescriptorsDiscovered(IAsyncOperation<GattDescriptorsResult> asyncOp, AsyncStatus status, std::string uuid, std::string serviceId, std::string characteristicId);
+    void OnReadValue(IAsyncOperation<GattReadResult> asyncOp, AsyncStatus status, std::string uuid, std::string serviceId, std::string characteristicId, std::string descriptorId);
+    void OnWriteValue(IAsyncOperation<GattWriteResult> asyncOp, AsyncStatus status, std::string uuid, std::string serviceId, std::string characteristicId, std::string descriptorId);
+    void OnReadHandle(IAsyncOperation<GattReadResult> asyncOp, AsyncStatus status, std::string uuid, int handle);
+    void OnWriteHandle(IAsyncOperation<GattWriteResult> asyncOp, AsyncStatus status, std::string uuid, int handle);
+    // clang-format on
+
+    Emit mEmit;
+    RadioWatcher mWatcher;
+    AdapterState mRadioState;
+    BluetoothLEAdvertisementWatcher mAdvertismentWatcher;
+    winrt::event_revoker<IBluetoothLEAdvertisementWatcher> mReceivedRevoker;
+    winrt::event_revoker<IBluetoothLEAdvertisementWatcher> mStoppedRevoker;
+    bool mAllowDuplicates;
+
+    std::unordered_map<std::string, PeripheralWinrt> mDeviceMap;
+    std::set<std::string> mAdvertismentMap;
+    NotifyMap mNotifyMap;
+};

package/lib/win/src/callbacks.cc

@@ -0,0 +1,274 @@
+//
+//  callbacks.cc
+//  noble-mac-native
+//
+//  Created by Georg Vienna on 30.08.18.
+//
+#include "callbacks.h"
+
+#include <napi-thread-safe-callback.hpp>
+
+#define _s(val) Napi::String::New(env, val)
+#define _b(val) Napi::Boolean::New(env, val)
+#define _n(val) Napi::Number::New(env, val)
+#define _u(str) toUuid(env, str)
+
+Napi::String toUuid(Napi::Env& env, const std::string& uuid)
+{
+    std::string str(uuid);
+    str.erase(std::remove(str.begin(), str.end(), '-'), str.end());
+    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+    return _s(str);
+}
+
+Napi::String toAddressType(Napi::Env& env, const AddressType& type)
+{
+    if (type == PUBLIC)
+    {
+        return _s("public");
+    }
+    else if (type == RANDOM)
+    {
+        return _s("random");
+    }
+    return _s("unknown");
+}
+
+Napi::Buffer<uint8_t> toBuffer(Napi::Env& env, const Data& data)
+{
+    if (data.empty())
+    {
+        return Napi::Buffer<uint8_t>::New(env, 0);
+    }
+    return Napi::Buffer<uint8_t>::Copy(env, &data[0], data.size());
+}
+
+Napi::Array toUuidArray(Napi::Env& env, const std::vector<std::string>& data)
+{
+    if (data.empty())
+    {
+        return Napi::Array::New(env);
+    }
+    auto arr = Napi::Array::New(env, data.size());
+    for (size_t i = 0; i < data.size(); i++)
+    {
+        arr.Set(i, _u(data[i]));
+    }
+    return arr;
+}
+
+Napi::Array toArray(Napi::Env& env, const std::vector<std::string>& data)
+{
+    if (data.empty())
+    {
+        return Napi::Array::New(env);
+    }
+    auto arr = Napi::Array::New(env, data.size());
+    for (size_t i = 0; i < data.size(); i++)
+    {
+        arr.Set(i, _s(data[i]));
+    }
+    return arr;
+}
+
+void Emit::Wrap(const Napi::Value& receiver, const Napi::Function& callback)
+{
+    mCallback = std::make_shared<ThreadSafeCallback>(receiver, callback);
+}
+
+void Emit::RadioState(const std::string& state)
+{
+    mCallback->call([state](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('stateChange', state);
+        args = { _s("stateChange"), _s(state) };
+    });
+}
+
+void Emit::ScanState(bool start)
+{
+    mCallback->call([start](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('scanStart') emit('scanStop')
+        args = { _s(start ? "scanStart" : "scanStop") };
+    });
+}
+
+void Emit::Scan(const std::string& uuid, int rssi, const Peripheral& peripheral)
+{
+    auto address = peripheral.address;
+    auto addressType = peripheral.addressType;
+    auto connectable = peripheral.connectable;
+    auto name = peripheral.name;
+    auto txPowerLevel = peripheral.txPowerLevel;
+    auto manufacturerData = peripheral.manufacturerData;
+    auto serviceData = peripheral.serviceData;
+    auto serviceUuids = peripheral.serviceUuids;
+    mCallback->call([uuid, rssi, address, addressType, connectable, name, txPowerLevel,
+                     manufacturerData, serviceData,
+                     serviceUuids](Napi::Env env, std::vector<napi_value>& args) {
+        Napi::Object advertisment = Napi::Object::New(env);
+        advertisment.Set(_s("localName"), _s(name));
+        advertisment.Set(_s("txPowerLevel"), txPowerLevel);
+        advertisment.Set(_s("manufacturerData"), toBuffer(env, manufacturerData));
+        auto array =
+            serviceData.empty() ? Napi::Array::New(env) : Napi::Array::New(env, serviceData.size());
+        for (size_t i = 0; i < serviceData.size(); i++)
+        {
+            Napi::Object data = Napi::Object::New(env);
+            data.Set(_s("uuid"), _u(serviceData[i].first));
+            data.Set(_s("data"), toBuffer(env, serviceData[i].second));
+            array.Set(i, data);
+        }
+        advertisment.Set(_s("serviceData"), array);
+        advertisment.Set(_s("serviceUuids"), toUuidArray(env, serviceUuids));
+        // emit('discover', deviceUuid, address, addressType, connectable, advertisement, rssi);
+        args = { _s("discover"),  _u(uuid),     _s(address), toAddressType(env, addressType),
+                 _b(connectable), advertisment, _n(rssi) };
+    });
+}
+
+void Emit::Connected(const std::string& uuid, const std::string& error)
+{
+    mCallback->call([uuid, error](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('connect', deviceUuid) error added here
+        args = { _s("connect"), _u(uuid), error.empty() ? env.Null() : _s(error) };
+    });
+}
+
+void Emit::Disconnected(const std::string& uuid)
+{
+    mCallback->call([uuid](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('disconnect', deviceUuid);
+        args = { _s("disconnect"), _u(uuid) };
+    });
+}
+
+void Emit::RSSI(const std::string& uuid, int rssi)
+{
+    mCallback->call([uuid, rssi](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('rssiUpdate', deviceUuid, rssi);
+        args = { _s("rssiUpdate"), _u(uuid), _n(rssi) };
+    });
+}
+
+void Emit::ServicesDiscovered(const std::string& uuid, const std::vector<std::string>& serviceUuids)
+{
+    mCallback->call([uuid, serviceUuids](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('servicesDiscover', deviceUuid, serviceUuids)
+        args = { _s("servicesDiscover"), _u(uuid), toUuidArray(env, serviceUuids) };
+    });
+}
+
+void Emit::IncludedServicesDiscovered(const std::string& uuid, const std::string& serviceUuid,
+                                      const std::vector<std::string>& serviceUuids)
+{
+    mCallback->call(
+        [uuid, serviceUuid, serviceUuids](Napi::Env env, std::vector<napi_value>& args) {
+            // emit('includedServicesDiscover', deviceUuid, serviceUuid, includedServiceUuids)
+            args = { _s("includedServicesDiscover"), _u(uuid), _u(serviceUuid),
+                     toUuidArray(env, serviceUuids) };
+        });
+}
+
+void Emit::CharacteristicsDiscovered(
+    const std::string& uuid, const std::string& serviceUuid,
+    const std::vector<std::pair<std::string, std::vector<std::string>>>& characteristics)
+{
+    mCallback->call(
+        [uuid, serviceUuid, characteristics](Napi::Env env, std::vector<napi_value>& args) {
+            auto arr = characteristics.empty() ? Napi::Array::New(env)
+                                               : Napi::Array::New(env, characteristics.size());
+            for (size_t i = 0; i < characteristics.size(); i++)
+            {
+                Napi::Object characteristic = Napi::Object::New(env);
+                characteristic.Set(_s("uuid"), _u(characteristics[i].first));
+                characteristic.Set(_s("properties"), toArray(env, characteristics[i].second));
+                arr.Set(i, characteristic);
+            }
+            // emit('characteristicsDiscover', deviceUuid, serviceUuid, { uuid, properties:
+            // ['broadcast', 'read', ...]})
+            args = { _s("characteristicsDiscover"), _u(uuid), _u(serviceUuid), arr };
+        });
+}
+
+void Emit::Read(const std::string& uuid, const std::string& serviceUuid,
+                const std::string& characteristicUuid, const Data& data, bool isNotification)
+{
+    mCallback->call([uuid, serviceUuid, characteristicUuid, data,
+                     isNotification](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('read', deviceUuid, serviceUuid, characteristicsUuid, data, isNotification);
+        args = { _s("read"),          _u(uuid),          _u(serviceUuid), _u(characteristicUuid),
+                 toBuffer(env, data), _b(isNotification) };
+    });
+}
+
+void Emit::Write(const std::string& uuid, const std::string& serviceUuid,
+                 const std::string& characteristicUuid)
+{
+    mCallback->call(
+        [uuid, serviceUuid, characteristicUuid](Napi::Env env, std::vector<napi_value>& args) {
+            // emit('write', deviceUuid, servicesUuid, characteristicsUuid)
+            args = { _s("write"), _u(uuid), _u(serviceUuid), _u(characteristicUuid) };
+        });
+}
+
+void Emit::Notify(const std::string& uuid, const std::string& serviceUuid,
+                  const std::string& characteristicUuid, bool state)
+{
+    mCallback->call([uuid, serviceUuid, characteristicUuid, state](Napi::Env env,
+                                                                   std::vector<napi_value>& args) {
+        // emit('notify', deviceUuid, servicesUuid, characteristicsUuid, state)
+        args = { _s("notify"), _u(uuid), _u(serviceUuid), _u(characteristicUuid), _b(state) };
+    });
+}
+
+void Emit::DescriptorsDiscovered(const std::string& uuid, const std::string& serviceUuid,
+                                 const std::string& characteristicUuid,
+                                 const std::vector<std::string>& descriptorUuids)
+{
+    mCallback->call([uuid, serviceUuid, characteristicUuid,
+                     descriptorUuids](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('descriptorsDiscover', deviceUuid, servicesUuid, characteristicsUuid, descriptors:
+        // [uuids])
+        args = { _s("descriptorsDiscover"), _u(uuid), _u(serviceUuid), _u(characteristicUuid),
+                 toUuidArray(env, descriptorUuids) };
+    });
+}
+
+void Emit::ReadValue(const std::string& uuid, const std::string& serviceUuid,
+                     const std::string& characteristicUuid, const std::string& descriptorUuid,
+                     const Data& data)
+{
+    mCallback->call([uuid, serviceUuid, characteristicUuid, descriptorUuid,
+                     data](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('valueRead', deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data)
+        args = { _s("valueRead"),        _u(uuid),           _u(serviceUuid),
+                 _u(characteristicUuid), _u(descriptorUuid), toBuffer(env, data) };
+    });
+}
+
+void Emit::WriteValue(const std::string& uuid, const std::string& serviceUuid,
+                      const std::string& characteristicUuid, const std::string& descriptorUuid)
+{
+    mCallback->call([uuid, serviceUuid, characteristicUuid,
+                     descriptorUuid](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('valueWrite', deviceUuid, serviceUuid, characteristicUuid, descriptorUuid);
+        args = { _s("valueWrite"), _u(uuid), _u(serviceUuid), _u(characteristicUuid),
+                 _u(descriptorUuid) };
+    });
+}
+
+void Emit::ReadHandle(const std::string& uuid, int descriptorHandle, const Data& data)
+{
+    mCallback->call([uuid, descriptorHandle, data](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('handleRead', deviceUuid, descriptorHandle, data);
+        args = { _s("handleRead"), _u(uuid), _n(descriptorHandle), toBuffer(env, data) };
+    });
+}
+
+void Emit::WriteHandle(const std::string& uuid, int descriptorHandle)
+{
+    mCallback->call([uuid, descriptorHandle](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('handleWrite', deviceUuid, descriptorHandle);
+        args = { _s("handleWrite"), _u(uuid), _n(descriptorHandle) };
+    });
+}

package/lib/win/src/callbacks.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <napi.h>
+#include "peripheral.h"
+
+class ThreadSafeCallback;
+
+class Emit
+{
+public:
+    // clang-format off
+    void Wrap(const Napi::Value& receiver, const Napi::Function& callback);
+    void RadioState(const std::string& status);
+    void ScanState(bool start);
+    void Scan(const std::string& uuid, int rssi, const Peripheral& peripheral);
+    void Connected(const std::string& uuid, const std::string& error = "");
+    void Disconnected(const std::string& uuid);
+    void RSSI(const std::string& uuid, int rssi);
+    void ServicesDiscovered(const std::string& uuid, const std::vector<std::string>& serviceUuids);
+    void IncludedServicesDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::vector<std::string>& serviceUuids);
+    void CharacteristicsDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::vector<std::pair<std::string, std::vector<std::string>>>& characteristics);
+    void Read(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const Data& data, bool isNotification);
+    void Write(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid);
+    void Notify(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, bool state);
+    void DescriptorsDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::vector<std::string>& descriptorUuids);
+    void ReadValue(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::string& descriptorUuid, const Data& data);
+    void WriteValue(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::string& descriptorUuid);
+    void ReadHandle(const std::string& uuid, int descriptorHandle, const Data& data);
+    void WriteHandle(const std::string& uuid, int descriptorHandle);
+    // clang-format on
+protected:
+    std::shared_ptr<ThreadSafeCallback> mCallback;
+};

package/lib/win/src/napi_winrt.cc

@@ -0,0 +1,76 @@
+//
+//  napi_objc.mm
+//  noble-mac-native
+//
+//  Created by Georg Vienna on 30.08.18.
+//
+#include "napi_winrt.h"
+
+#include <winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h>
+#include <rpc.h>
+
+using namespace winrt::Windows::Devices::Bluetooth;
+
+winrt::guid napiToUuid(Napi::String string)
+{
+    std::string str = string.Utf8Value();
+    if (str.size() == 32)
+    {
+        str.insert(8, "-");
+        str.insert(13, "-");
+        str.insert(18, "-");
+        str.insert(23, "-");
+    }
+    if (str.size() == 4)
+    {
+        int id = std::stoi(str, 0, 16);
+        return BluetoothUuidHelper::FromShortId(id);
+    }
+    UUID uuid;
+    UuidFromString((RPC_CSTR)str.c_str(), &uuid);
+    std::array<uint8_t, 8> data4;
+    std::copy_n(uuid.Data4, data4.size(), data4.begin());
+    return winrt::guid(uuid.Data1, uuid.Data2, uuid.Data3, data4);
+}
+
+std::vector<winrt::guid> napiToUuidArray(Napi::Array array)
+{
+    std::vector<winrt::guid> uuids;
+    for (size_t i = 0; i < array.Length(); i++)
+    {
+        Napi::Value val = array[i];
+        uuids.push_back(napiToUuid(val.As<Napi::String>()));
+    }
+    return uuids;
+}
+
+Data napiToData(Napi::Buffer<byte> buffer)
+{
+    Data data;
+    auto bytes = buffer.Data();
+    data.assign(bytes, bytes + buffer.Length());
+    return data;
+}
+
+int napiToNumber(Napi::Number number)
+{
+    return number.Int32Value();
+}
+
+std::vector<winrt::guid> getUuidArray(const Napi::Value& value)
+{
+    if (value.IsArray())
+    {
+        return napiToUuidArray(value.As<Napi::Array>());
+    }
+    return std::vector<winrt::guid>();
+}
+
+bool getBool(const Napi::Value& value, bool def)
+{
+    if (value.IsBoolean())
+    {
+        return value.As<Napi::Boolean>().Value();
+    }
+    return def;
+}

package/lib/win/src/napi_winrt.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <napi.h>
+#include "winrt/base.h"
+#include "peripheral.h"
+
+std::vector<winrt::guid> getUuidArray(const Napi::Value& value);
+bool getBool(const Napi::Value& value, bool def);
+
+winrt::guid napiToUuid(Napi::String string);
+Data napiToData(Napi::Buffer<unsigned char> buffer);
+int napiToNumber(Napi::Number number);