@stoprocent/noble 1.16.0 → 1.17.0

package/examples/peripheral-explorer-async.js

@@ -9,7 +9,7 @@ noble.on('stateChange', async (state) => {
   if (state === 'poweredOn') {
     if (directConnect === '1') {
       await noble.stopScanningAsync();
-      await noble.connectAsync(peripheralIdOrAddress.replace(/:/g, ''))
+      await noble.connectAsync(peripheralIdOrAddress.replace(/:/g, ''));
     } else {
       await noble.startScanningAsync();
     }

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/gap.js

@@ -279,7 +279,6 @@ Gap.prototype.parseServices = function (
 
   if (leMetaEventType !== LE_META_EVENT_TYPE_SCAN_RESPONSE) {
     // reset service data every non-scan response event
-    advertisement.serviceData = [];
     advertisement.serviceUuids = [];
     advertisement.serviceSolicitationUuids = [];
   }
@@ -371,40 +370,40 @@ Gap.prototype.parseServices = function (
         }
         break;
 
-      case 0x16: // 16-bit Service Data, there can be multiple occurences
-        advertisement.serviceData.push({
-          uuid: bytes
-            .slice(0, 2)
-            .toString('hex')
-            .match(/.{1,2}/g)
-            .reverse()
-            .join(''),
-          data: bytes.slice(2, bytes.length)
-        });
-        break;
-
-      case 0x20: // 32-bit Service Data, there can be multiple occurences
-        advertisement.serviceData.push({
-          uuid: bytes
-            .slice(0, 4)
-            .toString('hex')
-            .match(/.{1,2}/g)
-            .reverse()
-            .join(''),
-          data: bytes.slice(4, bytes.length)
-        });
-        break;
-
-      case 0x21: // 128-bit Service Data, there can be multiple occurences
-        advertisement.serviceData.push({
-          uuid: bytes
-            .slice(0, 16)
+      case 0x16: // 16-bit Service Data
+      case 0x20: // 32-bit Service Data
+      case 0x21: // 128-bit Service Data
+        {
+          let uuidLength;
+          if (eirType === 0x16) {
+            uuidLength = 2;
+          } else if (eirType === 0x20) {
+            uuidLength = 4;
+          } else {
+            uuidLength = 16;
+          }
+          
+          const serviceUuid = bytes
+            .slice(0, uuidLength)
             .toString('hex')
             .match(/.{1,2}/g)
             .reverse()
-            .join(''),
-          data: bytes.slice(16, bytes.length)
-        });
+            .join('');
+          
+          // Find existing service data index
+          const existingIndex = advertisement.serviceData.findIndex(s => s.uuid === serviceUuid);
+          const serviceData = {
+            uuid: serviceUuid,
+            data: bytes.slice(uuidLength, bytes.length)
+          };
+
+          // Update or append service data
+          if (existingIndex >= 0) {
+            advertisement.serviceData[existingIndex] = serviceData;
+          } else {
+            advertisement.serviceData.push(serviceData);
+          }
+        }
         break;
 
       case 0x1f: // List of 32 bit solicitation UUIDs

package/lib/hci-socket/hci.js

@@ -928,8 +928,10 @@ Hci.prototype.processCmdCompleteEvent = function (cmd, status, result) {
     this.readBdAddr();
   } else if (cmd === LE_READ_LOCAL_SUPPORTED_FEATURES) {
     if (status === 0) {
-      const featuresLow = result.readUInt32LE(0);
-      this._isExtended = (featuresLow & (1 << 6)) !== 0;
+      // Set _isExtended based on leExtendedAdvertising bit (12)
+      this._isExtended = !!(result.readUInt32LE(0) & (1 << 12));
+
+      this.emit('leFeatures', result);
 
       if (this._isExtended) {
         this.setCodedPhySupport();

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/src/peripheral_winrt.cc

@@ -8,7 +8,7 @@ using namespace winrt::Windows::Storage::Streams;
 using winrt::Windows::Devices::Bluetooth::BluetoothCacheMode;
 using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattCharacteristicsResult;
 using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattDescriptorsResult;
-using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattDeviceServicesResult;
+using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattDeviceServicesResult;    
 using winrt::Windows::Foundation::AsyncStatus;
 using winrt::Windows::Foundation::IAsyncOperation;
 
@@ -31,6 +31,62 @@ PeripheralWinrt::~PeripheralWinrt()
     }
 }
 
+void PeripheralWinrt::ProcessServiceData(const BluetoothLEAdvertisementDataSection& ds, size_t uuidSize) 
+{
+    auto d = ds.Data();
+    auto dr = DataReader::FromBuffer(d);
+    dr.ByteOrder(ByteOrder::LittleEndian);
+    
+    std::vector<uint8_t> data;
+    std::string uuidStr;
+
+    if (uuidSize == 16) { // 128-bit UUID
+        uint64_t low = dr.ReadUInt64();
+        uint64_t high = dr.ReadUInt64();
+        
+        char uuid[37];
+        snprintf(uuid, sizeof(uuid), 
+                "%08x-%04x-%04x-%04x-%012llx",
+                (uint32_t)((high >> 32) & 0xFFFFFFFF),
+                (uint16_t)((high >> 16) & 0xFFFF),
+                (uint16_t)(high & 0xFFFF),
+                (uint16_t)((low >> 48) & 0xFFFF),
+                (unsigned long long)(low & 0xFFFFFFFFFFFF));
+        uuidStr = uuid;
+    } 
+    else { // 16-bit or 32-bit UUID
+        char uuid[9];  // Max 8 chars for 32-bit UUID + null terminator
+        if (uuidSize == 2) {
+            uint16_t serviceUuid = dr.ReadUInt16();
+            snprintf(uuid, sizeof(uuid), "%04x", serviceUuid);
+        } else { // 4 bytes
+            uint32_t serviceUuid = dr.ReadUInt32();
+            snprintf(uuid, sizeof(uuid), "%08x", serviceUuid);
+        }
+        uuidStr = uuid;
+    }
+    
+    // Read remaining data
+    data.resize(d.Length() - uuidSize);
+    dr.ReadBytes(data);
+    
+    // Find and update existing entry or add new one
+    bool found = false;
+    for (auto& pair : serviceData) {
+        if (pair.first == uuidStr) {
+            pair.second = data;
+            found = true;
+            break;
+        }
+    }
+    
+    if (!found) {
+        serviceData.push_back(std::make_pair(uuidStr, data));
+    }
+    
+    dr.Close();
+}
+
 void PeripheralWinrt::Update(const int rssiValue, const BluetoothLEAdvertisement& advertisment,
                              const BluetoothLEAdvertisementType& advertismentType)
 {
@@ -56,7 +112,7 @@ void PeripheralWinrt::Update(const int rssiValue, const BluetoothLEAdvertisement
                 txPowerLevel -= 256;
             dr.Close();
         }
-        if (ds.DataType() == BluetoothLEAdvertisementDataTypes::ManufacturerSpecificData())
+        else if (ds.DataType() == BluetoothLEAdvertisementDataTypes::ManufacturerSpecificData())
         {
             auto d = ds.Data();
             auto dr = DataReader::FromBuffer(d);
@@ -64,6 +120,18 @@ void PeripheralWinrt::Update(const int rssiValue, const BluetoothLEAdvertisement
             dr.ReadBytes(manufacturerData);
             dr.Close();
         }
+        else if (ds.DataType() == BluetoothLEAdvertisementDataTypes::ServiceData16BitUuids())
+        {
+            ProcessServiceData(ds, 2);  // 2 bytes for 16-bit UUID
+        }
+        else if (ds.DataType() == BluetoothLEAdvertisementDataTypes::ServiceData32BitUuids())
+        {
+            ProcessServiceData(ds, 4);  // 4 bytes for 32-bit UUID
+        }
+        else if (ds.DataType() == BluetoothLEAdvertisementDataTypes::ServiceData128BitUuids())
+        {
+            ProcessServiceData(ds, 16);  // 16 bytes for 128-bit UUID
+        }
     }
 
     serviceUuids.clear();
@@ -258,7 +326,8 @@ void PeripheralWinrt::GetDescriptor(winrt::guid serviceUuid, winrt::guid charact
                 [=](std::optional<GattCharacteristic> characteristic) {
                     if (characteristic)
                     {
-                        GetDescriptorFromCharacteristic(*characteristic, descriptorUuid, callback);
+                        GetDescriptorFromCharacteristic(*characteristic, descriptorUuid,
+                                                            callback);
                     }
                     else
                     {

package/lib/win/src/peripheral_winrt.h

@@ -79,4 +79,5 @@ private:
     GetDescriptorFromCharacteristic(GattCharacteristic characteristic, winrt::guid descriptorUuid,
                                     std::function<void(std::optional<GattDescriptor>)> callback);
     std::unordered_map<winrt::guid, CachedService> cachedServices;
+    void ProcessServiceData(const BluetoothLEAdvertisementDataSection& ds, size_t uuidSize);
 };

package/package.json

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

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

@@ -1085,6 +1085,151 @@ describe('hci-socket gap', () => {
 
       assert.notCalled(discoverCallback);
     });
+
+    it('should accumulate different service UUIDs and data across multiple reports', () => {
+      const hci = {
+        on: sinon.spy()
+      };
+
+      const status = 'status';
+      const type = 0x01;
+      const address = 'a:d:d:r:e:s:s';
+      const addressType = 'addressType';
+      const rssi = 'rssi';
+
+      // First report
+      const eirType1 = 0x16;
+      const serviceUuid1 = Buffer.from([0x01, 0x02]);
+      const serviceData1 = Buffer.from([0x03, 0x04]);
+      const eirLength1 = serviceUuid1.length + serviceData1.length + 1;
+      const eirLengthAndType1 = Buffer.from([eirLength1, eirType1]);
+      const eir1 = Buffer.concat([eirLengthAndType1, serviceUuid1, serviceData1]);
+
+      const gap = new Gap(hci);
+      gap.onHciLeAdvertisingReport(status, type, address, addressType, eir1, rssi);
+
+      // Second report with different UUID and data
+      const eirType2 = 0x16;
+      const serviceUuid2 = Buffer.from([0x05, 0x06]);
+      const serviceData2 = Buffer.from([0x07, 0x08]);
+      const eirLength2 = serviceUuid2.length + serviceData2.length + 1;
+      const eirLengthAndType2 = Buffer.from([eirLength2, eirType2]);
+      const eir2 = Buffer.concat([eirLengthAndType2, serviceUuid2, serviceData2]);
+
+      gap.onHciLeAdvertisingReport(status, type, address, addressType, eir2, rssi);
+
+      const expectedDiscovery = {
+        address,
+        addressType,
+        connectable: true,
+        advertisement: {
+          localName: undefined,
+          txPowerLevel: undefined,
+          manufacturerData: undefined,
+          serviceData: [
+            {
+              uuid: '0201',
+              data: serviceData1
+            },
+            {
+              uuid: '0605',
+              data: serviceData2
+            }
+          ],
+          serviceUuids: [],
+          solicitationServiceUuids: [],
+          serviceSolicitationUuids: []
+        },
+        rssi,
+        count: 2,
+        hasScanResponse: false
+      };
+      
+      should(gap._discoveries[address]).deepEqual(expectedDiscovery);
+    });
+
+    it('should overwrite service data when receiving same UUID with different data', () => {
+      const hci = {
+        on: sinon.spy()
+      };
+
+      const status = 'status';
+      const type = 0x01;
+      const address = 'a:d:d:r:e:s:s';
+      const addressType = 'addressType';
+      const rssi = 'rssi';
+
+      // First report
+      const eirType = 0x16;
+      const serviceUuid = Buffer.from([0x01, 0x02]);
+      const serviceData1 = Buffer.from([0x03, 0x04]);
+      const eirLength1 = serviceUuid.length + serviceData1.length + 1;
+      const eirLengthAndType1 = Buffer.from([eirLength1, eirType]);
+      const eir1 = Buffer.concat([eirLengthAndType1, serviceUuid, serviceData1]);
+
+      const gap = new Gap(hci);
+      gap.onHciLeAdvertisingReport(status, type, address, addressType, eir1, rssi);
+
+      // Verify first state
+      const expectedDiscovery1 = {
+        address,
+        addressType,
+        connectable: true,
+        advertisement: {
+          localName: undefined,
+          txPowerLevel: undefined,
+          manufacturerData: undefined,
+          serviceData: [
+            {
+              uuid: '0201',
+              data: serviceData1
+            }
+          ],
+          serviceUuids: [],
+          solicitationServiceUuids: [],
+          serviceSolicitationUuids: []
+        },
+        rssi,
+        count: 1,
+        hasScanResponse: false
+      };
+      
+      should(gap._discoveries[address]).deepEqual(expectedDiscovery1);
+
+      // Second report with same UUID but different data
+      const serviceData2 = Buffer.from([0x05, 0x06]);
+      const eirLength2 = serviceUuid.length + serviceData2.length + 1;
+      const eirLengthAndType2 = Buffer.from([eirLength2, eirType]);
+      const eir2 = Buffer.concat([eirLengthAndType2, serviceUuid, serviceData2]);
+
+      gap.onHciLeAdvertisingReport(status, type, address, addressType, eir2, rssi);
+
+      // Verify data was overwritten
+      const expectedDiscovery2 = {
+        address,
+        addressType,
+        connectable: true,
+        advertisement: {
+          localName: undefined,
+          txPowerLevel: undefined,
+          manufacturerData: undefined,
+          serviceData: [
+            {
+              uuid: '0201',
+              data: serviceData2
+            }
+          ],
+          serviceUuids: [],
+          solicitationServiceUuids: [],
+          serviceSolicitationUuids: []
+        },
+        rssi,
+        count: 2,
+        hasScanResponse: false
+      };
+      
+      should(gap._discoveries[address]).deepEqual(expectedDiscovery2);
+    });
   });
 
   it('should reset the service data on non scan responses', () => {

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

@@ -744,7 +744,7 @@ describe('hci-socket hci', () => {
         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
+          const result = Buffer.from("bd5f660000000000", "hex");
       
           hci.processCmdCompleteEvent(cmd, status, result);