@stoprocent/bleno 0.8.6 → 0.9.0

package/README.md

@@ -23,12 +23,18 @@ Need a BLE central module? See [@stoprocent/noble](https://github.com/stoprocent
 This fork of `bleno` was created to introduce several key improvements and new features:
 
 1. **HCI UART Support**: This version enables HCI UART communication through the `@stoprocent/node-bluetooth-hci-socket` dependency, allowing more flexible use of Bluetooth devices across platforms.
-   
-2. **macOS Native Bindings Fix**: I have fixed the native bindings for macOS, ensuring better compatibility and performance on Apple devices.
 
-3. **New Features**: A `setAddress` function has been added, allowing users to set the MAC address of the peripheral device. Additionally, I plan to add raw L2CAP channel support, enhancing low-level Bluetooth communication capabilities.
+2. **Multi-Connection Support**: Added support for multiple concurrent BLE central connections, allowing the peripheral to handle several connected devices simultaneously. This enables scenarios where multiple clients can connect and interact with the peripheral at the same time.
 
-If you appreciate these enhancements and the continued development of this project, please consider supporting my work. 
+3. **macOS Native Bindings Fix**: I have fixed the native bindings for macOS, ensuring better compatibility and performance on Apple devices.
+
+4. **Modern Async API**: Added Promise-based async methods for all major operations, making it easier to use with modern JavaScript/TypeScript applications.
+
+5. **TypeScript Support**: Full TypeScript definitions included for better development experience and type safety.
+
+6. **New Features**: A `setAddress` function has been added, allowing users to set the MAC address of the peripheral device. Additionally, I plan to add raw L2CAP channel support, enhancing low-level Bluetooth communication capabilities.
+
+If you appreciate these enhancements and the continued development of this project, please consider supporting my work.
 
 [![Buy me a coffee](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/stoprocent)
 
@@ -41,6 +47,12 @@ npm install @stoprocent/bleno --save
 
 ## Usage
 
+#### TypeScript
+``` typescript
+import bleno from "@stoprocent/bleno";
+```
+
+#### JavaScript
 ```javascript
 const bleno = require('@stoprocent/bleno');
 ```
@@ -50,11 +62,31 @@ See [examples folder](https://github.com/stoprocent/bleno/blob/master/examples)
 
 ## Prerequisites
 
+### Import
+
+#### Binding will be picked automatically
+
+``` typescript
+import bleno from "@stoprocent/bleno";
+```
+
+#### Binding picked manually
+
+``` typescript
+import { withBindings } from "@stoprocent/bleno";
+
+const bleno = withBindings('default');
+const bleno = withBindings('mac');
+const bleno = withBindings('hci', { hciDriver: '...', bindParams: ... });
+```
+
+> For available `hciDriver: DriverType` and `bindParams: BindParams` please refer to [@stoprocent/bluetooth-hci-socket](https://github.com/stoprocent/node-bluetooth-hci-socket/blob/main/index.d.ts) interface.
+
 #### UART (Any OS)
 
 Please refer to [https://github.com/stoprocent/node-bluetooth-hci-socket#uartserial-any-os](https://github.com/stoprocent/node-bluetooth-hci-socket#uartserial-any-os)
 
-##### Example 1 (UART port spcified as enviromental variable)
+##### Example 1 (UART port specified as environmental variable)
 
 ```bash
 $ export BLUETOOTH_HCI_SOCKET_UART_PORT=/dev/tty...
@@ -67,21 +99,53 @@ __NOTE:__ `BLUETOOTH_HCI_SOCKET_UART_BAUDRATE` defaults to `1000000` so only nee
 const bleno = require('@stoprocent/bleno');
 ```
 
-##### Example 2 (UART port spcified in `bindParams`)
+##### Example 2 (UART port specified in `bindParams`)
 
-```bash
-$ export BLUETOOTH_HCI_SOCKET_FORCE_UART=1
-```
+```typescript
+import { withBindings } from "@stoprocent/bleno";
 
-```javascript
-const bleno = require('@stoprocent/bleno/with-custom-binding') ( { 
-  bindParams: { 
-    uart: { 
-      port: '/dev/tty...', 
-      baudRate: 1000000
+const bleno = withBindings('hci', { 
+    hciDriver: 'uart', 
+    bindParams: { 
+        uart: { 
+            port: '/dev/cu.usbserial-1420' 
+        } 
     } 
-  } 
-} );
+});
+
+await bleno.waitForPoweredOnAsync(1000); // Timeout of 1s
+await bleno.startAdvertisingAsync('hello', ['d00d', 'b00b']);
+```
+
+### Multi-Connection Support
+
+This fork of bleno supports multiple concurrent BLE central connections, allowing several clients to connect to your peripheral simultaneously. 
+
+The library automatically restarts advertising after accepting a connection, enabling seamless multi-client connectivity by default. If you want to prevent additional connections, you can explicitly stop advertising in the accept callback:
+
+```typescript
+// Default behavior - allows multiple connections
+bleno.on('accept', async (address, handle) => {
+  console.log(`New connection accepted: ${address}, handle: ${handle}`);
+  // Advertising automatically continues - no action needed
+});
+
+// Optional: Stop additional connections
+bleno.on('accept', async (address, handle) => {
+  console.log(`New connection accepted: ${address}, handle: ${handle}`);
+  // Explicitly stop advertising if you want to prevent additional connections
+  await bleno.stopAdvertisingAsync();
+});
+```
+
+If you stop advertising, you'll need to manually restart it after the last client disconnects to keep the device connectable.
+
+```typescript
+bleno.on('disconnect', async (address, handle) => {
+  console.log(`Client disconnected: ${address}, handle: ${handle}`);
+  // Only need to restart advertising if you explicitly stopped it
+  // await bleno.startAdvertisingAsync('my-device', ['service-uuid']);
+});
 ```
 
 ### OS X
@@ -150,17 +214,29 @@ Make sure you have read and write permissions on the ```/dev/usb/*``` device tha
    * Compatible Bluetooth 4.0 USB adapter
    * [WinUSB](https://msdn.microsoft.com/en-ca/library/windows/hardware/ff540196(v=vs.85).aspx) driver setup for Bluetooth 4.0 USB adapter, using [Zadig tool](http://zadig.akeo.ie/)
 
+## API Reference
+
 ### Actions
 
+#### Wait for powered on state
+
+```typescript
+// Promise-based
+await bleno.waitForPoweredOnAsync(timeout: number); // timeout in milliseconds
+```
+
 #### Set address
 
 ```javascript
+// Callback-based
 bleno.setAddress('00:11:22:33:44:55'); // set adapter's mac address
+
+// Promise-based
+await bleno.setAddressAsync('00:11:22:33:44:55');
 ```
-__NOTE:__ Curently this feature is only supported on HCI as it's using vendor specific commands. Source of the commands is based on the [BlueZ bdaddr.c](https://github.com/pauloborges/bluez/blob/master/tools/bdaddr.c).
+__NOTE:__ Currently this feature is only supported on HCI as it's using vendor specific commands. Source of the commands is based on the [BlueZ bdaddr.c](https://github.com/pauloborges/bluez/blob/master/tools/bdaddr.c).
 __NOTE:__ `bleno.state` must be `poweredOn` before address can be set. `bleno.on('stateChange', callback(state));` can be used to listen for state change events.
 
-
 #### Advertising
 
 ##### Start advertising
@@ -168,10 +244,13 @@ __NOTE:__ `bleno.state` must be `poweredOn` before address can be set. `bleno.on
 NOTE: ```bleno.state``` must be ```poweredOn``` before advertising is started. ```bleno.on('stateChange', callback(state));``` can be used register for state change events.
 
 ```javascript
+// Callback-based
 var name = 'name';
 var serviceUuids = ['fffffffffffffffffffffffffffffff0']
-
 bleno.startAdvertising(name, serviceUuids[, callback(error)]);
+
+// Promise-based
+await bleno.startAdvertisingAsync(name, serviceUuids);
 ```
 
  __Note:__: there are limits on the name and service UUID's
@@ -187,12 +266,16 @@ bleno.startAdvertising(name, serviceUuids[, callback(error)]);
 ##### Start advertising iBeacon
 
 ```javascript
+// Callback-based
 var uuid = 'e2c56db5dffb48d2b060d0f5a71096e0';
 var major = 0; // 0x0000 - 0xffff
 var minor = 0; // 0x0000 - 0xffff
 var measuredPower = -59; // -128 - 127
 
 bleno.startAdvertisingIBeacon(uuid, major, minor, measuredPower[, callback(error)]);
+
+// Promise-based
+await bleno.startAdvertisingIBeaconAsync(uuid, major, minor, measuredPower);
 ```
 
  __Notes:__:
@@ -202,10 +285,14 @@ bleno.startAdvertisingIBeacon(uuid, major, minor, measuredPower[, callback(error
 ##### Start advertising with EIR data (__Linux only__)
 
 ```javascript
+// Callback-based
 var scanData = Buffer.alloc(...); // maximum 31 bytes
 var advertisementData = Buffer.alloc(...); // maximum 31 bytes
 
 bleno.startAdvertisingWithEIRData(advertisementData[, scanData, callback(error)]);
+
+// Promise-based
+await bleno.startAdvertisingWithEIRDataAsync(advertisementData[, scanData]);
 ```
 
   * For EIR format section [Bluetooth Core Specification](https://www.bluetooth.org/docman/handlers/downloaddoc.ashx?doc_id=229737) sections and 8 and 18 for more information the data format.
@@ -213,7 +300,11 @@ bleno.startAdvertisingWithEIRData(advertisementData[, scanData, callback(error)]
 ##### Stop advertising
 
 ```javascript
+// Callback-based
 bleno.stopAdvertising([callback]);
+
+// Promise-based
+await bleno.stopAdvertisingAsync();
 ```
 
 #### Set services
@@ -221,11 +312,15 @@ bleno.stopAdvertising([callback]);
 Set the primary services available on the peripheral.
 
 ```javascript
+// Callback-based
 var services = [
    ... // see PrimaryService for data type
 ];
 
 bleno.setServices(services[, callback(error)]);
+
+// Promise-based
+await bleno.setServicesAsync(services);
 ```
 
 #### Disconnect client
@@ -237,7 +332,11 @@ bleno.disconnect(); // Linux only
 #### Update RSSI
 
 ```javascript
+// Callback-based
 bleno.updateRssi([callback(error, rssi)]); // not available in OS X 10.9
+
+// Promise-based
+const rssi = await bleno.updateRssiAsync();
 ```
 
 ### Primary Service
@@ -266,13 +365,53 @@ var characteristic = new Characteristic({
     descriptors: [
         // see Descriptor for data type
     ],
-    onReadRequest: null, // optional read request handler, function(offset, callback) { ... }
-    onWriteRequest: null, // optional write request handler, function(data, offset, withoutResponse, callback) { ...}
-    onSubscribe: null, // optional notify/indicate subscribe handler, function(maxValueSize, updateValueCallback) { ...}
-    onUnsubscribe: null, // optional notify/indicate unsubscribe handler, function() { ...}
-    onNotify: null, // optional notify sent handler, function() { ...}
-    onIndicate: null // optional indicate confirmation received handler, function() { ...}
+    onReadRequest: null, // optional read request handler, function(handle, offset, callback) { ... }
+    onWriteRequest: null, // optional write request handler, function(handle, data, offset, withoutResponse, callback) { ...}
+    onSubscribe: null, // optional notify/indicate subscribe handler, function(handle, maxValueSize, updateValueCallback) { ...}
+    onUnsubscribe: null, // optional notify/indicate unsubscribe handler, function(handle) { ...}
+    onNotify: null, // optional notify sent handler, function(handle) { ...}
+    onIndicate: null // optional indicate confirmation received handler, function(handle) { ...}
+});
+```
+
+#### Multi-Connection Support
+
+With multi-connection support, each handler now receives a `handle` parameter to identify which client connection is making the request:
+
+```javascript
+// Example of a characteristic with multi-connection support
+var multiConnectionCharacteristic = new Characteristic({
+    uuid: 'fff1',
+    properties: ['read', 'write', 'notify'],
+    onReadRequest: function(handle, offset, callback) {
+        console.log('Read request from connection: ' + handle);
+        // Process the read request for this specific connection
+        callback(Characteristic.RESULT_SUCCESS, Buffer.from('Data for connection ' + handle));
+    },
+    onWriteRequest: function(handle, data, offset, withoutResponse, callback) {
+        console.log('Write request from connection: ' + handle);
+        // Process the write request for this specific connection
+        console.log('Data received: ' + data.toString());
+        callback(Characteristic.RESULT_SUCCESS);
+    },
+    onSubscribe: function(handle, maxValueSize, updateValueCallback) {
+        console.log('Subscribe from connection: ' + handle);
+        // Store the callback for this specific connection to use later
+        // You might want to store these in a Map keyed by handle
+        connectionCallbacks.set(handle, updateValueCallback);
+    },
+    onUnsubscribe: function(handle) {
+        console.log('Unsubscribe from connection: ' + handle);
+        // Remove the callback for this connection
+        connectionCallbacks.delete(handle);
+    }
 });
+
+// Later, to notify a specific connection:
+const callback = connectionCallbacks.get(someConnectionHandle);
+if (callback) {
+    callback(Buffer.from('Notification for connection ' + someConnectionHandle));
+}
 ```
 
 #### Result codes
@@ -281,12 +420,14 @@ var characteristic = new Characteristic({
   * Characteristic.RESULT_INVALID_OFFSET
   * Characteristic.RESULT_INVALID_ATTRIBUTE_LENGTH
   * Characteristic.RESULT_UNLIKELY_ERROR
+  * Characteristic.RESULT_ATTR_NOT_LONG
 
 #### Read requests
 
 Can specify read request handler via constructor options or by extending Characteristic and overriding onReadRequest.
 
 Parameters to handler are
+  * ```handle``` (connection handle)
   * ```offset``` (0x0000 - 0xffff)
   * ```callback```
 
@@ -305,6 +446,7 @@ callback(result, data);
 Can specify write request handler via constructor options or by extending Characteristic and overriding onWriteRequest.
 
 Parameters to handler are
+  * ```handle``` (connection handle)
   * ```data``` (Buffer)
   * ```offset``` (0x0000 - 0xffff)
   * ```withoutResponse``` (true | false)
@@ -323,6 +465,7 @@ callback(result);
 Can specify notify subscribe handler via constructor options or by extending Characteristic and overriding onSubscribe.
 
 Parameters to handler are
+  * ```handle``` (connection handle)
   * ```maxValueSize``` (maximum data size)
   * ```updateValueCallback``` (callback to call when value has changed)
 
@@ -330,12 +473,18 @@ Parameters to handler are
 
 Can specify notify unsubscribe handler via constructor options or by extending Characteristic and overriding onUnsubscribe.
 
+Parameters to handler are
+  * ```handle``` (connection handle)
+
 #### Notify value changes
 
 Call the ```updateValueCallback``` callback (see Notify subscribe), with an argument of type ```Buffer```
 
 Can specify notify sent handler via constructor options or by extending Characteristic and overriding onNotify.
 
+Parameters to handler are
+  * ```handle``` (connection handle)
+
 ### Descriptor
 
 ```javascript
@@ -357,6 +506,24 @@ state = <"unknown" | "resetting" | "unsupported" | "unauthorized" | "poweredOff"
 bleno.on('stateChange', callback(state));
 ```
 
+#### Platform
+
+```javascript
+bleno.on('platform', callback(platform));
+```
+
+#### Address change
+
+```javascript
+bleno.on('addressChange', callback(address));
+```
+
+#### MTU change
+
+```javascript
+bleno.on('mtuChange', callback(mtu));
+```
+
 #### Advertisement started
 
 ```javascript
@@ -382,19 +549,19 @@ bleno.on('servicesSetError', callback(error));
 #### Accept
 
 ```javascript
-bleno.on('accept', callback(clientAddress)); // not available on OS X 10.9
+bleno.on('accept', callback(address, handle)); // handle provided for multi-connection support
 ```
 
 #### Disconnect
 
 ```javascript
-bleno.on('disconnect', callback(clientAddress)); // Linux only
+bleno.on('disconnect', callback(address, handle)); // handle provided for multi-connection support
 ```
 
 #### RSSI Update
 
 ```javascript
-bleno.on('rssiUpdate', callback(rssi)); // not available on OS X 10.9
+bleno.on('rssiUpdate', callback(rssi));
 ```
 
 ### Running on Linux
@@ -459,4 +626,4 @@ Advertising intervals must be between 20 ms to 10 s (10,000 ms).
  * Tools
    * LightBlue for [iOS](https://itunes.apple.com/us/app/lightblue/id557428110)/[OS X](https://itunes.apple.com/us/app/lightblue/id639944780)
    * [nRF Master Control Panel (BLE)](https://play.google.com/store/apps/details?id=no.nordicsemi.android.mcp&hl=en) for Android
-   * [hcitool](http://linux.die.net/man/1/hcitool) and ```gatttool``` by [BlueZ](http://www.bluez.org) for Linux
+   * [hcitool](http://linux.die.net/man/1/hcitool) and ```gatttool``` by [BlueZ](http://www.bluez.org) for Linux

package/examples/echo/async.js

@@ -0,0 +1,47 @@
+const { withBindings } = require('../../');
+
+const bleno = withBindings('default');
+// const bleno = withBindings('mac');
+// const bleno = withBindings('hci', { hciDriver: 'uart' });
+
+const BlenoPrimaryService = bleno.PrimaryService;
+
+const EchoCharacteristic = require('./characteristic');
+
+console.log('bleno - echo');
+
+async function run () {
+  try {
+    await bleno.waitForPoweredOnAsync();
+    console.log("Powered on");
+    await bleno.setAddressAsync('11:22:44:55:99:77');
+    console.log("Address set");
+    await bleno.startAdvertisingAsync('echo-async', ['ec00']);
+    console.log("Advertising started");
+    await bleno.setServicesAsync([
+    new BlenoPrimaryService ({
+        uuid: 'ec00',
+        characteristics: [
+          new EchoCharacteristic()
+        ]
+      })
+    ]);
+    console.log("Services set");
+  } catch (error) {
+    console.error("Error: ", error);
+  }
+}
+
+bleno.on('accept', async (address) => {
+  console.log("Accepted: ", address);
+  // We are not stopping advertising here because we want to allow another central to be able to connect
+  // await bleno.stopAdvertisingAsync();
+});
+
+bleno.on('disconnect', async (address) => {
+  console.log("Disconnected: ", address);
+  // We are not starting advertising here because we didnt stop advertising in the accept event
+  // await bleno.startAdvertisingAsync('echo-async', ['ec00']);
+});
+
+run();

package/examples/echo/characteristic.js

@@ -1,8 +1,6 @@
-const bleno = require('../..');
+const { Characteristic } = require('../../');
 
-const BlenoCharacteristic = bleno.Characteristic;
-
-class EchoCharacteristic extends BlenoCharacteristic {
+class EchoCharacteristic extends Characteristic {
   constructor () {
     super({
       uuid: 'ec0e',
@@ -11,34 +9,34 @@ class EchoCharacteristic extends BlenoCharacteristic {
     });
 
     this._value = Buffer.alloc(0);
-    this._updateValueCallback = null;
+    this._updateValueCallbacks = new Map();
   }
 
-  onReadRequest (offset, callback) {
-    console.log('EchoCharacteristic - onReadRequest: value = ' + this._value.toString('hex'));
+  onReadRequest (connection, offset, callback) {
+    console.log('EchoCharacteristic - onReadRequest: handle = ' + connection + ' value = ' + this._value.toString('hex'));
     callback(this.RESULT_SUCCESS, this._value);
   }
 
-  onWriteRequest (data, offset, withoutResponse, callback) {
+  onWriteRequest (connection, data, offset, withoutResponse, callback) {
     this._value = data;
-    console.log('EchoCharacteristic - onWriteRequest: value = ' + this._value.toString('hex'));
+    console.log('EchoCharacteristic - onWriteRequest: handle = ' + connection + ' value = ' + this._value.toString('hex'));
 
-    if (this._updateValueCallback) {
+    for (const updateValueCallback of this._updateValueCallbacks.values()) {
       console.log('EchoCharacteristic - onWriteRequest: notifying');
-      this._updateValueCallback(this._value);
+      updateValueCallback(this._value);
     }
 
     callback(this.RESULT_SUCCESS);
   }
 
-  onSubscribe (maxValueSize, updateValueCallback) {
-    console.log('EchoCharacteristic - onSubscribe');
-    this._updateValueCallback = updateValueCallback;
+  onSubscribe (connection, maxValueSize, updateValueCallback) {
+    console.log('EchoCharacteristic - onSubscribe: handle = ' + connection);
+    this._updateValueCallbacks.set(connection, updateValueCallback);
   }
 
-  onUnsubscribe () {
-    console.log('EchoCharacteristic - onUnsubscribe');
-    this._updateValueCallback = null;
+  onUnsubscribe (connection) {
+    console.log('EchoCharacteristic - onUnsubscribe: handle = ' + connection);
+    this._updateValueCallbacks.delete(connection);
   }
 }
 

package/examples/echo/main.js

@@ -1,4 +1,8 @@
-const bleno = require('../..');
+const { withBindings } = require('../../');
+
+const bleno = withBindings('default');
+// const bleno = withBindings('mac');
+// const bleno = withBindings('hci', { hciDriver: 'uart' });
 
 const BlenoPrimaryService = bleno.PrimaryService;
 
@@ -17,6 +21,20 @@ bleno.on('stateChange', function (state) {
   }
 });
 
+bleno.on('accept', function (device, handle) {
+  console.log('on -> accept: ' + device + ' ' + handle);
+  // If you want to stop advertising after a connection is accepted
+  // Another central will not be able to connect until advertising is started again
+  bleno.stopAdvertising();
+});
+
+bleno.on('disconnect', function (device, handle) {
+  console.log('on -> disconnect: ' + device + ' ' + handle);
+  // If you want to start advertising again after a disconnection
+  // Another central will not be able to connect until advertising is started again
+  bleno.startAdvertising('echo', ['ec00']);
+});
+
 bleno.on('advertisingStart', function (error) {
   console.log('on -> advertisingStart: ' + (error ? 'error ' + error : 'success'));
 

package/examples/uart/main.js

@@ -1,7 +1,8 @@
-const bleno = require('../../with-custom-binding')({
+
+const { withBindings } = require('../../');
+const bleno = withBindings('hci', {
   bindParams: {
     uart: {
-      port: '/dev/tty...', // Specify the path to the UART device
       baudRate: 1000000
     }
   }

package/examples/with-bindings/main.js

@@ -0,0 +1,35 @@
+const { withBindings } = require('../../');
+
+const blenoMac = withBindings('mac');
+
+const blenoUart = withBindings('hci', { hciDriver: 'uart' });
+
+blenoMac.on('stateChange', state => {
+  console.log('[MAC] on -> stateChange: ' + state);
+
+  if (state === 'poweredOn') {
+    blenoMac.stopAdvertising();
+    blenoMac.startAdvertising('test', ['a2744045-7004-4da9-8ed3-6d2d9a208c0a']);
+  } else {
+    blenoMac.stopAdvertising();
+  }
+});
+
+blenoUart.on('stateChange', state => {
+    console.log('[UART] on -> stateChange: ' + state);
+  
+    if (state === 'poweredOn') {
+      blenoUart.stopAdvertising();
+      blenoUart.startAdvertising('test', ['a2744045-7004-4da9-8ed3-6d2d9a208c0a']);
+    } else {
+      blenoUart.stopAdvertising();
+    }
+  });
+
+blenoMac.on('advertisingStart', error => {
+  console.log('[MAC] on -> advertisingStart: ' + (error ? 'error ' + error : 'success'));
+});
+
+blenoUart.on('advertisingStart', error => {
+    console.log('[UART] on -> advertisingStart: ' + (error ? 'error ' + error : 'success'));
+});