@stoprocent/bleno 0.8.6 → 0.10.0

package/index.d.ts

@@ -1,155 +1,200 @@
-// Type definitions for bleno 0.4
-// Project: https://github.com/sandeepmistry/bleno
-// Definitions by: Manuel Francisco Naranjo <naranjo.manuel@gmail.com>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
 /// <reference types="node" />
-
-type State = 'poweredOn' | 'poweredOff' | 'unauthorized' | 'unsupported' | 'unknown' | 'resetting';
-
-type Property = 'read' | 'write' | 'indicate' | 'notify' | 'writeWithoutResponse';
-
-interface CharacteristicOptions {
-    uuid: string;
-    properties?: ReadonlyArray<Property> | null;
-    secure?: ReadonlyArray<Property> | null;
-    value?: Buffer | null;
-    descriptors?: ReadonlyArray<Descriptor> | null;
-    onIndicate?: (() => void) | null;
-    onNotify?: (() => void) | null;
-    onReadRequest?: ((
-        offset: number,
-        callback: (result: number, data?: Buffer) => void
-    ) => void) | null;
-    onSubscribe?: ((maxValueSize: number, updateValueCallback: (data: Buffer) => void) => void) | null;
-    onUnsubscribe?: (() => void) | null;
-    onWriteRequest?: ((
-        data: Buffer,
-        offset: number,
-        withoutResponse: boolean,
-        callback: (result: number) => void
-    ) => void) | null;
+declare module '@stoprocent/bluetooth-hci-socket' {
+    type DriverType = any; // Fallback type
+    interface BindParams {
+        [key: string]: any;
+    }
 }
 
-declare class Characteristic {
-    uuid: string;
-    properties: ReadonlyArray<Property>;
-    secure: ReadonlyArray<Property>;
-    value: Buffer | null;
-    descriptors: ReadonlyArray<Descriptor>;
-
-    constructor(options: CharacteristicOptions);
-
-    onIndicate(): void;
-
-    onNotify(): void;
-
-    onReadRequest(offset: number, callback: (result: number, data?: Buffer) => void): void;
-
-    onSubscribe(maxValueSize: number, updateValueCallback: (data: Buffer) => void): void;
-
-    onUnsubscribe(): void;
-
-    onWriteRequest(data: Buffer, offset: number, withoutResponse: boolean, callback: (result: number) => void): void;
-
-    toString(): string;
+declare module '@stoprocent/bleno' {
+    import { EventEmitter } from 'events';
+
+    export type State = 'poweredOn' | 'poweredOff' | 'unauthorized' | 'unsupported' | 'unknown' | 'resetting';
+
+    export type Property = 'read' | 'write' | 'indicate' | 'notify' | 'writeWithoutResponse';
+
+    export type ConnectionHandle = number | string;
 
-    readonly RESULT_ATTR_NOT_LONG: number;
+    // Common callback types
+    export type ReadRequestCallback = (result: number, data?: Buffer) => void;
+    export type UpdateValueCallback = (data?: Buffer) => void;
+    export type WriteRequestCallback = (result: number) => void;
 
-    readonly RESULT_INVALID_ATTRIBUTE_LENGTH: number;
+    // Common function types
+    export type OnReadRequestFn = (handle: ConnectionHandle, offset: number, callback: ReadRequestCallback) => void;
+    export type OnSubscribeFn = (handle: ConnectionHandle, maxValueSize: number, updateValueCallback: UpdateValueCallback) => void;
+    export type OnUnsubscribeFn = (handle: ConnectionHandle) => void;
+    export type OnWriteRequestFn = (handle: ConnectionHandle, data: Buffer, offset: number, withoutResponse: boolean, callback: WriteRequestCallback) => void;
+    export type OnIndicateFn = (handle: ConnectionHandle) => void;
+    export type OnNotifyFn = (handle: ConnectionHandle) => void;
 
-    readonly RESULT_INVALID_OFFSET: number;
+    export interface CharacteristicOptions {
+        uuid: string;
+        properties?: ReadonlyArray<Property> | null;
+        secure?: ReadonlyArray<Property> | null;
+        value?: Buffer | null;
+        descriptors?: ReadonlyArray<Descriptor> | null;
+        onIndicate?: OnIndicateFn | null;
+        onNotify?: OnNotifyFn | null;
+        onReadRequest?: OnReadRequestFn | null;
+        onSubscribe?: OnSubscribeFn | null;
+        onUnsubscribe?: OnUnsubscribeFn | null;
+        onWriteRequest?: OnWriteRequestFn | null;
+    }
 
-    readonly RESULT_SUCCESS: number;
+    export class Characteristic {
+        uuid: string;
+        properties: ReadonlyArray<Property>;
+        secure: ReadonlyArray<Property>;
+        value: Buffer | null;
+        descriptors: ReadonlyArray<Descriptor>;
 
-    readonly RESULT_UNLIKELY_ERROR: number;
+        constructor(options: CharacteristicOptions);
 
-    static readonly RESULT_ATTR_NOT_LONG: number;
+        onIndicate: OnIndicateFn;
+        onNotify: OnNotifyFn;
+        onReadRequest: OnReadRequestFn;
+        onSubscribe: OnSubscribeFn;
+        onUnsubscribe: OnUnsubscribeFn;
+        onWriteRequest: OnWriteRequestFn;
 
-    static readonly RESULT_INVALID_ATTRIBUTE_LENGTH: number;
+        toString(): string;
 
-    static readonly RESULT_INVALID_OFFSET: number;
+        readonly RESULT_ATTR_NOT_LONG: number;
+        readonly RESULT_INVALID_ATTRIBUTE_LENGTH: number;
+        readonly RESULT_INVALID_OFFSET: number;
+        readonly RESULT_SUCCESS: number;
+        readonly RESULT_UNLIKELY_ERROR: number;
+
+        static readonly RESULT_ATTR_NOT_LONG: number;
+        static readonly RESULT_INVALID_ATTRIBUTE_LENGTH: number;
+        static readonly RESULT_INVALID_OFFSET: number;
+        static readonly RESULT_SUCCESS: number;
+        static readonly RESULT_UNLIKELY_ERROR: number;
+    }
+
+    export interface DescriptorOptions {
+        uuid: string;
+        value?: Buffer | string | null;
+    }
 
-    static readonly RESULT_SUCCESS: number;
+    export class Descriptor {
+        uuid: string;
+        value: Buffer;
+
+        constructor(options: DescriptorOptions);
 
-    static readonly RESULT_UNLIKELY_ERROR: number;
-}
-
-interface DescriptorOptions {
-    uuid: string;
-    value?: Buffer | string | null;
-}
-
-declare class Descriptor {
-    uuid: string;
-    value: Buffer;
-
-    constructor(options: DescriptorOptions);
+        toString(): string;
+    }
 
-    toString(): string;
-}
+    export interface PrimaryServiceOptions {
+        uuid: string;
+        characteristics?: ReadonlyArray<Characteristic> | null;
+    }
 
-interface PrimaryServiceOptions {
-    uuid: string;
-    characteristics?: ReadonlyArray<Characteristic> | null;
-}
+    export class PrimaryService {
+        uuid: string;
+        characteristics: ReadonlyArray<Characteristic>;
 
-declare class PrimaryService {
-    uuid: string;
-    characteristics: ReadonlyArray<Characteristic>;
+        constructor(options: PrimaryServiceOptions);
 
-    constructor(options: PrimaryServiceOptions);
+        toString(): string;
+    }
 
-    toString(): string;
-}
+    export class Bleno extends EventEmitter {
+        readonly Characteristic: typeof Characteristic;
+        readonly Descriptor: typeof Descriptor;
+        readonly PrimaryService: typeof PrimaryService;
 
-export interface Bleno extends NodeJS.EventEmitter {
-    readonly Characteristic: typeof Characteristic;
-    readonly Descriptor: typeof Descriptor;
-    readonly PrimaryService: typeof PrimaryService;
+        readonly address: string;
 
-    readonly address: string;
+        readonly mtu: number;
+
+        readonly platform: string;
+
+        readonly rssi: number;
+
+        readonly state: State;
+
+        disconnect(): void;
+
+        stop(): void;
+
+        setAddress(address: string): void;
+
+        setServices(services: ReadonlyArray<PrimaryService>, callback?: (arg: Error | undefined | null) => void): void;
+
+        startAdvertising(name: string, serviceUuids?: ReadonlyArray<string>, callback?: (arg: Error | undefined | null) => void): void;
+
+        startAdvertisingIBeacon(uuid: string, major: number, minor: number, measuredPower: number, callback?: (arg: Error | undefined | null) => void): void;
 
-    readonly mtu: number;
+        startAdvertisingWithEIRData(advertisementData: Buffer, callback?: (arg: Error | undefined | null) => void): void;
+        startAdvertisingWithEIRData(advertisementData: Buffer, scanData: Buffer, callback?: (arg: Error | undefined | null) => void): void;
+
+        stopAdvertising(callback?: () => void): void;
 
-    readonly platform: string;
+        updateRssi(callback?: (err: null, rssi: number) => void): void;
 
-    readonly rssi: number;
+        // Async methods
+        waitForPoweredOnAsync(timeout?: number): Promise<void>;
 
-    readonly state: State;
+        setAddressAsync(address: string): Promise<void>;
+        
+        setServicesAsync(services: ReadonlyArray<PrimaryService>): Promise<void>;
+        
+        startAdvertisingAsync(name: string, serviceUuids?: ReadonlyArray<string>): Promise<void>;
+        
+        startAdvertisingIBeaconAsync(
+            uuid: string,
+            major: number,
+            minor: number,
+            measuredPower: number
+        ): Promise<void>;
+        
+        startAdvertisingWithEIRDataAsync(advertisementData: Buffer): Promise<void>;
+        startAdvertisingWithEIRDataAsync(advertisementData: Buffer, scanData: Buffer): Promise<void>;
+        
+        stopAdvertisingAsync(): Promise<void>;
+        
+        updateRssiAsync(): Promise<number>;
 
-    disconnect(): void;
+        on(event: 'stateChange', cb: (state: State) => void): this;
+        on(event: 'platform', cb: (platform: NodeJS.Platform) => void): this;
+        on(event: 'addressChange', cb: (address: string) => void): this;
+        on(event: 'accept', cb: (address: string, handle: ConnectionHandle) => void): this;
+        on(event: 'mtuChange', cb: (mtu: number) => void): this;
+        on(event: 'disconnect', cb: (address: string, handle: ConnectionHandle) => void): this;
+        on(event: 'advertisingStart', cb: (err?: Error | null) => void): this;
+        on(event: 'advertisingStartError', cb: (err: Error) => void): this;
+        on(event: 'advertisingStop', cb: () => void): this;
+        on(event: 'servicesSet', cb: (err?: Error | null) => void): this;
+        on(event: 'servicesSetError', cb: (err: Error) => void): this;
+        on(event: 'rssiUpdate', cb: (rssi: number) => void): this;
+    }
 
-    stop(): void;
+    export type BindingType = 'default' | 'hci' | 'mac';
 
-    setAddress(address: string): void;
+    export interface BaseBindingsOptions {
 
-    setServices(services: ReadonlyArray<PrimaryService>, callback?: (arg: Error | undefined | null) => void): void;
+    }
 
-    startAdvertising(name: string, serviceUuids?: ReadonlyArray<string>, callback?: (arg: Error | undefined | null) => void): void;
+    export interface HciBindingsOptions extends BaseBindingsOptions {
+        hciDriver?: import('@stoprocent/bluetooth-hci-socket').DriverType;
+        bindParams?: import('@stoprocent/bluetooth-hci-socket').BindParams;
+    }
 
-    startAdvertisingIBeacon(uuid: string, major: number, minor: number, measuredPower: number, callback?: (arg: Error | undefined | null) => void): void;
+    export interface MacBindingsOptions extends BaseBindingsOptions {
 
-    startAdvertisingWithEIRData(advertisementData: Buffer, callback?: (arg: Error | undefined | null) => void): void;
-    startAdvertisingWithEIRData(advertisementData: Buffer, scanData: Buffer, callback?: (arg: Error | undefined | null) => void): void;
+    }
 
-    stopAdvertising(callback?: () => void): void;
+    export type WithBindingsOptions = HciBindingsOptions | MacBindingsOptions;
 
-    updateRssi(callback?: (err: null, rssi: number) => void): void;
-
-    on(event: 'stateChange', cb: (state: State) => void): this;
-    on(event: 'platform', cb: (platform: NodeJS.Platform) => void): this;
-    on(event: 'addressChange', cb: (address: string) => void): this;
-    on(event: 'accept', cb: (address: string) => void): this;
-    on(event: 'mtuChange', cb: (mtu: number) => void): this;
-    on(event: 'disconnect', cb: (clientAddress: string) => void): this;
-    on(event: 'advertisingStart', cb: (err?: Error | null) => void): this;
-    on(event: 'advertisingStartError', cb: (err: Error) => void): this;
-    on(event: 'advertisingStop', cb: () => void): this;
-    on(event: 'servicesSet', cb: (err?: Error | null) => void): this;
-    on(event: 'servicesSetError', cb: (err: Error) => void): this;
-    on(event: 'rssiUpdate', cb: (rssi: number) => void): this;
-}
+    export function withBindings(
+        bindingType?: BindingType, 
+        options?: WithBindingsOptions
+    ): Bleno;
 
-declare const bleno: Bleno;
-export = bleno;
+    // Define a default export
+    const BlenoDefault: Bleno;
+    export default BlenoDefault;
+}

package/index.js

@@ -1 +1,5 @@
-module.exports = require('./with-custom-binding')();
+const withBindings = require('./lib/resolve-bindings');
+
+// Expose both the default instance and the custom binding function
+module.exports = withBindings();
+module.exports.withBindings = withBindings;

package/lib/bleno.js

@@ -59,22 +59,43 @@ class Bleno extends EventEmitter {
     this.address = address;
   }
 
-  onAccept (clientAddress) {
-    debug('accept ' + clientAddress);
-    this.emit('accept', clientAddress);
+  onAccept (clientAddress, handle) {
+    debug('accept ' + clientAddress + ' ' + handle);
+    this.emit('accept', clientAddress, handle);
   }
 
   onMtuChange (mtu) {
     debug('mtu ' + mtu);
-
     this.mtu = mtu;
-
     this.emit('mtuChange', mtu);
   }
 
-  onDisconnect (clientAddress) {
-    debug('disconnect ' + clientAddress);
-    this.emit('disconnect', clientAddress);
+  onDisconnect (clientAddress, handle) {
+    debug('disconnect ' + clientAddress + ' ' + handle);
+    this.emit('disconnect', clientAddress, handle);
+  }
+
+  async waitForPoweredOnAsync (timeout = 10000) {
+    if (this.state === 'poweredOn') {
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.removeListener('stateChange', stateChangeHandler);
+        reject(new Error(`Timeout waiting for poweredOn state. Current state: ${this.state}`));
+      }, timeout);
+
+      const stateChangeHandler = (state) => {
+        if (state === 'poweredOn') {
+          clearTimeout(timeoutId);
+          this.removeListener('stateChange', stateChangeHandler);
+          resolve();
+        }
+      };
+
+      this.on('stateChange', stateChangeHandler);
+    });
   }
 
   setAddress (address) {
@@ -85,6 +106,27 @@ class Bleno extends EventEmitter {
     }
   }
 
+  setAddressAsync (address) {
+    if (this._bindings.setAddress === undefined) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {  
+        reject(new Error('Timeout waiting for address change'));
+      }, 2000);
+      this._bindings.once('addressChange', (address) => {
+        if (address === address) {
+          clearTimeout(timeout);
+          resolve();
+        }
+        else {
+          reject(new Error('Address change failed'));
+        }
+      });
+      this.setAddress(address);
+    });
+  }
+
   startAdvertising (name, serviceUuids, callback) {
     if (this.state !== 'poweredOn') {
       const error = new Error('Could not start advertising, state is ' + this.state + ' (not poweredOn)');
@@ -111,6 +153,15 @@ class Bleno extends EventEmitter {
     }
   }
 
+  startAdvertisingAsync (name, serviceUuids) {
+    return new Promise((resolve, reject) => {
+      this.startAdvertising(name, serviceUuids, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
   startAdvertisingIBeacon (uuid, major, minor, measuredPower, callback) {
     if (this.state !== 'poweredOn') {
       const error = new Error('Could not start advertising, state is ' + this.state + ' (not poweredOn)');
@@ -144,14 +195,18 @@ class Bleno extends EventEmitter {
     }
   }
 
+  startAdvertisingIBeaconAsync (uuid, major, minor, measuredPower) {
+    return new Promise((resolve, reject) => {
+      this.startAdvertisingIBeacon(uuid, major, minor, measuredPower, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
   onAdvertisingStart (error) {
     debug('advertisingStart: ' + error);
-
-    if (error) {
-      this.emit('advertisingStartError', error);
-    } else {
-      this.emit('advertisingStart', error);
-    }
+    this.emit('advertisingStart', error);
   }
 
   startAdvertisingWithEIRData (advertisementData, scanData, callback) {
@@ -177,6 +232,15 @@ class Bleno extends EventEmitter {
     }
   }
 
+  startAdvertisingWithEIRDataAsync (advertisementData, scanData) {
+    return new Promise((resolve, reject) => {
+      this.startAdvertisingWithEIRData(advertisementData, scanData, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
   stopAdvertising (callback) {
     if (typeof callback === 'function') {
       this.once('advertisingStop', callback);
@@ -184,6 +248,15 @@ class Bleno extends EventEmitter {
     this._bindings.stopAdvertising();
   }
 
+  stopAdvertisingAsync () {
+    return new Promise((resolve, reject) => {
+      this.stopAdvertising((error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
   onAdvertisingStop () {
     debug('advertisingStop');
     this.emit('advertisingStop');
@@ -196,6 +269,15 @@ class Bleno extends EventEmitter {
     this._bindings.setServices(services);
   }
 
+  setServicesAsync (services) {
+    return new Promise((resolve, reject) => {
+      this.setServices(services, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
   onServicesSet (error) {
     debug('servicesSet');
 
@@ -206,9 +288,9 @@ class Bleno extends EventEmitter {
     }
   }
 
-  disconnect () {
-    debug('disconnect');
-    this._bindings.disconnect();
+  disconnect (handle = null) {
+    debug('disconnect ' + (handle ? handle : 'all'));
+    this._bindings.disconnect(handle);
   }
 
   stop () {
@@ -224,6 +306,15 @@ class Bleno extends EventEmitter {
     this._bindings.updateRssi();
   }
 
+  updateRssiAsync () {
+    return new Promise((resolve, reject) => {
+      this.updateRssi((error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+  }
+
   onRssiUpdate (rssi) {
     this.emit('rssiUpdate', rssi);
   }

package/lib/characteristic.js

@@ -45,6 +45,9 @@ class Characteristic extends EventEmitter {
     this.on('unsubscribe', this.onUnsubscribe.bind(this));
     this.on('notify', this.onNotify.bind(this));
     this.on('indicate', this.onIndicate.bind(this));
+
+    this._maxValueSizes = new Map();
+    this._updateValueCallbacks = new Map();
   }
 
   toString () {
@@ -57,28 +60,42 @@ class Characteristic extends EventEmitter {
     });
   }
 
-  onReadRequest (offset, callback) {
+  getMaxValueSize (connection) {
+    return this._maxValueSizes.get(connection);
+  }
+
+  onReadRequest (connection, offset, callback) {
     callback(this.RESULT_UNLIKELY_ERROR, null);
   }
 
-  onWriteRequest (data, offset, withoutResponse, callback) {
+  onWriteRequest (connection, data, offset, withoutResponse, callback) {
     callback(this.RESULT_UNLIKELY_ERROR);
   }
 
-  onSubscribe (maxValueSize, updateValueCallback) {
-    this.maxValueSize = maxValueSize;
-    this.updateValueCallback = updateValueCallback;
+  onSubscribe (connection, maxValueSize, updateValueCallback) {
+    this._maxValueSizes.set(connection, maxValueSize);
+    this._updateValueCallbacks.set(connection, updateValueCallback);
   }
 
-  onUnsubscribe () {
-    this.maxValueSize = null;
-    this.updateValueCallback = null;
+  onUnsubscribe (connection) {
+    this._maxValueSizes.delete(connection);
+    this._updateValueCallbacks.delete(connection);
   }
 
-  onNotify () {
+  onNotify (connection) {
   }
 
-  onIndicate () {
+  onIndicate (connection) {
+  }
+
+  notify (data, connection = null) {
+    if (connection && this._updateValueCallbacks.has(connection)) {
+      this._updateValueCallbacks.get(connection)(data);
+    } else if (!connection) {
+      for (const callback of this._updateValueCallbacks.values()) {
+        callback(data);
+      }
+    }
   }
 }
 

package/lib/common/include/ThreadSafeCallback.h

@@ -0,0 +1,95 @@
+#pragma once
+
+#include <napi.h>
+#include <vector>
+#include <functional>
+
+class ThreadSafeCallback {
+public:
+    // More descriptive type aliases
+    using ArgumentVector = std::vector<napi_value>;
+    using ArgumentFunction = std::function<void(napi_env, ArgumentVector&)>;
+
+    // Constructor with validation
+    ThreadSafeCallback(const Napi::Value& receiver, const Napi::Function& jsCallback);
+    
+    // Destructor
+    ~ThreadSafeCallback();
+
+    // Delete copy and move operations explicitly
+    ThreadSafeCallback(const ThreadSafeCallback&) = delete;
+    ThreadSafeCallback& operator=(const ThreadSafeCallback&) = delete;
+    ThreadSafeCallback& operator=(ThreadSafeCallback&&) = delete;
+
+    // Public interface
+    void call(ArgumentFunction argFunction);
+
+private:
+    // Static callback handler
+    static void callJsCallback(Napi::Env env,
+                             Napi::Function jsCallback,
+                             Napi::Reference<Napi::Value>* context,
+                             ArgumentFunction* argFn);
+
+    // Type alias for the thread-safe function
+    using ThreadSafeFunc = Napi::TypedThreadSafeFunction<
+        Napi::Reference<Napi::Value>,
+        ArgumentFunction,
+        callJsCallback>;
+
+    // Member variables
+    Napi::Reference<Napi::Value> receiver_;
+    ThreadSafeFunc threadSafeFunction_;
+};
+
+// Implementation
+
+inline ThreadSafeCallback::ThreadSafeCallback(
+    const Napi::Value& receiver,
+    const Napi::Function& jsCallback) {
+    
+    if (!(receiver.IsObject() || receiver.IsFunction())) {
+        throw Napi::Error::New(jsCallback.Env(),
+            "Callback receiver must be an object or function");
+    }
+    if (!jsCallback.IsFunction()) {
+        throw Napi::Error::New(jsCallback.Env(),
+            "Callback must be a function");
+    }
+
+    receiver_ = Napi::Persistent(receiver);
+    threadSafeFunction_ = ThreadSafeFunc::New(
+        jsCallback.Env(),
+        jsCallback,
+        "ThreadSafeCallback callback",
+        0, 1,
+        &receiver_);
+}
+
+inline ThreadSafeCallback::~ThreadSafeCallback() {
+    threadSafeFunction_.Abort();
+}
+
+inline void ThreadSafeCallback::call(ArgumentFunction argFunction) {
+    auto argFn = new ArgumentFunction(argFunction);
+    if (threadSafeFunction_.BlockingCall(argFn) != napi_ok) {
+        delete argFn;
+    }
+}
+
+inline void ThreadSafeCallback::callJsCallback(
+    Napi::Env env,
+    Napi::Function jsCallback,
+    Napi::Reference<Napi::Value>* context,
+    ArgumentFunction* argFn) {
+    
+    if (argFn != nullptr) {
+        ArgumentVector args;
+        (*argFn)(env, args);
+        delete argFn;
+
+        if (env != nullptr && jsCallback != nullptr) {
+            jsCallback.Call(context->Value(), args);
+        }
+    }
+}