@stoprocent/noble 1.10.3 → 1.10.4

package/lib/hci-socket/gatt.js

@@ -199,9 +199,9 @@ Gatt.prototype.errorResponse = function (opcode, handle, status) {
 
 Gatt.prototype._queueCommand = function (buffer, callback, writeCallback) {
   this._commandQueue.push({
-    buffer: buffer,
-    callback: callback,
-    writeCallback: writeCallback
+    buffer,
+    callback,
+    writeCallback
   });
 
   if (this._currentCommand === null) {
@@ -375,7 +375,7 @@ Gatt.prototype.discoverServices = function (uuids) {
       }
     }
 
-    if ((opcode !== ATT_OP_READ_BY_GROUP_RESP && opcode !== ATT_OP_ERROR) || services[services.length - 1].endHandle === 0xffff) {
+    if (opcode !== ATT_OP_READ_BY_GROUP_RESP || services[services.length - 1].endHandle === 0xffff) {
       const serviceUuids = [];
       for (i = 0; i < services.length; i++) {
         const uuid = services[i].uuid.trim();

package/lib/hci-socket/hci.js

@@ -3,7 +3,7 @@ const debug = require('debug')('hci');
 const events = require('events');
 const util = require('util');
 
-const BluetoothHciSocket = require('@abandonware/bluetooth-hci-socket');
+const BluetoothHciSocket = require('@stoprocent/bluetooth-hci-socket');
 
 const HCI_COMMAND_PKT = 0x01;
 const HCI_ACLDATA_PKT = 0x02;
@@ -845,8 +845,8 @@ Hci.prototype.onSocketData = function (data) {
         this.emit('aclDataPkt', handle, cid, pktData);
       } else {
         this._handleBuffers[handle] = {
-          length: length,
-          cid: cid,
+          length,
+          cid,
           data: pktData
         };
       }

package/lib/mac/binding.gyp

@@ -1,26 +1,38 @@
 {
+  'variables': {
+    'openssl_fips' : '' 
+  },
   'targets': [
     {
       'target_name': 'binding',
-      'sources': [ 'src/noble_mac.mm', 'src/napi_objc.mm', 'src/ble_manager.mm', 'src/objc_cpp.mm', 'src/callbacks.cc'  ],
-      'include_dirs': ["<!@(node -p \"require('node-addon-api').include\")"],
-      'dependencies': ["<!(node -p \"require('node-addon-api').gyp\")"],
+      'sources': [ 
+        'src/noble_mac.mm', 
+        'src/napi_objc.mm', 
+        'src/ble_manager.mm', 
+        'src/objc_cpp.mm', 
+        'src/callbacks.cc' 
+      ],
+      'include_dirs': [
+        "<!(node -p \"require('node-addon-api').include_dir\")"
+      ],
       'cflags!': [ '-fno-exceptions' ],
       'cflags_cc!': [ '-fno-exceptions' ],
+      "defines": ["NAPI_CPP_EXCEPTIONS"],
       'xcode_settings': {
         'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+        'MACOSX_DEPLOYMENT_TARGET': '10.9',
         'CLANG_CXX_LIBRARY': 'libc++',
-        'MACOSX_DEPLOYMENT_TARGET': '10.7',
         'OTHER_CFLAGS': [
-            '-fobjc-arc',
+          '-fobjc-arc',
+          '-arch x86_64',
+          '-arch arm64'
         ],
-      },
-      'link_settings': {
-        'libraries': [
-          '$(SDKROOT)/System/Library/Frameworks/CoreBluetooth.framework',
+        'OTHER_LDFLAGS': [
+          '-framework CoreBluetooth',
+          '-arch x86_64',
+          '-arch arm64'
         ]
-      },
-      'product_dir': '../lib/mac/native',
+      }
     }
   ]
 }

package/lib/noble.js

@@ -18,7 +18,7 @@ function Noble (bindings) {
   this._services = {};
   this._characteristics = {};
   this._descriptors = {};
-  this._discoveredPeripheralUUids = [];
+  this._discoveredPeripheralUUids = {};
 
   this._bindings.on('stateChange', this.onStateChange.bind(this));
   this._bindings.on('addressChange', this.onAddressChange.bind(this));
@@ -58,7 +58,11 @@ function Noble (bindings) {
       this.initialized = true;
 
       process.nextTick(() => {
-        this._bindings.init();
+        try {
+          this._bindings.init();
+        } catch (error) {
+          this.emit('warning', 'Initialization of USB device failed: ' + error.message);
+        }
       });
     }
   });
@@ -131,7 +135,7 @@ const startScanning = function (serviceUuids, allowDuplicates, callback) {
         });
       }
 
-      this._discoveredPeripheralUUids = [];
+      this._discoveredPeripheralUUids = {};
       this._allowDuplicates = allowDuplicates;
 
       this._bindings.startScanning(serviceUuids, allowDuplicates);
@@ -204,10 +208,10 @@ Noble.prototype.onDiscover = function (uuid, address, addressType, connectable,
     peripheral.rssi = rssi;
   }
 
-  const previouslyDiscoverd = (this._discoveredPeripheralUUids.indexOf(uuid) !== -1);
+  const previouslyDiscoverd = this._discoveredPeripheralUUids[uuid] === true;
 
   if (!previouslyDiscoverd) {
-    this._discoveredPeripheralUUids.push(uuid);
+    this._discoveredPeripheralUUids[uuid] = true;
   }
 
   if (this._allowDuplicates || !previouslyDiscoverd || (!scannable && !connectable)) {
@@ -587,7 +591,7 @@ Noble.prototype.onHandleNotify = function (peripheralUuid, handle, data) {
 
 Noble.prototype.onMtu = function (peripheralUuid, mtu) {
   const peripheral = this._peripherals[peripheralUuid];
-  if (peripheral && 'mtu' in peripheral && mtu) peripheral.mtu = mtu;
+  if (peripheral && mtu) peripheral.mtu = mtu;
 };
 
 module.exports = Noble;

package/lib/peripheral.js

@@ -1,8 +1,6 @@
 const events = require('events');
 const util = require('util');
 
-const Manufacturer = require('./manufacture');
-
 function Peripheral (noble, id, address, addressType, connectable, advertisement, rssi, scannable) {
   this._noble = noble;
 
@@ -17,11 +15,6 @@ function Peripheral (noble, id, address, addressType, connectable, advertisement
   this.services = null;
   this.mtu = null;
   this.state = 'disconnected';
-  this.manufacturer = null;
-
-  if (typeof this.advertisement !== 'undefined' && typeof this.advertisement.manufacturerData !== 'undefined') {
-    this.manufacturer = new Manufacturer(noble, this.advertisement.manufacturerData);
-  }
 }
 
 util.inherits(Peripheral, events.EventEmitter);

package/lib/resolve-bindings.js

@@ -1,7 +1,43 @@
+const os = require('os');
 
-module.exports = function (options) {
-  if (process.env.NOBLE_HCI_UART_PORT) {
-    return new (require('./hci-uart/bindings'))(options);
+function getWindowsBindings () {
+  const ver = os
+    .release()
+    .split('.')
+    .map((str) => parseInt(str, 10));
+  if (
+    !(
+      ver[0] > 10 ||
+      (ver[0] === 10 && ver[1] > 0) ||
+      (ver[0] === 10 && ver[1] === 0 && ver[2] >= 15063)
+    )
+  ) {
+    return require('./hci-socket/bindings');
+  } else {
+    return require('./win/bindings');
+  }
+}
+
+module.exports = function (options = {}) {
+  const platform = os.platform();
+
+  if (process.env.NOBLE_WEBSOCKET) {
+    return new (require('./websocket/bindings'))(options);
+  } else if (process.env.NOBLE_DISTRIBUTED) {
+    return new (require('./distributed/bindings'))(options);
+  } else if (
+    platform === 'linux' ||
+    platform === 'freebsd' ||
+    (process.env.BLUETOOTH_HCI_SOCKET_UART_PORT ||
+      process.env.BLUETOOTH_HCI_SOCKET_FORCE_UART) ||
+    (process.env.BLUETOOTH_HCI_SOCKET_USB_VID &&
+      process.env.BLUETOOTH_HCI_SOCKET_USB_PID)
+  ) {
+    return new (require('./hci-socket/bindings'))(options);
+  } else if (platform === 'darwin') {
+    return new (require('./mac/bindings'))(options);
+  } else if (platform === 'win32') {
+    return new (getWindowsBindings())(options);
   } else {
     throw new Error('Unsupported platform');
   }

package/lib/webbluetooth/bindings.js

@@ -109,9 +109,9 @@ NobleBindings.prototype.startScanning = function (options, allowDuplicates) {
 
         self._peripherals[address] = {
           uuid: address,
-          address: address,
+          address,
           advertisement: { localName: device.name }, // advertisement,
-          device: device,
+          device,
           cachedServices: {},
           localName: device.name,
           serviceUuids: options.services

package/lib/websocket/bindings.js

@@ -79,9 +79,9 @@ NobleBindings.prototype._onMessage = function (event) {
 
     this._peripherals[peripheralUuid] = {
       uuid: peripheralUuid,
-      address: address,
-      advertisement: advertisement,
-      rssi: rssi
+      address,
+      advertisement,
+      rssi
     };
 
     this.emit('discover', peripheralUuid, address, addressType, connectable, advertisement, rssi);
@@ -135,8 +135,8 @@ NobleBindings.prototype._sendCommand = function (command, errorCallback) {
 NobleBindings.prototype.startScanning = function (serviceUuids, allowDuplicates) {
   this._startScanCommand = {
     action: 'startScanning',
-    serviceUuids: serviceUuids,
-    allowDuplicates: allowDuplicates
+    serviceUuids,
+    allowDuplicates
   };
   this._sendCommand(this._startScanCommand);
 
@@ -186,7 +186,7 @@ NobleBindings.prototype.discoverServices = function (deviceUuid, uuids) {
   this._sendCommand({
     action: 'discoverServices',
     peripheralUuid: peripheral.uuid,
-    uuids: uuids
+    uuids
   });
 };
 
@@ -196,8 +196,8 @@ NobleBindings.prototype.discoverIncludedServices = function (deviceUuid, service
   this._sendCommand({
     action: 'discoverIncludedServices',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    serviceUuids: serviceUuids
+    serviceUuid,
+    serviceUuids
   });
 };
 
@@ -207,8 +207,8 @@ NobleBindings.prototype.discoverCharacteristics = function (deviceUuid, serviceU
   this._sendCommand({
     action: 'discoverCharacteristics',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuids: characteristicUuids
+    serviceUuid,
+    characteristicUuids
   });
 };
 
@@ -218,8 +218,8 @@ NobleBindings.prototype.read = function (deviceUuid, serviceUuid, characteristic
   this._sendCommand({
     action: 'read',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid
+    serviceUuid,
+    characteristicUuid
   });
 };
 
@@ -229,10 +229,10 @@ NobleBindings.prototype.write = function (deviceUuid, serviceUuid, characteristi
   this._sendCommand({
     action: 'write',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid,
+    serviceUuid,
+    characteristicUuid,
     data: data.toString('hex'),
-    withoutResponse: withoutResponse
+    withoutResponse
   });
 };
 
@@ -242,9 +242,9 @@ NobleBindings.prototype.broadcast = function (deviceUuid, serviceUuid, character
   this._sendCommand({
     action: 'broadcast',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid,
-    broadcast: broadcast
+    serviceUuid,
+    characteristicUuid,
+    broadcast
   });
 };
 
@@ -254,9 +254,9 @@ NobleBindings.prototype.notify = function (deviceUuid, serviceUuid, characterist
   this._sendCommand({
     action: 'notify',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid,
-    notify: notify
+    serviceUuid,
+    characteristicUuid,
+    notify
   });
 };
 
@@ -266,8 +266,8 @@ NobleBindings.prototype.discoverDescriptors = function (deviceUuid, serviceUuid,
   this._sendCommand({
     action: 'discoverDescriptors',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid
+    serviceUuid,
+    characteristicUuid
   });
 };
 
@@ -277,9 +277,9 @@ NobleBindings.prototype.readValue = function (deviceUuid, serviceUuid, character
   this._sendCommand({
     action: 'readValue',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid,
-    descriptorUuid: descriptorUuid
+    serviceUuid,
+    characteristicUuid,
+    descriptorUuid
   });
 };
 
@@ -289,9 +289,9 @@ NobleBindings.prototype.writeValue = function (deviceUuid, serviceUuid, characte
   this._sendCommand({
     action: 'writeValue',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid,
-    descriptorUuid: descriptorUuid,
+    serviceUuid,
+    characteristicUuid,
+    descriptorUuid,
     data: data.toString('hex')
   });
 };
@@ -302,7 +302,7 @@ NobleBindings.prototype.readHandle = function (deviceUuid, handle) {
   this._sendCommand({
     action: 'readHandle',
     peripheralUuid: peripheral.uuid,
-    handle: handle
+    handle
   });
 };
 
@@ -312,9 +312,9 @@ NobleBindings.prototype.writeHandle = function (deviceUuid, handle, data, withou
   this._sendCommand({
     action: 'writeHandle',
     peripheralUuid: peripheral.uuid,
-    handle: handle,
+    handle,
     data: data.toString('hex'),
-    withoutResponse: withoutResponse
+    withoutResponse
   });
 };
 

package/lib/win/binding.gyp

@@ -1,22 +1,42 @@
 {
+  'variables': {
+    'openssl_fips' : '' 
+  },
   'targets': [
     {
       'target_name': 'binding',
-      'sources': [ 'src/noble_winrt.cc', 'src/napi_winrt.cc', 'src/peripheral_winrt.cc', 'src/radio_watcher.cc', 'src/notify_map.cc', 'src/ble_manager.cc', 'src/winrt_cpp.cc', 'src/winrt_guid.cc', 'src/callbacks.cc' ],
-      'include_dirs': ["<!@(node -p \"require('node-addon-api').include\")", "<!@(node -p \"require('napi-thread-safe-callback').include\")"],
-      'dependencies': ["<!(node -p \"require('node-addon-api').gyp\")"],
+      'sources': [ 
+        'src/noble_winrt.cc', 
+        'src/napi_winrt.cc', 
+        'src/peripheral_winrt.cc',
+        'src/radio_watcher.cc', 
+        'src/notify_map.cc', 
+        'src/ble_manager.cc', 
+        'src/winrt_cpp.cc', 
+        'src/winrt_guid.cc', 
+        'src/callbacks.cc' 
+      ],
+      'include_dirs': [
+        "<!(node -p \"require('node-addon-api').include_dir\")",
+        "<!@(node -p \"require('napi-thread-safe-callback').include\")"
+      ],
       'cflags!': [ '-fno-exceptions' ],
       'cflags_cc!': [ '-fno-exceptions' ],
       'msvs_settings': {
         'VCCLCompilerTool': {
           'ExceptionHandling': 1,
-          'AdditionalOptions': ['/await', '/std:c++latest'],
+          'AdditionalOptions': [
+            '/await', 
+            '/std:c++latest'
+          ],
         },
       },
       'msvs_target_platform_version':'10.0.18362.0',
       'msvs_target_platform_minversion':'10.0.18362.0',
       'conditions': [
-        ['OS=="win"', { 'defines': [ '_HAS_EXCEPTIONS=1' ] }]
+        ['OS=="win"', { 
+          'defines': [ '_HAS_EXCEPTIONS=1' ] 
+        }]
       ],
     }
   ]

package/lib/win/src/ble_manager.cc

@@ -12,8 +12,10 @@
 #include <winrt/Windows.Storage.Streams.h>
 using winrt::Windows::Devices::Bluetooth::BluetoothCacheMode;
 using winrt::Windows::Devices::Bluetooth::BluetoothConnectionStatus;
+using winrt::Windows::Devices::Bluetooth::BluetoothLEDevice;
 using winrt::Windows::Storage::Streams::DataReader;
 using winrt::Windows::Storage::Streams::DataWriter;
+using winrt::Windows::Storage::Streams::IBuffer;
 
 template <typename T> auto inFilter(std::vector<T> filter, T object)
 {
@@ -190,7 +192,7 @@ bool BLEManager::Connect(const std::string& uuid)
     return true;
 }
 
-void BLEManager::OnConnected(IAsyncOperation<BluetoothLEDevice> asyncOp, AsyncStatus& status,
+void BLEManager::OnConnected(IAsyncOperation<BluetoothLEDevice> asyncOp, AsyncStatus status,
                              const std::string uuid)
 {
     if (status == AsyncStatus::Completed)
@@ -375,6 +377,7 @@ void BLEManager::OnCharacteristicsDiscovered(IAsyncOperation<GattCharacteristics
         auto result = asyncOp.GetResults();
         CHECK_RESULT(result);
         std::vector<std::pair<std::string, std::vector<std::string>>> characteristicsUuids;
+
         FOR(characteristic, result.Characteristics())
         {
             auto id = characteristic.Uuid();

package/lib/win/src/ble_manager.h

@@ -47,7 +47,7 @@ private:
     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 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);

package/lib/win/src/peripheral_winrt.cc

@@ -2,6 +2,7 @@
 #include "winrt_cpp.h"
 
 #include <winrt/Windows.Storage.Streams.h>
+#include <winrt/Windows.Foundation.Collections.h>
 using namespace winrt::Windows::Storage::Streams;
 
 using winrt::Windows::Devices::Bluetooth::BluetoothCacheMode;
@@ -43,6 +44,7 @@ void PeripheralWinrt::Update(const int rssiValue, const BluetoothLEAdvertisement
         advertismentType == BluetoothLEAdvertisementType::ConnectableDirected;
 
     manufacturerData.clear();
+
     for (auto ds : advertisment.DataSections())
     {
         if (ds.DataType() == BluetoothLEAdvertisementDataTypes::TxPowerLevel())

package/lib/win/src/radio_watcher.cc

@@ -9,6 +9,7 @@
 
 #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;

package/lib/win/src/winrt_cpp.cc

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

package/package.json

@@ -2,15 +2,16 @@
   "author": "Sandeep Mistry",
   "maintainers": [
     "Jacob Rosenthal",
-    "Luis Montes"
+    "Luis Montes",
+    "Marek Serafin"
   ],
   "license": "MIT",
   "name": "@stoprocent/noble",
   "description": "A Node.js BLE (Bluetooth Low Energy) central library.",
-  "version": "1.10.3",
+  "version": "1.10.4",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/stoprocent/noble.git"
+    "url": "https://github.com/stoprocent/noble.git"
   },
   "bugs": {
     "url": "https://github.com/stoprocent/noble/issues"
@@ -28,57 +29,50 @@
   "engines": {
     "node": ">=6"
   },
-  "os": [
-    "darwin",
-    "linux",
-    "freebsd",
-    "win32"
-  ],
   "dependencies": {
-    "debug": "^4.3.1"
+    "debug": "^4.3.4",
+    "napi-thread-safe-callback": "^0.0.6",
+    "node-addon-api": "^4.3.0",
+    "node-gyp-build": "^4.5.0"
   },
   "optionalDependencies": {
-    "async": "^3.2.4",
-    "serialport": "^10.4.0"
+    "@stoprocent/bluetooth-hci-socket": "^0.6.4"
   },
   "devDependencies": {
-    "async": "^3.2.0",
+    "@semantic-release/exec": "6.0.3",
+    "async": "^3.2.4",
     "cross-env": "^7.0.3",
-    "eslint": "^7.32.0",
-    "eslint-config-semistandard": "^16.0.0",
-    "eslint-config-standard": "^16.0.3",
-    "eslint-plugin-import": "^2.25.3",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^5.2.0",
-    "mocha": "^9.2.2",
-    "node-gyp": "^8.4.1",
+    "eslint": "^8.31.0",
+    "eslint-config-semistandard": "^17.0.0",
+    "eslint-config-standard": "^17.0.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-n": "^15.6.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "mocha": "^10.2.0",
+    "node-gyp": "^9.4.0",
     "nyc": "^15.1.0",
-    "prebuildify": "^5.0.0",
-    "prebuildify-ci": "^1.0.5",
-    "prettier": "^2.3.0",
+    "prebuildify": "^5.0.1",
+    "prebuildify-cross": "5.0.0",
+    "prettier": "^2.8.1",
     "proxyquire": "^2.1.3",
+    "semantic-release": "21.1.0",
     "should": "~13.2.3",
-    "sinon": "^12.0.1",
-    "ws": "^8.3.0"
+    "sinon": "^15.0.1",
+    "ws": "^8.11.0"
   },
   "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",
+    "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"
-  },
-  "binary": {
-    "napi_versions": [
-      4
-    ]
-  },
-  "homepage": "https://github.com/stoprocent/noble#readme",
-  "directories": {
-    "example": "examples",
-    "lib": "lib",
-    "test": "test"
   }
 }