@stoprocent/noble 1.19.0 → 2.0.0

package/lib/noble.js

@@ -1,659 +1,750 @@
 const debug = require('debug')('noble');
 
-const events = require('events');
-const util = require('util');
+const { EventEmitter } = require('events');
 
 const Peripheral = require('./peripheral');
 const Service = require('./service');
 const Characteristic = require('./characteristic');
 const Descriptor = require('./descriptor');
 
-function Noble (bindings) {
-  this.initialized = false;
-
-  this.address = 'unknown';
-  this._state = 'unknown';
-  this._bindings = bindings;
+class Noble extends EventEmitter {
   
-  this._cleanupPeriperals();
-
-  this._bindings.on('stateChange', this.onStateChange.bind(this));
-  this._bindings.on('addressChange', this.onAddressChange.bind(this));
-  this._bindings.on('scanParametersSet', this.onScanParametersSet.bind(this));
-  this._bindings.on('scanStart', this.onScanStart.bind(this));
-  this._bindings.on('scanStop', this.onScanStop.bind(this));
-  this._bindings.on('discover', this.onDiscover.bind(this));
-  this._bindings.on('connect', this.onConnect.bind(this));
-  this._bindings.on('disconnect', this.onDisconnect.bind(this));
-  this._bindings.on('rssiUpdate', this.onRssiUpdate.bind(this));
-  this._bindings.on('servicesDiscover', this.onServicesDiscover.bind(this));
-  this._bindings.on('servicesDiscovered', this.onServicesDiscovered.bind(this));
-  this._bindings.on('includedServicesDiscover', this.onIncludedServicesDiscover.bind(this));
-  this._bindings.on('characteristicsDiscover', this.onCharacteristicsDiscover.bind(this));
-  this._bindings.on('characteristicsDiscovered', this.onCharacteristicsDiscovered.bind(this));
-  this._bindings.on('read', this.onRead.bind(this));
-  this._bindings.on('write', this.onWrite.bind(this));
-  this._bindings.on('broadcast', this.onBroadcast.bind(this));
-  this._bindings.on('notify', this.onNotify.bind(this));
-  this._bindings.on('descriptorsDiscover', this.onDescriptorsDiscover.bind(this));
-  this._bindings.on('valueRead', this.onValueRead.bind(this));
-  this._bindings.on('valueWrite', this.onValueWrite.bind(this));
-  this._bindings.on('handleRead', this.onHandleRead.bind(this));
-  this._bindings.on('handleWrite', this.onHandleWrite.bind(this));
-  this._bindings.on('handleNotify', this.onHandleNotify.bind(this));
-  this._bindings.on('onMtu', this.onMtu.bind(this));
-
-  this.on('warning', (message) => {
-    if (this.listeners('warning').length === 1) {
-      console.warn(`noble: ${message}`);
-    }
-  });
-
-  // lazy init bindings on first new listener, should be on stateChange
-  this.on('newListener', (event) => {
-    if (event === 'stateChange' && !this.initialized) {
-      this.initialized = true;
-      process.nextTick(() => {
-        try {
-          this._bindings.init();
-        } catch (error) {
-          this.emit('warning', 'Initialization of USB device failed: ' + error.message);
-        }
-      });
-    }
-  });
+  constructor (bindings) {
+    super();
 
-  // or lazy init bindings if someone attempts to get state first
-  Object.defineProperties(this, {
-    state: {
-      get: function () {
-        if (!this.initialized) {
-          this.initialized = true;
-          this._bindings.init();
-        }
-        return this._state;
-      }
-    }
-  });
-}
-
-util.inherits(Noble, events.EventEmitter);
-
-Noble.prototype._cleanupPeriperals = function () {
-  this._peripherals = {};
-  this._services = {};
-  this._characteristics = {};
-  this._descriptors = {};
-  this._discoveredPeripheralUUids = {};
-};
+    this._address = 'unknown';
+    this._state = 'unknown';
+    
+    this._initialized = false;
+    this._bindings = bindings;
 
-Noble.prototype.onStateChange = function (state) {
-  debug(`stateChange ${state}`);
+    this._discoveredPeripherals = new Set();
+    this._peripherals = new Map();
+    this._services = {};
+    this._characteristics = {};
+    this._descriptors = {};
 
-  // If the state is poweredOff and the previous state was poweredOn, clean up the peripherals
-  if (state === 'poweredOff' && this._state === 'poweredOn') {
     this._cleanupPeriperals();
-  }
-
-  this._state = state;
-  this.emit('stateChange', state);
-};
 
-Noble.prototype.onAddressChange = function (address) {
-  debug(`addressChange ${address}`);
+    this.on('warning', message => console.warn(`noble: ${message}`));
 
-  this.address = address;
-};
-
-Noble.prototype.setScanParameters = function (interval, window, callback) {
-  if (callback) {
-    this.once('scanParametersSet', callback);
+    this.on('newListener', event => {
+      if (event === 'stateChange' && this._initialized === false) {
+        this._initialized = true;
+        process.nextTick(this._initializeBindings.bind(this));
+      }
+    });
   }
-  this._bindings.setScanParameters(interval, window);
-};
 
-Noble.prototype.onScanParametersSet = function () {
-  debug('scanParametersSet');
-  this.emit('scanParametersSet');
-};
+  get state () {
+    if (this._initialized === false) {
+      this._initializeBindings();
+    }
+    return this._state;
+  }
+
+  get address () {
+    return this._address;
+  }
+
+  _initializeBindings () {
+    this._initialized = true;
+    this._registerListeners();
+    this._bindings.start();
+  }
+
+  _registerListeners () {
+    this._bindings.on('stateChange', this._onStateChange.bind(this));
+    this._bindings.on('addressChange', this._onAddressChange.bind(this));
+    this._bindings.on('scanParametersSet', this._onScanParametersSet.bind(this));
+    this._bindings.on('scanStart', this._onScanStart.bind(this));
+    this._bindings.on('scanStop', this._onScanStop.bind(this));
+    this._bindings.on('discover', this._onDiscover.bind(this));
+    this._bindings.on('connect', this._onConnect.bind(this));
+    this._bindings.on('disconnect', this._onDisconnect.bind(this));
+    this._bindings.on('rssiUpdate', this._onRssiUpdate.bind(this));
+    this._bindings.on('servicesDiscover', this._onServicesDiscover.bind(this));
+    this._bindings.on('servicesDiscovered', this._onServicesDiscovered.bind(this));
+    this._bindings.on('includedServicesDiscover', this._onIncludedServicesDiscover.bind(this));
+    this._bindings.on('characteristicsDiscover', this._onCharacteristicsDiscover.bind(this));
+    this._bindings.on('characteristicsDiscovered', this._onCharacteristicsDiscovered.bind(this));
+    this._bindings.on('read', this._onRead.bind(this));
+    this._bindings.on('write', this._onWrite.bind(this));
+    this._bindings.on('broadcast', this._onBroadcast.bind(this));
+    this._bindings.on('notify', this._onNotify.bind(this));
+    this._bindings.on('descriptorsDiscover', this._onDescriptorsDiscover.bind(this));
+    this._bindings.on('valueRead', this._onValueRead.bind(this));
+    this._bindings.on('valueWrite', this._onValueWrite.bind(this));
+    this._bindings.on('handleRead', this._onHandleRead.bind(this));
+    this._bindings.on('handleWrite', this._onHandleWrite.bind(this));
+    this._bindings.on('handleNotify', this._onHandleNotify.bind(this));
+    this._bindings.on('onMtu', this._onMtu.bind(this));
+  }
+
+  _createPeripheral (uuid, address, addressType, connectable, advertisement, rssi, scannable) {
+    const peripheral = new Peripheral(this, uuid, address, addressType, connectable, advertisement, rssi, scannable);
+
+    this._peripherals.set(uuid, peripheral);
+    this._services[uuid] = {};
+    this._characteristics[uuid] = {};
+    this._descriptors[uuid] = {};
 
-Noble.prototype.setAddress = function (address) {
-  if (this._bindings.setAddress) {
-    this._bindings.setAddress(address);
-  } else {
-    this.emit('warning', 'current binding does not implement setAddress method.');
+    return peripheral;
   }
-};
-
-Noble.prototype.waitForPoweredOn = function (timeout = 10000) {
-  return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      reject(new Error('Timeout waiting for Noble to be powered on'));
-    }, timeout);
 
-    let listener;
-    listener = (state) => {
-      clearTimeout(timeoutId);
-      if (state === 'poweredOn') {
-        resolve();
-      } else {
-        this.once('stateChange', listener);
+  _cleanupPeriperals (uuid = null) {
+    const terminateConnection = (peripheral) => {
+      if (peripheral.state === 'connecting') {
+        // To unblock the async connect call
+        this._onConnect(peripheral.id, new Error('cleanup'));
+      }
+      else if (peripheral.state !== 'disconnected') {
+        this._onDisconnect(peripheral.id, 'cleanup');
       }
     };
-
-    this.once('stateChange', listener);
-  });
-};
-
-const startScanning = function (serviceUuids, allowDuplicates, callback) {
-  if (typeof serviceUuids === 'function') {
-    this.emit('warning', 'calling startScanning(callback) is deprecated');
-  }
-
-  if (typeof allowDuplicates === 'function') {
-    this.emit('warning', 'calling startScanning(serviceUuids, callback) is deprecated');
-  }
-
-  const scan = function (state) {
-    if (state !== 'poweredOn') {
-      const error = new Error(`Could not start scanning, state is ${state} (not poweredOn)`);
-
-      if (typeof callback === 'function') {
-        callback(error);
-      } else {
-        throw error;
+    if (uuid) {
+      const peripheral = this._peripherals.get(uuid);
+      if (peripheral) {
+        terminateConnection(peripheral);
       }
+      this._peripherals.delete(uuid);
+      this._discoveredPeripherals.delete(uuid);
+      delete this._services[uuid];
+      delete this._characteristics[uuid];
+      delete this._descriptors[uuid];
     } else {
-      if (callback) {
-        this.once('scanStart', filterDuplicates => {
-          callback(null, filterDuplicates);
-        });
-      }
-
-      this._discoveredPeripheralUUids = {};
-      this._allowDuplicates = allowDuplicates;
-
-      this._bindings.startScanning(serviceUuids, allowDuplicates);
+      this._peripherals.forEach(peripheral => terminateConnection(peripheral));
+      this._peripherals.clear();
+      this._discoveredPeripherals.clear();
+      this._services = {};
+      this._characteristics = {};
+      this._descriptors = {};
     }
-  };
+  }
 
-  // if bindings still not init, do it now
-  if (!this.initialized) {
-    this.initialized = true;
+  _onStateChange (state) {
+    debug(`stateChange ${state}`);
 
-    this._bindings.init();
+    // If the state is poweredOff and the previous state was poweredOn, clean up the peripherals
+    if (state === 'poweredOff' && this._state === 'poweredOn') {
+      this._cleanupPeriperals();
+    }
 
-    this.once('stateChange', scan.bind(this));
-  } else {
-    scan.call(this, this._state);
+    this._state = state;
+    this.emit('stateChange', state);
   }
-};
 
-Noble.prototype.startScanning = startScanning;
-Noble.prototype.startScanningAsync = function (serviceUUIDs, allowDuplicates) {
-  return util.promisify((callback) => this.startScanning(serviceUUIDs, allowDuplicates, callback))();
-};
+  _onAddressChange (address) {
+    debug(`addressChange ${address}`);
+    this._address = address;
+    this.emit('addressChange', address);
+  }
 
-Noble.prototype.onScanStart = function (filterDuplicates) {
-  debug('scanStart');
-  this.emit('scanStart', filterDuplicates);
-};
+  setScanParameters (interval, window, callback) {
+    if (callback) {
+      this.once('scanParametersSet', callback);
+    }
+    this._bindings.setScanParameters(interval, window);
+  }
 
-const stopScanning = function (callback) {
-  if (callback) {
-    this.once('scanStop', callback);
+  _onScanParametersSet () {
+    debug('scanParametersSet');
+    this.emit('scanParametersSet');
   }
-  if (this._bindings && this.initialized) {
-    this._bindings.stopScanning();
+  
+  setAddress (address) {
+    if (this._bindings.setAddress) {
+      this._bindings.setAddress(address);
+    } else {
+      this.emit('warning', 'current binding does not implement setAddress method.');
+    }
   }
-};
 
-Noble.prototype.stopScanning = stopScanning;
-Noble.prototype.stopScanningAsync = util.promisify(stopScanning);
+  async waitForPoweredOnAsync (timeout = 10000) {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error('Timeout waiting for Noble to be powered on'));
+      }, timeout);
 
-Noble.prototype.onScanStop = function () {
-  debug('scanStop');
-  this.emit('scanStop');
-};
-
-Noble.prototype.reset = function () {
-  if (this._bindings.reset) {
-    this._bindings.reset();
-  }  
-};
+      const listener = (state) => {
+        clearTimeout(timeoutId);
+        if (state === 'poweredOn') {
+          resolve();
+        } else {
+          this.once('stateChange', listener);
+        }
+      };
 
-Noble.prototype.stop = function () {
-  if (this._bindings.stop) {
-    this._bindings.stop();
+      this.once('stateChange', listener);
+    });
   }
-};
 
-Noble.prototype.onDiscover = function (uuid, address, addressType, connectable, advertisement, rssi, scannable) {
-  let peripheral = this._peripherals[uuid];
+  startScanning (serviceUuids, allowDuplicates, callback) {
+    const self = this;
+    const scan = (state) => {
+      if (state !== 'poweredOn') {
+        self.once('stateChange', scan.bind(self));
+        const error = new Error(`Could not start scanning, state is ${state} (not poweredOn)`);
 
-  if (!peripheral) {
-    peripheral = new Peripheral(this, uuid, address, addressType, connectable, advertisement, rssi, scannable);
+        if (typeof callback === 'function') {
+          callback(error);
+        } else {
+          throw error;
+        }
+      } else {
+        if (callback) {
+          this.once('scanStart', filterDuplicates => callback(null, filterDuplicates));
+        }
 
-    this._peripherals[uuid] = peripheral;
-    this._services[uuid] = {};
-    this._characteristics[uuid] = {};
-    this._descriptors[uuid] = {};
-  } else {
-    // "or" the advertisment data with existing
-    for (const i in advertisement) {
-      if (advertisement[i] !== undefined) {
-        peripheral.advertisement[i] = advertisement[i];
+        this._discoveredPeripherals.clear();
+        this._allowDuplicates = allowDuplicates;
+
+        this._bindings.startScanning(serviceUuids, allowDuplicates);
       }
+    };
+    // if bindings still not init, do it now
+    if (this._initialized === false) {
+      this.once('stateChange', scan.bind(this));
+      this._initializeBindings();
+    } else {
+      scan.call(this, this._state);
     }
-
-    peripheral.connectable = connectable;
-    peripheral.scannable = scannable;
-    peripheral.rssi = rssi;
   }
 
-  const previouslyDiscoverd = this._discoveredPeripheralUUids[uuid] === true;
-
-  if (!previouslyDiscoverd) {
-    this._discoveredPeripheralUUids[uuid] = true;
+  async startScanningAsync (serviceUUIDs, allowDuplicates) {
+    return new Promise((resolve, reject) => {
+      this.startScanning(serviceUUIDs, allowDuplicates, error => error ? reject(error) : resolve());
+    });
   }
 
-  if (this._allowDuplicates || !previouslyDiscoverd || (!scannable && !connectable)) {
-    this.emit('discover', peripheral);
+  _onScanStart (filterDuplicates) {
+    debug('scanStart');
+    this.emit('scanStart', filterDuplicates);
   }
-};
 
-Noble.prototype.connect = function (peripheralUuid, parameters, callback) {
-  // Check if callback is a function
-  if (typeof callback === 'function') {
-    // Create a unique event name using the peripheral UUID
-    const eventName = `connect:${peripheralUuid}`;
+  stopScanning (callback) {
+    if (this._initialized === false || this._bindings === null) {
+      callback(new Error('Bindings are not initialized'));
+      return;
+    }
+    if (callback) {
+      this.once('scanStop', callback);
+    }
+    this._bindings.stopScanning();
+  }
 
-    // Add a one-time listener for this specific event
-    this.once(eventName, (error) => {
-      callback(error, this._peripherals[peripheralUuid]);
+  async stopScanningAsync () {
+    return new Promise((resolve, reject) => {
+      this.stopScanning(error => error ? reject(error) : resolve());
     });
   }
 
-  // Proceed to initiate the connection
-  this._bindings.connect(peripheralUuid, parameters);
-};
-Noble.prototype.connectAsync = function (peripheralUuid, parameters) {
-  return util.promisify((callback) => this.connect(peripheralUuid, parameters, callback))();
-};
-
-Noble.prototype.onConnect = function (peripheralUuid, error) {
-  const peripheral = this._peripherals[peripheralUuid];
+  async *discoverAsync () {
+    const deviceQueue = [];
+    let scanning = true;
+    
+    this.once('scanStop', () => scanning = false);
+    
+    const listener = peripheral => deviceQueue.push(peripheral);
+    this.on('discover', listener);
+    
+    await this.startScanningAsync();
+    
+    while (scanning || deviceQueue.length > 0) {
+        if (deviceQueue.length > 0) {
+            yield deviceQueue.shift();
+        } else {
+            await new Promise(resolve => {
+                const tempListener = () => resolve();
+                this.once('discover', tempListener);
+                setTimeout(tempListener, 1000);
+            });
+        }
+    }
 
-  if (peripheral) {
-    // Emit a unique connect event for the specific peripheral
-    this.emit(`connect:${peripheralUuid}`, error);
+    await this.stopScanningAsync();
+  }
 
-    peripheral.state = error ? 'error' : 'connected';
-    // Also emit the general 'connect' event for a peripheral
-    peripheral.emit('connect', error);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid} connected!`);
+  _onScanStop () {
+    debug('scanStop');
+    this.emit('scanStop');
   }
-};
 
-Noble.prototype.cancelConnect = function (peripheralUuid, parameters) {
-  this._bindings.cancelConnect(peripheralUuid, parameters);
-};
+  reset () {
+    if (typeof this._bindings.reset !== 'function') { return; }
+    this._bindings.reset();
+  }
 
-Noble.prototype.disconnect = function (peripheralUuid) {
-  this._bindings.disconnect(peripheralUuid);
-};
+  stop () {
+    if (typeof this._bindings.stop !== 'function') { return; }
+    this._bindings.stop();
+  }
 
-Noble.prototype.onDisconnect = function (peripheralUuid, reason) {
-  const peripheral = this._peripherals[peripheralUuid];
+  _onDiscover (uuid, address, addressType, connectable, advertisement, rssi, scannable) {
+    let peripheral = this._peripherals.get(uuid);
 
-  if (peripheral) {
-    peripheral.state = 'disconnected';
-    peripheral.emit('disconnect', reason);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid} disconnected!`);
-  }
-};
+    if (!peripheral) {
+      peripheral = this._createPeripheral(uuid, address, addressType, connectable, advertisement, rssi, scannable);
+    } else {
+      // "or" the advertisment data with existing
+      for (const i in advertisement) {
+        if (advertisement[i] !== undefined) {
+          peripheral.advertisement[i] = advertisement[i];
+        }
+      }
 
-Noble.prototype.updateRssi = function (peripheralUuid) {
-  this._bindings.updateRssi(peripheralUuid);
-};
+      peripheral.connectable = connectable;
+      peripheral.scannable = scannable;
+      peripheral.rssi = rssi;
+    }
 
-Noble.prototype.onRssiUpdate = function (peripheralUuid, rssi) {
-  const peripheral = this._peripherals[peripheralUuid];
+    const previouslyDiscoverd = this._discoveredPeripherals.has(uuid);
 
-  if (peripheral) {
-    peripheral.rssi = rssi;
+    if (!previouslyDiscoverd) {
+      this._discoveredPeripherals.add(uuid);
+    }
+    if (this._allowDuplicates || !previouslyDiscoverd || (!scannable && !connectable)) {
+      this.emit('discover', peripheral);
+    }
+  }
 
-    peripheral.emit('rssiUpdate', rssi);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid} RSSI update!`);
+  _getPeripheralId (idOrAddress) {
+    let identifier;
+    // Convert the peripheralId to an identifier
+    if (/^[0-9A-Fa-f]+$/.test(idOrAddress) === false) {
+      identifier = this._bindings.addressToId(idOrAddress);
+      if (identifier === null) {
+        throw new Error(`Invalid peripheral ID or Address ${idOrAddress}`);
+      }
+    } else {
+      identifier = idOrAddress;
+    }
+    return identifier;
   }
-};
 
-/// add an array of service objects (as retrieved via the servicesDiscovered event)
-Noble.prototype.addServices = function (peripheralUuid, services) {
-  const servObjs = [];
+  connect (idOrAddress, parameters, callback) {
+    // Get the identifier for the peripheral
+    const identifier = this._getPeripheralId(idOrAddress);
+    // Check if callback is a function
+    if (typeof callback === 'function') {
+      // Add a one-time listener for this specific event
+      this.once(`connect:${identifier}`, error => callback(error, this._peripherals.get(identifier)));
+    }
 
-  for (let i = 0; i < services.length; i++) {
-    const o = this.addService(peripheralUuid, services[i]);
-    servObjs.push(o);
+    // Proceed to initiate the connection
+    this._bindings.connect(identifier, parameters);
   }
-  return servObjs;
-};
+  
+  async connectAsync (idOrAddress, parameters) {
+    return new Promise((resolve, reject) => {
+      this.connect(idOrAddress, parameters, (error, peripheral) => error ? reject(error) : resolve(peripheral));
+    });
+  }
+
+  _onConnect (peripheralId, error) {
+    const peripheral = this._peripherals.get(peripheralId);
 
-/// service is a ServiceObject { uuid, startHandle, endHandle,..}
-Noble.prototype.addService = function (peripheralUuid, service) {
-  const peripheral = this._peripherals[peripheralUuid];
+    if (peripheral) {
+      // Emit a unique connect event for the specific peripheral
+      this.emit(`connect:${peripheralId}`, error);
 
-  // pass on to lower layers (gatt)
-  if (this._bindings.addService) {
-    this._bindings.addService(peripheralUuid, service);
+      peripheral.state = error ? 'error' : 'connected';
+      // Also emit the general 'connect' event for a peripheral
+      peripheral.emit('connect', error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId} connected!`);
+    }
   }
 
-  if (!peripheral.services) {
-    peripheral.services = [];
+  cancelConnect (idOrAddress, parameters) {
+    // Get the identifier for the peripheral
+    const identifier = this._getPeripheralId(idOrAddress);
+    
+    // Check if the peripheral is connecting
+    const peripheral = this._peripherals.get(identifier);
+    if (peripheral && peripheral.state === 'connecting') {
+      peripheral.state = 'disconnected';
+    }
+    // Emit a unique connect event for the specific peripheral
+    this.emit(`connect:${identifier}`, new Error('connection canceled!'));
+    // Cancel the connection
+    this._bindings.cancelConnect(identifier, parameters);
   }
-  // allocate internal service object and return
-  const serv = new Service(this, peripheralUuid, service.uuid);
 
-  this._services[peripheralUuid][service.uuid] = serv;
-  this._characteristics[peripheralUuid][service.uuid] = {};
-  this._descriptors[peripheralUuid][service.uuid] = {};
+  disconnect (peripheralId) {
+    // Disconnect the peripheral
+    this._bindings.disconnect(peripheralId);
+  }
 
-  peripheral.services.push(serv);
+  _onDisconnect (peripheralId, reason) {
+    const peripheral = this._peripherals.get(peripheralId);
 
-  return serv;
-};
+    if (peripheral) {
+      peripheral.state = 'disconnected';
+      peripheral.emit('disconnect', reason);
+      this.emit(`disconnect:${peripheralId}`, reason);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId} disconnected!`);
+    }
+  }
 
-/// callback receiving a list of service objects from the gatt layer
-Noble.prototype.onServicesDiscovered = function (peripheralUuid, services) {
-  const peripheral = this._peripherals[peripheralUuid];
+  updateRssi (peripheralId) {
+    this._bindings.updateRssi(peripheralId);
+  }
 
-  if (peripheral) { peripheral.emit('servicesDiscovered', peripheral, services); } // pass on to higher layers
-};
+  _onRssiUpdate (peripheralId, rssi, error) {
+    const peripheral = this._peripherals.get(peripheralId);
 
-Noble.prototype.discoverServices = function (peripheralUuid, uuids) {
-  this._bindings.discoverServices(peripheralUuid, uuids);
-};
+    if (peripheral) {
+      peripheral.rssi = rssi;
 
-Noble.prototype.onServicesDiscover = function (peripheralUuid, serviceUuids) {
-  const peripheral = this._peripherals[peripheralUuid];
+      peripheral.emit('rssiUpdate', rssi, error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId} RSSI update!`);
+    }
+  }
 
-  if (peripheral) {
-    const services = [];
+  /// add an array of service objects (as retrieved via the servicesDiscovered event)
+  addServices (peripheralId, services) {
+    const servObjs = [];
 
-    for (let i = 0; i < serviceUuids.length; i++) {
-      const serviceUuid = serviceUuids[i];
-      const service = new Service(this, peripheralUuid, serviceUuid);
+    for (let i = 0; i < services.length; i++) {
+      const o = this.addService(peripheralId, services[i]);
+      servObjs.push(o);
+    }
+    return servObjs;
+  }
 
-      this._services[peripheralUuid][serviceUuid] = service;
-      this._characteristics[peripheralUuid][serviceUuid] = {};
-      this._descriptors[peripheralUuid][serviceUuid] = {};
+  /// service is a ServiceObject { uuid, startHandle, endHandle,..}
+  addService (peripheralId, service) {
+    const peripheral = this._peripherals.get(peripheralId);
 
-      services.push(service);
+    // pass on to lower layers (gatt)
+    if (this._bindings.addService) {
+      this._bindings.addService(peripheralId, service);
     }
 
-    peripheral.services = services;
+    if (!peripheral.services) {
+      peripheral.services = [];
+    }
+    // allocate internal service object and return
+    const serv = new Service(this, peripheralId, service.uuid);
 
-    peripheral.emit('servicesDiscover', services);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid} services discover!`);
-  }
-};
+    this._services[peripheralId][service.uuid] = serv;
+    this._characteristics[peripheralId][service.uuid] = {};
+    this._descriptors[peripheralId][service.uuid] = {};
 
-Noble.prototype.discoverIncludedServices = function (peripheralUuid, serviceUuid, serviceUuids) {
-  this._bindings.discoverIncludedServices(peripheralUuid, serviceUuid, serviceUuids);
-};
+    peripheral.services.push(serv);
 
-Noble.prototype.onIncludedServicesDiscover = function (peripheralUuid, serviceUuid, includedServiceUuids) {
-  const service = this._services[peripheralUuid][serviceUuid];
+    return serv;
+  }
 
-  if (service) {
-    service.includedServiceUuids = includedServiceUuids;
+  /// callback receiving a list of service objects from the gatt layer
+  _onServicesDiscovered (peripheralId, services) {
+    const peripheral = this._peripherals.get(peripheralId);
 
-    service.emit('includedServicesDiscover', includedServiceUuids);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid}, ${serviceUuid} included services discover!`);
+    if (peripheral) { peripheral.emit('servicesDiscovered', peripheral, services); } // pass on to higher layers
   }
-};
 
-/// add characteristics to the peripheral; returns an array of initialized Characteristics objects
-Noble.prototype.addCharacteristics = function (peripheralUuid, serviceUuid, characteristics) {
-  // first, initialize gatt layer:
-  if (this._bindings.addCharacteristics) {
-    this._bindings.addCharacteristics(peripheralUuid, serviceUuid, characteristics);
+  discoverServices (peripheralId, uuids) {
+    this._bindings.discoverServices(peripheralId, uuids);
   }
 
-  const service = this._services[peripheralUuid][serviceUuid];
-  if (!service) {
-    this.emit('warning', `unknown service ${peripheralUuid}, ${serviceUuid} characteristics discover!`);
-    return;
-  }
+  _onServicesDiscover (peripheralId, serviceUuids, error) {
+    const peripheral = this._peripherals.get(peripheralId);
+
+    if (peripheral) {
+      const services = [];
 
-  const characteristics_ = [];
-  for (let i = 0; i < characteristics.length; i++) {
-    const characteristicUuid = characteristics[i].uuid;
+      for (let i = 0; i < serviceUuids.length; i++) {
+        const serviceUuid = serviceUuids[i];
+        const service = new Service(this, peripheralId, serviceUuid);
 
-    const characteristic = new Characteristic(
-      this,
-      peripheralUuid,
-      serviceUuid,
-      characteristicUuid,
-      characteristics[i].properties
-    );
+        this._services[peripheralId][serviceUuid] = service;
+        this._characteristics[peripheralId][serviceUuid] = {};
+        this._descriptors[peripheralId][serviceUuid] = {};
 
-    this._characteristics[peripheralUuid][serviceUuid][characteristicUuid] = characteristic;
-    this._descriptors[peripheralUuid][serviceUuid][characteristicUuid] = {};
+        services.push(service);
+      }
+
+      peripheral.services = services;
+      
+      peripheral.emit('servicesDiscover', services, error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId} services discover!`);
+    }
+  }
 
-    characteristics_.push(characteristic);
+  discoverIncludedServices (peripheralId, serviceUuid, serviceUuids) {
+    this._bindings.discoverIncludedServices(peripheralId, serviceUuid, serviceUuids);
   }
-  service.characteristics = characteristics_;
-  return characteristics_;
-};
 
-Noble.prototype.onCharacteristicsDiscovered = function (peripheralUuid, serviceUuid, characteristics) {
-  const service = this._services[peripheralUuid][serviceUuid];
+  _onIncludedServicesDiscover (peripheralId, serviceUuid, includedServiceUuids, error) {
+    const service = this._services[peripheralId][serviceUuid];
 
-  service.emit('characteristicsDiscovered', characteristics);
-};
+    if (service) {
+      service.includedServiceUuids = includedServiceUuids;
 
-Noble.prototype.discoverCharacteristics = function (peripheralUuid, serviceUuid, characteristicUuids) {
-  this._bindings.discoverCharacteristics(peripheralUuid, serviceUuid, characteristicUuids);
-};
+      service.emit('includedServicesDiscover', includedServiceUuids, error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId}, ${serviceUuid} included services discover!`);
+    }
+  }
 
-Noble.prototype.onCharacteristicsDiscover = function (peripheralUuid, serviceUuid, characteristics) {
-  const service = this._services[peripheralUuid][serviceUuid];
+  /// add characteristics to the peripheral; returns an array of initialized Characteristics objects
+  addCharacteristics (peripheralId, serviceUuid, characteristics) {
+    // first, initialize gatt layer:
+    if (this._bindings.addCharacteristics) {
+      this._bindings.addCharacteristics(peripheralId, serviceUuid, characteristics);
+    }
 
-  if (service) {
-    const characteristics_ = [];
+    const service = this._services[peripheralId][serviceUuid];
+    if (!service) {
+      this.emit('warning', `unknown service ${peripheralId}, ${serviceUuid} characteristics discover!`);
+      return;
+    }
 
+    const characteristics_ = [];
     for (let i = 0; i < characteristics.length; i++) {
       const characteristicUuid = characteristics[i].uuid;
 
       const characteristic = new Characteristic(
         this,
-        peripheralUuid,
+        peripheralId,
         serviceUuid,
         characteristicUuid,
         characteristics[i].properties
       );
 
-      this._characteristics[peripheralUuid][serviceUuid][characteristicUuid] = characteristic;
-      this._descriptors[peripheralUuid][serviceUuid][characteristicUuid] = {};
+      this._characteristics[peripheralId][serviceUuid][characteristicUuid] = characteristic;
+      this._descriptors[peripheralId][serviceUuid][characteristicUuid] = {};
 
       characteristics_.push(characteristic);
     }
-
     service.characteristics = characteristics_;
+    return characteristics_;
+  }
 
-    service.emit('characteristicsDiscover', characteristics_);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid}, ${serviceUuid} characteristics discover!`);
+  _onCharacteristicsDiscovered (peripheralId, serviceUuid, characteristics) {
+    const service = this._services[peripheralId][serviceUuid];
+
+    service.emit('characteristicsDiscovered', characteristics);
+  }
+
+  discoverCharacteristics (peripheralId, serviceUuid, characteristicUuids) {
+    this._bindings.discoverCharacteristics(peripheralId, serviceUuid, characteristicUuids);
   }
-};
 
-Noble.prototype.read = function (peripheralUuid, serviceUuid, characteristicUuid) {
-  this._bindings.read(peripheralUuid, serviceUuid, characteristicUuid);
-};
+  _onCharacteristicsDiscover (peripheralId, serviceUuid, characteristics, error) {
+    const service = this._services[peripheralId][serviceUuid];
+
+    if (service) {
+      const characteristics_ = [];
+
+      for (let i = 0; i < characteristics.length; i++) {
+        const characteristicUuid = characteristics[i].uuid;
+
+        const characteristic = new Characteristic(
+          this,
+          peripheralId,
+          serviceUuid,
+          characteristicUuid,
+          characteristics[i].properties
+        );
 
-Noble.prototype.onRead = function (peripheralUuid, serviceUuid, characteristicUuid, data, isNotification) {
-  const characteristic = this._characteristics[peripheralUuid][serviceUuid][characteristicUuid];
+        this._characteristics[peripheralId][serviceUuid][characteristicUuid] = characteristic;
+        this._descriptors[peripheralId][serviceUuid][characteristicUuid] = {};
 
-  if (characteristic) {
-    characteristic.emit('data', data, isNotification);
+        characteristics_.push(characteristic);
+      }
+
+      service.characteristics = characteristics_;
+
+      service.emit('characteristicsDiscover', characteristics_, error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId}, ${serviceUuid} characteristics discover!`);
+    }
+  }
 
-    characteristic.emit('read', data, isNotification); // for backwards compatbility
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid}, ${serviceUuid}, ${characteristicUuid} read!`);
+  read (peripheralId, serviceUuid, characteristicUuid) {
+    this._bindings.read(peripheralId, serviceUuid, characteristicUuid);
   }
-};
 
-Noble.prototype.write = function (peripheralUuid, serviceUuid, characteristicUuid, data, withoutResponse) {
-  this._bindings.write(peripheralUuid, serviceUuid, characteristicUuid, data, withoutResponse);
-};
+  _onRead (peripheralId, serviceUuid, characteristicUuid, data, isNotification, error) {
+    const characteristic = this._characteristics[peripheralId][serviceUuid][characteristicUuid];
 
-Noble.prototype.onWrite = function (peripheralUuid, serviceUuid, characteristicUuid) {
-  const characteristic = this._characteristics[peripheralUuid][serviceUuid][characteristicUuid];
+    if (characteristic) {
+      characteristic.emit('read', data, isNotification, error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId}, ${serviceUuid}, ${characteristicUuid} read!`);
+    }
+  }
 
-  if (characteristic) {
-    characteristic.emit('write');
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid}, ${serviceUuid}, ${characteristicUuid} write!`);
+  write (peripheralId, serviceUuid, characteristicUuid, data, withoutResponse) {
+    this._bindings.write(peripheralId, serviceUuid, characteristicUuid, data, withoutResponse);
   }
-};
 
-Noble.prototype.broadcast = function (peripheralUuid, serviceUuid, characteristicUuid, broadcast) {
-  this._bindings.broadcast(peripheralUuid, serviceUuid, characteristicUuid, broadcast);
-};
+  _onWrite (peripheralId, serviceUuid, characteristicUuid, error) {
+    const characteristic = this._characteristics[peripheralId][serviceUuid][characteristicUuid];
 
-Noble.prototype.onBroadcast = function (peripheralUuid, serviceUuid, characteristicUuid, state) {
-  const characteristic = this._characteristics[peripheralUuid][serviceUuid][characteristicUuid];
+    if (characteristic) {
+      characteristic.emit('write', error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId}, ${serviceUuid}, ${characteristicUuid} write!`);
+    }
+  }
 
-  if (characteristic) {
-    characteristic.emit('broadcast', state);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid}, ${serviceUuid}, ${characteristicUuid} broadcast!`);
+  broadcast (peripheralId, serviceUuid, characteristicUuid, broadcast) {
+    this._bindings.broadcast(peripheralId, serviceUuid, characteristicUuid, broadcast);
   }
-};
 
-Noble.prototype.notify = function (peripheralUuid, serviceUuid, characteristicUuid, notify) {
-  this._bindings.notify(peripheralUuid, serviceUuid, characteristicUuid, notify);
-};
+  _onBroadcast (peripheralId, serviceUuid, characteristicUuid, state) {
+    const characteristic = this._characteristics[peripheralId][serviceUuid][characteristicUuid];
+
+    if (characteristic) {
+      characteristic.emit('broadcast', state);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId}, ${serviceUuid}, ${characteristicUuid} broadcast!`);
+    }
+  }
 
-Noble.prototype.onNotify = function (peripheralUuid, serviceUuid, characteristicUuid, state) {
-  const characteristic = this._characteristics[peripheralUuid][serviceUuid][characteristicUuid];
+  notify (peripheralId, serviceUuid, characteristicUuid, notify) {
+    this._bindings.notify(peripheralId, serviceUuid, characteristicUuid, notify);
+  }
 
-  if (characteristic) {
-    characteristic.emit('notify', state);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid}, ${serviceUuid}, ${characteristicUuid} notify!`);
+  _onNotify (peripheralId, serviceUuid, characteristicUuid, state, error) {
+    const characteristic = this._characteristics[peripheralId][serviceUuid][characteristicUuid];
+    if (characteristic) {
+      characteristic.emit('notify', state, error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId}, ${serviceUuid}, ${characteristicUuid} notify!`);
+    }
   }
-};
 
-Noble.prototype.discoverDescriptors = function (peripheralUuid, serviceUuid, characteristicUuid) {
-  this._bindings.discoverDescriptors(peripheralUuid, serviceUuid, characteristicUuid);
-};
+  discoverDescriptors (peripheralId, serviceUuid, characteristicUuid) {
+    this._bindings.discoverDescriptors(peripheralId, serviceUuid, characteristicUuid);
+  }
 
-Noble.prototype.onDescriptorsDiscover = function (peripheralUuid, serviceUuid, characteristicUuid, descriptors) {
-  const characteristic = this._characteristics[peripheralUuid][serviceUuid][characteristicUuid];
+  _onDescriptorsDiscover (peripheralId, serviceUuid, characteristicUuid, descriptors, error) {
+    const characteristic = this._characteristics[peripheralId][serviceUuid][characteristicUuid];
 
-  if (characteristic) {
-    const descriptors_ = [];
+    if (characteristic) {
+      const descriptors_ = [];
 
-    for (let i = 0; i < descriptors.length; i++) {
-      const descriptorUuid = descriptors[i];
+      for (let i = 0; i < descriptors.length; i++) {
+        const descriptorUuid = descriptors[i];
 
-      const descriptor = new Descriptor(
-        this,
-        peripheralUuid,
-        serviceUuid,
-        characteristicUuid,
-        descriptorUuid
-      );
+        const descriptor = new Descriptor(
+          this,
+          peripheralId,
+          serviceUuid,
+          characteristicUuid,
+          descriptorUuid
+        );
 
-      this._descriptors[peripheralUuid][serviceUuid][characteristicUuid][descriptorUuid] = descriptor;
+        this._descriptors[peripheralId][serviceUuid][characteristicUuid][descriptorUuid] = descriptor;
 
-      descriptors_.push(descriptor);
-    }
+        descriptors_.push(descriptor);
+      }
 
-    characteristic.descriptors = descriptors_;
+      characteristic.descriptors = descriptors_;
 
-    characteristic.emit('descriptorsDiscover', descriptors_);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid}, ${serviceUuid}, ${characteristicUuid} descriptors discover!`);
+      characteristic.emit('descriptorsDiscover', descriptors_, error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId}, ${serviceUuid}, ${characteristicUuid} descriptors discover!`);
+    }
   }
-};
 
-Noble.prototype.readValue = function (peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid) {
-  this._bindings.readValue(peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid);
-};
+  readValue (peripheralId, serviceUuid, characteristicUuid, descriptorUuid) {
+    this._bindings.readValue(peripheralId, serviceUuid, characteristicUuid, descriptorUuid);
+  }
 
-Noble.prototype.onValueRead = function (peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid, data) {
-  const descriptor = this._descriptors[peripheralUuid][serviceUuid][characteristicUuid][descriptorUuid];
+  _onValueRead (peripheralId, serviceUuid, characteristicUuid, descriptorUuid, data, error) {
+    const descriptor = this._descriptors[peripheralId][serviceUuid][characteristicUuid][descriptorUuid];
 
-  if (descriptor) {
-    descriptor.emit('valueRead', data);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid}, ${serviceUuid}, ${characteristicUuid}, ${descriptorUuid} value read!`);
+    if (descriptor) {
+      descriptor.emit('valueRead', data, error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId}, ${serviceUuid}, ${characteristicUuid}, ${descriptorUuid} value read!`);
+    }
   }
-};
 
-Noble.prototype.writeValue = function (peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid, data) {
-  this._bindings.writeValue(peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid, data);
-};
+  writeValue (peripheralId, serviceUuid, characteristicUuid, descriptorUuid, data) {
+    this._bindings.writeValue(peripheralId, serviceUuid, characteristicUuid, descriptorUuid, data);
+  }
 
-Noble.prototype.onValueWrite = function (peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid) {
-  const descriptor = this._descriptors[peripheralUuid][serviceUuid][characteristicUuid][descriptorUuid];
+  _onValueWrite (peripheralId, serviceUuid, characteristicUuid, descriptorUuid, error) {
+    const descriptor = this._descriptors[peripheralId][serviceUuid][characteristicUuid][descriptorUuid];
 
-  if (descriptor) {
-    descriptor.emit('valueWrite');
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid}, ${serviceUuid}, ${characteristicUuid}, ${descriptorUuid} value write!`);
+    if (descriptor) {
+      descriptor.emit('valueWrite', error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId}, ${serviceUuid}, ${characteristicUuid}, ${descriptorUuid} value write!`);
+    }
   }
-};
 
-Noble.prototype.readHandle = function (peripheralUuid, handle) {
-  this._bindings.readHandle(peripheralUuid, handle);
-};
+  readHandle (peripheralId, handle) {
+    this._bindings.readHandle(peripheralId, handle);
+  }
 
-Noble.prototype.onHandleRead = function (peripheralUuid, handle, data) {
-  const peripheral = this._peripherals[peripheralUuid];
+  _onHandleRead (peripheralId, handle, data, error) {
+    const peripheral = this._peripherals.get(peripheralId);
 
-  if (peripheral) {
-    peripheral.emit(`handleRead${handle}`, data);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid} handle read!`);
+    if (peripheral) {
+      peripheral.emit(`handleRead${handle}`, data, error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId} handle read!`);
+    }
   }
-};
 
-Noble.prototype.writeHandle = function (peripheralUuid, handle, data, withoutResponse) {
-  this._bindings.writeHandle(peripheralUuid, handle, data, withoutResponse);
-};
+  writeHandle (peripheralId, handle, data, withoutResponse) {
+    this._bindings.writeHandle(peripheralId, handle, data, withoutResponse);
+  }
 
-Noble.prototype.onHandleWrite = function (peripheralUuid, handle) {
-  const peripheral = this._peripherals[peripheralUuid];
+  _onHandleWrite (peripheralId, handle, error) {
+    const peripheral = this._peripherals.get(peripheralId);
 
-  if (peripheral) {
-    peripheral.emit(`handleWrite${handle}`);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid} handle write!`);
+    if (peripheral) {
+      peripheral.emit(`handleWrite${handle}`, error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId} handle write!`);
+    }
   }
-};
 
-Noble.prototype.onHandleNotify = function (peripheralUuid, handle, data) {
-  const peripheral = this._peripherals[peripheralUuid];
+  _onHandleNotify (peripheralId, handle, data, error) {
+    const peripheral = this._peripherals.get(peripheralId);
 
-  if (peripheral) {
-    peripheral.emit('handleNotify', handle, data);
-  } else {
-    this.emit('warning', `unknown peripheral ${peripheralUuid} handle notify!`);
+    if (peripheral) {
+      peripheral.emit('handleNotify', handle, data, error);
+    } else {
+      this.emit('warning', `unknown peripheral ${peripheralId} handle notify!`);
+    }
   }
-};
 
-Noble.prototype.onMtu = function (peripheralUuid, mtu) {
-  const peripheral = this._peripherals[peripheralUuid];
-  if (peripheral && mtu) peripheral.mtu = mtu;
-};
+  _onMtu (peripheralId, mtu) {
+    const peripheral = this._peripherals.get(peripheralId);
+    if (peripheral && mtu) {
+      peripheral.mtu = mtu;
+      peripheral.emit('mtu', mtu);
+    }
+  }
+
+  async _withDisconnectHandler (peripheralId, operation) {
+    return new Promise((resolve, reject) => {
+      const disconnectListener = error => reject(error);
+      this.once(`disconnect:${peripheralId}`, disconnectListener);
+      
+      Promise.resolve(operation())
+        .then(result => {
+          this.removeListener(`disconnect:${peripheralId}`, disconnectListener);
+          resolve(result);
+        })
+        .catch(error => {
+          this.removeListener(`disconnect:${peripheralId}`, disconnectListener);
+          reject(error);
+        });
+    });
+  }
+}
 
 module.exports = Noble;