@stoprocent/noble 2.3.5 → 2.3.7

package/lib/common/include/ThreadSafeCallback.h

@@ -72,7 +72,9 @@ inline ThreadSafeCallback::~ThreadSafeCallback() {
 
 inline void ThreadSafeCallback::call(ArgumentFunction argFunction) {
     auto argFn = new ArgumentFunction(argFunction);
-    if (threadSafeFunction_.BlockingCall(argFn) != napi_ok) {
+    // Use NonBlockingCall to avoid hanging if environment is destroyed
+    // This will queue the callback but not block waiting for it
+    if (threadSafeFunction_.NonBlockingCall(argFn) != napi_ok) {
         delete argFn;
     }
 }
@@ -83,13 +85,50 @@ inline void ThreadSafeCallback::callJsCallback(
     Napi::Reference<Napi::Value>* context,
     ArgumentFunction* argFn) {
     
-    if (argFn != nullptr) {
+    if (argFn == nullptr) {
+        return;
+    }
+
+    // Check if environment and callback are valid before proceeding
+    if (env == nullptr || jsCallback == nullptr || context == nullptr) {
+        delete argFn;
+        return;
+    }
+
+    // Check if context reference is still valid
+    if (context->IsEmpty()) {
+        delete argFn;
+        return;
+    }
+    
+    try {
         ArgumentVector args;
         (*argFn)(env, args);
         delete argFn;
 
-        if (env != nullptr && jsCallback != nullptr) {
-            jsCallback.Call(context->Value(), args);
+        // Get the receiver value and check if it's valid
+        Napi::Value receiverValue = context->Value();
+        // Check if receiver value is null or undefined (invalid)
+        if (receiverValue.IsNull() || receiverValue.IsUndefined()) {
+            return;
+        }
+
+        // Attempt to call the callback with error handling
+        // If the environment is being destroyed, this may fail
+        // Note: N-API errors don't throw C++ exceptions, so this won't catch
+        // napi_open_callback_scope failures, but it helps with other cases
+        try {
+            jsCallback.Call(receiverValue, args);
+        } catch (const std::exception&) {
+            // Silently ignore exceptions - environment might be destroyed
+        } catch (...) {
+            // Catch any other exceptions during callback execution
         }
+    } catch (const std::exception&) {
+        // If argument building fails, just clean up
+        delete argFn;
+    } catch (...) {
+        // Catch any other exceptions and clean up
+        delete argFn;
     }
 }

package/lib/mac/src/ble_manager.h

@@ -16,6 +16,7 @@
 @property NSMutableDictionary *peripherals;
 @property NSMutableDictionary *mtus;
 @property NSMutableSet *discovered;
+@property (strong) dispatch_source_t stateCheckTimer;
 
 
 - (instancetype)init: (const Napi::Value&) receiver with: (const Napi::Function&) callback;

package/lib/mac/src/ble_manager.mm

@@ -21,6 +21,27 @@
         self.discovered = [NSMutableSet set];
         self.peripherals = [NSMutableDictionary dictionaryWithCapacity:10];
         self.mtus = [NSMutableDictionary dictionaryWithCapacity:10];
+        
+        // Set up periodic state checking to handle sleep/wake cycles using GCD timer
+        // Check every 2 seconds for state changes on the same dispatch queue
+        self.stateCheckTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, self.dispatchQueue);
+        if (self.stateCheckTimer) {
+            dispatch_source_set_timer(self.stateCheckTimer, 
+                                    dispatch_time(DISPATCH_TIME_NOW, 2.0 * NSEC_PER_SEC),
+                                    2.0 * NSEC_PER_SEC, 
+                                    0.1 * NSEC_PER_SEC); // 100ms leeway
+            __weak typeof(self) weakSelf = self;
+            dispatch_source_set_event_handler(self.stateCheckTimer, ^{
+                __strong typeof(weakSelf) strongSelf = weakSelf;
+                if (strongSelf) {
+                    CBManagerState currentState = strongSelf.centralManager.state;
+                    if (currentState != strongSelf.lastState) {
+                        [strongSelf centralManagerDidUpdateState:strongSelf.centralManager];
+                    }
+                }
+            });
+            dispatch_resume(self.stateCheckTimer);
+        }
     }
     return self;
 }
@@ -519,5 +540,12 @@
     return nil;
 }
 
-@end
+- (void)dealloc {
+    // Clean up GCD timer
+    if (self.stateCheckTimer) {
+        dispatch_source_cancel(self.stateCheckTimer);
+        self.stateCheckTimer = nil;
+    }
+}
 
+@end

package/lib/noble.js

@@ -188,10 +188,12 @@ class Noble extends EventEmitter {
     const self = this;
     const scan = (state) => {
       if (state !== 'poweredOn') {
-        self.once('stateChange', scan.bind(self));
+        const boundScan = scan.bind(self);
+        self.once('stateChange', boundScan);
         const error = new Error(`Could not start scanning, state is ${state} (not poweredOn)`);
 
         if (typeof callback === 'function') {
+          self.removeListener('stateChange', boundScan);
           callback(error);
         } else {
           throw error;

package/package.json

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

package/test/noble.test.js

@@ -184,6 +184,24 @@ describe('noble', () => {
       );
       expect(mockBindings.startScanning).not.toHaveBeenCalled();
     });
+
+    test('should not cause MaxListenersExceededWarning warnings after repeated unauthorized errors', async () => {
+      noble._state = 'unauthorized';
+
+      const promise = noble.waitForPoweredOnAsync(0);
+
+      for (let i = 0; i < 10; i++) {
+        try {
+          await noble.startScanningAsync([]);
+        } catch (error) {
+        }
+      }
+
+      const finalListenerCount = noble.listenerCount('stateChange');
+
+      await expect(promise).rejects.toThrow('Timeout waiting for Noble to be powered on');
+      expect(finalListenerCount).toBeLessThanOrEqual(1);
+    });
   });
 
   describe('stopScanning', () => {
@@ -421,7 +439,7 @@ describe('noble', () => {
       await expect(promise).rejects.toThrow('Timeout waiting for Noble to be powered on');
     });
 
-    test('should not cause MaxListenersExceededWarning with multiple timeout calls', async () => {
+    test('should not cause MaxListenersExceededWarning warnings with multiple timeout calls', async () => {
       noble._state = 'poweredOff';
 
       const promises = [];