@stoprocent/noble 2.0.1 → 2.1.0

package/README.md

@@ -8,7 +8,7 @@ A Node.js BLE (Bluetooth Low Energy) central module.
 
 Want to implement a peripheral? Check out [@stoprocent/bleno](https://github.com/stoprocent/bleno).
 
-__NOTE__: Currently, running both noble (central) and bleno (peripheral) together only works with macOS bindings or when using separate HCI/UART dongles. Support for running both on a single HCI adapter (e.g., on Linux systems) will be added in future releases.
+> **Note:** Currently, running both noble (central) and bleno (peripheral) together only works with macOS bindings or when using separate HCI/UART dongles. Support for running both on a single HCI adapter (e.g., on Linux systems) will be added in future releases.
 
 ## About This Fork
 
@@ -360,6 +360,8 @@ const characteristics = await service.discoverCharacteristicsAsync([characterist
 
 ### Characteristic Methods
 
+> **Note:** The `data` event is the primary event for handling both read responses and notifications. When using the event-based approach, you can differentiate between read responses and notifications using the `isNotification` parameter. The previously used `read` event **has been deprecated and removed**. Instead, use the `data` event with `isNotification=false` to identify read responses.
+
 ```typescript
 // Read characteristic value
 const data = await characteristic.readAsync();
@@ -373,10 +375,34 @@ await characteristic.subscribeAsync();
 // Unsubscribe from notifications
 await characteristic.unsubscribeAsync();
 
+// Receive notifications using async iterator
+for await (const data of characteristic.notificationsAsync()) {
+  console.log(`Received notification: ${data}`);
+}
+
 // Discover descriptors
 const descriptors = await characteristic.discoverDescriptorsAsync();
 ```
 
+### Characteristic Events
+
+```typescript
+// Receive data (both read responses and notifications)
+characteristic.on('data', (data: Buffer, isNotification: boolean) => {
+  console.log(`Received ${isNotification ? 'notification' : 'read response'}: ${data}`);
+});
+
+// Write completion 
+characteristic.on('write', (error: Error | undefined) => {
+  console.log('Write completed');
+});
+
+// Descriptor discovery
+characteristic.on('descriptorsDiscover', (descriptors: Descriptor[]) => {
+  console.log('Descriptors discovered');
+});
+```
+
 ### Descriptor Methods
 
 ```typescript
@@ -604,4 +630,4 @@ The following environment variables can configure noble's behavior:
 | BLUETOOTH_HCI_SOCKET_UART_PORT | UART port for HCI communication | none | `export BLUETOOTH_HCI_SOCKET_UART_PORT=/dev/ttyUSB0` |
 | BLUETOOTH_HCI_SOCKET_UART_BAUDRATE | UART baudrate | 1000000 | `export BLUETOOTH_HCI_SOCKET_UART_BAUDRATE=1000000` |
 
-**Note:** The preferred method for configuration is now using the `withBindings()` API rather than environment variables.
+> **Note:** The preferred method for configuration is now using the `withBindings()` API rather than environment variables.

package/examples/echo.js

@@ -48,34 +48,32 @@ async function connectAndSetUp (peripheral) {
     console.log('Discovered services and characteristics');
     const echoCharacteristic = characteristics[0];
 
-    // data callback receives notifications
-    echoCharacteristic.on('read', (data, isNotification) => {
-      console.log(`Received: "${data}"`);
-    });
-
-    // subscribe to be notified whenever the peripheral update the characteristic
-    try {
-      await echoCharacteristic.subscribeAsync();
-      console.log('Subscribed for echoCharacteristic notifications');
-    } catch (error) {
-      console.error('Error subscribing to echoCharacteristic:', error);
-      return;
-    }
-
     // create an interval to send data to the service
     let count = 0;
-    setInterval(async () => {
+    const interval = setInterval(async () => {
       count++;
       const message = Buffer.from(`hello, ble ${count}`, 'utf-8');
       console.log(`Sending:  '${message}'`);
       await echoCharacteristic.writeAsync(message, false);
-    }, 2500);
+    }, 500);
+
+    // subscribe to be notified whenever the peripheral update the characteristic
+    try {
+      for await (const data of echoCharacteristic.notificationsAsync()) {
+        console.log(`Received: "${data}"`);
+        if (count >= 15) {
+          break;
+        }
+      }
+    } finally {
+      clearInterval(interval);
+      await peripheral.disconnectAsync();
+      noble.stop();
+    }
 
   } catch (error) {
     console.error('Error during connection setup:', error);
   }
-
-  peripheral.on('disconnect', () => console.log('disconnected'));
 }
 
 // Handle process termination

package/index.d.ts

@@ -174,36 +174,37 @@ declare module '@stoprocent/noble' {
     
         readAsync(): Promise<Buffer>;
         writeAsync(data: Buffer, withoutResponse: boolean): Promise<void>;
-        broadcastAsync(broadcast: boolean): Promise<void>;
-        notifyAsync(notify: boolean): Promise<void>;
-        discoverDescriptorsAsync(): Promise<Descriptor[]>;
         subscribeAsync(): Promise<void>;
         unsubscribeAsync(): Promise<void>;
+        discoverDescriptorsAsync(): Promise<Descriptor[]>;
+        broadcastAsync(broadcast: boolean): Promise<void>;
+        
+        /**
+         * Async iterator for receiving notifications from the characteristic.
+         * Automatically handles subscription and cleanup when finished.
+         * @returns AsyncGenerator that yields notification data
+         */
+        notificationsAsync(): AsyncGenerator<Buffer, void, unknown>;
         
         read(callback?: (error: Error | undefined, data: Buffer) => void): void;
         write(data: Buffer, withoutResponse: boolean, callback?: (error: Error | undefined) => void): void;
-        broadcast(broadcast: boolean, callback?: (error: Error | undefined) => void): void;
-        notify(notify: boolean, callback?: (error: Error | undefined) => void): void;
-        discoverDescriptors(callback?: (error: Error | undefined, descriptors: Descriptor[]) => void): void;
         subscribe(callback?: (error: Error | undefined) => void): void;
         unsubscribe(callback?: (error: Error | undefined) => void): void;
+        discoverDescriptors(callback?: (error: Error | undefined, descriptors: Descriptor[]) => void): void;
+        broadcast(broadcast: boolean, callback?: (error: Error | undefined) => void): void;
         
         toString(): string;
         
-        on(event: "read", listener: (data: Buffer, isNotification: boolean) => void): this;
-        on(event: "write", withoutResponse: boolean, listener: (error: Error | undefined) => void): this;
-        on(event: "broadcast", listener: (state: string) => void): this;
-        on(event: "notify", listener: (state: string) => void): this;
         on(event: "data", listener: (data: Buffer, isNotification: boolean) => void): this;
+        on(event: "write", listener: (error: Error | undefined) => void): this;
         on(event: "descriptorsDiscover", listener: (descriptors: Descriptor[]) => void): this;
+        on(event: "broadcast", listener: (state: string) => void): this;
         on(event: string, listener: Function): this;
     
-        once(event: "read", listener: (data: Buffer, isNotification: boolean) => void): this;
-        once(event: "write", withoutResponse: boolean, listener: (error: Error | undefined) => void): this;
-        once(event: "broadcast", listener: (state: string) => void): this;
-        once(event: "notify", listener: (state: string) => void): this;
         once(event: "data", listener: (data: Buffer, isNotification: boolean) => void): this;
+        once(event: "write", listener: (error: Error | undefined) => void): this;
         once(event: "descriptorsDiscover", listener: (descriptors: Descriptor[]) => void): this;
+        once(event: "broadcast", listener: (state: string) => void): this;
         once(event: string, listener: Function): this;
     }
     

package/lib/characteristic.js

@@ -9,6 +9,7 @@ class Characteristic extends EventEmitter {
     this._noble = noble;
     this._peripheralId = peripheralId;
     this._serviceUuid = serviceUuid;
+    this._isNotifying = false;
 
     this.uuid = uuid;
     this.name = null;
@@ -21,6 +22,9 @@ class Characteristic extends EventEmitter {
       this.name = characteristic.name;
       this.type = characteristic.type;
     }
+    
+    // set the isNotifying state
+    this.on('notify', (state, error) => !error ? this._isNotifying = state : null);
   }
 
   toString () {
@@ -39,13 +43,13 @@ class Characteristic extends EventEmitter {
         // 'read' for non-notifications is only present for backwards compatbility
         if (!isNotification) {
           // remove the listener
-          this.removeListener('read', onRead);
+          this.removeListener('data', onRead);
           // call the callback
           callback(error, data);
         }
       };
 
-      this.on('read', onRead);
+      this.on('data', onRead);
     }
 
     this._noble.read(
@@ -97,28 +101,38 @@ class Characteristic extends EventEmitter {
     });
   }
 
-  broadcast (broadcast, callback) {
-    if (callback) {
-      this.once('broadcast', error => callback(error));
-    }
+  subscribe (callback) {
+    this._notify(true, callback);
+  }
 
-    this._noble.broadcast(
-      this._peripheralId,
-      this._serviceUuid,
-      this.uuid,
-      broadcast
-    );
+  async subscribeAsync () {
+    return this._noble._withDisconnectHandler(this._peripheralId, () => {
+      return new Promise((resolve, reject) => {
+        this.subscribe((error, state) => error ? reject(error) : resolve(state));
+      });
+    });
   }
 
-  async broadcastAsync (broadcast) {
+  unsubscribe (callback) {
+    this._notify(false, callback);
+  }
+
+  async unsubscribeAsync () {
     return this._noble._withDisconnectHandler(this._peripheralId, () => {
       return new Promise((resolve, reject) => {
-        this.broadcast(broadcast, (state, error) => error ? reject(error) : resolve(state));
+        this.unsubscribe(error => error ? reject(error) : resolve());
       });
     });
   }
 
-  notify (notify, callback) {
+  _notify (notify, callback) {
+    if (notify === this._isNotifying) {
+      if (callback) {
+        callback(null, this._isNotifying);
+      }
+      return;
+    }
+
     if (callback) {
       this.once('notify', (state, error) => callback(error, state));
     }
@@ -131,54 +145,115 @@ class Characteristic extends EventEmitter {
     );
   }
 
-  async notifyAsync (notify) {
-    return this._noble._withDisconnectHandler(this._peripheralId, () => {
-      return new Promise((resolve, reject) => {
-        this.notify(notify, (error, state) => error ? reject(error) : resolve(state));
-      });
-    });
-  }
-
-  subscribe (callback) {
-    this.notify(true, callback);
+  async *notificationsAsync () {
+    const notifications = [];
+    let notifying = true;
+    
+    // Main data listener that populates the notifications array
+    const dataListener = (data, isNotification, error) => {
+      if (error) {
+        notifying = false;
+      }
+      if (isNotification) {
+        notifications.push(data);
+      }
+    };
+    
+    // Notify state listener
+    const notifyListener = (state) => {
+      notifying = state;
+    };
+    
+    // Set up listeners
+    this.on('data', dataListener);
+    this.on('notify', notifyListener);
+    
+    try {
+      // Start subscribing
+      await this.subscribeAsync();
+      
+      // Process notifications
+      while (notifying || notifications.length > 0) {
+        if (notifications.length > 0) {
+          // If we have notifications, yield them
+          yield notifications.shift();
+        } else if (notifying) {
+          // Wait for more data or notify=false
+          await new Promise(resolve => {
+            // Create listeners that automatically remove themselves
+            const tempDataListener = (...args) => {
+              this.removeListener('data', tempDataListener);
+              this.removeListener('notify', tempNotifyListener);
+              resolve();
+            };
+            
+            const tempNotifyListener = (state) => {
+              if (state === false) {
+                this.removeListener('data', tempDataListener);
+                this.removeListener('notify', tempNotifyListener);
+                resolve();
+              }
+            };
+            
+            // Set up temporary listeners
+            this.once('data', tempDataListener);
+            this.once('notify', tempNotifyListener);
+            
+            // Clean up if we already have notifications (race condition)
+            if (notifications.length > 0) {
+              this.removeListener('data', tempDataListener);
+              this.removeListener('notify', tempNotifyListener);
+              resolve();
+            }
+          });
+        }
+      }
+    } finally {
+      // Clean up all listeners
+      this.removeListener('data', dataListener);
+      this.removeListener('notify', notifyListener);
+      // Unsubscribe
+      await this.unsubscribeAsync();
+    }
   }
 
-  async subscribeAsync () {
-    return this._noble._withDisconnectHandler(this._peripheralId, () => {
-      return new Promise((resolve, reject) => {
-        this.subscribe((error, state) => error ? reject(error) : resolve(state));
-      });
-    });
-  }
+  discoverDescriptors (callback) {
+    if (callback) {
+      this.once('descriptorsDiscover', (descriptors, error) => callback(error, descriptors));
+    }
 
-  unsubscribe (callback) {
-    this.notify(false, callback);
+    this._noble.discoverDescriptors(
+      this._peripheralId,
+      this._serviceUuid,
+      this.uuid
+    );
   }
 
-  async unsubscribeAsync () {
+  async discoverDescriptorsAsync () {
     return this._noble._withDisconnectHandler(this._peripheralId, () => {
       return new Promise((resolve, reject) => {
-        this.unsubscribe(error => error ? reject(error) : resolve());
+        this.discoverDescriptors((error, descriptors) => error ? reject(error) : resolve(descriptors));
       });
     });
   }
 
-  discoverDescriptors (callback) {
+  broadcast (broadcast, callback) {
     if (callback) {
-      this.once('descriptorsDiscover', (descriptors, error) => callback(error, descriptors));
+      this.once('broadcast', error => callback(error));
     }
 
-    this._noble.discoverDescriptors(
+    this._noble.broadcast(
       this._peripheralId,
       this._serviceUuid,
-      this.uuid
+      this.uuid,
+      broadcast
     );
   }
 
-  async discoverDescriptorsAsync () {
+  async broadcastAsync (broadcast) {
     return this._noble._withDisconnectHandler(this._peripheralId, () => {
       return new Promise((resolve, reject) => {
-        this.discoverDescriptors((error, descriptors) => error ? reject(error) : resolve(descriptors));
+        this.broadcast(broadcast, (state, error) => error ? reject(error) : resolve(state));
       });
     });
   }

package/lib/noble.js

@@ -247,26 +247,74 @@ class Noble extends EventEmitter {
     const deviceQueue = [];
     let scanning = true;
     
-    this.once('scanStop', () => scanning = false);
+    // Main discover listener to add devices to the queue
+    const discoverListener = peripheral => deviceQueue.push(peripheral);
     
-    const listener = peripheral => deviceQueue.push(peripheral);
-    this.on('discover', listener);
+    // State change listener
+    const scanStopListener = () => scanning = false;
     
-    await this.startScanningAsync();
+    // Set up listeners
+    this.on('discover', discoverListener);
+    this.once('scanStop', scanStopListener);
     
-    while (scanning || deviceQueue.length > 0) {
-        if (deviceQueue.length > 0) {
-            yield deviceQueue.shift();
-        } else {
-            await new Promise(resolve => {
-                const tempListener = () => resolve();
-                this.once('discover', tempListener);
-                setTimeout(tempListener, 1000);
-            });
+    try {
+        // Start the scanning process
+        await this.startScanningAsync();
+        
+        // Process discovered devices
+        while (scanning || deviceQueue.length > 0) {
+            if (deviceQueue.length > 0) {
+                // If we have devices in the queue, yield them
+                yield deviceQueue.shift();
+            } else if (scanning) {
+                // Wait for either a new device or scan stop
+                await new Promise(resolve => {
+                    const tempDiscoverListener = () => resolve();
+                    
+                    // Set up a temporary discover listener
+                    this.once('discover', tempDiscoverListener);
+                    
+                    // Set up a cleanup for when scanning stops
+                    const tempScanStopListener = () => {
+                        this.removeListener('discover', tempDiscoverListener);
+                        resolve();
+                    };
+                    this.once('scanStop', tempScanStopListener);
+                    
+                    // Handle race condition where a device might arrive during promise setup
+                    if (deviceQueue.length > 0) {
+                        this.removeListener('discover', tempDiscoverListener);
+                        this.removeListener('scanStop', tempScanStopListener);
+                        resolve();
+                    }
+                    
+                    // Optional: Add a maximum wait time, but with proper cleanup
+                    // This can be removed to eliminate timer dependency
+                    if (scanning) {
+                        const timeoutId = setTimeout(() => {
+                            this.removeListener('discover', tempDiscoverListener);
+                            this.removeListener('scanStop', tempScanStopListener);
+                            resolve();
+                        }, 1000);
+                        
+                        // Make sure we clear the timeout if we resolve before timeout
+                        const clearTimeoutFn = () => clearTimeout(timeoutId);
+                        this.once('discover', clearTimeoutFn);
+                        this.once('scanStop', clearTimeoutFn);
+                    }
+                });
+            }
+        }
+    } finally {
+        // Clean up listeners
+        this.removeListener('discover', discoverListener);
+        this.removeListener('scanStop', scanStopListener);
+        
+        // Ensure scanning is stopped
+        if (scanning) {
+            await this.stopScanningAsync();
         }
     }
-
-    await this.stopScanningAsync();
   }
 
   _onScanStop () {
@@ -578,7 +626,7 @@ class Noble extends EventEmitter {
     const characteristic = this._characteristics[peripheralId][serviceUuid][characteristicUuid];
 
     if (characteristic) {
-      characteristic.emit('read', data, isNotification, error);
+      characteristic.emit('data', data, isNotification, error);
     } else {
       this.emit('warning', `unknown peripheral ${peripheralId}, ${serviceUuid}, ${characteristicUuid} read!`);
     }

package/package.json

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

package/test/lib/characteristic.test.js

@@ -80,9 +80,9 @@ describe('characteristic', () => {
       const callback = jest.fn();
 
       characteristic.read(callback);
-      characteristic.emit('read');
+      characteristic.emit('data');
       // Check for single callback
-      characteristic.emit('read');
+      characteristic.emit('data');
 
       expect(callback).toHaveBeenCalledWith(undefined, undefined);
       expect(callback).toHaveBeenCalledTimes(1);
@@ -99,9 +99,9 @@ describe('characteristic', () => {
       const data = 'data';
 
       characteristic.read(callback);
-      characteristic.emit('read', data);
+      characteristic.emit('data', data);
       // Check for single callback
-      characteristic.emit('read', data);
+      characteristic.emit('data', data);
 
       expect(callback).toHaveBeenCalledWith(undefined, data);
       expect(callback).toHaveBeenCalledTimes(1);
@@ -118,9 +118,9 @@ describe('characteristic', () => {
       const data = 'data';
 
       characteristic.read(callback);
-      characteristic.emit('read', data, true);
+      characteristic.emit('data', data, true);
       // Check for single callback
-      characteristic.emit('read', data, true);
+      characteristic.emit('data', data, true);
 
       expect(callback).not.toHaveBeenCalled();
       expect(mockNoble.read).toHaveBeenCalledWith(
@@ -135,7 +135,7 @@ describe('characteristic', () => {
   describe('readAsync', () => {
     test('should delegate to noble', async () => {
       const promise = characteristic.readAsync();
-      characteristic.emit('read');
+      characteristic.emit('data');
       
       await expect(promise).resolves.toBeUndefined();
       expect(mockNoble.read).toHaveBeenCalledWith(
@@ -148,7 +148,7 @@ describe('characteristic', () => {
 
     test('should returns without data', async () => {
       const promise = characteristic.readAsync();
-      characteristic.emit('read');
+      characteristic.emit('data');
       
       await expect(promise).resolves.toBeUndefined();
       expect(mockNoble.read).toHaveBeenCalledWith(
@@ -163,7 +163,7 @@ describe('characteristic', () => {
       const data = 'data';
 
       const promise = characteristic.readAsync();
-      characteristic.emit('read', data);
+      characteristic.emit('data', data);
       
       await expect(promise).resolves.toEqual(data);
       expect(mockNoble.read).toHaveBeenCalledWith(
@@ -179,7 +179,7 @@ describe('characteristic', () => {
       const data = 'data';
 
       const promise = characteristic.readAsync();
-      characteristic.emit('read', data, true);
+      characteristic.emit('data', data, true);
       
       await expect(promise).resolves.toBeUndefined();
       expect(mockNoble.read).toHaveBeenCalledWith(
@@ -418,7 +418,7 @@ describe('characteristic', () => {
 
   describe('notify', () => {
     test('should delegate to noble, true', () => {
-      characteristic.notify(true);
+      characteristic._notify(true);
 
       expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
@@ -430,7 +430,10 @@ describe('characteristic', () => {
     });
 
     test('should delegate to noble, false', () => {
-      characteristic.notify(false);
+      
+      characteristic._isNotifying = true;
+
+      characteristic._notify(false);
 
       expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
@@ -444,7 +447,7 @@ describe('characteristic', () => {
     test('should callback', () => {
       const callback = jest.fn();
 
-      characteristic.notify(true, callback);
+      characteristic._notify(true, callback);
       characteristic.emit('notify');
       // Check for single callback
       characteristic.emit('notify');
@@ -461,36 +464,6 @@ describe('characteristic', () => {
     });
   });
 
-  describe('notifyAsync', () => {
-    test('should delegate to noble, true', async () => {
-      const promise = characteristic.notifyAsync(true);
-      characteristic.emit('notify');
-      
-      await expect(promise).resolves.toBeUndefined();
-      expect(mockNoble.notify).toHaveBeenCalledWith(
-        mockPeripheralId,
-        mockServiceUuid,
-        mockUuid,
-        true
-      );
-      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
-    });
-
-    test('should delegate to noble, false', async () => {
-      const promise = characteristic.notifyAsync(false);
-      characteristic.emit('notify');
-      
-      await expect(promise).resolves.toBeUndefined();
-      expect(mockNoble.notify).toHaveBeenCalledWith(
-        mockPeripheralId,
-        mockServiceUuid,
-        mockUuid,
-        false
-      );
-      expect(mockNoble.notify).toHaveBeenCalledTimes(1);
-    });
-  });
-
   describe('subscribe', () => {
     test('should delegate to noble notify, true', () => {
       characteristic.subscribe();
@@ -542,6 +515,7 @@ describe('characteristic', () => {
 
   describe('unsubscribe', () => {
     test('should delegate to noble notify, false', () => {
+      characteristic._isNotifying = true;
       characteristic.unsubscribe();
 
       expect(mockNoble.notify).toHaveBeenCalledWith(
@@ -555,13 +529,13 @@ describe('characteristic', () => {
 
     test('should callback', () => {
       const callback = jest.fn();
-
+      characteristic._isNotifying = true;
       characteristic.unsubscribe(callback);
-      characteristic.emit('notify');
+      characteristic.emit('notify', false);
       // Check for single callback
-      characteristic.emit('notify');
+      characteristic.emit('notify', false);
 
-      expect(callback).toHaveBeenCalledWith(undefined, undefined);
+      expect(callback).toHaveBeenCalledWith(undefined, false);
       expect(callback).toHaveBeenCalledTimes(1);
       expect(mockNoble.notify).toHaveBeenCalledWith(
         mockPeripheralId,
@@ -574,9 +548,10 @@ describe('characteristic', () => {
   });
 
   describe('unsubscribeAsync', () => {
-    test('should delegate to noble notify, false', async () => {
+    test('should delegate to noble notify, false', async () => {  
+      characteristic._isNotifying = true;
       const promise = characteristic.unsubscribeAsync();
-      characteristic.emit('notify');
+      characteristic.emit('notify', false);
       
       await expect(promise).resolves.toBeUndefined();
       expect(mockNoble.notify).toHaveBeenCalledWith(
@@ -589,6 +564,187 @@ describe('characteristic', () => {
     });
   });
 
+  describe('notificationsAsync', () => {
+    test('should call subscribeAsync and unsubscribeAsync', async () => {
+      // Spy on subscribeAsync and unsubscribeAsync
+      jest.spyOn(characteristic, 'subscribeAsync');
+      jest.spyOn(characteristic, 'unsubscribeAsync');
+
+      // Create an async generator
+      const iterator = characteristic.notificationsAsync();
+      
+      // Wait for iterator setup with setTimeout
+      setTimeout(() => {
+        // Emit a data event with non-notification
+        characteristic.emit('notify', true);
+        characteristic.emit('data', 'test-data-1', true);
+      }, 10);
+      
+      // Get the value from the iterator
+      const result = await iterator.next();
+
+      // Stop the iteration with timeout to ensure proper sequence
+      setTimeout(() => {
+        characteristic.emit('notify', false);
+      }, 10);
+      
+      // We need to consume until the end to ensure unsubscribeAsync is called
+      await iterator.next();
+      
+      // Verify that subscribeAsync was called
+      expect(characteristic.subscribeAsync).toHaveBeenCalledTimes(1);
+      expect(characteristic.unsubscribeAsync).toHaveBeenCalledTimes(1);
+      
+      // Check the yielded data
+      expect(result.value).toEqual('test-data-1');
+      expect(result.done).toBe(false);
+    });
+  
+    test('should yield multiple data values', async () => {
+      const data1 = 'test-data-1';
+      const data2 = 'test-data-2';
+      
+      // Assume that the characteristic is already notifying
+      characteristic._isNotifying = true;
+
+      // Setup the async iterator
+      const iterator = characteristic.notificationsAsync();
+      
+      // Emit events with setTimeout to ensure proper sequence
+      setTimeout(() => {
+        // Emit first data event (non-notification)
+        characteristic.emit('data', data1, true);
+      }, 10);
+      
+      // Get first value
+      const result1 = await iterator.next();
+      
+      // Emit second data event with timeout
+      setTimeout(() => {
+        characteristic.emit('data', data2, true);
+      }, 10);
+      
+      // Get second value
+      const result2 = await iterator.next();
+      
+      // End the notifications
+      setTimeout(() => {
+        characteristic.emit('notify', false);
+      }, 10);
+      
+      // Consume until complete
+      await iterator.next();
+      
+      // Check the yielded values
+      expect(result1.value).toEqual(data1);
+      expect(result1.done).toBe(false);
+      expect(result2.value).toEqual(data2);
+      expect(result2.done).toBe(false);
+    });
+  
+    test('should ignore notification data', async () => {
+      // Setup the async iterator
+      const iterator = characteristic.notificationsAsync();
+      
+      // Assume that the characteristic is already notifying
+      characteristic._isNotifying = true;
+
+      setTimeout(() => {
+        // Emit real data
+        characteristic.emit('data', 'actual-data', true);
+        
+        // Emit notification data that should be ignored
+        characteristic.emit('data', 'ignored-data', true);
+      }, 10);
+      
+      // Get the value
+      const result = await iterator.next();
+      
+      // End the notifications
+      setTimeout(() => {
+        characteristic.emit('notify', false);
+      }, 10);
+      
+      // Consume until complete
+      await iterator.next();
+      
+      // Check that notification data was ignored
+      expect(result.value).toEqual('actual-data');
+    });
+  
+    test('should end iteration on error', async () => {
+      // Setup the async iterator
+      const iterator = characteristic.notificationsAsync();
+      
+      setTimeout(() => {
+        // Emit an error
+        characteristic.emit('data', null, false, new Error('test error'));
+      }, 10);
+      
+      // Get the next value - should complete the iterator
+      const result = await iterator.next();
+      const doneResult = await iterator.next();
+      
+      // Check that the iteration is complete
+      expect(doneResult.done).toBe(true);
+    });
+  
+    test('should end iteration when notify is false', async () => {
+      // Setup the async iterator
+      const iterator = characteristic.notificationsAsync();
+      
+      setTimeout(() => {
+        // End the notifications
+        characteristic.emit('notify', false);
+      }, 10);
+      
+      // Get the next value - should complete the iterator
+      const result = await iterator.next();
+      
+      // Check that the iteration is complete
+      expect(result.done).toBe(true);
+    });
+  
+    // Your working test (already correct)
+    test('should handle notify event states correctly', async () => {
+      // Setup the async iterator
+      const iterator = characteristic.notificationsAsync();
+      
+      setTimeout(() => {
+        // subscribeAsync would trigger a notify event with true
+        characteristic.emit('notify', true);
+        // Emit some data
+        characteristic.emit('data', 'test-data-1', true);
+        characteristic.emit('data', 'test-data-2', true);
+        characteristic.emit('data', 'test-data-3', true);
+      }, 10);
+  
+      // Get the value
+      const result = await iterator.next();
+      expect(result.value).toEqual('test-data-1');
+      expect(result.done).toBe(false);
+  
+      const result2 = await iterator.next();
+      expect(result2.value).toEqual('test-data-2');
+      expect(result2.done).toBe(false);
+  
+      const result3 = await iterator.next();
+      expect(result3.value).toEqual('test-data-3');
+      expect(result3.done).toBe(false);
+  
+      setTimeout(() => {
+        // Now unsubscribe by emitting notify with false
+        characteristic.emit('notify', false);
+      }, 10);
+      
+      // The iterator should complete
+      const doneResult = await iterator.next();
+  
+      // Check that the iteration is complete
+      expect(doneResult.done).toBe(true);
+    });
+  });
+
   describe('discoverDescriptors', () => {
     test('should delegate to noble', () => {
       characteristic.discoverDescriptors();