@stoprocent/noble 1.15.1 → 1.16.0

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

@@ -29,6 +29,7 @@ export declare function connect(peripheralUuid: string, options?: object, callba
 export declare function connectAsync(peripheralUuid: string, options?: object): Promise<Peripheral>;
 export declare function cancelConnect(peripheralUuid: string, options?: object): void;
 export declare function reset(): void;
+export declare function stop(): void;
 
 export declare function setAddress(address: string): void;
 

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
@@ -113,7 +114,7 @@ NobleBindings.prototype.init = function () {
   is present it can throw an exception - in which case we don't
   want to try and clear up afterwards (issue #502) */
   process.on('SIGINT', this.onSigIntBinded);
-  process.on('exit', this.onExit.bind(this));
+  process.on('exit', this.stop.bind(this));
 };
 
 NobleBindings.prototype.onSigInt = function () {
@@ -126,12 +127,13 @@ NobleBindings.prototype.onSigInt = function () {
   }
 };
 
-NobleBindings.prototype.onExit = function () {
+NobleBindings.prototype.stop = function () {
   this.stopScanning();
-
   for (const handle in this._aclStreams) {
     this._hci.disconnect(handle);
   }
+  this._hci.reset();
+  this._hci.stop();
 };
 
 NobleBindings.prototype.onStateChange = function (state) {

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');
     }
@@ -290,6 +285,10 @@ Hci.prototype.reset = function () {
   this._socket.write(cmd);
 };
 
+Hci.prototype.stop = function () {
+  this._socket.stop();
+};
+
 Hci.prototype.readSupportedCommands = function () {
   const cmd = Buffer.alloc(4);
 
@@ -365,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);
 
@@ -913,6 +926,22 @@ Hci.prototype.processCmdCompleteEvent = function (cmd, status, result) {
     this.setLeEventMask();
     this.readLocalVersion();
     this.readBdAddr();
+  } else if (cmd === LE_READ_LOCAL_SUPPORTED_FEATURES) {
+    if (status === 0) {
+      const featuresLow = result.readUInt32LE(0);
+      this._isExtended = (featuresLow & (1 << 6)) !== 0;
+
+      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

@@ -190,7 +190,15 @@ Noble.prototype.onScanStop = function () {
 };
 
 Noble.prototype.reset = function () {
-  this._bindings.reset();
+  if (this._bindings.reset) {
+    this._bindings.reset();
+  }  
+};
+
+Noble.prototype.stop = function () {
+  if (this._bindings.stop) {
+    this._bindings.stop();
+  }
 };
 
 Noble.prototype.onDiscover = function (uuid, address, addressType, connectable, advertisement, rssi, scannable) {

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.1",
+  "version": "1.16.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/stoprocent/noble.git"
@@ -34,7 +34,7 @@
     "node-gyp-build": "^4.8.1"
   },
   "optionalDependencies": {
-    "@stoprocent/bluetooth-hci-socket": "^1.4.1"
+    "@stoprocent/bluetooth-hci-socket": "^1.4.2"
   },
   "devDependencies": {
     "@commitlint/cli": "^19.3.0",
@@ -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', () => {
@@ -268,22 +279,28 @@ describe('hci-socket bindings', () => {
     assert.calledTwice(process.on);
   });
 
-  describe('onExit', () => {
+  describe('stop', () => {
     it('no handles', () => {
       bindings._gap.stopScanning = fake.resolves(null);
+      bindings._hci.reset = fake.resolves(null);
+      bindings._hci.stop = fake.resolves(null);
 
-      bindings.onExit();
+      bindings.stop();
 
       assert.calledOnce(bindings._gap.stopScanning);
+      assert.calledOnce(bindings._hci.reset);
+      assert.calledOnce(bindings._hci.stop);
     });
 
     it('with handles', () => {
       bindings._gap.stopScanning = fake.resolves(null);
       bindings._hci.disconnect = fake.resolves(null);
+      bindings._hci.reset = fake.resolves(null);
+      bindings._hci.stop = fake.resolves(null);
 
       bindings._aclStreams = [1, 2, 3];
 
-      bindings.onExit();
+      bindings.stop();
 
       assert.calledOnce(bindings._gap.stopScanning);
       assert.calledThrice(bindings._hci.disconnect);

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([0x40, 0x00, 0x00, 0x00]); // Bit 6 set for extended features
+      
+          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', () => {