@stoprocent/noble 1.15.2 → 1.16.1

package/examples/peripheral-explorer-async.js

@@ -1,17 +1,25 @@
 const noble = require('../');
 
-const peripheralIdOrAddress = process.argv[2].toLowerCase();
+const directConnect = process.argv[2].toLowerCase();
+const peripheralIdOrAddress = process.argv[3].toLowerCase();
+
+const starTime = Date.now();
 
 noble.on('stateChange', async (state) => {
   if (state === 'poweredOn') {
-    await noble.startScanningAsync([], false);
+    if (directConnect === '1') {
+      await noble.stopScanningAsync();
+      await noble.connectAsync(peripheralIdOrAddress.replace(/:/g, ''));
+    } else {
+      await noble.startScanningAsync();
+    }
   }
 });
 
 noble.on('discover', async (peripheral) => {
   if ([peripheral.id, peripheral.address].includes(peripheralIdOrAddress)) {
     await noble.stopScanningAsync();
-
+    
     console.log(`Peripheral with ID ${peripheral.id} found`);
     const advertisement = peripheral.advertisement;
 
@@ -59,7 +67,9 @@ const explore = async (peripheral) => {
     process.exit(0);
   });
 
-  await peripheral.connectAsync();
+  if (peripheral.state !== 'connected') {
+    await peripheral.connectAsync();
+  }
 
   const services = await peripheral.discoverServicesAsync([]);
 
@@ -114,7 +124,9 @@ const explore = async (peripheral) => {
     }
   }
 
+  console.log(`Time taken: ${Date.now() - starTime}ms`);
   await peripheral.disconnectAsync();
+
 };
 
 process.on('SIGINT', function () {

package/index.d.ts

@@ -13,6 +13,7 @@
 
 import events = require("events");
 
+export declare function waitForPoweredOn(timeout?: number): Promise<void>;
 /**
  * @deprecated
  */

package/lib/hci-socket/bindings.js

@@ -53,11 +53,12 @@ NobleBindings.prototype.stopScanning = function () {
 
 NobleBindings.prototype.connect = function (peripheralUuid, parameters) {
   let address = this._addresses[peripheralUuid];
-  const addressType = this._addresseTypes[peripheralUuid] || 'random'; // Default to 'random' if type is not defined
-
+  let addressType = this._addresseTypes[peripheralUuid] || 'random'; // Default to 'random' if type is not defined
+  
   // If address is not available, generate it from the UUID using the transformation logic inline
   if (!address) {
     address = peripheralUuid.match(/.{1,2}/g).join(':'); // Converts UUID back to MAC address format
+    addressType = (parseInt(address.slice(0, 2).slice(0,2), 16) & 0x02) === 0  ? 'public' : 'random';
   }
 
   // Manage connection attempts

package/lib/hci-socket/hci.js

@@ -49,6 +49,7 @@ const OCF_READ_RSSI = 0x0005;
 const OGF_LE_CTL = 0x08;
 const OCF_LE_SET_EVENT_MASK = 0x0001;
 const OCF_LE_READ_BUFFER_SIZE = 0x0002;
+const OCF_LE_READ_LOCAL_SUPPORTED_FEATURES = 0x0003;
 const OCF_LE_SET_EXTENDED_SCAN_PARAMETERS = 0x0041;
 const OCF_LE_SET_EXTENDED_SCAN_ENABLE = 0x0042;
 const OCF_LE_SET_SCAN_PARAMETERS = 0x000b;
@@ -77,6 +78,7 @@ const READ_RSSI_CMD = OCF_READ_RSSI | (OGF_STATUS_PARAM << 10);
 
 const LE_SET_EVENT_MASK_CMD = OCF_LE_SET_EVENT_MASK | (OGF_LE_CTL << 10);
 const LE_READ_BUFFER_SIZE_CMD = OCF_LE_READ_BUFFER_SIZE | (OGF_LE_CTL << 10);
+const LE_READ_LOCAL_SUPPORTED_FEATURES = OCF_LE_READ_LOCAL_SUPPORTED_FEATURES | (OGF_LE_CTL << 10);
 const LE_SET_EXTENDED_SCAN_PARAMETERS_CMD =
   OCF_LE_SET_EXTENDED_SCAN_PARAMETERS | (OGF_LE_CTL << 10);
 const LE_SET_EXTENDED_SCAN_ENABLE_CMD =
@@ -164,7 +166,8 @@ Hci.prototype.init = function (options) {
       this._bound = true;
     }
     this._socket.start();
-
+    
+    this.reset();
     this.pollIsDevUp();
   }
 };
@@ -181,17 +184,9 @@ Hci.prototype.pollIsDevUp = function () {
         return;
       }
 
-      if (this._isExtended) {
-        this.setCodedPhySupport();
-      }
       this.setSocketFilter();
-      this.setEventMask();
-      this.setLeEventMask();
-      this.readLocalVersion();
-      this.writeLeHostSupported();
-      this.readLeHostSupported();
-      this.readLeBufferSize();
-      this.readBdAddr();
+      this.readLeSupportedFeatures();
+      // Subsequent calls moved to processCmdCompleteEvent for LE_READ_LOCAL_SUPPORTED_FEATURES
     } else {
       this.emit('stateChange', 'poweredOff');
     }
@@ -369,6 +364,20 @@ Hci.prototype.setLeEventMask = function () {
   this._socket.write(cmd);
 };
 
+Hci.prototype.readLeSupportedFeatures = function () {
+  const cmd = Buffer.alloc(4);
+
+  // header
+  cmd.writeUInt8(HCI_COMMAND_PKT, 0);
+  cmd.writeUInt16LE(LE_READ_LOCAL_SUPPORTED_FEATURES, 1);
+
+  // length
+  cmd.writeUInt8(0x0, 3);
+
+  debug(`le read supported feature - writing: ${cmd.toString('hex')}`);
+  this._socket.write(cmd);
+};
+
 Hci.prototype.readLeBufferSize = function () {
   const cmd = Buffer.alloc(4);
 
@@ -917,6 +926,24 @@ Hci.prototype.processCmdCompleteEvent = function (cmd, status, result) {
     this.setLeEventMask();
     this.readLocalVersion();
     this.readBdAddr();
+  } else if (cmd === LE_READ_LOCAL_SUPPORTED_FEATURES) {
+    if (status === 0) {
+      // Set _isExtended based on leExtendedAdvertising bit (12)
+      this._isExtended = !!(result.readUInt32LE(0) & (1 << 12));
+
+      this.emit('leFeatures', result);
+
+      if (this._isExtended) {
+        this.setCodedPhySupport();
+      }
+      this.setEventMask();
+      this.setLeEventMask();
+      this.readLocalVersion();
+      this.writeLeHostSupported();
+      this.readLeHostSupported();
+      this.readLeBufferSize();
+      this.readBdAddr();
+    }
   } else if (cmd === READ_LE_HOST_SUPPORTED_CMD) {
     if (status === 0) {
       const le = result.readUInt8(0);

package/lib/noble.js

@@ -118,6 +118,26 @@ Noble.prototype.setAddress = function (address) {
   }
 };
 
+Noble.prototype.waitForPoweredOn = function (timeout = 10000) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error('Timeout waiting for Noble to be powered on'));
+    }, timeout);
+
+    let listener;
+    listener = (state) => {
+      clearTimeout(timeoutId);
+      if (state === 'poweredOn') {
+        resolve();
+      } else {
+        this.once('stateChange', listener);
+      }
+    };
+
+    this.once('stateChange', listener);
+  });
+};
+
 const startScanning = function (serviceUuids, allowDuplicates, callback) {
   if (typeof serviceUuids === 'function') {
     this.emit('warning', 'calling startScanning(callback) is deprecated');

package/lib/win/binding.gyp

@@ -35,7 +35,7 @@
       'msvs_target_platform_minversion':'10.0.18362.0',
       'conditions': [
         ['OS=="win"', { 
-          'defines': [ '_HAS_EXCEPTIONS=1' ] 
+          'defines': [ '_HAS_EXCEPTIONS=1', 'NAPI_CPP_EXCEPTIONS' ] 
         }]
       ],
     }

package/package.json

@@ -6,7 +6,7 @@
   "license": "MIT",
   "name": "@stoprocent/noble",
   "description": "A Node.js BLE (Bluetooth Low Energy) central library.",
-  "version": "1.15.2",
+  "version": "1.16.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/stoprocent/noble.git"
@@ -52,7 +52,7 @@
     "mocha": "^10.7.0",
     "nyc": "^17.0.0",
     "prebuildify": "^6.0.1",
-    "prebuildify-cross": "thegecko/prebuildify-cross#fix-docker",
+    "prebuildify-cross": "^5.1.1",
     "semantic-release": "^24.1.1",
     "jshint": "^2.13.6",
     "prettier": "^3.3.3",

package/test/lib/hci-socket/bindings.test.js

@@ -132,7 +132,7 @@ describe('hci-socket bindings', () => {
   });
 
   describe('connect', () => {
-    it('missing peripheral, no queue', () => {
+    it('missing peripheral, no queue, public address', () => {
       bindings._hci.createLeConn = fake.resolves(null);
 
       bindings.connect('112233445566', 'parameters');
@@ -140,7 +140,18 @@ describe('hci-socket bindings', () => {
       should(bindings._pendingConnectionUuid).eql('112233445566');
 
       assert.calledOnce(bindings._hci.createLeConn);
-      assert.calledWith(bindings._hci.createLeConn, '11:22:33:44:55:66', 'random', 'parameters');
+      assert.calledWith(bindings._hci.createLeConn, '11:22:33:44:55:66', 'public', 'parameters');
+    });
+
+    it('missing peripheral, no queue, random address', () => {
+      bindings._hci.createLeConn = fake.resolves(null);
+
+      bindings.connect('f32233445566', 'parameters');
+
+      should(bindings._pendingConnectionUuid).eql('f32233445566');
+
+      assert.calledOnce(bindings._hci.createLeConn);
+      assert.calledWith(bindings._hci.createLeConn, 'f3:22:33:44:55:66', 'random', 'parameters');
     });
 
     it('existing peripheral, no queue', () => {

package/test/lib/hci-socket/hci.test.js

@@ -109,6 +109,7 @@ describe('hci-socket hci', () => {
       hci.readLeBufferSize = sinon.spy();
       hci.readBdAddr = sinon.spy();
       hci.init = sinon.spy();
+      hci.readLeSupportedFeatures = sinon.spy();
       hci.setCodedPhySupport = sinon.spy();
 
       hci.on('stateChange', callback);
@@ -170,13 +171,7 @@ describe('hci-socket hci', () => {
       hci.pollIsDevUp();
 
       assert.calledOnceWithExactly(hci.setSocketFilter);
-      assert.calledOnceWithExactly(hci.setEventMask);
-      assert.calledOnceWithExactly(hci.setLeEventMask);
-      assert.calledOnceWithExactly(hci.readLocalVersion);
-      assert.calledOnceWithExactly(hci.writeLeHostSupported);
-      assert.calledOnceWithExactly(hci.readLeHostSupported);
-      assert.calledOnceWithExactly(hci.readLeBufferSize);
-      assert.calledOnceWithExactly(hci.readBdAddr);
+      assert.calledOnceWithExactly(hci.readLeSupportedFeatures);
 
       assert.notCalled(hci.setCodedPhySupport);
       assert.notCalled(hci._socket.removeAllListeners);
@@ -193,14 +188,7 @@ describe('hci-socket hci', () => {
       hci.pollIsDevUp();
 
       assert.calledOnceWithExactly(hci.setSocketFilter);
-      assert.calledOnceWithExactly(hci.setEventMask);
-      assert.calledOnceWithExactly(hci.setLeEventMask);
-      assert.calledOnceWithExactly(hci.readLocalVersion);
-      assert.calledOnceWithExactly(hci.writeLeHostSupported);
-      assert.calledOnceWithExactly(hci.readLeHostSupported);
-      assert.calledOnceWithExactly(hci.readLeBufferSize);
-      assert.calledOnceWithExactly(hci.readBdAddr);
-      assert.calledOnceWithExactly(hci.setCodedPhySupport);
+      assert.calledOnceWithExactly(hci.readLeSupportedFeatures);
 
       assert.notCalled(hci._socket.removeAllListeners);
       assert.notCalled(hci.init);
@@ -698,6 +686,81 @@ describe('hci-socket hci', () => {
       should(hci._aclConnections).have.keys(4660, 4661);
       should(hci._aclConnections.get(4660)).deepEqual({ pending: 3 });
       should(hci._aclConnections.get(4661)).deepEqual({ pending: 2 });
+
+      describe('LE_READ_LOCAL_SUPPORTED_FEATURES', () => {
+        beforeEach(() => {
+          hci.setCodedPhySupport = sinon.spy();
+          hci.setEventMask = sinon.spy();
+          hci.setLeEventMask = sinon.spy();
+          hci.readLocalVersion = sinon.spy();
+          hci.writeLeHostSupported = sinon.spy();
+          hci.readLeHostSupported = sinon.spy();
+          hci.readLeBufferSize = sinon.spy();
+          hci.readBdAddr = sinon.spy();
+        });
+      
+        it('should not process on error status', () => {
+          const cmd = 8195;
+          const status = 1;
+          const result = Buffer.from([0x00, 0x00, 0x00, 0x00]);
+      
+          hci.processCmdCompleteEvent(cmd, status, result);
+      
+          // Verify no methods were called
+          assert.notCalled(hci.setCodedPhySupport);
+          assert.notCalled(hci.setEventMask);
+          assert.notCalled(hci.setLeEventMask);
+          assert.notCalled(hci.readLocalVersion);
+          assert.notCalled(hci.writeLeHostSupported);
+          assert.notCalled(hci.readLeHostSupported);
+          assert.notCalled(hci.readLeBufferSize);
+          assert.notCalled(hci.readBdAddr);
+      
+          should(hci._isExtended).equal(false);
+        });
+      
+        it('should process without extended features', () => {
+          const cmd = 8195;
+          const status = 0;
+          const result = Buffer.from([0x00, 0x00, 0x00, 0x00]); // No bits set
+      
+          hci.processCmdCompleteEvent(cmd, status, result);
+      
+          // Verify extended-specific method not called
+          assert.notCalled(hci.setCodedPhySupport);
+      
+          // Verify other methods were called
+          assert.calledOnce(hci.setEventMask);
+          assert.calledOnce(hci.setLeEventMask);
+          assert.calledOnce(hci.readLocalVersion);
+          assert.calledOnce(hci.writeLeHostSupported);
+          assert.calledOnce(hci.readLeHostSupported);
+          assert.calledOnce(hci.readLeBufferSize);
+          assert.calledOnce(hci.readBdAddr);
+      
+          should(hci._isExtended).equal(false);
+        });
+      
+        it('should process with extended features', () => {
+          const cmd = 8195;
+          const status = 0;
+          const result = Buffer.from("bd5f660000000000", "hex");
+      
+          hci.processCmdCompleteEvent(cmd, status, result);
+      
+          // Verify all methods were called including extended-specific
+          assert.calledOnce(hci.setCodedPhySupport);
+          assert.calledOnce(hci.setEventMask);
+          assert.calledOnce(hci.setLeEventMask);
+          assert.calledOnce(hci.readLocalVersion);
+          assert.calledOnce(hci.writeLeHostSupported);
+          assert.calledOnce(hci.readLeHostSupported);
+          assert.calledOnce(hci.readLeBufferSize);
+          assert.calledOnce(hci.readBdAddr);
+      
+          should(hci._isExtended).equal(true);
+        });
+      });
     });
 
     it('should only processCmdStatusEvent - HCI_EVENT_PKT / EVT_CMD_STATUS', () => {