@stoprocent/noble 1.19.0 → 2.0.0

package/lib/win/src/radio_watcher.cc

@@ -1,29 +1,52 @@
-//
-//  radio_watcher.cc
-//  noble-winrt-native
-//
-//  Created by Georg Vienna on 07.09.18.
-//
+// Standard library includes
+#include <future>
+#include <string>
+#include <sstream>
+#include <iomanip>
+#include <cstdint>
 
-#pragma once
+// Windows Runtime includes
+#include <winrt/Windows.Foundation.Collections.h>
+#include <winrt/Windows.Devices.Bluetooth.h>
+#include <winrt/Windows.Devices.Enumeration.h>
+#include <winrt/Windows.Devices.Radios.h>
 
+// Project includes
 #include "radio_watcher.h"
 #include "winrt_cpp.h"
-#include <winrt/Windows.Foundation.Collections.h>
 
-using winrt::Windows::Devices::Radios::RadioKind;
-using winrt::Windows::Foundation::AsyncStatus;
+using namespace winrt::Windows::Devices::Enumeration;
+using namespace winrt::Windows::Devices::Bluetooth;
+using namespace winrt::Windows::Devices::Bluetooth::GenericAttributeProfile;
+using winrt::Windows::Devices::Radios::RadioState;
 
 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}\""
+const char* adapterStateToString(AdapterState state)
+{
+    switch (state)
+    {
+    case AdapterState::Unsupported:
+        return "unsupported";
+    case AdapterState::On:
+        return "poweredOn";
+        break;
+    case AdapterState::Off:
+        return "poweredOff";
+        break;
+    case AdapterState::Disabled:
+        return "poweredOff";
+        break;
+    default:
+        return "unknown";
+    }
+}
 
 RadioWatcher::RadioWatcher()
-    : mRadio(nullptr), watcher(DeviceInformation::CreateWatcher(RADIO_INTERFACE_CLASS_GUID))
+    : mRadio(nullptr), watcher(DeviceInformation::CreateWatcher(BluetoothAdapter::GetDeviceSelector()))
 {
     mAddedRevoker = watcher.Added(winrt::auto_revoke, bind2(this, &RadioWatcher::OnAdded));
     mUpdatedRevoker = watcher.Updated(winrt::auto_revoke, bind2(this, &RadioWatcher::OnUpdated));
@@ -32,80 +55,68 @@ RadioWatcher::RadioWatcher()
     mCompletedRevoker = watcher.EnumerationCompleted(winrt::auto_revoke, completed);
 }
 
-void RadioWatcher::Start(std::function<void(Radio& radio)> on)
+void RadioWatcher::Start(std::function<void(Radio& radio, const AdapterCapabilities& capabilities)> 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;
-                }
+winrt::fire_and_forget RadioWatcher::OnRadioChanged() {
+    try {
+        auto adapter = co_await BluetoothAdapter::GetDefaultAsync();
+        
+        if (adapter) {
+            auto radio = co_await adapter.GetRadioAsync();
+
+            AdapterCapabilities capabilities;
+            capabilities.bluetoothAddress = adapter.BluetoothAddress();
+            capabilities.classicSecureConnectionsSupported = adapter.AreClassicSecureConnectionsSupported();
+            capabilities.lowEnergySecureConnectionsSupported = adapter.AreLowEnergySecureConnectionsSupported();
+            capabilities.extendedAdvertisingSupported = adapter.IsExtendedAdvertisingSupported();
+            capabilities.lowEnergySupported = adapter.IsLowEnergySupported();
+            capabilities.maxAdvertisementDataLength = adapter.MaxAdvertisementDataLength();
+            capabilities.peripheralRoleSupported = adapter.IsPeripheralRoleSupported();
+            capabilities.centralRoleSupported = adapter.IsCentralRoleSupported();
+
+            Radio bluetooth = nullptr;
+            if (radio.State() == RadioState::On && adapter.IsPeripheralRoleSupported()) {
+                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)
-                {
+            if (!bluetooth || bluetooth != mRadio) {
+                if (bluetooth) {
                     mRadioStateChangedRevoker.revoke();
-                    mRadioStateChangedRevoker = radio.StateChanged(
-                        winrt::auto_revoke, [=](Radio radio, auto&&) { radioStateChanged(radio); });
-                }
-                else
-                {
+                    mRadioStateChangedRevoker = bluetooth.StateChanged(
+                        winrt::auto_revoke, 
+                        [this, capabilities](Radio radio, auto&&) { 
+                            radioStateChanged(radio, capabilities); 
+                        });
+                } else {
                     mRadioStateChangedRevoker.revoke();
                 }
-                radioStateChanged(radio);
-                mRadio = radio;
+                
+                radioStateChanged(bluetooth, capabilities);
+                mRadio = bluetooth;
             }
-        }
-        else
-        {
+        } else {
             mRadio = nullptr;
             mRadioStateChangedRevoker.revoke();
-            radioStateChanged(mRadio);
+            AdapterCapabilities emptyCapabilities = {};
+            radioStateChanged(mRadio, emptyCapabilities);
         }
-    });
+    } catch (const winrt::hresult_error&) {
+        mRadio = nullptr;
+        mRadioStateChangedRevoker.revoke();
+        AdapterCapabilities emptyCapabilities = {};
+        radioStateChanged(mRadio, emptyCapabilities);
+    }
 }
 
 void RadioWatcher::OnAdded(DeviceWatcher watcher, DeviceInformation info)
 {
-    radioIds.insert(info.Id());
-    if (!inEnumeration)
-    {
-        OnRadioChanged();
-    }
+    if (inEnumeration) { return; }
+    OnRadioChanged();
 }
 
 void RadioWatcher::OnUpdated(DeviceWatcher watcher, DeviceInformationUpdate info)
@@ -115,7 +126,6 @@ void RadioWatcher::OnUpdated(DeviceWatcher watcher, DeviceInformationUpdate info
 
 void RadioWatcher::OnRemoved(DeviceWatcher watcher, DeviceInformationUpdate info)
 {
-    radioIds.erase(info.Id());
     OnRadioChanged();
 }
 

package/lib/win/src/radio_watcher.h

@@ -7,19 +7,24 @@
 
 #pragma once
 
+// Standard library includes
 #include <functional>
 #include <set>
+
+// Windows Runtime includes
 #include <winrt/Windows.Devices.Enumeration.h>
 #include <winrt/Windows.Devices.Radios.h>
+#include <winrt/Windows.Foundation.h>
 
+// Forward declarations
 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;
 
+// AdapterState enum
 enum class AdapterState : int32_t
 {
     Initial = -2,
@@ -30,32 +35,46 @@ enum class AdapterState : int32_t
     Disabled = (int32_t)RadioState::Disabled,
 };
 
+// AdapterCapabilities struct
+struct AdapterCapabilities {
+    uint64_t bluetoothAddress;
+    bool classicSecureConnectionsSupported;
+    bool lowEnergySecureConnectionsSupported;
+    bool extendedAdvertisingSupported;
+    bool lowEnergySupported;
+    uint32_t maxAdvertisementDataLength;
+    bool peripheralRoleSupported;
+    bool centralRoleSupported;
+};
+
+// Convert AdapterState to std:string
+const char* adapterStateToString(AdapterState state);
+
+// RadioWatcher class
 class RadioWatcher
 {
 public:
     RadioWatcher();
 
-    void Start(std::function<void(Radio& radio)> on);
+    void Start(std::function<void(Radio& radio, const AdapterCapabilities& capabilities)> on);
 
-private:
-    IAsyncOperation<Radio> GetRadios(std::set<winrt::hstring> ids);
+    winrt::fire_and_forget OnRadioChanged();
 
-    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);
 
+private:
+    Radio mRadio;
     DeviceWatcher watcher;
+    bool inEnumeration;
+    
+    std::function<void(Radio& radio, const AdapterCapabilities& capabilities)> radioStateChanged;
+    
     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

@@ -3,7 +3,7 @@
 #include <sstream>
 #include <iomanip>
 
-#include <winrt\Windows.Devices.Bluetooth.h>
+#include <winrt/Windows.Devices.Bluetooth.h>
 #include <winrt/Windows.Foundation.Collections.h>
 
 std::string ws2s(const wchar_t* wstr)

package/lib/win/src/winrt_cpp.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <vector>
+#include <string>
+
 #include <winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h>
 
 using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattCharacteristicProperties;

package/package.json

@@ -6,7 +6,7 @@
   "license": "MIT",
   "name": "@stoprocent/noble",
   "description": "A Node.js BLE (Bluetooth Low Energy) central library.",
-  "version": "1.19.0",
+  "version": "2.0.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/stoprocent/noble.git"
@@ -29,14 +29,14 @@
   },
   "dependencies": {
     "debug": "^4.3.7",
-    "napi-thread-safe-callback": "^0.0.6",
     "node-addon-api": "^8.1.0",
     "node-gyp-build": "^4.8.1"
   },
   "optionalDependencies": {
-    "@stoprocent/bluetooth-hci-socket": "^1.5.1"
+    "@stoprocent/bluetooth-hci-socket": "^2.1.1"
   },
   "devDependencies": {
+    "@babel/eslint-parser": "^7.27.0",
     "@commitlint/cli": "^19.3.0",
     "@commitlint/config-conventional": "^19.2.2",
     "@semantic-release/changelog": "^6.0.3",
@@ -46,35 +46,32 @@
     "async": "^3.2.6",
     "cross-env": "^7.0.3",
     "eslint": "^8.57.1",
-    "eslint-plugin-import": "^2.30.0",
+    "eslint-config-node": "^4.1.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jest": "^28.11.0",
     "eslint-plugin-n": "^17.10.3",
+    "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^7.1.0",
-    "mocha": "^10.7.0",
-    "nyc": "^17.0.0",
+    "jest": "^29.7.0",
+    "jshint": "^2.13.6",
     "prebuildify": "^6.0.1",
     "prebuildify-cross": "^5.1.1",
-    "semantic-release": "^24.1.1",
-    "jshint": "^2.13.6",
     "prettier": "^3.3.3",
     "proxyquire": "^2.1.3",
+    "semantic-release": "^24.1.1",
     "should": "^13.2.3",
-    "sinon": "^15.0.1",
-    "ws": "^8.11.0"
+    "sinon": "^15.0.1"
   },
   "scripts": {
     "install": "node-gyp-build",
     "lint": "eslint \"**/*.js\"",
     "lint-fix": "eslint \"**/*.js\" --fix",
-    "prebuildify": "prebuildify --napi --target 14.0.0 --force --strip --verbose",
-    "prebuildify-cross": "prebuildify-cross --napi --target 14.0.0 --force --strip --verbose",
+    "prebuildify": "prebuildify --napi --target 17.0.0 --force --strip --verbose",
+    "prebuildify-cross": "prebuildify-cross --napi --target 17.0.0 --force --strip --verbose",
     "semantic-release": "semantic-release",
     "pretest": "npm run rebuild",
     "rebuild": "node-gyp rebuild",
-    "coverage": "nyc npm test && nyc report --reporter=text-lcov > .nyc_output/lcov.info",
-    "test": "cross-env NODE_ENV=test mocha --recursive \"test/*.test.js\" \"test/**/*.test.js\" --exit"
-  },
-  "browser": {
-    "./lib/resolve-bindings.js": "./lib/resolve-bindings-web.js"
+    "test": "npx jest"
   },
   "publishConfig": {
     "access": "public"