@stoprocent/noble 1.19.0 → 2.0.0

package/lib/peripheral.js

@@ -1,212 +1,209 @@
-const events = require('events');
-const util = require('util');
-
-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';
-}
+const { EventEmitter } = require('events');
+
+class Peripheral extends EventEmitter {
+  constructor (noble, id, address, addressType, connectable, advertisement, rssi, scannable) {
+    super();
+    this._noble = noble;
+    this.id = id;
+    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';
+  }
 
-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);
-    });
+  get uuid () {
+    return this.id;
   }
 
-  if (this.state === 'connected') {
-    this.emit('connect', new Error('Peripheral already connected'));
-  } else {
-    this.state = 'connecting';
-    this._noble.connect(this.id, options);
+  toString () {
+    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
+    });
   }
-};
 
-Peripheral.prototype.connect = connect;
-Peripheral.prototype.connectAsync = function (options) {
-  return util.promisify(callback => this.connect(options, callback))();
-};
+  connect (options, callback) {
+    if (typeof options === 'function') {
+      callback = options;
+      options = undefined;
+    }
 
-Peripheral.prototype.cancelConnect = function (options) {
-  if (this.state === 'connecting') {
-    this.emit('connect', new Error('connection canceled!'));
-    this._noble.cancelConnect(this.id, options);
-  }
-};
+    if (callback) {
+      this.once('connect', error => callback(error));
+    }
 
-const disconnect = function (callback) {
-  if (callback) {
-    this.once('disconnect', () => {
-      callback(null);
-    });
+    if (this.state === 'connected') {
+      this.emit('connect', new Error('Peripheral already connected'));
+    } else {
+      this.state = 'connecting';
+      this._noble.connect(this.id, options);
+    }
   }
-  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);
+  async connectAsync (options) {
+    return new Promise((resolve, reject) => {
+      this.connect(options, error => error ? reject(error) : resolve());
     });
   }
 
-  this._noble.updateRssi(this.id);
-};
+  cancelConnect (options) {
+    if (this.state === 'connecting') {
+      this.emit('connect', new Error('connection canceled!'));
+      this._noble.cancelConnect(this.id, options);
+    }
+  }
 
-Peripheral.prototype.updateRssi = updateRssi;
-Peripheral.prototype.updateRssiAsync = util.promisify(updateRssi);
+  disconnect (callback) {
+    if (callback) {
+      this.once('disconnect', () => callback(null));
+    }
+    this.state = 'disconnecting';
+    this._noble.disconnect(this.id);
+  }
 
-const discoverServices = function (uuids, callback) {
-  if (callback) {
-    this.once('servicesDiscover', services => {
-      callback(null, services);
+  async disconnectAsync () {
+    return new Promise((resolve, reject) => {
+      this.disconnect(error => error ? reject(error) : resolve());
     });
   }
 
-  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;
+  updateRssi (callback) {
+    if (callback) {
+      this.once('rssiUpdate', (rssi, error) => callback(error, rssi));
     }
-    let numDiscovered = 0;
-    const allCharacteristics = [];
+    this._noble.updateRssi(this.id);
+  }
 
-    for (const i in services) {
-      const service = services[i];
+  async updateRssiAsync () {
+    return this._noble._withDisconnectHandler(this.id, () => {
+      return new Promise((resolve, reject) => {
+        this.updateRssi((error, rssi) => error ? reject(error) : resolve(rssi));
+      });
+    });
+  }
 
-      service.discoverCharacteristics(characteristicsUuids, (error, characteristics) => {
-        numDiscovered++;
+  discoverServices (uuids, callback) {
+    if (callback) {
+      this.once('servicesDiscover', (services, error) => callback(error, services));
+    }
+    this._noble.discoverServices(this.id, uuids);
+  }
 
-        // TODO: handle `error`?
-        if (error === null) {
-          for (const j in characteristics) {
-            const characteristic = characteristics[j];
+  async discoverServicesAsync (uuids) {
+    return this._noble._withDisconnectHandler(this.id, () => {
+      return new Promise((resolve, reject) => {
+        this.discoverServices(uuids, (error, services) => error ? reject(error) : resolve(services));
+      });
+    });
+  }
 
-            allCharacteristics.push(characteristic);
+  discoverSomeServicesAndCharacteristics (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++;
+          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);
+          if (numDiscovered === services.length) {
+            if (callback) {
+              callback(null, services, allCharacteristics);
+            }
           }
-        }
+        });
+      }
+    });
+  }
+
+  async discoverSomeServicesAndCharacteristicsAsync (serviceUuids, characteristicsUuids) {
+    return this._noble._withDisconnectHandler(this.id, () => {
+      return new Promise((resolve, reject) => {
+        this.discoverSomeServicesAndCharacteristics(
+          serviceUuids,
+          characteristicsUuids,
+          (error, services, characteristics) =>
+            error ? reject(error) : resolve({ services, characteristics })
+        );
       });
-    }
-  });
-};
-
-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);
-};
+  discoverAllServicesAndCharacteristics (callback) {
+    this.discoverSomeServicesAndCharacteristics([], [], callback);
+  }
 
-Peripheral.prototype.readHandle = readHandle;
-Peripheral.prototype.readHandleAsync = util.promisify(readHandle);
+  async discoverAllServicesAndCharacteristicsAsync () {
+    return this._noble._withDisconnectHandler(this.id, () => {
+      return new Promise((resolve, reject) => {
+        this.discoverAllServicesAndCharacteristics(
+          (error, services, characteristics) =>
+            error ? reject(error) : resolve({ services, characteristics })
+        );
+      });
+    });
+  }
 
-const writeHandle = function (handle, data, withoutResponse, callback) {
-  if (!(data instanceof Buffer)) {
-    throw new Error('data must be a Buffer');
+  readHandle (handle, callback) {
+    if (callback) {
+      this.once(`handleRead${handle}`, (data, error) => callback(error, data));
+    }
+    this._noble.readHandle(this.id, handle);
   }
 
-  if (callback) {
-    this.once(`handleWrite${handle}`, () => {
-      callback(null);
+  async readHandleAsync (handle) {
+    return this._noble._withDisconnectHandler(this.id, () => {
+      return new Promise((resolve, reject) => {
+        this.readHandle(handle, (error, data) => error ? reject(error) : resolve(data));
+      });
     });
   }
 
-  this._noble.writeHandle(this.id, handle, data, withoutResponse);
-};
+  writeHandle (handle, data, withoutResponse, callback) {
+    if (!(data instanceof Buffer)) {
+      throw new Error('data must be a Buffer');
+    }
+
+    if (callback) {
+      this.once(`handleWrite${handle}`, (error) => callback(error));
+    }
 
-Peripheral.prototype.writeHandle = writeHandle;
-Peripheral.prototype.writeHandleAsync = util.promisify(writeHandle);
+    this._noble.writeHandle(this.id, handle, data, withoutResponse);
+  }
+
+  async writeHandleAsync (handle, data, withoutResponse) {
+    return this._noble._withDisconnectHandler(this.id, () => {
+      return new Promise((resolve, reject) => {
+        this.writeHandle(handle, data, withoutResponse, error => error ? reject(error) : resolve());
+      });
+    });
+  }
+}
 
 module.exports = Peripheral;

package/lib/resolve-bindings.js

@@ -1,44 +1,51 @@
 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');
+const Noble = require('./noble');
+
+function loadBindings (bindingType = null, options = {}) {
+  switch (bindingType) {
+    case 'hci':
+      return new (require('./hci-socket/bindings'))(options);
+    case 'mac':
+      return new (require('./mac/bindings'))(options);
+    case 'win':
+      return new (getWindowsBindings())(options);
+    default:
+      throw new Error('Unsupported binding type: ' + bindingType);
   }
 }
 
-module.exports = function (options = {}) {
-  const platform = os.platform();
+function getWindowsBindings () {
+  const ver = os.release().split('.').map((str) => parseInt(str, 10));
+  const isWin10WithBLE = 
+    ver[0] > 10 ||
+    (ver[0] === 10 && ver[1] > 0) ||
+    (ver[0] === 10 && ver[1] === 0 && ver[2] >= 15063);
+  return isWin10WithBLE ? require('./win/bindings') : require('./hci-socket/bindings');
+}
 
-  if (process.env.NOBLE_WEBSOCKET) {
-    return new (require('./websocket/bindings'))(options);
-  } else if (process.env.NOBLE_DISTRIBUTED) {
-    return new (require('./distributed/bindings'))(options);
-  } else if (
+function getDefaultBindings (options = {}) {
+  const platform = os.platform();
+  if (
     platform === 'linux' ||
     platform === 'freebsd' ||
-    (process.env.BLUETOOTH_HCI_SOCKET_UART_PORT ||
-      process.env.BLUETOOTH_HCI_SOCKET_FORCE_UART) ||
-    (process.env.BLUETOOTH_HCI_SOCKET_USB_VID &&
-      process.env.BLUETOOTH_HCI_SOCKET_USB_PID)
+    process.env.BLUETOOTH_HCI_SOCKET_UART_PORT ||
+    process.env.BLUETOOTH_HCI_SOCKET_FORCE_UART ||
+    (process.env.BLUETOOTH_HCI_SOCKET_USB_VID && process.env.BLUETOOTH_HCI_SOCKET_USB_PID)
   ) {
-    return new (require('./hci-socket/bindings'))(options);
+    return loadBindings('hci', options);
   } else if (platform === 'darwin') {
-    return new (require('./mac/bindings'))(options);
+    return loadBindings('mac', options);
   } else if (platform === 'win32') {
-    return new (getWindowsBindings())(options);
+    return loadBindings('win', options);
   } else {
-    throw new Error('Unsupported platform');
+    throw new Error('Unsupported platform: ' + platform);
   }
+}
+
+module.exports = function (bindingType = 'default', options = {}) {
+  const bindings = bindingType === 'default' 
+    ? getDefaultBindings(options)
+    : loadBindings(bindingType, options);
+  return new Noble(bindings);
 };

package/lib/service.js

@@ -1,72 +1,75 @@
-const events = require('events');
-const util = require('util');
-
+const { EventEmitter } = require('events');
 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;
+class Service extends EventEmitter {
 
-  const service = services[uuid];
-  if (service) {
-    this.name = service.name;
-    this.type = service.type;
-  }
-}
+  constructor (noble, peripheralId, uuid) {
+    super();
+    
+    this._noble = noble;
+    this._peripheralId = peripheralId;
 
-util.inherits(Service, events.EventEmitter);
+    this.uuid = uuid;
+    this.name = null;
+    this.type = null;
+    this.includedServiceUuids = null;
+    this.characteristics = null;
 
-Service.prototype.toString = function () {
-  return JSON.stringify({
-    uuid: this.uuid,
-    name: this.name,
-    type: this.type,
-    includedServiceUuids: this.includedServiceUuids
-  });
-};
+    const service = services[uuid];
+    if (service) {
+      this.name = service.name;
+      this.type = service.type;
+    }
+  }
 
-const discoverIncludedServices = function (serviceUuids, callback) {
-  if (callback) {
-    this.once('includedServicesDiscover', includedServiceUuids => {
-      callback(null, includedServiceUuids);
+  toString () {
+    return JSON.stringify({
+      uuid: this.uuid,
+      name: this.name,
+      type: this.type,
+      includedServiceUuids: this.includedServiceUuids
     });
   }
 
-  this._noble.discoverIncludedServices(
-    this._peripheralId,
-    this.uuid,
-    serviceUuids
-  );
-};
+  discoverIncludedServices (serviceUuids, callback) {
+    if (callback) {
+      this.once('includedServicesDiscover', (includedServiceUuids, error) => callback(error, includedServiceUuids));
+    }
 
-Service.prototype.discoverIncludedServices = discoverIncludedServices;
-Service.prototype.discoverIncludedServicesAsync = function (serviceUuids) {
-  return util.promisify((callback) => this.discoverIncludedServices(serviceUuids, callback))();
-};
+    this._noble.discoverIncludedServices(
+      this._peripheralId,
+      this.uuid,
+      serviceUuids
+    );
+  }
 
-const discoverCharacteristics = function (characteristicUuids, callback) {
-  if (callback) {
-    this.once('characteristicsDiscover', characteristics => {
-      callback(null, characteristics);
+  async discoverIncludedServicesAsync (serviceUuids) {
+    return this._noble._withDisconnectHandler(this._peripheralId, () => {
+      return new Promise((resolve, reject) => {
+        this.discoverIncludedServices(serviceUuids, (error, includedServiceUuids) => error ? reject(error) : resolve(includedServiceUuids));
+      });
     });
   }
 
-  this._noble.discoverCharacteristics(
-    this._peripheralId,
-    this.uuid,
-    characteristicUuids
-  );
-};
+  discoverCharacteristics (characteristicUuids, callback) {
+    if (callback) {
+      this.once('characteristicsDiscover', (characteristics, error) => callback(error, characteristics));
+    }
 
-Service.prototype.discoverCharacteristics = discoverCharacteristics;
-Service.prototype.discoverCharacteristicsAsync = function (characteristicUuids) {
-  return util.promisify((callback) => this.discoverCharacteristics(characteristicUuids, callback))();
-};
+    this._noble.discoverCharacteristics(
+      this._peripheralId,
+      this.uuid,
+      characteristicUuids
+    );
+  }
+
+  async discoverCharacteristicsAsync (characteristicUuids) {
+    return this._noble._withDisconnectHandler(this._peripheralId, () => {
+      return new Promise((resolve, reject) => {
+        this.discoverCharacteristics(characteristicUuids, (error, characteristics) => error ? reject(error) : resolve(characteristics));
+      });
+    });
+  }
+}
 
 module.exports = Service;

package/lib/win/binding.gyp

@@ -6,19 +6,12 @@
     {
       'target_name': 'binding',
       'sources': [ 
-        'src/noble_winrt.cc', 
-        'src/napi_winrt.cc', 
-        'src/peripheral_winrt.cc',
-        'src/radio_watcher.cc', 
-        'src/notify_map.cc', 
-        'src/ble_manager.cc', 
-        'src/winrt_cpp.cc', 
-        'src/winrt_guid.cc', 
-        'src/callbacks.cc' 
+        "<!@(node -p \"require('fs').readdirSync('src').filter(f=>new RegExp('.*\\\\.(c|cc|cpp)$').test(f)).map(f=>'src/'+f).join(' ')\")",
+        "<!@(node -p \"require('fs').readdirSync('../common/src').filter(f=>new RegExp('.*\\\\.(c|cc|cpp)$').test(f)).map(f=>'../common/src/'+f).join(' ')\")"
       ],
       'include_dirs': [
         "<!(node -p \"require('node-addon-api').include_dir\")",
-        "<!@(node -p \"require('napi-thread-safe-callback').include\")"
+        "../common/include"
       ],
       'cflags!': [ '-fno-exceptions' ],
       'cflags_cc!': [ '-fno-exceptions' ],
@@ -27,7 +20,7 @@
           'ExceptionHandling': 1,
           'AdditionalOptions': [
             '/await', 
-            '/std:c++latest'
+            '/std:c++20'
           ],
         },
       },

package/lib/win/bindings.js

@@ -1,11 +1,9 @@
 const { EventEmitter } = require('events');
-const { inherits } = require('util');
 const { resolve } = require('path');
 const dir = resolve(__dirname, '..', '..');
 const binding = require('node-gyp-build')(dir);
-
 const { NobleWinrt } = binding;
 
-inherits(NobleWinrt, EventEmitter);
+Object.setPrototypeOf(NobleWinrt.prototype, EventEmitter.prototype);
 
 module.exports = NobleWinrt;