@stoprocent/bleno 0.8.5 → 0.9.0

package/lib/hci-socket/gatt.js

@@ -68,18 +68,36 @@ class Gatt extends EventEmitter {
     super();
 
     this.maxMtu = 256;
-    this._mtu = 23;
-    this._preparedWriteRequest = null;
+    
+    this._name = process.env.BLENO_DEVICE_NAME || os.hostname();
+    this._connections = new Map();
+    this._preparedWriteRequests = new Map();
+    this._aclStreamCallbacks = new Map();
+    this._lastIndicatedAttributes = new Map();
+    this._handles = [];
 
     this.setServices([]);
+  }
 
-    this.onAclStreamDataBinded = this.onAclStreamData.bind(this);
-    this.onAclStreamEndBinded = this.onAclStreamEnd.bind(this);
+  updateName (name) {
+    this._name = name;
+    let valueHandle = undefined;
+    for (let i = 0; i < this._handles.length; i++) {
+      // 
+      if (typeof this._handles[i] !== 'object') continue;
+      // Update the value of the characteristic
+      if (this._handles[i].type === 'characteristic' && this._handles[i].uuid === '2a00') {
+        this._handles[i].attribute.value = Buffer.from(name);
+        valueHandle = this._handles[i].valueHandle;
+      }
+      // Update the value of the characteristic value
+      if (this._handles[i].type === 'characteristicValue' && this._handles[i].handle === valueHandle) {
+        this._handles[i].value = Buffer.from(name);
+      }
+    }
   }
 
   setServices (services) {
-    const deviceName = process.env.BLENO_DEVICE_NAME || os.hostname();
-
     // base services and characteristics
     const allServices = [
       {
@@ -89,7 +107,7 @@ class Gatt extends EventEmitter {
             uuid: '2a00',
             properties: ['read'],
             secure: [],
-            value: Buffer.from(deviceName),
+            value: Buffer.from(this._name),
             descriptors: []
           },
           {
@@ -213,7 +231,7 @@ class Gatt extends EventEmitter {
             attribute: characteristic,
             properties: (0x02 | 0x04 | 0x08), // read/write
             secure: (secure & 0x10) ? (0x02 | 0x04 | 0x08) : 0,
-            value: Buffer.from([0x00, 0x00])
+            values: new Map()
           };
         }
 
@@ -255,43 +273,68 @@ class Gatt extends EventEmitter {
     debug('handles = ' + JSON.stringify(debugHandles, null, 2));
   }
 
-  setAclStream (aclStream) {
-    this._mtu = 23;
-    this._preparedWriteRequest = null;
-
-    this._aclStream = aclStream;
+  registerAclStream (aclStream, connection) {
+    this._connections.set(connection, {
+      aclStream,
+      mtu: 23,
+    });
+    
+    this._aclStreamCallbacks.set(connection, {
+      onData: function (connection, cid, data) {
+        this.onAclStreamData(connection, cid, data);
+      },
+      onEnd: function (connection) {
+        this.onAclStreamEnd(connection);
+      }
+    });
 
-    this._aclStream.on('data', this.onAclStreamDataBinded);
-    this._aclStream.on('end', this.onAclStreamEndBinded);
+    aclStream.on('data', this._aclStreamCallbacks.get(connection).onData.bind(this));
+    aclStream.on('end', this._aclStreamCallbacks.get(connection).onEnd.bind(this));
   }
 
-  onAclStreamData (cid, data) {
+  onAclStreamData (connection, cid, data) {
     if (cid !== ATT_CID) {
       return;
     }
 
-    this.handleRequest(data);
+    this.handleRequest(data, connection);
   }
 
-  onAclStreamEnd () {
-    this._aclStream.removeListener('data', this.onAclStreamDataBinded);
-    this._aclStream.removeListener('end', this.onAclStreamEndBinded);
+  onAclStreamEnd (connection) {
+    if (this._connections.has(connection) === false) {
+      return;
+    }
 
-    for (let i = 0; i < this._handles.length; i++) {
-      if (this._handles[i] && this._handles[i].type === 'descriptor' &&
-          this._handles[i].uuid === '2902' && this._handles[i].value.readUInt16LE(0) !== 0) {
-        this._handles[i].value = Buffer.from([0x00, 0x00]);
+    const { aclStream } = this._connections.get(connection);
+
+    aclStream.removeListener('data', this._aclStreamCallbacks.get(connection).onData);
+    aclStream.removeListener('end', this._aclStreamCallbacks.get(connection).onEnd);
 
+    // Clean up subscriptions for this connection
+    for (let i = 0; i < this._handles.length; i++) {
+      if (this._handles[i] && 
+          this._handles[i].type === 'descriptor' &&
+          this._handles[i].uuid === '2902' &&
+          this._handles[i].values &&
+          this._handles[i].values.has(connection)) {
+
+        this._handles[i].values.delete(connection);
+        
         if (this._handles[i].attribute && this._handles[i].attribute.emit) {
-          this._handles[i].attribute.emit('unsubscribe');
+          this._handles[i].attribute.emit('unsubscribe', connection);
         }
       }
     }
+
+    this._connections.delete(connection);
+    this._preparedWriteRequests.delete(connection);
   }
 
-  send (data) {
+  send (data, connection) {
     debug('send: ' + data.toString('hex'));
-    this._aclStream.write(ATT_CID, data);
+    if (this._connections.has(connection)) {
+      this._connections.get(connection).aclStream.write(ATT_CID, data);
+    }
   }
 
   errorResponse (opcode, handle, status) {
@@ -305,53 +348,53 @@ class Gatt extends EventEmitter {
     return buf;
   }
 
-  handleRequest (request) {
-    debug('handing request: ' + request.toString('hex'));
+  handleRequest (request, connection) {
+    debug('handling request: ' + request.toString('hex'));
 
     const requestType = request[0];
     let response = null;
 
     switch (requestType) {
       case ATT_OP_MTU_REQ:
-        response = this.handleMtuRequest(request);
+        response = this.handleMtuRequest(request, connection);
         break;
 
       case ATT_OP_FIND_INFO_REQ:
-        response = this.handleFindInfoRequest(request);
+        response = this.handleFindInfoRequest(request, connection);
         break;
 
       case ATT_OP_FIND_BY_TYPE_REQ:
-        response = this.handleFindByTypeRequest(request);
+        response = this.handleFindByTypeRequest(request, connection);
         break;
 
       case ATT_OP_READ_BY_TYPE_REQ:
-        response = this.handleReadByTypeRequest(request);
+        response = this.handleReadByTypeRequest(request, connection);
         break;
 
       case ATT_OP_READ_REQ:
       case ATT_OP_READ_BLOB_REQ:
-        response = this.handleReadOrReadBlobRequest(request);
+        response = this.handleReadOrReadBlobRequest(request, connection);
         break;
 
       case ATT_OP_READ_BY_GROUP_REQ:
-        response = this.handleReadByGroupRequest(request);
+        response = this.handleReadByGroupRequest(request, connection);
         break;
 
       case ATT_OP_WRITE_REQ:
       case ATT_OP_WRITE_CMD:
-        response = this.handleWriteRequestOrCommand(request);
+        response = this.handleWriteRequestOrCommand(request, connection);
         break;
 
       case ATT_OP_PREP_WRITE_REQ:
-        response = this.handlePrepareWriteRequest(request);
+        response = this.handlePrepareWriteRequest(request, connection);
         break;
 
       case ATT_OP_EXEC_WRITE_REQ:
-        response = this.handleExecuteWriteRequest(request);
+        response = this.handleExecuteWriteRequest(request, connection);
         break;
 
       case ATT_OP_HANDLE_CNF:
-        this.handleConfirmation(request);
+        this.handleConfirmation(request, connection);
         break;
 
       default:
@@ -361,12 +404,11 @@ class Gatt extends EventEmitter {
 
     if (response) {
       debug('response: ' + response.toString('hex'));
-
-      this.send(response);
+      this.send(response, connection);
     }
   }
 
-  handleMtuRequest (request) {
+  handleMtuRequest (request, connection) {
     let mtu = request.readUInt16LE(1);
 
     if (mtu < 23) {
@@ -375,9 +417,11 @@ class Gatt extends EventEmitter {
       mtu = this.maxMtu;
     }
 
-    this._mtu = mtu;
+    if (this._connections.has(connection)) {
+      this._connections.get(connection).mtu = mtu;
+    }
 
-    this.emit('mtuChange', this._mtu);
+    this.emit('mtuChange', mtu);
 
     const response = Buffer.alloc(3);
 
@@ -387,7 +431,9 @@ class Gatt extends EventEmitter {
     return response;
   }
 
-  handleFindInfoRequest (request) {
+  handleFindInfoRequest (request, connection) {
+    const { mtu } = this._connections.get(connection);
+    
     const startHandle = request.readUInt16LE(1);
     const endHandle = request.readUInt16LE(3);
 
@@ -435,7 +481,7 @@ class Gatt extends EventEmitter {
       }
 
       const lengthPerInfo = (uuidSize === 2) ? 4 : 18;
-      const maxInfo = Math.floor((this._mtu - 2) / lengthPerInfo);
+      const maxInfo = Math.floor((mtu - 2) / lengthPerInfo);
       numInfo = Math.min(numInfo, maxInfo);
 
       const response = Buffer.alloc(2 + numInfo * lengthPerInfo);
@@ -459,7 +505,9 @@ class Gatt extends EventEmitter {
     return this.errorResponse(ATT_OP_FIND_INFO_REQ, startHandle, ATT_ECODE_ATTR_NOT_FOUND);
   }
 
-  handleFindByTypeRequest (request) {
+  handleFindByTypeRequest (request, connection) {
+    const { mtu } = this._connections.get(connection);
+
     const startHandle = request.readUInt16LE(1);
     const endHandle = request.readUInt16LE(3);
     const uuid = request.slice(5, 7).toString('hex').match(/.{1,2}/g).reverse().join('');
@@ -486,7 +534,7 @@ class Gatt extends EventEmitter {
     if (handles.length) {
       const lengthPerHandle = 4;
       let numHandles = handles.length;
-      const maxHandles = Math.floor((this._mtu - 1) / lengthPerHandle);
+      const maxHandles = Math.floor((mtu - 1) / lengthPerHandle);
 
       numHandles = Math.min(numHandles, maxHandles);
 
@@ -506,7 +554,9 @@ class Gatt extends EventEmitter {
     return this.errorResponse(ATT_OP_FIND_BY_TYPE_REQ, startHandle, ATT_ECODE_ATTR_NOT_FOUND);
   }
 
-  handleReadByGroupRequest (request) {
+  handleReadByGroupRequest (request, connection) {
+    const { mtu } = this._connections.get(connection);
+
     const startHandle = request.readUInt16LE(1);
     const endHandle = request.readUInt16LE(3);
     const uuid = request.slice(5).toString('hex').match(/.{1,2}/g).reverse().join('');
@@ -541,7 +591,7 @@ class Gatt extends EventEmitter {
         }
 
         const lengthPerService = (uuidSize === 2) ? 6 : 20;
-        const maxServices = Math.floor((this._mtu - 2) / lengthPerService);
+        const maxServices = Math.floor((mtu - 2) / lengthPerService);
         numServices = Math.min(numServices, maxServices);
 
         const response = Buffer.alloc(2 + numServices * lengthPerService);
@@ -569,7 +619,9 @@ class Gatt extends EventEmitter {
     return this.errorResponse(ATT_OP_READ_BY_GROUP_REQ, startHandle, ATT_ECODE_UNSUPP_GRP_TYPE);
   }
 
-  handleReadByTypeRequest (request) {
+  handleReadByTypeRequest (request, connection) {
+    const { mtu } = this._connections.get(connection);
+    
     let response = null;
     const requestType = request[0];
 
@@ -606,7 +658,7 @@ class Gatt extends EventEmitter {
         }
 
         const lengthPerCharacteristic = (uuidSize === 2) ? 7 : 21;
-        const maxCharacteristics = Math.floor((this._mtu - 2) / lengthPerCharacteristic);
+        const maxCharacteristics = Math.floor((mtu - 2) / lengthPerCharacteristic);
         numCharacteristics = Math.min(numCharacteristics, maxCharacteristics);
 
         response = Buffer.alloc(2 + numCharacteristics * lengthPerCharacteristic);
@@ -653,15 +705,15 @@ class Gatt extends EventEmitter {
         }
       }
 
-      if (secure && !this._aclStream.encrypted) {
+      if (secure && !this._connections.get(connection).aclStream.encrypted) {
         response = this.errorResponse(ATT_OP_READ_BY_TYPE_REQ, startHandle, ATT_ECODE_AUTHENTICATION);
       } else if (valueHandle) {
-        const callback = (function (valueHandle) {
+        const callback = (function (requestType, valueHandle, connection) {
           return function (result, data) {
             let callbackResponse;
 
             if (ATT_ECODE_SUCCESS === result) {
-              const dataLength = Math.min(data.length, this._mtu - 4);
+              const dataLength = Math.min(data.length, mtu - 4);
               callbackResponse = Buffer.alloc(4 + dataLength);
 
               callbackResponse[0] = ATT_OP_READ_BY_TYPE_RESP;
@@ -676,16 +728,22 @@ class Gatt extends EventEmitter {
 
             debug('read by type response: ' + callbackResponse.toString('hex'));
 
-            this.send(callbackResponse);
+            this.send(callbackResponse, connection);
           }.bind(this);
-        }.bind(this))(valueHandle);
+        }.bind(this))(requestType, valueHandle, connection);
 
-        const data = this._handles[valueHandle].value;
+        let data = undefined;
+        if (this._handles[valueHandle].values && this._handles[valueHandle].values.has(connection)) {
+          data = this._handles[valueHandle].values.get(connection);
+        }
+        else {
+          data = this._handles[valueHandle].value;
+        }
 
         if (data) {
           callback(ATT_ECODE_SUCCESS, data);
         } else if (handleAttribute) {
-          handleAttribute.emit('readRequest', 0, callback);
+          handleAttribute.emit('readRequest', connection, 0, callback);
         } else {
           callback(ATT_ECODE_UNLIKELY);
         }
@@ -697,7 +755,7 @@ class Gatt extends EventEmitter {
     return response;
   }
 
-  handleReadOrReadBlobRequest (request) {
+  handleReadOrReadBlobRequest (request, connection) {
     let response = null;
 
     const requestType = request[0];
@@ -711,12 +769,13 @@ class Gatt extends EventEmitter {
       let data = null;
       const handleType = handle.type;
 
-      const callback = (function (requestType, valueHandle) {
+      const callback = (function (requestType, valueHandle, connection) {
         return function (result, data) {
           let callbackResponse;
+          const { mtu } = this._connections.get(connection);
 
           if (ATT_ECODE_SUCCESS === result) {
-            const dataLength = Math.min(data.length, this._mtu - 1);
+            const dataLength = Math.min(data.length, mtu - 1);
             callbackResponse = Buffer.alloc(1 + dataLength);
 
             callbackResponse[0] = (requestType === ATT_OP_READ_BLOB_REQ) ? ATT_OP_READ_BLOB_RESP : ATT_OP_READ_RESP;
@@ -729,9 +788,9 @@ class Gatt extends EventEmitter {
 
           debug('read response: ' + callbackResponse.toString('hex'));
 
-          this.send(callbackResponse);
+          this.send(callbackResponse, connection);
         }.bind(this);
-      }.bind(this))(requestType, valueHandle);
+      }.bind(this))(requestType, valueHandle, connection);
 
       if (handleType === 'service' || handleType === 'includedService') {
         result = ATT_ECODE_SUCCESS;
@@ -758,7 +817,7 @@ class Gatt extends EventEmitter {
         }
 
         if (handleProperties & 0x02) {
-          if (handleSecure & 0x02 && !this._aclStream.encrypted) {
+          if (handleSecure & 0x02 && !this._connections.get(connection).aclStream.encrypted) {
             result = ATT_ECODE_AUTHENTICATION;
           } else {
             data = handle.value;
@@ -766,7 +825,7 @@ class Gatt extends EventEmitter {
             if (data) {
               result = ATT_ECODE_SUCCESS;
             } else {
-              handleAttribute.emit('readRequest', offset, callback);
+              handleAttribute.emit('readRequest', connection, offset, callback);
             }
           }
         } else {
@@ -797,7 +856,7 @@ class Gatt extends EventEmitter {
     return response;
   }
 
-  handleWriteRequestOrCommand (request) {
+  handleWriteRequestOrCommand (request, connection) {
     let response = null;
 
     const requestType = request[0];
@@ -817,7 +876,7 @@ class Gatt extends EventEmitter {
       const handleSecure = handle.secure;
 
       if (handleProperties && (withoutResponse ? (handleProperties & 0x04) : (handleProperties & 0x08))) {
-        const callback = (function (requestType, valueHandle, withoutResponse) {
+        const callback = (function (requestType, valueHandle, withoutResponse, connection) {
           return function (result) {
             if (!withoutResponse) {
               let callbackResponse;
@@ -830,12 +889,12 @@ class Gatt extends EventEmitter {
 
               debug('write response: ' + callbackResponse.toString('hex'));
 
-              this.send(callbackResponse);
+              this.send(callbackResponse, connection);
             }
           }.bind(this);
-        }.bind(this))(requestType, valueHandle, withoutResponse);
+        }.bind(this))(requestType, valueHandle, withoutResponse, connection);
 
-        if (handleSecure & (withoutResponse ? 0x04 : 0x08) && !this._aclStream.encrypted) {
+        if (handleSecure & (withoutResponse ? 0x04 : 0x08) && !this._connections.get(connection).aclStream.encrypted) {
           response = this.errorResponse(requestType, valueHandle, ATT_ECODE_AUTHENTICATION);
         } else if (handle.type === 'descriptor' || handle.uuid === '2902') {
           let result;
@@ -846,12 +905,18 @@ class Gatt extends EventEmitter {
             const value = data.readUInt16LE(0);
             const handleAttribute = handle.attribute;
 
-            handle.value = data;
+            if (handle.values) {
+              handle.values.set(connection, data);
+            }
+            else {
+              handle.value = data;
+            }
 
             if (value & 0x0003) {
-              const updateValueCallback = (function (valueHandle, attribute) {
+              const updateValueCallback = (function (valueHandle, attribute, connection) {
                 return function (data) {
-                  const dataLength = Math.min(data.length, this._mtu - 3);
+                  const { mtu } = this._connections.get(connection);
+                  const dataLength = Math.min(data.length, mtu - 3);
                   const useNotify = attribute.properties.indexOf('notify') !== -1;
                   const useIndicate = attribute.properties.indexOf('indicate') !== -1;
 
@@ -866,9 +931,9 @@ class Gatt extends EventEmitter {
                     }
 
                     debug('notify message: ' + notifyMessage.toString('hex'));
-                    this.send(notifyMessage);
+                    this.send(notifyMessage, connection);
 
-                    attribute.emit('notify');
+                    attribute.emit('notify', connection);
                   } else if (useIndicate) {
                     const indicateMessage = Buffer.alloc(3 + dataLength);
 
@@ -879,20 +944,21 @@ class Gatt extends EventEmitter {
                       indicateMessage[3 + i] = data[i];
                     }
 
-                    this._lastIndicatedAttribute = attribute;
+                    this._lastIndicatedAttributes.set(connection, attribute);
 
                     debug('indicate message: ' + indicateMessage.toString('hex'));
-                    this.send(indicateMessage);
+                    this.send(indicateMessage, connection);
                   }
                 }.bind(this);
-              }.bind(this))(valueHandle - 1, handleAttribute);
+              }.bind(this))(valueHandle - 1, handleAttribute, connection);
 
               if (handleAttribute.emit) {
-                handleAttribute.emit('subscribe', this._mtu - 3, updateValueCallback);
+                const { mtu } = this._connections.get(connection);
+                handleAttribute.emit('subscribe', connection, mtu - 3, updateValueCallback);
               }
             } else {
               if (handleAttribute.emit) {
-                handleAttribute.emit('unsubscribe');
+                handleAttribute.emit('unsubscribe', connection);
               }
             }
 
@@ -901,7 +967,7 @@ class Gatt extends EventEmitter {
 
           callback(result);
         } else {
-          handle.attribute.emit('writeRequest', data, offset, withoutResponse, callback);
+          handle.attribute.emit('writeRequest', connection, data, offset, withoutResponse, callback);
         }
       } else {
         response = this.errorResponse(requestType, valueHandle, ATT_ECODE_WRITE_NOT_PERM);
@@ -913,7 +979,7 @@ class Gatt extends EventEmitter {
     return response;
   }
 
-  handlePrepareWriteRequest (request) {
+  handlePrepareWriteRequest (request, connection) {
     let response;
 
     const requestType = request[0];
@@ -931,14 +997,15 @@ class Gatt extends EventEmitter {
         const handleSecure = handle.secure;
 
         if (handleProperties && (handleProperties & 0x08)) {
-          if ((handleSecure & 0x08) && !this._aclStream.encrypted) {
+          if ((handleSecure & 0x08) && !this._connections.get(connection).aclStream.encrypted) {
             response = this.errorResponse(requestType, valueHandle, ATT_ECODE_AUTHENTICATION);
-          } else if (this._preparedWriteRequest) {
-            if (this._preparedWriteRequest.handle !== handle) {
+          } else if (this._preparedWriteRequests.has(connection)) {
+            const preparedWriteRequest = this._preparedWriteRequests.get(connection);
+            if (preparedWriteRequest.handle !== handle) {
               response = this.errorResponse(requestType, valueHandle, ATT_ECODE_UNLIKELY);
-            } else if (offset === (this._preparedWriteRequest.offset + this._preparedWriteRequest.data.length)) {
-              this._preparedWriteRequest.data = Buffer.concat([
-                this._preparedWriteRequest.data,
+            } else if (offset === (preparedWriteRequest.offset + preparedWriteRequest.data.length)) {
+              preparedWriteRequest.data = Buffer.concat([
+                preparedWriteRequest.data,
                 data
               ]);
 
@@ -949,12 +1016,12 @@ class Gatt extends EventEmitter {
               response = this.errorResponse(requestType, valueHandle, ATT_ECODE_INVALID_OFFSET);
             }
           } else {
-            this._preparedWriteRequest = {
+            this._preparedWriteRequests.set(connection, {
               handle,
               valueHandle,
               offset,
               data
-            };
+            });
 
             response = Buffer.alloc(request.length);
             request.copy(response);
@@ -973,19 +1040,20 @@ class Gatt extends EventEmitter {
     return response;
   }
 
-  handleExecuteWriteRequest (request) {
+  handleExecuteWriteRequest (request, connection) {
     let response = null;
 
     const requestType = request[0];
     const flag = request[1];
 
-    if (this._preparedWriteRequest) {
-      const valueHandle = this._preparedWriteRequest.valueHandle;
+    if (this._preparedWriteRequests.has(connection)) {
+      const preparedWriteRequest = this._preparedWriteRequests.get(connection);
+      const valueHandle = preparedWriteRequest.valueHandle;
 
       if (flag === 0x00) {
         response = Buffer.from([ATT_OP_EXEC_WRITE_RESP]);
       } else if (flag === 0x01) {
-        const callback = (function (requestType, valueHandle) {
+        const callback = (function (requestType, valueHandle, connection) {
           return function (result) {
             let callbackResponse;
 
@@ -997,16 +1065,16 @@ class Gatt extends EventEmitter {
 
             debug('execute write response: ' + callbackResponse.toString('hex'));
 
-            this.send(callbackResponse);
+            this.send(callbackResponse, connection);
           }.bind(this);
-        }.bind(this))(requestType, this._preparedWriteRequest.valueHandle);
+        }.bind(this))(requestType, valueHandle, connection);
 
-        this._preparedWriteRequest.handle.attribute.emit('writeRequest', this._preparedWriteRequest.data, this._preparedWriteRequest.offset, false, callback);
+        preparedWriteRequest.handle.attribute.emit('writeRequest', connection, preparedWriteRequest.data, preparedWriteRequest.offset, false, callback);
       } else {
         response = this.errorResponse(requestType, 0x0000, ATT_ECODE_UNLIKELY);
       }
 
-      this._preparedWriteRequest = null;
+      this._preparedWriteRequests.delete(connection);
     } else {
       response = this.errorResponse(requestType, 0x0000, ATT_ECODE_UNLIKELY);
     }
@@ -1014,14 +1082,18 @@ class Gatt extends EventEmitter {
     return response;
   }
 
-  handleConfirmation (request) {
-    if (this._lastIndicatedAttribute) {
-      if (this._lastIndicatedAttribute.emit) {
-        this._lastIndicatedAttribute.emit('indicate');
-      }
+  handleConfirmation (request, connection) {
+    if (this._lastIndicatedAttributes.has(connection) === false) {
+      return;
+    }
 
-      this._lastIndicatedAttribute = null;
+    const lastIndicatedAttribute = this._lastIndicatedAttributes.get(connection);
+    if (lastIndicatedAttribute.emit) {
+      lastIndicatedAttribute.emit('indicate', connection);
     }
+
+    this._lastIndicatedAttributes.delete(connection);
+    this._lastIndicatedAttributes.delete(connection);
   }
 }
 

package/lib/hci-socket/hci.js

@@ -1,8 +1,8 @@
 const debug = require('debug')('hci');
 
 const { EventEmitter } = require('events');
+const { loadDriver } = require('@stoprocent/bluetooth-hci-socket');
 
-const BluetoothHciSocket = require('@stoprocent/bluetooth-hci-socket');
 const vendorSpecific = require('./vs');
 
 const HCI_COMMAND_PKT = 0x01;
@@ -77,10 +77,12 @@ const STATUS_MAPPER = require('./hci-status');
 class Hci extends EventEmitter {
   constructor (options) {
     super();
-
     options = options || {};
-    this._manufacturer = null;
+    
+    const BluetoothHciSocket = loadDriver(options.hciDriver || 'default');
     this._socket = new BluetoothHciSocket();
+
+    this._manufacturer = null;
     this._isDevUp = null;
     this._state = null;
     this._deviceId = null;

package/lib/hci-socket/mgmt.js

@@ -86,4 +86,4 @@ class Mgmt {
   }
 }
 
-module.exports = new Mgmt();
+module.exports = Mgmt;