@stoprocent/noble 1.19.0 → 2.0.0

package/lib/{win/src/callbacks.cc → common/src/Emit.cc}

@@ -1,14 +1,7 @@
-//
-//  callbacks.cc
-//  noble-mac-native
-//
-//  Created by Georg Vienna on 30.08.18.
-//
-#include "callbacks.h"
-
-#include <napi-thread-safe-callback.hpp>
+#include "Emit.h"
 
 #define _s(val) Napi::String::New(env, val)
+#define _e(val) Napi::Error::New(env, _s(val)).Value()
 #define _b(val) Napi::Boolean::New(env, val)
 #define _n(val) Napi::Number::New(env, val)
 #define _u(str) toUuid(env, str)
@@ -36,11 +29,12 @@ Napi::String toAddressType(Napi::Env& env, const AddressType& type)
 
 Napi::Buffer<uint8_t> toBuffer(Napi::Env& env, const Data& data)
 {
-    if (data.empty())
-    {
+    if (data.empty()) {
         return Napi::Buffer<uint8_t>::New(env, 0);
     }
-    return Napi::Buffer<uint8_t>::Copy(env, &data[0], data.size());
+    else {
+        return Napi::Buffer<uint8_t>::Copy(env, &data[0], data.size());
+    }
 }
 
 Napi::Array toUuidArray(Napi::Env& env, const std::vector<std::string>& data)
@@ -84,6 +78,14 @@ void Emit::RadioState(const std::string& state)
     });
 }
 
+void Emit::Address(const std::string& address)
+{
+    mCallback->call([address](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('addressChange', address);
+        args = { _s("addressChange"), _s(address) };
+    }); 
+}
+
 void Emit::ScanState(bool start)
 {
     mCallback->call([start](Napi::Env env, std::vector<napi_value>& args) {
@@ -94,6 +96,7 @@ void Emit::ScanState(bool start)
 
 void Emit::Scan(const std::string& uuid, int rssi, const Peripheral& peripheral)
 {
+    // Copy values to capture in lambda
     auto address = peripheral.address;
     auto addressType = peripheral.addressType;
     auto connectable = peripheral.connectable;
@@ -102,24 +105,41 @@ void Emit::Scan(const std::string& uuid, int rssi, const Peripheral& peripheral)
     auto manufacturerData = peripheral.manufacturerData;
     auto serviceData = peripheral.serviceData;
     auto serviceUuids = peripheral.serviceUuids;
+
     mCallback->call([uuid, rssi, address, addressType, connectable, name, txPowerLevel,
                      manufacturerData, serviceData,
                      serviceUuids](Napi::Env env, std::vector<napi_value>& args) {
         Napi::Object advertisment = Napi::Object::New(env);
-        advertisment.Set(_s("localName"), _s(name));
-        advertisment.Set(_s("txPowerLevel"), txPowerLevel);
-        advertisment.Set(_s("manufacturerData"), toBuffer(env, manufacturerData));
-        auto array =
-            serviceData.empty() ? Napi::Array::New(env) : Napi::Array::New(env, serviceData.size());
-        for (size_t i = 0; i < serviceData.size(); i++)
-        {
-            Napi::Object data = Napi::Object::New(env);
-            data.Set(_s("uuid"), _u(serviceData[i].first));
-            data.Set(_s("data"), toBuffer(env, serviceData[i].second));
-            array.Set(i, data);
+        
+        // Handle optional name
+        advertisment.Set(_s("localName"), 
+            name.has_value() ? _s(name.value()) : env.Null());
+        
+        // Handle optional txPowerLevel
+        advertisment.Set(_s("txPowerLevel"), 
+            txPowerLevel.has_value() ? _n(txPowerLevel.value()) : env.Null());
+        
+        // Handle optional manufacturerData
+        advertisment.Set(_s("manufacturerData"), 
+            manufacturerData.has_value() ? toBuffer(env, manufacturerData.value()) : Napi::Buffer<uint8_t>::New(env, 0));
+
+        // Handle optional serviceData
+        auto array = Napi::Array::New(env);
+        if (serviceData.has_value()) {
+            const auto& data = serviceData.value();
+            array = Napi::Array::New(env, data.size());
+            for (size_t i = 0; i < data.size(); i++) {
+                Napi::Object dataObj = Napi::Object::New(env);
+                dataObj.Set(_s("uuid"), _u(data[i].first));
+                dataObj.Set(_s("data"), toBuffer(env, data[i].second));
+                array.Set(i, dataObj);
+            }
         }
         advertisment.Set(_s("serviceData"), array);
-        advertisment.Set(_s("serviceUuids"), toUuidArray(env, serviceUuids));
+
+        // Handle optional serviceUuids
+        advertisment.Set(_s("serviceUuids"), serviceUuids.has_value() ? toUuidArray(env, serviceUuids.value()) : Napi::Array::New(env));
+        
         // emit('discover', deviceUuid, address, addressType, connectable, advertisement, rssi);
         args = { _s("discover"),  _u(uuid),     _s(address), toAddressType(env, addressType),
                  _b(connectable), advertisment, _n(rssi) };
@@ -130,7 +150,7 @@ void Emit::Connected(const std::string& uuid, const std::string& error)
 {
     mCallback->call([uuid, error](Napi::Env env, std::vector<napi_value>& args) {
         // emit('connect', deviceUuid) error added here
-        args = { _s("connect"), _u(uuid), error.empty() ? env.Null() : _s(error) };
+        args = { _s("connect"), _u(uuid), error.empty() ? env.Null() : _e(error) };
     });
 }
 
@@ -142,39 +162,39 @@ void Emit::Disconnected(const std::string& uuid)
     });
 }
 
-void Emit::RSSI(const std::string& uuid, int rssi)
+void Emit::RSSI(const std::string& uuid, int rssi, const std::string& error)
 {
-    mCallback->call([uuid, rssi](Napi::Env env, std::vector<napi_value>& args) {
+    mCallback->call([uuid, rssi, error](Napi::Env env, std::vector<napi_value>& args) {
         // emit('rssiUpdate', deviceUuid, rssi);
-        args = { _s("rssiUpdate"), _u(uuid), _n(rssi) };
+        args = { _s("rssiUpdate"), _u(uuid), _n(rssi), error.empty() ? env.Null() : _e(error) };
     });
 }
 
-void Emit::ServicesDiscovered(const std::string& uuid, const std::vector<std::string>& serviceUuids)
+void Emit::ServicesDiscovered(const std::string& uuid, const std::vector<std::string>& serviceUuids, const std::string& error)
 {
-    mCallback->call([uuid, serviceUuids](Napi::Env env, std::vector<napi_value>& args) {
+    mCallback->call([uuid, serviceUuids, error](Napi::Env env, std::vector<napi_value>& args) {
         // emit('servicesDiscover', deviceUuid, serviceUuids)
-        args = { _s("servicesDiscover"), _u(uuid), toUuidArray(env, serviceUuids) };
+        args = { _s("servicesDiscover"), _u(uuid), toUuidArray(env, serviceUuids), error.empty() ? env.Null() : _e(error) };
     });
 }
 
 void Emit::IncludedServicesDiscovered(const std::string& uuid, const std::string& serviceUuid,
-                                      const std::vector<std::string>& serviceUuids)
+                                      const std::vector<std::string>& serviceUuids, const std::string& error)
 {
     mCallback->call(
-        [uuid, serviceUuid, serviceUuids](Napi::Env env, std::vector<napi_value>& args) {
+        [uuid, serviceUuid, serviceUuids, error](Napi::Env env, std::vector<napi_value>& args) {
             // emit('includedServicesDiscover', deviceUuid, serviceUuid, includedServiceUuids)
             args = { _s("includedServicesDiscover"), _u(uuid), _u(serviceUuid),
-                     toUuidArray(env, serviceUuids) };
+                     toUuidArray(env, serviceUuids), error.empty() ? env.Null() : _e(error) };
         });
 }
 
 void Emit::CharacteristicsDiscovered(
     const std::string& uuid, const std::string& serviceUuid,
-    const std::vector<std::pair<std::string, std::vector<std::string>>>& characteristics)
+    const std::vector<std::pair<std::string, std::vector<std::string>>>& characteristics, const std::string& error)
 {
     mCallback->call(
-        [uuid, serviceUuid, characteristics](Napi::Env env, std::vector<napi_value>& args) {
+        [uuid, serviceUuid, characteristics, error](Napi::Env env, std::vector<napi_value>& args) {
             auto arr = characteristics.empty() ? Napi::Array::New(env)
                                                : Napi::Array::New(env, characteristics.size());
             for (size_t i = 0; i < characteristics.size(); i++)
@@ -186,89 +206,112 @@ void Emit::CharacteristicsDiscovered(
             }
             // emit('characteristicsDiscover', deviceUuid, serviceUuid, { uuid, properties:
             // ['broadcast', 'read', ...]})
-            args = { _s("characteristicsDiscover"), _u(uuid), _u(serviceUuid), arr };
+            args = { _s("characteristicsDiscover"), _u(uuid), _u(serviceUuid), arr, error.empty() ? env.Null() : _e(error) };
         });
 }
 
 void Emit::Read(const std::string& uuid, const std::string& serviceUuid,
-                const std::string& characteristicUuid, const Data& data, bool isNotification)
+                const std::string& characteristicUuid, const Data& data, bool isNotification, const std::string& error)
 {
     mCallback->call([uuid, serviceUuid, characteristicUuid, data,
-                     isNotification](Napi::Env env, std::vector<napi_value>& args) {
+                     isNotification, error](Napi::Env env, std::vector<napi_value>& args) {
         // emit('read', deviceUuid, serviceUuid, characteristicsUuid, data, isNotification);
-        args = { _s("read"),          _u(uuid),          _u(serviceUuid), _u(characteristicUuid),
-                 toBuffer(env, data), _b(isNotification) };
+        args = { 
+            _s("read"), 
+            _u(uuid), 
+            _u(serviceUuid), 
+            _u(characteristicUuid), 
+            error.empty() ? toBuffer(env, data) : env.Null(), 
+            _b(isNotification), 
+            error.empty() ? env.Null() : _e(error) 
+        };
     });
 }
 
 void Emit::Write(const std::string& uuid, const std::string& serviceUuid,
-                 const std::string& characteristicUuid)
+                 const std::string& characteristicUuid, const std::string& error)
 {
     mCallback->call(
-        [uuid, serviceUuid, characteristicUuid](Napi::Env env, std::vector<napi_value>& args) {
+        [uuid, serviceUuid, characteristicUuid, error](Napi::Env env, std::vector<napi_value>& args) {
             // emit('write', deviceUuid, servicesUuid, characteristicsUuid)
-            args = { _s("write"), _u(uuid), _u(serviceUuid), _u(characteristicUuid) };
+            args = { _s("write"), _u(uuid), _u(serviceUuid), _u(characteristicUuid), error.empty() ? env.Null() : _e(error) };
         });
 }
 
 void Emit::Notify(const std::string& uuid, const std::string& serviceUuid,
-                  const std::string& characteristicUuid, bool state)
+                  const std::string& characteristicUuid, bool state, const std::string& error)
 {
-    mCallback->call([uuid, serviceUuid, characteristicUuid, state](Napi::Env env,
+    mCallback->call([uuid, serviceUuid, characteristicUuid, state, error](Napi::Env env,
                                                                    std::vector<napi_value>& args) {
         // emit('notify', deviceUuid, servicesUuid, characteristicsUuid, state)
-        args = { _s("notify"), _u(uuid), _u(serviceUuid), _u(characteristicUuid), _b(state) };
+        args = { _s("notify"), _u(uuid), _u(serviceUuid), _u(characteristicUuid), _b(state), error.empty() ? env.Null() : _e(error) };
     });
 }
 
 void Emit::DescriptorsDiscovered(const std::string& uuid, const std::string& serviceUuid,
                                  const std::string& characteristicUuid,
-                                 const std::vector<std::string>& descriptorUuids)
+                                 const std::vector<std::string>& descriptorUuids, const std::string& error)
 {
-    mCallback->call([uuid, serviceUuid, characteristicUuid,
-                     descriptorUuids](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('descriptorsDiscover', deviceUuid, servicesUuid, characteristicsUuid, descriptors:
-        // [uuids])
-        args = { _s("descriptorsDiscover"), _u(uuid), _u(serviceUuid), _u(characteristicUuid),
-                 toUuidArray(env, descriptorUuids) };
+    mCallback->call([uuid, serviceUuid, characteristicUuid, descriptorUuids, error](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('descriptorsDiscover', deviceUuid, servicesUuid, characteristicsUuid, descriptors:[uuids])
+        args = { 
+            _s("descriptorsDiscover"), 
+            _u(uuid), 
+            _u(serviceUuid), 
+            _u(characteristicUuid), 
+            toUuidArray(env, descriptorUuids), 
+            error.empty() ? env.Null() : _e(error) 
+        };
     });
 }
 
 void Emit::ReadValue(const std::string& uuid, const std::string& serviceUuid,
                      const std::string& characteristicUuid, const std::string& descriptorUuid,
-                     const Data& data)
+                     const Data& data, const std::string& error)
 {
     mCallback->call([uuid, serviceUuid, characteristicUuid, descriptorUuid,
-                     data](Napi::Env env, std::vector<napi_value>& args) {
+                     data, error](Napi::Env env, std::vector<napi_value>& args) {
         // emit('valueRead', deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data)
-        args = { _s("valueRead"),        _u(uuid),           _u(serviceUuid),
-                 _u(characteristicUuid), _u(descriptorUuid), toBuffer(env, data) };
+        args = { 
+            _s("valueRead"), 
+            _u(uuid), 
+            _u(serviceUuid), 
+            _u(characteristicUuid), 
+            _u(descriptorUuid), 
+            error.empty() ? toBuffer(env, data) : env.Null(), 
+            error.empty() ? env.Null() : _e(error) 
+        };
     });
 }
 
 void Emit::WriteValue(const std::string& uuid, const std::string& serviceUuid,
-                      const std::string& characteristicUuid, const std::string& descriptorUuid)
+                      const std::string& characteristicUuid, const std::string& descriptorUuid, const std::string& error)
 {
-    mCallback->call([uuid, serviceUuid, characteristicUuid,
-                     descriptorUuid](Napi::Env env, std::vector<napi_value>& args) {
+    mCallback->call([uuid, serviceUuid, characteristicUuid, descriptorUuid, error](Napi::Env env, std::vector<napi_value>& args) {
         // emit('valueWrite', deviceUuid, serviceUuid, characteristicUuid, descriptorUuid);
         args = { _s("valueWrite"), _u(uuid), _u(serviceUuid), _u(characteristicUuid),
-                 _u(descriptorUuid) };
+                 _u(descriptorUuid), error.empty() ? env.Null() : _e(error) };
     });
 }
 
-void Emit::ReadHandle(const std::string& uuid, int descriptorHandle, const Data& data)
+void Emit::ReadHandle(const std::string& uuid, int descriptorHandle, const Data& data, const std::string& error)
 {
-    mCallback->call([uuid, descriptorHandle, data](Napi::Env env, std::vector<napi_value>& args) {
+    mCallback->call([uuid, descriptorHandle, data, error](Napi::Env env, std::vector<napi_value>& args) {
         // emit('handleRead', deviceUuid, descriptorHandle, data);
-        args = { _s("handleRead"), _u(uuid), _n(descriptorHandle), toBuffer(env, data) };
+        args = { 
+            _s("handleRead"), 
+            _u(uuid), 
+            _n(descriptorHandle), 
+            error.empty() ? toBuffer(env, data) : env.Null(), 
+            error.empty() ? env.Null() : _e(error) 
+        };
     });
 }
 
-void Emit::WriteHandle(const std::string& uuid, int descriptorHandle)
+void Emit::WriteHandle(const std::string& uuid, int descriptorHandle, const std::string& error)
 {
-    mCallback->call([uuid, descriptorHandle](Napi::Env env, std::vector<napi_value>& args) {
+    mCallback->call([uuid, descriptorHandle, error](Napi::Env env, std::vector<napi_value>& args) {
         // emit('handleWrite', deviceUuid, descriptorHandle);
-        args = { _s("handleWrite"), _u(uuid), _n(descriptorHandle) };
+        args = { _s("handleWrite"), _u(uuid), _n(descriptorHandle), error.empty() ? env.Null() : _e(error) };
     });
 }

package/lib/descriptor.js

@@ -1,72 +1,75 @@
-const events = require('events');
-const util = require('util');
-
+const { EventEmitter } = require('events');
 const descriptors = require('./descriptors.json');
 
-function Descriptor (noble, peripheralId, serviceUuid, characteristicUuid, uuid) {
-  this._noble = noble;
-  this._peripheralId = peripheralId;
-  this._serviceUuid = serviceUuid;
-  this._characteristicUuid = characteristicUuid;
+class Descriptor extends EventEmitter {
+  constructor (noble, peripheralId, serviceUuid, characteristicUuid, uuid) {
+    super();
+    
+    this._noble = noble;
+    this._peripheralId = peripheralId;
+    this._serviceUuid = serviceUuid;
+    this._characteristicUuid = characteristicUuid;
 
-  this.uuid = uuid;
-  this.name = null;
-  this.type = null;
+    this.uuid = uuid;
+    this.name = null;
+    this.type = null;
 
-  const descriptor = descriptors[uuid];
-  if (descriptor) {
-    this.name = descriptor.name;
-    this.type = descriptor.type;
+    const descriptor = descriptors[uuid];
+    if (descriptor) {
+      this.name = descriptor.name;
+      this.type = descriptor.type;
+    }
   }
-}
 
-util.inherits(Descriptor, events.EventEmitter);
+  toString () {
+    return JSON.stringify({
+      uuid: this.uuid,
+      name: this.name,
+      type: this.type
+    });
+  }
 
-Descriptor.prototype.toString = function () {
-  return JSON.stringify({
-    uuid: this.uuid,
-    name: this.name,
-    type: this.type
-  });
-};
+  readValue (callback) {
+    if (callback) {
+      this.once('valueRead', (data, error) => callback(error, data));
+    }
+    this._noble.readValue(
+      this._peripheralId,
+      this._serviceUuid,
+      this._characteristicUuid,
+      this.uuid
+    );
+  }
 
-const readValue = function (callback) {
-  if (callback) {
-    this.once('valueRead', data => {
-      callback(null, data);
+  async readValueAsync () {
+    return new Promise((resolve, reject) => {
+      this.readValue((error, data) => error ? reject(error) : resolve(data));
     });
   }
-  this._noble.readValue(
-    this._peripheralId,
-    this._serviceUuid,
-    this._characteristicUuid,
-    this.uuid
-  );
-};
 
-Descriptor.prototype.readValue = readValue;
-Descriptor.prototype.readValueAsync = util.promisify(readValue);
+  writeValue (data, callback) {
+    if (!(data instanceof Buffer)) {
+      throw new Error('data must be a Buffer');
+    }
 
-const writeValue = function (data, callback) {
-  if (!(data instanceof Buffer)) {
-    throw new Error('data must be a Buffer');
+    if (callback) {
+      this.once('valueWrite', error => callback(error));
+    }
+    this._noble.writeValue(
+      this._peripheralId,
+      this._serviceUuid,
+      this._characteristicUuid,
+      this.uuid,
+      data
+    );
   }
 
-  if (callback) {
-    this.once('valueWrite', () => {
-      callback(null);
+  // Using modern async/await pattern instead of util.promisify
+  async writeValueAsync (data) {
+    return new Promise((resolve, reject) => {
+      this.writeValue(data, error => error ? reject(error) : resolve());
     });
   }
-  this._noble.writeValue(
-    this._peripheralId,
-    this._serviceUuid,
-    this._characteristicUuid,
-    this.uuid,
-    data
-  );
-};
-
-Descriptor.prototype.writeValue = writeValue;
-Descriptor.prototype.writeValueAsync = util.promisify(writeValue);
+}
 
 module.exports = Descriptor;

package/lib/hci-socket/acl-stream.js

@@ -1,6 +1,4 @@
-const events = require('events');
-const util = require('util');
-
+const { EventEmitter } = require('events');
 const Smp = require('./smp');
 
 const AclStream = function (hci, handle, localAddressType, localAddress, remoteAddressType, remoteAddress) {
@@ -18,7 +16,7 @@ const AclStream = function (hci, handle, localAddressType, localAddress, remoteA
   this._smp.on('end', this.onSmpEndBinded);
 };
 
-util.inherits(AclStream, events.EventEmitter);
+Object.setPrototypeOf(AclStream.prototype, EventEmitter.prototype);
 
 AclStream.prototype.encrypt = function () {
   this._smp.sendPairingRequest();