@stoprocent/bleno 0.7.0

package/index.d.ts

@@ -0,0 +1,153 @@
+// 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 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;
+
+    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;
+}
+
+interface DescriptorOptions {
+    uuid: string;
+    value?: Buffer | string | null;
+}
+
+declare class Descriptor {
+    uuid: string;
+    value: Buffer;
+
+    constructor(options: DescriptorOptions);
+
+    toString(): string;
+}
+
+interface PrimaryServiceOptions {
+    uuid: string;
+    characteristics?: ReadonlyArray<Characteristic> | null;
+}
+
+declare class PrimaryService {
+    uuid: string;
+    characteristics: ReadonlyArray<Characteristic>;
+
+    constructor(options: PrimaryServiceOptions);
+
+    toString(): string;
+}
+
+interface Bleno extends NodeJS.EventEmitter {
+    readonly Characteristic: typeof Characteristic;
+    readonly Descriptor: typeof Descriptor;
+    readonly PrimaryService: typeof PrimaryService;
+
+    readonly address: string;
+
+    readonly mtu: number;
+
+    readonly platform: string;
+
+    readonly rssi: number;
+
+    readonly state: State;
+
+    disconnect(): 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;
+
+    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;
+
+    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;
+}
+
+declare const bleno: Bleno;
+export = bleno;

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./with-custom-binding')();

package/lib/bleno.js

@@ -0,0 +1,231 @@
+const debug = require('debug')('bleno');
+const UuidUtil = require('./uuid-util');
+
+const { EventEmitter } = require('events');
+
+const PrimaryService = require('./primary-service');
+const Characteristic = require('./characteristic');
+const Descriptor = require('./descriptor');
+
+class Bleno extends EventEmitter {
+  constructor (bindings) {
+    super();
+    this.initialized = false;
+    this.platform = 'unknown';
+    this.state = 'unknown';
+    this.address = 'unknown';
+    this.rssi = 0;
+    this.mtu = 20;
+
+    this._bindings = bindings;
+
+    this._bindings.on('stateChange', this.onStateChange.bind(this));
+    this._bindings.on('platform', this.onPlatform.bind(this));
+    this._bindings.on('addressChange', this.onAddressChange.bind(this));
+    this._bindings.on('advertisingStart', this.onAdvertisingStart.bind(this));
+    this._bindings.on('advertisingStop', this.onAdvertisingStop.bind(this));
+    this._bindings.on('servicesSet', this.onServicesSet.bind(this));
+    this._bindings.on('accept', this.onAccept.bind(this));
+    this._bindings.on('mtuChange', this.onMtuChange.bind(this));
+    this._bindings.on('disconnect', this.onDisconnect.bind(this));
+    this._bindings.on('rssiUpdate', this.onRssiUpdate.bind(this));
+
+    this.on('newListener', (event) => {
+      if (event === 'stateChange' && !this.initialized) {
+        this._bindings.init();
+
+        this.initialized = true;
+      }
+    });
+  }
+
+  onPlatform (platform) {
+    debug('platform ' + platform);
+
+    this.platform = platform;
+  }
+
+  onStateChange (state) {
+    debug('stateChange ' + state);
+
+    this.state = state;
+
+    this.emit('stateChange', state);
+  }
+
+  onAddressChange (address) {
+    debug('addressChange ' + address);
+
+    this.address = address;
+  }
+
+  onAccept (clientAddress) {
+    debug('accept ' + clientAddress);
+    this.emit('accept', clientAddress);
+  }
+
+  onMtuChange (mtu) {
+    debug('mtu ' + mtu);
+
+    this.mtu = mtu;
+
+    this.emit('mtuChange', mtu);
+  }
+
+  onDisconnect (clientAddress) {
+    debug('disconnect ' + clientAddress);
+    this.emit('disconnect', clientAddress);
+  }
+
+  setAddress (address) {
+    if (this._bindings.setAddress) {
+      this._bindings.setAddress(address);
+    } else {
+      this.emit('warning', 'current binding does not implement setAddress method.');
+    }
+  }
+
+  startAdvertising (name, serviceUuids, callback) {
+    if (this.state !== 'poweredOn') {
+      const error = new Error('Could not start advertising, state is ' + this.state + ' (not poweredOn)');
+
+      if (typeof callback === 'function') {
+        callback(error);
+      } else {
+        throw error;
+      }
+    } else {
+      if (typeof callback === 'function') {
+        this.once('advertisingStart', callback);
+      }
+
+      const undashedServiceUuids = [];
+
+      if (serviceUuids && serviceUuids.length) {
+        for (let i = 0; i < serviceUuids.length; i++) {
+          undashedServiceUuids[i] = UuidUtil.removeDashes(serviceUuids[i]);
+        }
+      }
+
+      this._bindings.startAdvertising(name, undashedServiceUuids);
+    }
+  }
+
+  startAdvertisingIBeacon (uuid, major, minor, measuredPower, callback) {
+    if (this.state !== 'poweredOn') {
+      const error = new Error('Could not start advertising, state is ' + this.state + ' (not poweredOn)');
+
+      if (typeof callback === 'function') {
+        callback(error);
+      } else {
+        throw error;
+      }
+    } else {
+      const undashedUuid = UuidUtil.removeDashes(uuid);
+      const uuidData = Buffer.from(undashedUuid, 'hex');
+      const uuidDataLength = uuidData.length;
+      const iBeaconData = Buffer.alloc(uuidData.length + 5);
+
+      for (let i = 0; i < uuidDataLength; i++) {
+        iBeaconData[i] = uuidData[i];
+      }
+
+      iBeaconData.writeUInt16BE(major, uuidDataLength);
+      iBeaconData.writeUInt16BE(minor, uuidDataLength + 2);
+      iBeaconData.writeInt8(measuredPower, uuidDataLength + 4);
+
+      if (typeof callback === 'function') {
+        this.once('advertisingStart', callback);
+      }
+
+      debug('iBeacon data = ' + iBeaconData.toString('hex'));
+
+      this._bindings.startAdvertisingIBeacon(iBeaconData);
+    }
+  }
+
+  onAdvertisingStart (error) {
+    debug('advertisingStart: ' + error);
+
+    if (error) {
+      this.emit('advertisingStartError', error);
+    } else {
+      this.emit('advertisingStart', error);
+    }
+  }
+
+  startAdvertisingWithEIRData (advertisementData, scanData, callback) {
+    if (typeof scanData === 'function') {
+      callback = scanData;
+      scanData = null;
+    }
+
+    if (this.state !== 'poweredOn') {
+      const error = new Error('Could not advertising scanning, state is ' + this.state + ' (not poweredOn)');
+
+      if (typeof callback === 'function') {
+        callback(error);
+      } else {
+        throw error;
+      }
+    } else {
+      if (typeof callback === 'function') {
+        this.once('advertisingStart', callback);
+      }
+
+      this._bindings.startAdvertisingWithEIRData(advertisementData, scanData);
+    }
+  }
+
+  stopAdvertising (callback) {
+    if (typeof callback === 'function') {
+      this.once('advertisingStop', callback);
+    }
+    this._bindings.stopAdvertising();
+  }
+
+  onAdvertisingStop () {
+    debug('advertisingStop');
+    this.emit('advertisingStop');
+  }
+
+  setServices (services, callback) {
+    if (typeof callback === 'function') {
+      this.once('servicesSet', callback);
+    }
+    this._bindings.setServices(services);
+  }
+
+  onServicesSet (error) {
+    debug('servicesSet');
+
+    if (error) {
+      this.emit('servicesSetError', error);
+    } else {
+      this.emit('servicesSet', error);
+    }
+  }
+
+  disconnect () {
+    debug('disconnect');
+    this._bindings.disconnect();
+  }
+
+  updateRssi (callback) {
+    if (typeof callback === 'function') {
+      this.once('rssiUpdate', (rssi) => callback(null, rssi));
+    }
+
+    this._bindings.updateRssi();
+  }
+
+  onRssiUpdate (rssi) {
+    this.emit('rssiUpdate', rssi);
+  }
+}
+
+Bleno.prototype.PrimaryService = PrimaryService;
+Bleno.prototype.Characteristic = Characteristic;
+Bleno.prototype.Descriptor = Descriptor;
+
+module.exports = Bleno;

package/lib/characteristic.js

@@ -0,0 +1,91 @@
+const { EventEmitter } = require('events');
+const UuidUtil = require('./uuid-util');
+
+class Characteristic extends EventEmitter {
+  constructor (options) {
+    super();
+
+    this.uuid = UuidUtil.removeDashes(options.uuid);
+    this.properties = options.properties || [];
+    this.secure = options.secure || [];
+    this.value = options.value || null;
+    this.descriptors = options.descriptors || [];
+
+    if (this.value && (this.properties.length !== 1 || this.properties[0] !== 'read')) {
+      throw new Error('Characteristics with value can be read only!');
+    }
+
+    if (options.onReadRequest) {
+      this.onReadRequest = options.onReadRequest;
+    }
+
+    if (options.onWriteRequest) {
+      this.onWriteRequest = options.onWriteRequest;
+    }
+
+    if (options.onSubscribe) {
+      this.onSubscribe = options.onSubscribe;
+    }
+
+    if (options.onUnsubscribe) {
+      this.onUnsubscribe = options.onUnsubscribe;
+    }
+
+    if (options.onNotify) {
+      this.onNotify = options.onNotify;
+    }
+
+    if (options.onIndicate) {
+      this.onIndicate = options.onIndicate;
+    }
+
+    this.on('readRequest', this.onReadRequest.bind(this));
+    this.on('writeRequest', this.onWriteRequest.bind(this));
+    this.on('subscribe', this.onSubscribe.bind(this));
+    this.on('unsubscribe', this.onUnsubscribe.bind(this));
+    this.on('notify', this.onNotify.bind(this));
+    this.on('indicate', this.onIndicate.bind(this));
+  }
+
+  toString () {
+    return JSON.stringify({
+      uuid: this.uuid,
+      properties: this.properties,
+      secure: this.secure,
+      value: this.value,
+      descriptors: this.descriptors
+    });
+  }
+
+  onReadRequest (offset, callback) {
+    callback(this.RESULT_UNLIKELY_ERROR, null);
+  }
+
+  onWriteRequest (data, offset, withoutResponse, callback) {
+    callback(this.RESULT_UNLIKELY_ERROR);
+  }
+
+  onSubscribe (maxValueSize, updateValueCallback) {
+    this.maxValueSize = maxValueSize;
+    this.updateValueCallback = updateValueCallback;
+  }
+
+  onUnsubscribe () {
+    this.maxValueSize = null;
+    this.updateValueCallback = null;
+  }
+
+  onNotify () {
+  }
+
+  onIndicate () {
+  }
+}
+
+Characteristic.RESULT_SUCCESS = Characteristic.prototype.RESULT_SUCCESS = 0x00;
+Characteristic.RESULT_INVALID_OFFSET = Characteristic.prototype.RESULT_INVALID_OFFSET = 0x07;
+Characteristic.RESULT_ATTR_NOT_LONG = Characteristic.prototype.RESULT_ATTR_NOT_LONG = 0x0b;
+Characteristic.RESULT_INVALID_ATTRIBUTE_LENGTH = Characteristic.prototype.RESULT_INVALID_ATTRIBUTE_LENGTH = 0x0d;
+Characteristic.RESULT_UNLIKELY_ERROR = Characteristic.prototype.RESULT_UNLIKELY_ERROR = 0x0e;
+
+module.exports = Characteristic;

package/lib/descriptor.js

@@ -0,0 +1,17 @@
+const UuidUtil = require('./uuid-util');
+
+class Descriptor {
+  constructor (options) {
+    this.uuid = UuidUtil.removeDashes(options.uuid);
+    this.value = options.value || Buffer.alloc(0);
+  }
+
+  toString () {
+    return JSON.stringify({
+      uuid: this.uuid,
+      value: Buffer.isBuffer(this.value) ? this.value.toString('hex') : this.value
+    });
+  }
+}
+
+module.exports = Descriptor;

package/lib/hci-socket/acl-stream.js

@@ -0,0 +1,37 @@
+const { EventEmitter } = require('events');
+const Smp = require('./smp');
+
+class AclStream extends EventEmitter {
+  constructor (hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress) {
+    super();
+    this._hci = hci;
+    this._handle = handle;
+    this.encypted = false;
+
+    this._smp = new Smp(this, localAddressType, localAddress, remoteAddressType, remoteAddress);
+  }
+
+  write (cid, data) {
+    this._hci.queueAclDataPkt(this._handle, cid, data);
+  }
+
+  push (cid, data) {
+    if (data) {
+      this.emit('data', cid, data);
+    } else {
+      this.emit('end');
+    }
+  }
+
+  pushEncrypt (encrypt) {
+    this.encrypted = !!encrypt;
+
+    this.emit('encryptChange', this.encrypted);
+  }
+
+  pushLtkNegReply () {
+    this.emit('ltkNegReply');
+  }
+}
+
+module.exports = AclStream;