@stoprocent/noble 1.19.0 → 2.0.0

package/lib/webbluetooth/bindings.js

@@ -1,368 +0,0 @@
-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,
-          advertisement: { localName: device.name }, // advertisement,
-          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

@@ -1,321 +0,0 @@
-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,
-      advertisement,
-      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,
-    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
-  });
-};
-
-NobleBindings.prototype.discoverIncludedServices = function (deviceUuid, serviceUuid, serviceUuids) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand({
-    action: 'discoverIncludedServices',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    serviceUuids
-  });
-};
-
-NobleBindings.prototype.discoverCharacteristics = function (deviceUuid, serviceUuid, characteristicUuids) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand({
-    action: 'discoverCharacteristics',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuids
-  });
-};
-
-NobleBindings.prototype.read = function (deviceUuid, serviceUuid, characteristicUuid) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand({
-    action: 'read',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid
-  });
-};
-
-NobleBindings.prototype.write = function (deviceUuid, serviceUuid, characteristicUuid, data, withoutResponse) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand({
-    action: 'write',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid,
-    data: data.toString('hex'),
-    withoutResponse
-  });
-};
-
-NobleBindings.prototype.broadcast = function (deviceUuid, serviceUuid, characteristicUuid, broadcast) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand({
-    action: 'broadcast',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid,
-    broadcast
-  });
-};
-
-NobleBindings.prototype.notify = function (deviceUuid, serviceUuid, characteristicUuid, notify) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand({
-    action: 'notify',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid,
-    notify
-  });
-};
-
-NobleBindings.prototype.discoverDescriptors = function (deviceUuid, serviceUuid, characteristicUuid) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand({
-    action: 'discoverDescriptors',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid
-  });
-};
-
-NobleBindings.prototype.readValue = function (deviceUuid, serviceUuid, characteristicUuid, descriptorUuid) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand({
-    action: 'readValue',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid,
-    descriptorUuid
-  });
-};
-
-NobleBindings.prototype.writeValue = function (deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand({
-    action: 'writeValue',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid,
-    descriptorUuid,
-    data: data.toString('hex')
-  });
-};
-
-NobleBindings.prototype.readHandle = function (deviceUuid, handle) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand({
-    action: 'readHandle',
-    peripheralUuid: peripheral.uuid,
-    handle
-  });
-};
-
-NobleBindings.prototype.writeHandle = function (deviceUuid, handle, data, withoutResponse) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand({
-    action: 'writeHandle',
-    peripheralUuid: peripheral.uuid,
-    handle,
-    data: data.toString('hex'),
-    withoutResponse
-  });
-};
-
-module.exports = NobleBindings;

package/lib/win/src/peripheral.h

@@ -1,23 +0,0 @@
-#pragma once
-
-using Data = std::vector<uint8_t>;
-
-enum AddressType
-{
-    PUBLIC,
-    RANDOM,
-    UNKNOWN,
-};
-
-class Peripheral
-{
-public:
-    std::string address = "unknown";
-    AddressType addressType = UNKNOWN;
-    bool connectable = false;
-    std::string name;
-    int txPowerLevel;
-    Data manufacturerData;
-    std::vector<std::pair<std::string, Data>> serviceData;
-    std::vector<std::string> serviceUuids;
-};