@stoprocent/noble 2.1.7 → 2.3.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/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/lib/win/src/ble_manager.cc

@@ -5,6 +5,7 @@
 #include <winrt/Windows.Storage.Streams.h>
 #include <winrt/Windows.Security.Cryptography.h>
 #include <winrt/Windows.Devices.Bluetooth.h>
+#include <winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h>
 
 
 using winrt::Windows::Devices::Bluetooth::BluetoothCacheMode;
@@ -17,6 +18,7 @@ using winrt::Windows::Storage::Streams::IBuffer;
 using winrt::Windows::Storage::Streams::ByteOrder;
 using winrt::Windows::Security::Cryptography::CryptographicBuffer;
 using winrt::Windows::Devices::Bluetooth::Advertisement::BluetoothLEAdvertisementBytePattern;
+using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattSession;
 
 template <typename T> auto inFilter(std::vector<T> filter, T object)
 {
@@ -324,6 +326,10 @@ void BLEManager::OnConnected(IAsyncOperation<BluetoothLEDevice> asyncOp, AsyncSt
             peripheral.device = device;
             peripheral.connectionToken = token;
             mEmit.Connected(uuid);
+            
+            // Get GATT session to access the MTU
+            auto completed = bind2(this, &BLEManager::OnGattSessionCreated, uuid);
+            GattSession::FromDeviceIdAsync(device.BluetoothDeviceId()).Completed(completed);
         }
         else
         {
@@ -336,6 +342,46 @@ void BLEManager::OnConnected(IAsyncOperation<BluetoothLEDevice> asyncOp, AsyncSt
     }
 }
 
+void BLEManager::OnGattSessionCreated(IAsyncOperation<GattSession> asyncOp, AsyncStatus status, const std::string uuid)
+{
+    if (status == AsyncStatus::Completed)
+    {
+        auto session = asyncOp.GetResults();
+        if (session)
+        {
+            // MaxPduSize is equivalent to the MTU-3 (MTU minus ATT header)
+            // MTU = MaxPduSize + 3
+            int mtu = session.MaxPduSize();
+            mEmit.MTU(uuid, mtu);
+            
+            // Subscribe to MTU changes
+            auto onPduSizeChanged = bind2(this, &BLEManager::OnMaxPduSizeChanged, uuid);
+            
+            // Store both the session and the event token in the peripheral
+            PeripheralWinrt& peripheral = mDeviceMap[uuid];
+            peripheral.gattSession = session;
+            auto token = session.MaxPduSizeChanged(onPduSizeChanged);
+            peripheral.maxPduSizeChangedToken = token;
+        }
+        else
+        {
+            LOGE("Failed to get GattSession for device %s", uuid.c_str());
+        }
+    }
+    else
+    {
+        LOGE("Failed to create GattSession: %s", asyncStatusToString(status).c_str());
+    }
+}
+
+// Add this new method to handle the MaxPduSizeChanged event
+void BLEManager::OnMaxPduSizeChanged(GattSession session, winrt::Windows::Foundation::IInspectable object, const std::string uuid)
+{
+    // Update MTU value when it changes
+    int mtu = session.MaxPduSize();
+    mEmit.MTU(uuid, mtu);
+}
+
 bool BLEManager::Disconnect(const std::string& uuid)
 {
     CHECK_DEVICE();

package/lib/win/src/ble_manager.h

@@ -44,6 +44,8 @@ private:
     void OnScanStopped(BluetoothLEAdvertisementWatcher watcher, const BluetoothLEAdvertisementWatcherStoppedEventArgs& args);
     void OnConnected(IAsyncOperation<BluetoothLEDevice> asyncOp, AsyncStatus status, std::string uuid);
     void OnConnectionStatusChanged(BluetoothLEDevice device, winrt::Windows::Foundation::IInspectable inspectable);
+    void OnGattSessionCreated(IAsyncOperation<GattSession> asyncOp, AsyncStatus status, std::string uuid);
+    void OnMaxPduSizeChanged(GattSession session, winrt::Windows::Foundation::IInspectable object, std::string uuid);
     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);
     void OnCharacteristicsDiscovered(IAsyncOperation<GattCharacteristicsResult> asyncOp, AsyncStatus status, std::string uuid, std::string serviceId, std::vector<winrt::guid> characteristicUUIDs);

package/lib/win/src/peripheral_winrt.cc

@@ -163,6 +163,10 @@ void PeripheralWinrt::Update(const int rssiValue, const BluetoothLEAdvertisement
 void PeripheralWinrt::Disconnect()
 {
     cachedServices.clear();
+    if (gattSession.has_value() && maxPduSizeChangedToken)
+    {
+        gattSession->MaxPduSizeChanged(maxPduSizeChangedToken);
+    }
     if (device.has_value() && connectionToken)
     {
         device->Close();

package/lib/win/src/peripheral_winrt.h

@@ -4,12 +4,14 @@
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
 #include <winrt/Windows.Devices.Bluetooth.Advertisement.h>
+#include <winrt/Windows.Devices.Bluetooth.GenericAttributeProfile.h>
 
 using namespace winrt::Windows::Devices::Bluetooth::Advertisement;
 using winrt::Windows::Devices::Bluetooth::BluetoothLEDevice;
 using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattCharacteristic;
 using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattDescriptor;
 using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattDeviceService;
+using winrt::Windows::Devices::Bluetooth::GenericAttributeProfile::GattSession;
 
 #include "winrt/Windows.Devices.Bluetooth.h"
 
@@ -68,6 +70,8 @@ public:
     uint64_t bluetoothAddress;
     std::optional<BluetoothLEDevice> device;
     winrt::event_token connectionToken;
+    std::optional<GattSession> gattSession;
+    winrt::event_token maxPduSizeChangedToken;
 
 private:
     void GetServiceFromDevice(winrt::guid serviceUuid,

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.7",
+  "version": "2.3.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/stoprocent/noble.git"