@stoprocent/noble 1.19.0 → 2.0.0

package/lib/win/src/ble_manager.h

@@ -1,26 +1,20 @@
-//
-//  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 "Emit.h"
+#include "notify_map.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;
+using winrt::Windows::Foundation::IAsyncOperation;
+using winrt::Windows::Foundation::IInspectable;
 
-class BLEManager
-{
+class BLEManager {
 public:
     // clang-format off
     BLEManager(const Napi::Value& receiver, const Napi::Function& callback);
@@ -28,6 +22,7 @@ public:
     void StopScan();
     bool Connect(const std::string& uuid);
     bool Disconnect(const std::string& uuid);
+    bool CancelConnect(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);
@@ -44,7 +39,7 @@ public:
 
 private:
     // clang-format off
-    void OnRadio(Radio& radio);
+    void OnRadio(Radio& radio, const AdapterCapabilities& capabilities);
     void OnScanResult(BluetoothLEAdvertisementWatcher watcher, const BluetoothLEAdvertisementReceivedEventArgs& args);
     void OnScanStopped(BluetoothLEAdvertisementWatcher watcher, const BluetoothLEAdvertisementWatcherStoppedEventArgs& args);
     void OnConnected(IAsyncOperation<BluetoothLEDevice> asyncOp, AsyncStatus status, std::string uuid);
@@ -62,16 +57,19 @@ private:
     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
+    
+    bool mAllowDuplicates;
 
     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::vector<winrt::guid> mScanServiceUUIDs;
     std::set<std::string> mAdvertismentMap;
     NotifyMap mNotifyMap;
 };

package/lib/win/src/napi_winrt.cc

@@ -1,9 +1,3 @@
-//
-//  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>
@@ -21,7 +15,7 @@ winrt::guid napiToUuid(Napi::String string)
         str.insert(18, "-");
         str.insert(23, "-");
     }
-    if (str.size() == 4)
+    if (str.size() == 4 || str.size() == 8)
     {
         int id = std::stoi(str, 0, 16);
         return BluetoothUuidHelper::FromShortId(id);

package/lib/win/src/napi_winrt.h

@@ -2,7 +2,7 @@
 
 #include <napi.h>
 #include "winrt/base.h"
-#include "peripheral.h"
+#include "Peripheral.h"
 
 std::vector<winrt::guid> getUuidArray(const Napi::Value& value);
 bool getBool(const Napi::Value& value, bool def);

package/lib/win/src/noble_winrt.cc

@@ -1,12 +1,6 @@
-//
-//  noble_winrt.cc
-//  noble-winrt-native
-//
-//  Created by Georg Vienna on 03.09.18.
-//
 #include "noble_winrt.h"
-
 #include "napi_winrt.h"
+#include "winrt_cpp.h"
 
 #define THROW(msg)                                                      \
     Napi::TypeError::New(info.Env(), msg).ThrowAsJavaScriptException(); \
@@ -48,18 +42,26 @@
 #define CHECK_MANAGER()                                  \
     if (!manager)                                        \
     {                                                    \
-        THROW("BLEManager has already been cleaned up"); \
+        THROW(__FUNCTION__ ": BLEManager has already been cleaned up"); \
     }
 
 NobleWinrt::NobleWinrt(const Napi::CallbackInfo& info) : ObjectWrap(info)
 {
 }
 
-Napi::Value NobleWinrt::Init(const Napi::CallbackInfo& info)
+Napi::Value NobleWinrt::Start(const Napi::CallbackInfo& info)
 {
     Napi::Function emit = info.This().As<Napi::Object>().Get("emit").As<Napi::Function>();
     manager = new BLEManager(info.This(), emit);
-    return Napi::Value();
+    return info.Env().Undefined();
+}
+
+Napi::Value NobleWinrt::Stop(const Napi::CallbackInfo& info)
+{
+    CHECK_MANAGER()
+    delete manager;
+    manager = nullptr;
+    return info.Env().Undefined();
 }
 
 // startScanning(serviceUuids, allowDuplicates)
@@ -70,7 +72,7 @@ Napi::Value NobleWinrt::Scan(const Napi::CallbackInfo& info)
     // default value false
     auto duplicates = getBool(info[1], false);
     manager->Scan(vector, duplicates);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // stopScanning()
@@ -78,7 +80,7 @@ Napi::Value NobleWinrt::StopScan(const Napi::CallbackInfo& info)
 {
     CHECK_MANAGER()
     manager->StopScan();
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // connect(deviceUuid)
@@ -88,7 +90,7 @@ Napi::Value NobleWinrt::Connect(const Napi::CallbackInfo& info)
     ARG1(String)
     auto uuid = info[0].As<Napi::String>().Utf8Value();
     manager->Connect(uuid);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // disconnect(deviceUuid)
@@ -98,7 +100,17 @@ Napi::Value NobleWinrt::Disconnect(const Napi::CallbackInfo& info)
     ARG1(String)
     auto uuid = info[0].As<Napi::String>().Utf8Value();
     manager->Disconnect(uuid);
-    return Napi::Value();
+    return info.Env().Undefined();
+}
+
+// cancelConnect(deviceUuid)
+Napi::Value NobleWinrt::CancelConnect(const Napi::CallbackInfo& info)
+{
+    CHECK_MANAGER()
+    ARG1(String)
+    auto uuid = info[0].As<Napi::String>().Utf8Value();
+    manager->CancelConnect(uuid);
+    return info.Env().Undefined();
 }
 
 // updateRssi(deviceUuid)
@@ -108,7 +120,7 @@ Napi::Value NobleWinrt::UpdateRSSI(const Napi::CallbackInfo& info)
     ARG1(String)
     auto uuid = info[0].As<Napi::String>().Utf8Value();
     manager->UpdateRSSI(uuid);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // discoverServices(deviceUuid, uuids)
@@ -119,7 +131,7 @@ Napi::Value NobleWinrt::DiscoverServices(const Napi::CallbackInfo& info)
     auto uuid = info[0].As<Napi::String>().Utf8Value();
     std::vector<winrt::guid> uuids = getUuidArray(info[1]);
     manager->DiscoverServices(uuid, uuids);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // discoverIncludedServices(deviceUuid, serviceUuid, serviceUuids)
@@ -131,7 +143,7 @@ Napi::Value NobleWinrt::DiscoverIncludedServices(const Napi::CallbackInfo& info)
     auto service = napiToUuid(info[1].As<Napi::String>());
     std::vector<winrt::guid> uuids = getUuidArray(info[2]);
     manager->DiscoverIncludedServices(uuid, service, uuids);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // discoverCharacteristics(deviceUuid, serviceUuid, characteristicUuids)
@@ -143,7 +155,7 @@ Napi::Value NobleWinrt::DiscoverCharacteristics(const Napi::CallbackInfo& info)
     auto service = napiToUuid(info[1].As<Napi::String>());
     std::vector<winrt::guid> characteristics = getUuidArray(info[2]);
     manager->DiscoverCharacteristics(uuid, service, characteristics);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // read(deviceUuid, serviceUuid, characteristicUuid)
@@ -155,7 +167,7 @@ Napi::Value NobleWinrt::Read(const Napi::CallbackInfo& info)
     auto service = napiToUuid(info[1].As<Napi::String>());
     auto characteristic = napiToUuid(info[2].As<Napi::String>());
     manager->Read(uuid, service, characteristic);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // write(deviceUuid, serviceUuid, characteristicUuid, data, withoutResponse)
@@ -169,7 +181,7 @@ Napi::Value NobleWinrt::Write(const Napi::CallbackInfo& info)
     auto data = napiToData(info[3].As<Napi::Buffer<unsigned char>>());
     auto withoutResponse = info[4].As<Napi::Boolean>().Value();
     manager->Write(uuid, service, characteristic, data, withoutResponse);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // notify(deviceUuid, serviceUuid, characteristicUuid, notify)
@@ -182,7 +194,7 @@ Napi::Value NobleWinrt::Notify(const Napi::CallbackInfo& info)
     auto characteristic = napiToUuid(info[2].As<Napi::String>());
     auto on = info[3].As<Napi::Boolean>().Value();
     manager->Notify(uuid, service, characteristic, on);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // discoverDescriptors(deviceUuid, serviceUuid, characteristicUuid)
@@ -194,7 +206,7 @@ Napi::Value NobleWinrt::DiscoverDescriptors(const Napi::CallbackInfo& info)
     auto service = napiToUuid(info[1].As<Napi::String>());
     auto characteristic = napiToUuid(info[2].As<Napi::String>());
     manager->DiscoverDescriptors(uuid, service, characteristic);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // readValue(deviceUuid, serviceUuid, characteristicUuid, descriptorUuid)
@@ -207,7 +219,7 @@ Napi::Value NobleWinrt::ReadValue(const Napi::CallbackInfo& info)
     auto characteristic = napiToUuid(info[2].As<Napi::String>());
     auto descriptor = napiToUuid(info[3].As<Napi::String>());
     manager->ReadValue(uuid, service, characteristic, descriptor);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // writeValue(deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data)
@@ -221,7 +233,7 @@ Napi::Value NobleWinrt::WriteValue(const Napi::CallbackInfo& info)
     auto descriptor = napiToUuid(info[3].As<Napi::String>());
     auto data = napiToData(info[4].As<Napi::Buffer<unsigned char>>());
     manager->WriteValue(uuid, service, characteristic, descriptor, data);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // readHandle(deviceUuid, handle)
@@ -232,7 +244,7 @@ Napi::Value NobleWinrt::ReadHandle(const Napi::CallbackInfo& info)
     auto uuid = info[0].As<Napi::String>().Utf8Value();
     auto handle = napiToNumber(info[1].As<Napi::Number>());
     manager->ReadHandle(uuid, handle);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // writeHandle(deviceUuid, handle, data, (unused)withoutResponse)
@@ -244,26 +256,59 @@ Napi::Value NobleWinrt::WriteHandle(const Napi::CallbackInfo& info)
     auto handle = napiToNumber(info[1].As<Napi::Number>());
     auto data = napiToData(info[2].As<Napi::Buffer<unsigned char>>());
     manager->WriteHandle(uuid, handle, data);
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
-Napi::Value NobleWinrt::CleanUp(const Napi::CallbackInfo& info)
+// addressToId(address)
+Napi::Value NobleWinrt::AddressToId(const Napi::CallbackInfo& info)
 {
-    CHECK_MANAGER()
-    delete manager;
-    manager = nullptr;
-    return Napi::Value();
+    ARG1(String)
+    try {
+        auto address = info[0].As<Napi::String>().Utf8Value();
+        std::string cleanUuid = address;
+        cleanUuid.erase(std::remove(cleanUuid.begin(), cleanUuid.end(), ':'), cleanUuid.end());
+        
+        if (cleanUuid.length() != 12) {
+            return info.Env().Null();
+        }
+        
+        if (cleanUuid.find_first_not_of("0123456789ABCDEFabcdef") != std::string::npos) {
+            return info.Env().Null();
+        }
+        
+        return Napi::String::New(info.Env(), cleanUuid.c_str());
+    } catch (const std::exception& e) {
+        return info.Env().Null();
+    }
 }
 
-Napi::Function NobleWinrt::GetClass(Napi::Env env)
-{
-    // clang-format off
-    return DefineClass(env, "NobleWinrt", {
-        NobleWinrt::InstanceMethod("init", &NobleWinrt::Init),
+#pragma comment(lib, "windowsapp")
+Napi::Object NobleWinrt::Init(Napi::Env env, Napi::Object exports) {
+    Napi::HandleScope scope(env);
+
+    try
+    {
+        winrt::init_apartment();
+    }
+    catch (winrt::hresult_error hresult)
+    {
+        if (hresult.code() != RPC_E_CHANGED_MODE)
+        {
+            wprintf(L"Failed initializing apartment: %d %s", hresult.code().value,
+                    hresult.message().c_str());
+            Napi::TypeError::New(env, "Failed initializing apartment").ThrowAsJavaScriptException();
+            return exports;
+        }
+    }
+
+    Napi::Function func = DefineClass(env, "NobleWinrt", {
+        NobleWinrt::InstanceMethod("start", &NobleWinrt::Start),
+        NobleWinrt::InstanceMethod("stop", &NobleWinrt::Stop),
         NobleWinrt::InstanceMethod("startScanning", &NobleWinrt::Scan),
         NobleWinrt::InstanceMethod("stopScanning", &NobleWinrt::StopScan),
         NobleWinrt::InstanceMethod("connect", &NobleWinrt::Connect),
         NobleWinrt::InstanceMethod("disconnect", &NobleWinrt::Disconnect),
+        NobleWinrt::InstanceMethod("cancelConnect", &NobleWinrt::CancelConnect),
         NobleWinrt::InstanceMethod("updateRssi", &NobleWinrt::UpdateRSSI),
         NobleWinrt::InstanceMethod("discoverServices", &NobleWinrt::DiscoverServices),
         NobleWinrt::InstanceMethod("discoverIncludedServices", &NobleWinrt::DiscoverIncludedServices),
@@ -276,33 +321,15 @@ Napi::Function NobleWinrt::GetClass(Napi::Env env)
         NobleWinrt::InstanceMethod("writeValue", &NobleWinrt::WriteValue),
         NobleWinrt::InstanceMethod("readHandle", &NobleWinrt::ReadHandle),
         NobleWinrt::InstanceMethod("writeHandle", &NobleWinrt::WriteHandle),
-        NobleWinrt::InstanceMethod("cleanUp", &NobleWinrt::CleanUp),
-    });
-    // clang-format on
-}
+        NobleWinrt::InstanceMethod("addressToId", &NobleWinrt::AddressToId),
+        });
 
-#pragma comment(lib, "windowsapp")
+    Napi::FunctionReference* constructor = new Napi::FunctionReference();
+    *constructor = Napi::Persistent(func);
+    env.SetInstanceData(constructor);
 
-Napi::Object Init(Napi::Env env, Napi::Object exports)
-{
-    try
-    {
-        winrt::init_apartment();
-    }
-    catch (winrt::hresult_error hresult)
-    {
-        // electron already initialized the COM library
-        if (hresult.code() != RPC_E_CHANGED_MODE)
-        {
-            wprintf(L"Failed initializing apartment: %d %s", hresult.code().value,
-                    hresult.message().c_str());
-            Napi::TypeError::New(env, "Failed initializing apartment").ThrowAsJavaScriptException();
-            return exports;
-        }
-    }
-    Napi::String name = Napi::String::New(env, "NobleWinrt");
-    exports.Set(name, NobleWinrt::GetClass(env));
+    exports.Set("NobleWinrt", func);
     return exports;
 }
 
-NODE_API_MODULE(addon, Init)
+NODE_API_NAMED_ADDON(addon, NobleWinrt);

package/lib/win/src/noble_winrt.h

@@ -8,12 +8,13 @@ class NobleWinrt : public Napi::ObjectWrap<NobleWinrt>
 {
 public:
     NobleWinrt(const Napi::CallbackInfo&);
-    Napi::Value Init(const Napi::CallbackInfo&);
-    Napi::Value CleanUp(const Napi::CallbackInfo&);
+    Napi::Value Start(const Napi::CallbackInfo&);
+    Napi::Value Stop(const Napi::CallbackInfo&);
     Napi::Value Scan(const Napi::CallbackInfo&);
     Napi::Value StopScan(const Napi::CallbackInfo&);
     Napi::Value Connect(const Napi::CallbackInfo&);
     Napi::Value Disconnect(const Napi::CallbackInfo&);
+    Napi::Value CancelConnect(const Napi::CallbackInfo&);
     Napi::Value UpdateRSSI(const Napi::CallbackInfo&);
     Napi::Value DiscoverServices(const Napi::CallbackInfo&);
     Napi::Value DiscoverIncludedServices(const Napi::CallbackInfo& info);
@@ -26,8 +27,9 @@ public:
     Napi::Value WriteValue(const Napi::CallbackInfo& info);
     Napi::Value ReadHandle(const Napi::CallbackInfo& info);
     Napi::Value WriteHandle(const Napi::CallbackInfo& info);
+    Napi::Value AddressToId(const Napi::CallbackInfo& info);
 
-    static Napi::Function GetClass(Napi::Env);
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
 
 private:
     BLEManager* manager;

package/lib/win/src/notify_map.cc

@@ -1,10 +1,3 @@
-//
-//  notify_map.cc
-//  noble-winrt-native
-//
-//  Created by Georg Vienna on 07.09.18.
-//
-
 #include "notify_map.h"
 
 bool Key::operator==(const Key& other) const

package/lib/win/src/notify_map.h

@@ -1,14 +1,7 @@
-//
-//  notify_map.h
-//  noble-winrt-native
-//
-//  Created by Georg Vienna on 07.09.18.
-//
-
 #pragma once
 
-#include <winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h>
 #include "winrt_guid.h"
+#include <winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h>
 
 using namespace winrt::Windows::Devices::Bluetooth::GenericAttributeProfile;
 

package/lib/win/src/peripheral_winrt.cc

@@ -70,9 +70,14 @@ void PeripheralWinrt::ProcessServiceData(const BluetoothLEAdvertisementDataSecti
     data.resize(d.Length() - uuidSize);
     dr.ReadBytes(data);
     
+    // Initialize serviceData if it doesn't exist
+    if (!serviceData.has_value()) {
+        serviceData = std::vector<std::pair<std::string, Data>>();
+    }
+    
     // Find and update existing entry or add new one
     bool found = false;
-    for (auto& pair : serviceData) {
+    for (auto& pair : serviceData.value()) {
         if (pair.first == uuidStr) {
             pair.second = data;
             found = true;
@@ -81,7 +86,7 @@ void PeripheralWinrt::ProcessServiceData(const BluetoothLEAdvertisementDataSecti
     }
     
     if (!found) {
-        serviceData.push_back(std::make_pair(uuidStr, data));
+        serviceData.value().push_back(std::make_pair(uuidStr, data));
     }
     
     dr.Close();
@@ -90,16 +95,20 @@ void PeripheralWinrt::ProcessServiceData(const BluetoothLEAdvertisementDataSecti
 void PeripheralWinrt::Update(const int rssiValue, const BluetoothLEAdvertisement& advertisment,
                              const BluetoothLEAdvertisementType& advertismentType)
 {
+    // Handle name
     std::string localName = ws2s(advertisment.LocalName().c_str());
     if (!localName.empty())
     {
-        name = localName;
+        name = std::optional<std::string>(localName);
     }
 
     connectable = advertismentType == BluetoothLEAdvertisementType::ConnectableUndirected ||
         advertismentType == BluetoothLEAdvertisementType::ConnectableDirected;
 
-    manufacturerData.clear();
+    // Reset optional values
+    manufacturerData = std::nullopt;
+    serviceData = std::nullopt;
+    serviceUuids = std::nullopt;
 
     for (auto ds : advertisment.DataSections())
     {
@@ -107,17 +116,20 @@ void PeripheralWinrt::Update(const int rssiValue, const BluetoothLEAdvertisement
         {
             auto d = ds.Data();
             auto dr = DataReader::FromBuffer(d);
-            txPowerLevel = dr.ReadByte();
-            if (txPowerLevel >= 128)
-                txPowerLevel -= 256;
+            int power = dr.ReadByte();
+            if (power >= 128)
+                power -= 256;
+            txPowerLevel = std::optional<int>(power);
             dr.Close();
         }
         else if (ds.DataType() == BluetoothLEAdvertisementDataTypes::ManufacturerSpecificData())
         {
             auto d = ds.Data();
             auto dr = DataReader::FromBuffer(d);
-            manufacturerData.resize(d.Length());
-            dr.ReadBytes(manufacturerData);
+            Data mData;
+            mData.resize(d.Length());
+            dr.ReadBytes(mData);
+            manufacturerData = std::optional<Data>(mData);
             dr.Close();
         }
         else if (ds.DataType() == BluetoothLEAdvertisementDataTypes::ServiceData16BitUuids())
@@ -134,10 +146,15 @@ void PeripheralWinrt::Update(const int rssiValue, const BluetoothLEAdvertisement
         }
     }
 
-    serviceUuids.clear();
+    // Handle service UUIDs
+    std::vector<std::string> uuids;
     for (auto uuid : advertisment.ServiceUuids())
     {
-        serviceUuids.push_back(toStr(uuid));
+        uuids.push_back(toStr(uuid));
+    }
+    if (!uuids.empty())
+    {
+        serviceUuids = std::optional<std::vector<std::string>>(uuids);
     }
 
     rssi = rssiValue;
@@ -148,6 +165,7 @@ void PeripheralWinrt::Disconnect()
     cachedServices.clear();
     if (device.has_value() && connectionToken)
     {
+        device->Close();
         device->ConnectionStatusChanged(connectionToken);
     }
     device = std::nullopt;

package/lib/win/src/peripheral_winrt.h

@@ -16,7 +16,7 @@ using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattDeviceSer
 #include <string>
 #include <optional>
 
-#include "peripheral.h"
+#include "Peripheral.h"
 #include "winrt_guid.h"
 
 class CachedCharacteristic