@stoprocent/noble 1.9.2-16

package/lib/webbluetooth/bindings.js

@@ -0,0 +1,368 @@
+const util = require('util');
+const events = require('events');
+
+const debug = require('debug')('webble-bindings');
+
+function makeList (uuid) {
+  return { services: [uuid] };
+}
+
+function addDashes (uuid) {
+  if (!uuid || typeof uuid !== 'string') {
+    return uuid;
+  }
+  if (uuid && uuid.length === 32) {
+    uuid = `${uuid.substring(0, 8)}-${uuid.substring(8, 12)}-${uuid.substring(12, 16)}-${uuid.substring(16, 20)}-${uuid.substring(20)}`;
+  }
+  return uuid.toLowerCase();
+}
+
+function stripDashes (uuid) {
+  if (typeof uuid === 'string') {
+    uuid = uuid.split('-').join('');
+  }
+  return uuid;
+}
+
+const NobleBindings = function () {
+  this._ble = null;
+  this._startScanCommand = null;
+  this._peripherals = {};
+};
+util.inherits(NobleBindings, events.EventEmitter);
+
+NobleBindings.prototype.init = function (ble) {
+  if (ble) {
+    this._ble = ble;
+  } else {
+    this._ble = navigator.bluetooth;
+  }
+
+  const self = this;
+  process.nextTick(() => {
+    debug('initing');
+    if (!self._ble) {
+      return self.emit('error', new Error('This browser does not support WebBluetooth.'));
+    }
+    debug('emit powered on');
+    self.emit('stateChange', 'poweredOn');
+  });
+};
+
+NobleBindings.prototype.onOpen = function () {
+  debug('on -> open');
+};
+
+NobleBindings.prototype.onClose = function () {
+  debug('on -> close');
+
+  this.emit('stateChange', 'poweredOff');
+};
+
+NobleBindings.prototype.startScanning = function (options, allowDuplicates) {
+  const self = this;
+
+  if (Array.isArray(options)) {
+    options = { services: options };
+  }
+
+  if (typeof options !== 'object') {
+    options = { services: options };
+  }
+
+  if (!Array.isArray(options.services)) {
+    options.services = [options.services];
+  }
+
+  options.services = options.services.map(service => {
+    // web bluetooth requires 4 char hex service names to be passed in as integers
+    if (typeof service === 'string' && service.length === 4) {
+      service = parseInt(`0x${service}`);
+    } else if (typeof service === 'string' && service.length === 6 && service.indexOf('0x') === 0) {
+      service = parseInt(service);
+    }
+    return service;
+  });
+
+  const dashedUuids = options.services.map(addDashes);
+
+  const filterList = dashedUuids.map(makeList);
+  if (options.name) {
+    filterList.push({ name: options.name });
+  }
+  if (options.namePrefix) {
+    filterList.push({ namePrefix: options.namePrefix });
+  }
+
+  const request = { filters: filterList };
+
+  debug('startScanning', request, allowDuplicates);
+
+  this._ble.requestDevice(request)
+    .then(device => {
+      debug('scan finished', device);
+      self.emit('scanStop', {});
+      if (device) {
+        const address = device.id;
+        // TODO use device.adData when api is ready
+        // rssi = device.adData.rssi;
+
+        self._peripherals[address] = {
+          uuid: address,
+          address: address,
+          advertisement: { localName: device.name }, // advertisement,
+          device: device,
+          cachedServices: {},
+          localName: device.name,
+          serviceUuids: options.services
+        };
+        if (device.adData) {
+          self._peripherals[address].rssi = device.adData.rssi;
+        }
+
+        self.emit('discover', device.id, device.id, device.addressType, !device.paired, self._peripherals[address].advertisement, self._peripherals[address].rssi);
+      }
+    })
+    .catch(err => {
+      debug('err scanning', err);
+      self.emit('scanStop', {});
+      self.emit('error', err);
+    });
+
+  this.emit('scanStart');
+};
+
+NobleBindings.prototype.stopScanning = function () {
+  this._startScanCommand = null;
+
+  // TODO: need web api completed for this to work'=
+  this.emit('scanStop');
+};
+
+NobleBindings.prototype.connect = function (deviceUuid) {
+  const self = this;
+  debug('connect', deviceUuid);
+  const peripheral = this._peripherals[deviceUuid];
+  // clear any cached services in case this is a reconnect
+  peripheral.cachedServices = {};
+
+  // Attempts to connect to remote GATT Server.
+  peripheral.device.gatt.connect()
+    .then(gattServer => {
+      debug('peripheral connected', gattServer);
+
+      const onDisconnected = function (event) {
+        debug('disconnected', peripheral.uuid);
+        self.emit('disconnect', peripheral.uuid);
+      };
+      peripheral.device.addEventListener('gattserverdisconnected', onDisconnected, { once: true });
+
+      self.emit('connect', deviceUuid);
+    }, err => {
+      debug('err connecting', err);
+      self.emit('connect', deviceUuid, err);
+    });
+};
+
+NobleBindings.prototype.disconnect = function (deviceUuid) {
+  const peripheral = this._peripherals[deviceUuid];
+  if (peripheral.device.gatt) {
+    peripheral.device.gatt.disconnect();
+    this.emit('disconnect', deviceUuid);
+  }
+};
+
+NobleBindings.prototype.updateRssi = function (deviceUuid) {
+  // TODO: need web api completed for this to work
+  // var peripheral = this._peripherals[deviceUuid];
+  // this.emit('rssiUpdate', deviceUuid, rssi);
+};
+
+NobleBindings.prototype.discoverServices = function (deviceUuid, uuids) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  // TODO: need web api completed for this to work
+  if (peripheral) {
+    this.emit('servicesDiscover', deviceUuid, peripheral.serviceUuids);
+  }
+};
+
+NobleBindings.prototype.discoverIncludedServices = function (deviceUuid, serviceUuid, serviceUuids) {
+  // TODO impelment when web API has functionatility then emit response
+  // var peripheral = this._peripherals[deviceUuid];
+  // this.emit('includedServicesDiscover', deviceUuid, serviceUuid, includedServiceUuids);
+};
+
+NobleBindings.prototype.discoverCharacteristics = function (deviceUuid, serviceUuid, characteristicUuids) {
+  const self = this;
+  const peripheral = self._peripherals[deviceUuid];
+
+  if (peripheral) {
+    self.getPrimaryService(peripheral, serviceUuid)
+      .then(service => service.getCharacteristics())
+      .then(characteristics => {
+        const discoveredCharacteristics = characteristics.map(char => {
+          const charInfo = { uuid: stripDashes(char.uuid), properties: [] };
+
+          if (char.properties.writeWithoutResponse) {
+            charInfo.properties.push('writeWithoutResponse');
+          }
+
+          if (char.properties.write) {
+            charInfo.properties.push('write');
+          }
+
+          if (char.properties.read) {
+            charInfo.properties.push('read');
+          }
+
+          if (char.properties.notify) {
+            charInfo.properties.push('notify');
+          }
+
+          return charInfo;
+        });
+
+        debug('discoverCharacteristics', deviceUuid, serviceUuid, discoveredCharacteristics);
+        self.emit('characteristicsDiscover', deviceUuid, serviceUuid, discoveredCharacteristics);
+      });
+  }
+};
+
+NobleBindings.prototype.getPrimaryService = function (peripheral, serviceUuid) {
+  serviceUuid = addDashes(serviceUuid);
+
+  if (peripheral.cachedServices[serviceUuid]) {
+    return new Promise((resolve, reject) => {
+      resolve(peripheral.cachedServices[serviceUuid]);
+    });
+  }
+
+  return peripheral.device.gatt.getPrimaryService(serviceUuid)
+    .then(service => {
+      peripheral.cachedServices[serviceUuid] = service;
+      return service;
+    });
+};
+
+NobleBindings.prototype.read = function (deviceUuid, serviceUuid, characteristicUuid) {
+  const self = this;
+  const peripheral = this._peripherals[deviceUuid];
+  debug('read', deviceUuid, serviceUuid, characteristicUuid);
+
+  self.getPrimaryService(peripheral, serviceUuid)
+    .then(service => service.getCharacteristic(addDashes(characteristicUuid)))
+    .then(characteristic => characteristic.readValue())
+    .then(data => {
+      self.emit('read', peripheral.uuid, serviceUuid, characteristicUuid, Buffer.from(data.buffer), false);
+    })
+    .catch(err => {
+      debug('error reading characteristic', err);
+      self.emit('error', err);
+    });
+};
+
+NobleBindings.prototype.write = function (deviceUuid, serviceUuid, characteristicUuid, data, withoutResponse) {
+  const self = this;
+  const peripheral = this._peripherals[deviceUuid];
+  debug('write', deviceUuid, serviceUuid, characteristicUuid, data, withoutResponse);
+
+  self.getPrimaryService(peripheral, serviceUuid)
+    .then(service => service.getCharacteristic(addDashes(characteristicUuid)))
+    .then(characteristic => characteristic.writeValue(data))
+    .then(() => {
+      debug('value written');
+      self.emit('write', peripheral.uuid, serviceUuid, characteristicUuid);
+    })
+    .catch(err => {
+      debug('error writing to characteristic', serviceUuid, characteristicUuid, err);
+    });
+};
+
+NobleBindings.prototype.broadcast = function (deviceUuid, serviceUuid, characteristicUuid, broadcast) {
+  // TODO impelment when web API has functionatility then emit response
+  // var peripheral = this._peripherals[deviceUuid];
+  // this.emit('broadcast', deviceUuid, serviceUuid, characteristicUuid, state);
+};
+
+NobleBindings.prototype.notify = function (deviceUuid, serviceUuid, characteristicUuid, notify) {
+  const self = this;
+  const peripheral = this._peripherals[deviceUuid];
+
+  const charPromise = self.getPrimaryService(peripheral, serviceUuid)
+    .then(service => service.getCharacteristic(addDashes(characteristicUuid)));
+
+  peripheral.notifcationListeners = peripheral.notifcationListeners || {};
+
+  if (notify) {
+    charPromise.then(characteristic => characteristic.startNotifications())
+      .then(characteristic => {
+        debug('notifications started', characteristicUuid);
+        peripheral.notifcationListeners[`${serviceUuid}__${characteristicUuid}`] = function (evt) {
+          debug('oncharacteristicvaluechanged', evt, Buffer.from(evt.target.value.buffer));
+          self.emit('read', deviceUuid, serviceUuid, characteristicUuid, Buffer.from(evt.target.value.buffer), true);
+        };
+        characteristic.addEventListener('characteristicvaluechanged', peripheral.notifcationListeners[`${serviceUuid}__${characteristicUuid}`]);
+
+        const onDisconnected = function () {
+          characteristic.removeEventListener('characteristicvaluechanged', peripheral.notifcationListeners[`${serviceUuid}__${characteristicUuid}`]);
+          delete peripheral.notifcationListeners[`${serviceUuid}__${characteristicUuid}`];
+        };
+        peripheral.device.addEventListener('gattserverdisconnected', onDisconnected, { once: true });
+
+        self.emit('notify', deviceUuid, serviceUuid, characteristicUuid, true);
+        return characteristic;
+      })
+      .catch(err => {
+        debug('error enabling notifications on characteristic', err);
+        self.emit('error', err);
+      });
+  } else {
+    charPromise.then(characteristic => characteristic.stopNotifications())
+      .then(characteristic => {
+        debug('notifications stopped', characteristic);
+        if (peripheral.notifcationListeners[`${serviceUuid}__${characteristicUuid}`]) {
+          characteristic.removeEventListener('characteristicvaluechanged', peripheral.notifcationListeners[`${serviceUuid}__${characteristicUuid}`]);
+          delete peripheral.notifcationListeners[`${serviceUuid}__${characteristicUuid}`];
+        }
+        self.emit('notify', deviceUuid, serviceUuid, characteristicUuid, false);
+        return characteristic;
+      })
+      .catch(err => {
+        debug('error disabling notifications on characteristic', err);
+        self.emit('error', err);
+      });
+  }
+};
+
+NobleBindings.prototype.discoverDescriptors = function (deviceUuid, serviceUuid, characteristicUuid) {
+  // TODO impelment when web API has functionatility then emit response
+  // var peripheral = this._peripherals[deviceUuid];
+  // this.emit('descriptorsDiscover', deviceUuid, serviceUuid, characteristicUuid, descriptors);
+};
+
+NobleBindings.prototype.readValue = function (deviceUuid, serviceUuid, characteristicUuid, descriptorUuid) {
+  // TODO impelment when web API has functionatility then emit response
+  // var peripheral = this._peripherals[deviceUuid];
+  // this.emit('valueRead', deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data);
+};
+
+NobleBindings.prototype.writeValue = function (deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data) {
+  // TODO impelment when web API has functionatility then emit response
+  // var peripheral = this._peripherals[deviceUuid];
+  // this.emit('valueWrite', deviceUuid, serviceUuid, characteristicUuid, descriptorUuid);
+};
+
+NobleBindings.prototype.readHandle = function (deviceUuid, handle) {
+  // TODO impelment when web API has functionatility then emit response
+  // var peripheral = this._peripherals[deviceUuid];
+  // this.emit('handleRead', deviceUuid, handle, data);
+};
+
+NobleBindings.prototype.writeHandle = function (deviceUuid, handle, data, withoutResponse) {
+  // TODO impelment when web API has functionatility then emit response
+  // var peripheral = this._peripherals[deviceUuid];
+  // this.emit('handleWrite', deviceUuid, handle);
+};
+
+module.exports = NobleBindings;

package/lib/websocket/bindings.js

@@ -0,0 +1,321 @@
+const events = require('events');
+const util = require('util');
+
+const WebSocket = require('ws');
+
+const NobleBindings = function () {
+  const port = 0xB1e;
+  this._ws = new WebSocket(`ws://localhost:${port}`);
+
+  this._startScanCommand = null;
+  this._peripherals = {};
+
+  this.on('message', this._onMessage.bind(this));
+
+  if (!this._ws.on) {
+    this._ws.on = this._ws.addEventListener;
+  }
+
+  this._ws.on('open', this._onOpen.bind(this));
+  this._ws.on('close', this._onClose.bind(this));
+  this._ws.on('error', this._onClose.bind(this));
+
+  const _this = this;
+  this._ws.on('message', event => {
+    const data = (process.title === 'browser') ? event.data : event;
+
+    _this.emit('message', JSON.parse(data));
+  });
+};
+
+util.inherits(NobleBindings, events.EventEmitter);
+
+NobleBindings.prototype.init = function () {
+  // no-op
+};
+
+NobleBindings.prototype._onOpen = function () {
+  console.log('on -> open');
+};
+
+NobleBindings.prototype._onClose = function () {
+  console.log('on -> close');
+  this.emit('stateChange', 'poweredOff');
+};
+
+NobleBindings.prototype._onMessage = function (event) {
+  let {
+    type,
+    peripheralUuid,
+    address,
+    addressType,
+    connectable,
+    advertisement,
+    rssi,
+    serviceUuids,
+    serviceUuid,
+    includedServiceUuids,
+    characteristics,
+    characteristicUuid,
+    isNotification,
+    state,
+    descriptors,
+    descriptorUuid,
+    handle
+  } = event;
+  const data = event.data ? Buffer.from(event.data, 'hex') : null;
+
+  if (type === 'stateChange') {
+    console.log(state);
+    this.emit('stateChange', state);
+  } else if (type === 'discover') {
+    advertisement = {
+      localName: advertisement.localName,
+      txPowerLevel: advertisement.txPowerLevel,
+      serviceUuids: advertisement.serviceUuids,
+      manufacturerData: (advertisement.manufacturerData ? Buffer.from(advertisement.manufacturerData, 'hex') : null),
+      serviceData: (advertisement.serviceData ? Buffer.from(advertisement.serviceData, 'hex') : null)
+    };
+
+    this._peripherals[peripheralUuid] = {
+      uuid: peripheralUuid,
+      address: address,
+      advertisement: advertisement,
+      rssi: rssi
+    };
+
+    this.emit('discover', peripheralUuid, address, addressType, connectable, advertisement, rssi);
+  } else if (type === 'connect') {
+    this.emit('connect', peripheralUuid);
+  } else if (type === 'disconnect') {
+    this.emit('disconnect', peripheralUuid);
+  } else if (type === 'rssiUpdate') {
+    this.emit('rssiUpdate', peripheralUuid, rssi);
+  } else if (type === 'servicesDiscover') {
+    this.emit('servicesDiscover', peripheralUuid, serviceUuids);
+  } else if (type === 'includedServicesDiscover') {
+    this.emit('includedServicesDiscover', peripheralUuid, serviceUuid, includedServiceUuids);
+  } else if (type === 'characteristicsDiscover') {
+    this.emit('characteristicsDiscover', peripheralUuid, serviceUuid, characteristics);
+  } else if (type === 'read') {
+    this.emit('read', peripheralUuid, serviceUuid, characteristicUuid, data, isNotification);
+  } else if (type === 'write') {
+    this.emit('write', peripheralUuid, serviceUuid, characteristicUuid);
+  } else if (type === 'broadcast') {
+    this.emit('broadcast', peripheralUuid, serviceUuid, characteristicUuid, state);
+  } else if (type === 'notify') {
+    this.emit('notify', peripheralUuid, serviceUuid, characteristicUuid, state);
+  } else if (type === 'descriptorsDiscover') {
+    this.emit('descriptorsDiscover', peripheralUuid, serviceUuid, characteristicUuid, descriptors);
+  } else if (type === 'valueRead') {
+    this.emit('valueRead', peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid, data);
+  } else if (type === 'valueWrite') {
+    this.emit('valueWrite', peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid);
+  } else if (type === 'handleRead') {
+    this.emit('handleRead', peripheralUuid, handle, data);
+  } else if (type === 'handleWrite') {
+    this.emit('handleWrite', peripheralUuid, handle);
+  } else if (type === 'handleNotify') {
+    this.emit('handleNotify', peripheralUuid, handle, data);
+  }
+};
+
+NobleBindings.prototype._sendCommand = function (command, errorCallback) {
+  const message = JSON.stringify(command);
+  this._ws.send(message, error => {
+    if (error != null) {
+      console.warn('could not send command', command, error);
+      if (typeof errorCallback === 'function') {
+        errorCallback(error);
+      }
+    }
+  });
+};
+
+NobleBindings.prototype.startScanning = function (serviceUuids, allowDuplicates) {
+  this._startScanCommand = {
+    action: 'startScanning',
+    serviceUuids: serviceUuids,
+    allowDuplicates: allowDuplicates
+  };
+  this._sendCommand(this._startScanCommand);
+
+  this.emit('scanStart');
+};
+
+NobleBindings.prototype.stopScanning = function () {
+  this._startScanCommand = null;
+
+  this._sendCommand({
+    action: 'stopScanning'
+  });
+
+  this.emit('scanStop');
+};
+
+NobleBindings.prototype.connect = function (deviceUuid) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'connect',
+    peripheralUuid: peripheral.uuid
+  });
+};
+
+NobleBindings.prototype.disconnect = function (deviceUuid) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'disconnect',
+    peripheralUuid: peripheral.uuid
+  });
+};
+
+NobleBindings.prototype.updateRssi = function (deviceUuid) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'updateRssi',
+    peripheralUuid: peripheral.uuid
+  });
+};
+
+NobleBindings.prototype.discoverServices = function (deviceUuid, uuids) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'discoverServices',
+    peripheralUuid: peripheral.uuid,
+    uuids: uuids
+  });
+};
+
+NobleBindings.prototype.discoverIncludedServices = function (deviceUuid, serviceUuid, serviceUuids) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'discoverIncludedServices',
+    peripheralUuid: peripheral.uuid,
+    serviceUuid: serviceUuid,
+    serviceUuids: serviceUuids
+  });
+};
+
+NobleBindings.prototype.discoverCharacteristics = function (deviceUuid, serviceUuid, characteristicUuids) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'discoverCharacteristics',
+    peripheralUuid: peripheral.uuid,
+    serviceUuid: serviceUuid,
+    characteristicUuids: characteristicUuids
+  });
+};
+
+NobleBindings.prototype.read = function (deviceUuid, serviceUuid, characteristicUuid) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'read',
+    peripheralUuid: peripheral.uuid,
+    serviceUuid: serviceUuid,
+    characteristicUuid: characteristicUuid
+  });
+};
+
+NobleBindings.prototype.write = function (deviceUuid, serviceUuid, characteristicUuid, data, withoutResponse) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'write',
+    peripheralUuid: peripheral.uuid,
+    serviceUuid: serviceUuid,
+    characteristicUuid: characteristicUuid,
+    data: data.toString('hex'),
+    withoutResponse: withoutResponse
+  });
+};
+
+NobleBindings.prototype.broadcast = function (deviceUuid, serviceUuid, characteristicUuid, broadcast) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'broadcast',
+    peripheralUuid: peripheral.uuid,
+    serviceUuid: serviceUuid,
+    characteristicUuid: characteristicUuid,
+    broadcast: broadcast
+  });
+};
+
+NobleBindings.prototype.notify = function (deviceUuid, serviceUuid, characteristicUuid, notify) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'notify',
+    peripheralUuid: peripheral.uuid,
+    serviceUuid: serviceUuid,
+    characteristicUuid: characteristicUuid,
+    notify: notify
+  });
+};
+
+NobleBindings.prototype.discoverDescriptors = function (deviceUuid, serviceUuid, characteristicUuid) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'discoverDescriptors',
+    peripheralUuid: peripheral.uuid,
+    serviceUuid: serviceUuid,
+    characteristicUuid: characteristicUuid
+  });
+};
+
+NobleBindings.prototype.readValue = function (deviceUuid, serviceUuid, characteristicUuid, descriptorUuid) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'readValue',
+    peripheralUuid: peripheral.uuid,
+    serviceUuid: serviceUuid,
+    characteristicUuid: characteristicUuid,
+    descriptorUuid: descriptorUuid
+  });
+};
+
+NobleBindings.prototype.writeValue = function (deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'writeValue',
+    peripheralUuid: peripheral.uuid,
+    serviceUuid: serviceUuid,
+    characteristicUuid: characteristicUuid,
+    descriptorUuid: descriptorUuid,
+    data: data.toString('hex')
+  });
+};
+
+NobleBindings.prototype.readHandle = function (deviceUuid, handle) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'readHandle',
+    peripheralUuid: peripheral.uuid,
+    handle: handle
+  });
+};
+
+NobleBindings.prototype.writeHandle = function (deviceUuid, handle, data, withoutResponse) {
+  const peripheral = this._peripherals[deviceUuid];
+
+  this._sendCommand({
+    action: 'writeHandle',
+    peripheralUuid: peripheral.uuid,
+    handle: handle,
+    data: data.toString('hex'),
+    withoutResponse: withoutResponse
+  });
+};
+
+module.exports = NobleBindings;