@stoprocent/noble 2.1.6 → 2.2.0

package/examples/peripheral-explorer-async.js

@@ -13,6 +13,7 @@ try {
 }
 
 const starTime = Date.now();
+let cancelConnectTimeout;
 
 let peripheral;
 async function main () {
@@ -20,12 +21,13 @@ async function main () {
     await noble.waitForPoweredOnAsync();
 
     // Cancel the connection after 5 seconds if it is still connecting
-    setTimeout(() => {
+    cancelConnectTimeout = setTimeout(() => {
       noble.cancelConnect(peripheralIdOrAddress);
     }, 5000);
 
     if (directConnect === '1') {
       peripheral = await noble.connectAsync(peripheralIdOrAddress, { addressType });
+      clearTimeout(cancelConnectTimeout);
       await explore(peripheral);
     } else {
       await noble.startScanningAsync([], false);
@@ -92,13 +94,18 @@ const explore = async (peripheral) => {
     console.log('noble stopped');
   });
 
+  peripheral.on('mtu', (mtu) => {
+    console.log('MTU Updated: ', mtu);
+  });
+
   if (peripheral.state !== 'connected') {
     await peripheral.connectAsync();
+    clearTimeout(cancelConnectTimeout);
   }
 
   const rssi = await peripheral.updateRssiAsync();
   console.log('RSSI', rssi);
-
+   
   const services = await peripheral.discoverServicesAsync([]);
 
   for (const service of services) {

package/lib/common/include/Emit.h

@@ -18,6 +18,7 @@ public:
     void Scan(const std::string& uuid, int rssi, const Peripheral& peripheral);
     void Connected(const std::string& uuid, const std::string& error = "");
     void Disconnected(const std::string& uuid);
+    void MTU(const std::string& uuid, int mtu);
     void RSSI(const std::string& uuid, int rssi, const std::string& error = "");
     void ServicesDiscovered(const std::string& uuid, const std::vector<std::string>& serviceUuids, const std::string& error = "");
     void IncludedServicesDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::vector<std::string>& serviceUuids, const std::string& error = "");

package/lib/common/src/Emit.cc

@@ -162,6 +162,14 @@ void Emit::Disconnected(const std::string& uuid)
     });
 }
 
+void Emit::MTU(const std::string& uuid, int mtu)
+{
+    mCallback->call([uuid, mtu](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('onMtu', deviceUuid, mtu);
+        args = { _s("onMtu"), _u(uuid), _n(mtu) };
+    });
+}
+
 void Emit::RSSI(const std::string& uuid, int rssi, const std::string& error)
 {
     mCallback->call([uuid, rssi, error](Napi::Env env, std::vector<napi_value>& args) {

package/lib/hci-socket/bindings.js

@@ -130,7 +130,7 @@ NobleBindings.prototype.connect = function (peripheralUuid, parameters = {}) {
   const processNextConnection = () => {
     if (this._connectionQueue.length === 1) {
       const nextConn = this._connectionQueue[0]; // Look at next connection but don't remove yet
-      this._hci.createLeConn(nextConn.address, nextConn.addressType, nextConn.params);
+      this._hci.createLeConn(nextConn.address, nextConn.addressType, nextConn.params, Object.keys(this._handles).length === 0);
     }
   };
 
@@ -404,7 +404,7 @@ NobleBindings.prototype.onLeConnComplete = function (
   // Process next connection in queue if any
   if (this._connectionQueue.length > 0 && !this._isScanning) {
     const nextConn = this._connectionQueue[0];
-    this._hci.createLeConn(nextConn.address, nextConn.addressType, nextConn.params);
+    this._hci.createLeConn(nextConn.address, nextConn.addressType, nextConn.params, Object.keys(this._handles).length === 0);
   }
 };
 

package/lib/hci-socket/gap.js

@@ -40,11 +40,6 @@ Gap.prototype.setScanParameters = function (interval, window) {
 };
 
 Gap.prototype.startScanning = function (allowDuplicates) {
-  this._hci.once('reset', () => this.startScanningAfterReset(allowDuplicates));
-  this._hci.reset();
-};
-
-Gap.prototype.startScanningAfterReset = function (allowDuplicates) {
   this._scanState = 'starting';
   this._scanFilterDuplicates = !allowDuplicates;
 

package/lib/hci-socket/hci.js

@@ -508,9 +508,19 @@ Hci.prototype.setScanEnabled = function (enabled, filterDuplicates) {
   this._socket.write(cmd);
 };
 
-Hci.prototype.createLeConn = function (address, addressType, parameters = {}) {
-  this.once('reset', () => this.createLeConnAfterReset(address, addressType, parameters));
-  this.reset();
+// This is a mystery case for me. 
+// I don't know why we need to reset the hci socket before creating a LE connection.
+// Issues related to this:
+// https://github.com/stoprocent/noble/issues/12
+// https://github.com/bluez/bluez/issues/1178
+Hci.prototype.createLeConn = function (address, addressType, parameters = {}, reset = true) {
+  if (reset) {
+    this.once('reset', () => this.createLeConnAfterReset(address, addressType, parameters));
+    this.reset();
+  }
+  else {
+    this.createLeConnAfterReset(address, addressType, parameters);
+  }
 };
 
 Hci.prototype.createLeConnAfterReset = function (address, addressType, parameters = {}) {

package/lib/mac/src/ble_manager.h

@@ -14,8 +14,10 @@
 @property (assign) CBManagerState lastState;
 @property dispatch_queue_t dispatchQueue;
 @property NSMutableDictionary *peripherals;
+@property NSMutableDictionary *mtus;
 @property NSMutableSet *discovered;
 
+
 - (instancetype)init: (const Napi::Value&) receiver with: (const Napi::Function&) callback;
 - (void)scan: (NSArray<NSString*> *)serviceUUIDs allowDuplicates: (BOOL)allowDuplicates;
 - (void)stopScan;

package/lib/mac/src/ble_manager.mm

@@ -4,6 +4,10 @@
 
 #import <Foundation/Foundation.h>
 
+@interface BLEManager ()
+- (void)updateMtuForPeripheral:(CBPeripheral*) peripheral;
+@end
+
 @implementation BLEManager
 
 - (instancetype)init: (const Napi::Value&) receiver with: (const Napi::Function&) callback
@@ -16,10 +20,20 @@
         self.centralManager = [[CBCentralManager alloc] initWithDelegate:self queue:self.dispatchQueue];
         self.discovered = [NSMutableSet set];
         self.peripherals = [NSMutableDictionary dictionaryWithCapacity:10];
+        self.mtus = [NSMutableDictionary dictionaryWithCapacity:10];
     }
     return self;
 }
 
+- (void)updateMtuForPeripheral:(CBPeripheral*) peripheral {
+    NSUInteger mtu = [peripheral maximumWriteValueLengthForType:CBCharacteristicWriteWithoutResponse];
+    NSNumber *mtuNumber = [self.mtus objectForKey: peripheral.identifier];
+    if (!mtuNumber || [mtuNumber unsignedIntegerValue] != mtu) {
+        emit.MTU(getUuid(peripheral), mtu);
+        [self.mtus setObject:[NSNumber numberWithInt:mtu] forKey: peripheral.identifier];
+    }
+}
+
 - (void)centralManagerDidUpdateState:(CBCentralManager *)central 
 {
     if (central.state != self.lastState && self.lastState == CBManagerStatePoweredOff && central.state == CBManagerStatePoweredOn) {
@@ -154,6 +168,8 @@
     
     std::string uuid = getUuid(peripheral);
     emit.Connected(uuid, "");
+    [self updateMtuForPeripheral:peripheral];
+    
 }
 
 - (void) centralManager:(CBCentralManager *)central didFailToConnectPeripheral:(CBPeripheral *)peripheral error:(NSError *)error {
@@ -213,6 +229,7 @@
 - (void)peripheral:(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error {
     std::string uuid = getUuid(peripheral);
     std::vector<std::string> services = getServices(peripheral.services);
+    [self updateMtuForPeripheral:peripheral];
     emit.ServicesDiscovered(uuid, services, error ? error.localizedDescription.UTF8String : "");
 }
 
@@ -263,6 +280,7 @@
     std::string uuid = getUuid(peripheral);
     std::string serviceUuid = std::string([service.UUID.UUIDString UTF8String]);
     auto characteristics = getCharacteristics(service.characteristics);
+    [self updateMtuForPeripheral:peripheral];
     emit.CharacteristicsDiscovered(uuid, serviceUuid, characteristics, error ? error.localizedDescription.UTF8String : "");
 }
 

package/package.json

@@ -6,7 +6,7 @@
   "license": "MIT",
   "name": "@stoprocent/noble",
   "description": "A Node.js BLE (Bluetooth Low Energy) central library.",
-  "version": "2.1.6",
+  "version": "2.2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/stoprocent/noble.git"

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

@@ -239,7 +239,7 @@ describe('hci-socket bindings', () => {
       should(bindings._connectionQueue[0].params).eql({ addressType: 'public' });
 
       expect(bindings._hci.createLeConn).toHaveBeenCalledTimes(1);
-      expect(bindings._hci.createLeConn).toHaveBeenCalledWith('11:22:33:44:55:66', 'public', { addressType: 'public' });
+      expect(bindings._hci.createLeConn).toHaveBeenCalledWith('11:22:33:44:55:66', 'public', { addressType: 'public' }, true);
     });
 
     it('missing peripheral, no queue, random address', () => {
@@ -252,7 +252,7 @@ describe('hci-socket bindings', () => {
       should(bindings._connectionQueue[0].params).eql({ addressType: 'random' });
 
       expect(bindings._hci.createLeConn).toHaveBeenCalledTimes(1);
-      expect(bindings._hci.createLeConn).toHaveBeenCalledWith('f3:22:33:44:55:66', 'random', { addressType: 'random' });
+      expect(bindings._hci.createLeConn).toHaveBeenCalledWith('f3:22:33:44:55:66', 'random', { addressType: 'random' }, true);
     });
 
     it('existing peripheral, no queue', () => {
@@ -271,7 +271,7 @@ describe('hci-socket bindings', () => {
       should(bindings._connectionQueue[0].params).eql('parameters');
 
       expect(bindings._hci.createLeConn).toHaveBeenCalledTimes(1);
-      expect(bindings._hci.createLeConn).toHaveBeenCalledWith('address', 'addressType', 'parameters');
+      expect(bindings._hci.createLeConn).toHaveBeenCalledWith('address', 'addressType', 'parameters', true);
     });
 
     it('missing peripheral, with queue', () => {
@@ -801,8 +801,8 @@ describe('hci-socket bindings', () => {
       expect(connectCallback).toHaveBeenCalledTimes(1);
       expect(connectCallback).toHaveBeenCalledWith('112233445566', null);
       expect(Hci.createLeConnSpy).toHaveBeenCalledTimes(2);
-      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('112233445566', 'random', { addressType: 'random' });
-      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('998877665544', 'public', { addressType: 'public' });
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('112233445566', 'random', { addressType: 'random' }, true);
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('998877665544', 'public', { addressType: 'public' }, false);
 
       should(bindings._connectionQueue).length(1);
     });
@@ -822,14 +822,16 @@ describe('hci-socket bindings', () => {
       bindings.connect('queuedId_2', { addressType: 'public' });
       bindings.connect('queuedId_3', { addressType: 'random' });
 
+      bindings.emit('reset');
+
       bindings.on('connect', connectCallback);
       bindings.onLeConnComplete(status, handle, role, addressType, address);
 
       expect(connectCallback).toHaveBeenCalledTimes(1);
       expect(connectCallback).toHaveBeenCalledWith('112233445566', null);
       expect(Hci.createLeConnSpy).toHaveBeenCalledTimes(2);
-      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('112233445566', 'random', { addressType: 'random' });
-      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('998877665544', 'public', { addressType: 'public' });
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('112233445566', 'random', { addressType: 'random' }, true);
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('998877665544', 'public', { addressType: 'public' }, false);
       expect(bindings._connectionQueue).toHaveLength(2);
     });
 
@@ -865,9 +867,9 @@ describe('hci-socket bindings', () => {
       expect(connectCallback).toHaveBeenCalledWith('998877665544', null);
 
       expect(Hci.createLeConnSpy).toHaveBeenCalledTimes(3);
-      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('112233445566', 'random', { addressType: 'random' });
-      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('998877665544', 'public', { addressType: 'public' });
-      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('aabbccddeeff', 'random', { addressType: 'random' });
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('112233445566', 'random', { addressType: 'random' }, true);
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('998877665544', 'public', { addressType: 'public' }, false);
+      expect(Hci.createLeConnSpy).toHaveBeenCalledWith('aabbccddeeff', 'random', { addressType: 'random' }, false);
       expect(bindings._connectionQueue).toHaveLength(1);
     });
   });

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

@@ -46,7 +46,6 @@ describe('hci-socket gap', () => {
     const hci = {
       on: sinon.spy(),
       once: sinon.spy(),
-      reset: sinon.spy(),
       setScanEnabled: sinon.spy(),
       setScanParameters: sinon.spy()
     };
@@ -54,21 +53,6 @@ describe('hci-socket gap', () => {
     const gap = new Gap(hci);
     gap.startScanning(true);
 
-    assert.callCount(hci.once, 1);
-    assert.calledWithExactly(hci.reset);
-  });
-
-  it('startScanningAfterReset', () => {
-    const hci = {
-      on: sinon.spy(),
-      once: sinon.spy(),
-      setScanEnabled: sinon.spy(),
-      setScanParameters: sinon.spy()
-    };
-
-    const gap = new Gap(hci);
-    gap.startScanningAfterReset(true);
-
     should(gap._scanState).equal('starting');
     should(gap._scanFilterDuplicates).equal(false);