@stoprocent/noble 1.9.2-16

package/lib/peripheral.js

@@ -0,0 +1,219 @@
+const events = require('events');
+const util = require('util');
+
+const Manufacturer = require('./manufacture');
+
+function Peripheral (noble, id, address, addressType, connectable, advertisement, rssi, scannable) {
+  this._noble = noble;
+
+  this.id = id;
+  this.uuid = id; // for legacy
+  this.address = address;
+  this.addressType = addressType;
+  this.connectable = connectable;
+  this.scannable = scannable;
+  this.advertisement = advertisement;
+  this.rssi = rssi;
+  this.services = null;
+  this.mtu = null;
+  this.state = 'disconnected';
+  this.manufacturer = null;
+
+  if (typeof this.advertisement !== 'undefined' && typeof this.advertisement.manufacturerData !== 'undefined') {
+    this.manufacturer = new Manufacturer(noble, this.advertisement.manufacturerData);
+  }
+}
+
+util.inherits(Peripheral, events.EventEmitter);
+
+Peripheral.prototype.toString = function () {
+  return JSON.stringify({
+    id: this.id,
+    address: this.address,
+    addressType: this.addressType,
+    connectable: this.connectable,
+    advertisement: this.advertisement,
+    rssi: this.rssi,
+    mtu: this.mtu,
+    state: this.state
+  });
+};
+
+const connect = function (options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = undefined;
+  }
+
+  if (callback) {
+    this.once('connect', error => {
+      callback(error);
+    });
+  }
+
+  if (this.state === 'connected') {
+    this.emit('connect', new Error('Peripheral already connected'));
+  } else {
+    this.state = 'connecting';
+    this._noble.connect(this.id, options);
+  }
+};
+
+Peripheral.prototype.connect = connect;
+Peripheral.prototype.connectAsync = function (options) {
+  return util.promisify(callback => this.connect(options, callback))();
+};
+
+Peripheral.prototype.cancelConnect = function (options) {
+  if (this.state === 'connecting') {
+    this.emit('connect', new Error('connection canceled!'));
+    this._noble.cancelConnect(this.id, options);
+  }
+};
+
+const disconnect = function (callback) {
+  if (callback) {
+    this.once('disconnect', () => {
+      callback(null);
+    });
+  }
+  this.state = 'disconnecting';
+  this._noble.disconnect(this.id);
+};
+
+Peripheral.prototype.disconnect = disconnect;
+Peripheral.prototype.disconnectAsync = util.promisify(disconnect);
+
+const updateRssi = function (callback) {
+  if (callback) {
+    this.once('rssiUpdate', rssi => {
+      callback(null, rssi);
+    });
+  }
+
+  this._noble.updateRssi(this.id);
+};
+
+Peripheral.prototype.updateRssi = updateRssi;
+Peripheral.prototype.updateRssiAsync = util.promisify(updateRssi);
+
+const discoverServices = function (uuids, callback) {
+  if (callback) {
+    this.once('servicesDiscover', services => {
+      callback(null, services);
+    });
+  }
+
+  this._noble.discoverServices(this.id, uuids);
+};
+
+Peripheral.prototype.discoverServices = discoverServices;
+Peripheral.prototype.discoverServicesAsync = function (uuids) {
+  return util.promisify((callback) => this.discoverServices(uuids, callback))();
+};
+
+const discoverSomeServicesAndCharacteristics = function (serviceUuids, characteristicsUuids, callback) {
+  this.discoverServices(serviceUuids, (err, services) => {
+    if (!err && services.length < serviceUuids.length) {
+      err = 'Could not find all requested services';
+    }
+
+    if (err) {
+      callback(err, null, null);
+      return;
+    }
+    let numDiscovered = 0;
+    const allCharacteristics = [];
+
+    for (const i in services) {
+      const service = services[i];
+
+      service.discoverCharacteristics(characteristicsUuids, (error, characteristics) => {
+        numDiscovered++;
+
+        // TODO: handle `error`?
+        if (error === null) {
+          for (const j in characteristics) {
+            const characteristic = characteristics[j];
+
+            allCharacteristics.push(characteristic);
+          }
+        }
+
+        if (numDiscovered === services.length) {
+          if (callback) {
+            callback(null, services, allCharacteristics);
+          }
+        }
+      });
+    }
+  });
+};
+
+Peripheral.prototype.discoverSomeServicesAndCharacteristics = discoverSomeServicesAndCharacteristics;
+Peripheral.prototype.discoverSomeServicesAndCharacteristicsAsync = function (serviceUuids, characteristicsUuids) {
+  return new Promise((resolve, reject) =>
+    this.discoverSomeServicesAndCharacteristics(
+      serviceUuids,
+      characteristicsUuids,
+      (error, services, characteristics) =>
+        error
+          ? reject(error)
+          : resolve({
+            services,
+            characteristics
+          })
+    )
+  );
+};
+
+const discoverAllServicesAndCharacteristics = function (callback) {
+  this.discoverSomeServicesAndCharacteristics([], [], callback);
+};
+
+Peripheral.prototype.discoverAllServicesAndCharacteristics = discoverAllServicesAndCharacteristics;
+Peripheral.prototype.discoverAllServicesAndCharacteristicsAsync = function () {
+  return new Promise((resolve, reject) =>
+    this.discoverAllServicesAndCharacteristics(
+      (error, services, characteristics) =>
+        error
+          ? reject(error)
+          : resolve({
+            services,
+            characteristics
+          })
+    )
+  );
+};
+
+const readHandle = function (handle, callback) {
+  if (callback) {
+    this.once(`handleRead${handle}`, data => {
+      callback(null, data);
+    });
+  }
+
+  this._noble.readHandle(this.id, handle);
+};
+
+Peripheral.prototype.readHandle = readHandle;
+Peripheral.prototype.readHandleAsync = util.promisify(readHandle);
+
+const writeHandle = function (handle, data, withoutResponse, callback) {
+  if (!(data instanceof Buffer)) {
+    throw new Error('data must be a Buffer');
+  }
+
+  if (callback) {
+    this.once(`handleWrite${handle}`, () => {
+      callback(null);
+    });
+  }
+
+  this._noble.writeHandle(this.id, handle, data, withoutResponse);
+};
+
+Peripheral.prototype.writeHandle = writeHandle;
+Peripheral.prototype.writeHandleAsync = util.promisify(writeHandle);
+
+module.exports = Peripheral;

package/lib/resolve-bindings-web.js

@@ -0,0 +1,9 @@
+function resolveBindings (options) {
+  if (navigator.bluetooth && !process.env.NOBLE_WEBSOCKET) {
+    return new (require('./webbluetooth/bindings'))(options);
+  }
+
+  return new (require('./websocket/bindings'))(options);
+}
+
+module.exports = resolveBindings;

package/lib/resolve-bindings.js

@@ -0,0 +1,44 @@
+const os = require('os');
+
+function getWindowsBindings () {
+  const ver = os
+    .release()
+    .split('.')
+    .map((str) => parseInt(str, 10));
+  if (
+    !(
+      ver[0] > 10 ||
+      (ver[0] === 10 && ver[1] > 0) ||
+      (ver[0] === 10 && ver[1] === 0 && ver[2] >= 15063)
+    )
+  ) {
+    return require('./hci-socket/bindings');
+  } else {
+    return require('./win/bindings');
+  }
+}
+
+module.exports = function (options) {
+  const platform = os.platform();
+
+  if (process.env.NOBLE_WEBSOCKET) {
+    return new (require('./websocket/bindings'))(options);
+  } else if (process.env.NOBLE_HCI_UART_PORT) {
+    return new (require('./hci-uart/bindings'))(options);
+  } else if (process.env.NOBLE_DISTRIBUTED) {
+    return new (require('./distributed/bindings'))(options);
+  } else if (
+    platform === 'linux' ||
+    platform === 'freebsd' ||
+    (process.env.BLUETOOTH_HCI_SOCKET_USB_VID &&
+      process.env.BLUETOOTH_HCI_SOCKET_USB_PID)
+  ) {
+    return new (require('./hci-socket/bindings'))(options);
+  } else if (platform === 'darwin') {
+    return new (require('./mac/bindings'))(options);
+  } else if (platform === 'win32') {
+    return new (getWindowsBindings())(options);
+  } else {
+    throw new Error('Unsupported platform');
+  }
+};

package/lib/service.js

@@ -0,0 +1,72 @@
+const events = require('events');
+const util = require('util');
+
+const services = require('./services.json');
+
+function Service (noble, peripheralId, uuid) {
+  this._noble = noble;
+  this._peripheralId = peripheralId;
+
+  this.uuid = uuid;
+  this.name = null;
+  this.type = null;
+  this.includedServiceUuids = null;
+  this.characteristics = null;
+
+  const service = services[uuid];
+  if (service) {
+    this.name = service.name;
+    this.type = service.type;
+  }
+}
+
+util.inherits(Service, events.EventEmitter);
+
+Service.prototype.toString = function () {
+  return JSON.stringify({
+    uuid: this.uuid,
+    name: this.name,
+    type: this.type,
+    includedServiceUuids: this.includedServiceUuids
+  });
+};
+
+const discoverIncludedServices = function (serviceUuids, callback) {
+  if (callback) {
+    this.once('includedServicesDiscover', includedServiceUuids => {
+      callback(null, includedServiceUuids);
+    });
+  }
+
+  this._noble.discoverIncludedServices(
+    this._peripheralId,
+    this.uuid,
+    serviceUuids
+  );
+};
+
+Service.prototype.discoverIncludedServices = discoverIncludedServices;
+Service.prototype.discoverIncludedServicesAsync = function (serviceUuids) {
+  return util.promisify((callback) => this.discoverIncludedServices(serviceUuids, callback))();
+};
+
+const discoverCharacteristics = function (characteristicUuids, callback) {
+  if (callback) {
+    this.once('characteristicsDiscover', characteristics => {
+      callback(null, characteristics);
+    });
+  }
+
+  this._noble.discoverCharacteristics(
+    this._peripheralId,
+    this.uuid,
+    characteristicUuids
+  );
+};
+
+Service.prototype.discoverCharacteristics = discoverCharacteristics;
+Service.prototype.discoverCharacteristicsAsync = function (characteristicUuids) {
+  return util.promisify((callback) => this.discoverCharacteristics(characteristicUuids, callback))();
+};
+
+module.exports = Service;

package/lib/services.json

@@ -0,0 +1,92 @@
+{
+    "1800" : { "name" : "Generic Access"
+             , "type" : "org.bluetooth.service.generic_access"
+             }
+  , "1801" : { "name" : "Generic Attribute"
+             , "type" : "org.bluetooth.service.generic_attribute"
+             }
+  , "1802" : { "name" : "Immediate Alert"
+             , "type" : "org.bluetooth.service.immediate_alert"
+             }
+  , "1803" : { "name" : "Link Loss"
+             , "type" : "org.bluetooth.service.link_loss"
+             }
+  , "1804" : { "name" : "Tx Power"
+             , "type" : "org.bluetooth.service.tx_power"
+             }
+  , "1805" : { "name" : "Current Time Service"
+             , "type" : "org.bluetooth.service.current_time"
+             }
+  , "1806" : { "name" : "Reference Time Update Service"
+             , "type" : "org.bluetooth.service.reference_time_update"
+             }
+  , "1807" : { "name" : "Next DST Change Service"
+             , "type" : "org.bluetooth.service.next_dst_change"
+             }
+  , "1808" : { "name" : "Glucose"
+             , "type" : "org.bluetooth.service.glucose"
+             }
+  , "1809" : { "name" : "Health Thermometer"
+             , "type" : "org.bluetooth.service.health_thermometer"
+             }
+  , "180a" : { "name" : "Device Information"
+             , "type" : "org.bluetooth.service.device_information"
+             }
+  , "180d" : { "name" : "Heart Rate"
+             , "type" : "org.bluetooth.service.heart_rate"
+             }
+  , "180e" : { "name" : "Phone Alert Status Service"
+             , "type" : "org.bluetooth.service.phone_alert_service"
+             }
+  , "180f" : { "name" : "Battery Service"
+             , "type" : "org.bluetooth.service.battery_service"
+             }
+  , "1810" : { "name" : "Blood Pressure"
+             , "type" : "org.bluetooth.service.blood_pressuer"
+             }
+  , "1811" : { "name" : "Alert Notification Service"
+             , "type" : "org.bluetooth.service.alert_notification"
+             }
+  , "1812" : { "name" : "Human Interface Device"
+             , "type" : "org.bluetooth.service.human_interface_device"
+             }
+  , "1813" : { "name" : "Scan Parameters"
+             , "type" : "org.bluetooth.service.scan_parameters"
+             }
+  , "1814" : { "name" : "Running Speed and Cadence"
+             , "type" : "org.bluetooth.service.running_speed_and_cadence"
+             }
+  , "1815" : { "name" : "Automation IO"
+             , "type" : "org.bluetooth.service.automation_io"
+             }
+  , "1816" : { "name" : "Cycling Speed and Cadence"
+             , "type" : "org.bluetooth.service.cycling_speed_and_cadence"
+             }
+  , "1818" : { "name" : "Cycling Power"
+             , "type" : "org.bluetooth.service.cycling_power"
+             }
+  , "1819" : { "name" : "Location and Navigation"
+             , "type" : "org.bluetooth.service.location_and_navigation"
+             }
+  , "181a" : { "name" : "Environmental Sensing"
+             , "type" : "org.bluetooth.service.environmental_sensing"
+             }
+  , "181b" : { "name" : "Body Composition"
+             , "type" : "org.bluetooth.service.body_composition"
+             }
+  , "181c" : { "name" : "User Data"
+             , "type" : "org.bluetooth.service.user_data"
+             }
+  , "181d" : { "name" : "Weight Scale"
+             , "type" : "org.bluetooth.service.weight_scale"
+             }
+  , "181e" : { "name" : "Bond Management"
+             , "type" : "org.bluetooth.service.bond_management"
+             }
+  , "181f" : { "name" : "Continuous Glucose Monitoring"
+             , "type" : "org.bluetooth.service.continuous_glucose_monitoring"
+             }
+  , "1820" : { "name" : "Internet Protocol Support"
+             , "type" : "org.bluetooth.service.internet_protocol_support"
+             }
+}