@stoprocent/noble 1.19.0 → 2.0.0

package/lib/characteristic.js

@@ -1,161 +1,187 @@
-const events = require('events');
-const util = require('util');
+const { EventEmitter } = require('events');
 
 const characteristics = require('./characteristics.json');
 
-function Characteristic (noble, peripheralId, serviceUuid, uuid, properties) {
-  this._noble = noble;
-  this._peripheralId = peripheralId;
-  this._serviceUuid = serviceUuid;
-
-  this.uuid = uuid;
-  this.name = null;
-  this.type = null;
-  this.properties = properties;
-  this.descriptors = null;
+class Characteristic extends EventEmitter {
+  
+  constructor (noble, peripheralId, serviceUuid, uuid, properties) {
+    super();
+    this._noble = noble;
+    this._peripheralId = peripheralId;
+    this._serviceUuid = serviceUuid;
+
+    this.uuid = uuid;
+    this.name = null;
+    this.type = null;
+    this.properties = properties;
+    this.descriptors = null;
+
+    const characteristic = characteristics[uuid];
+    if (characteristic) {
+      this.name = characteristic.name;
+      this.type = characteristic.type;
+    }
+  }
 
-  const characteristic = characteristics[uuid];
-  if (characteristic) {
-    this.name = characteristic.name;
-    this.type = characteristic.type;
+  toString () {
+    return JSON.stringify({
+      uuid: this.uuid,
+      name: this.name,
+      type: this.type,
+      properties: this.properties
+    });
   }
-}
 
-util.inherits(Characteristic, events.EventEmitter);
-
-Characteristic.prototype.toString = function () {
-  return JSON.stringify({
-    uuid: this.uuid,
-    name: this.name,
-    type: this.type,
-    properties: this.properties
-  });
-};
-
-const read = function (callback) {
-  if (callback) {
-    const onRead = (data, isNotification) => {
-      // only call the callback if 'read' event and non-notification
-      // 'read' for non-notifications is only present for backwards compatbility
-      if (!isNotification) {
-        // remove the listener
-        this.removeListener('read', onRead);
-
-        // call the callback
-        callback(null, data);
-      }
-    };
-
-    this.on('read', onRead);
-  }
-
-  this._noble.read(
-    this._peripheralId,
-    this._serviceUuid,
-    this.uuid
-  );
-};
-
-Characteristic.prototype.read = read;
-Characteristic.prototype.readAsync = util.promisify(read);
-
-const write = function (data, withoutResponse, callback) {
-  if (process.title !== 'browser') {
-    const allowedTypes = [
-      Buffer,
-      Uint8Array,
-      Uint16Array,
-      Uint32Array
-    ];
-    if (!allowedTypes.some((allowedType) => data instanceof allowedType)) {
-      throw new Error(`data must be a ${allowedTypes.map((allowedType) => allowedType.name).join(' or ')}`);
+  read (callback) {
+    if (callback) {
+      const onRead = (data, isNotification, error) => {
+        // only call the callback if 'read' event and non-notification
+        // 'read' for non-notifications is only present for backwards compatbility
+        if (!isNotification) {
+          // remove the listener
+          this.removeListener('read', onRead);
+          // call the callback
+          callback(error, data);
+        }
+      };
+
+      this.on('read', onRead);
     }
+
+    this._noble.read(
+      this._peripheralId,
+      this._serviceUuid,
+      this.uuid
+    );
   }
 
-  if (callback) {
-    this.once('write', () => {
-      callback(null);
+  async readAsync () {
+    return this._noble._withDisconnectHandler(this._peripheralId, () => {
+      return new Promise((resolve, reject) => {
+        this.read((error, data) => error ? reject(error) : resolve(data));
+      });
     });
   }
 
-  this._noble.write(
-    this._peripheralId,
-    this._serviceUuid,
-    this.uuid,
-    data,
-    withoutResponse
-  );
-};
+  write (data, withoutResponse, callback) {
+    if (process.title !== 'browser') {
+      const allowedTypes = [
+        Buffer,
+        Uint8Array,
+        Uint16Array,
+        Uint32Array
+      ];
+      if (!allowedTypes.some((allowedType) => data instanceof allowedType)) {
+        throw new Error(`data must be a ${allowedTypes.map((allowedType) => allowedType.name).join(' or ')}`);
+      }
+    }
 
-Characteristic.prototype.write = write;
-Characteristic.prototype.writeAsync = util.promisify(write);
+    if (callback) {
+      this.once('write', error => callback(error));
+    }
 
-const broadcast = function (broadcast, callback) {
-  if (callback) {
-    this.once('broadcast', () => {
-      callback(null);
+    this._noble.write(
+      this._peripheralId,
+      this._serviceUuid,
+      this.uuid,
+      data,
+      withoutResponse
+    );
+  }
+
+  async writeAsync (data, withoutResponse) {
+    return this._noble._withDisconnectHandler(this._peripheralId, () => {
+      return new Promise((resolve, reject) => {
+        this.write(data, withoutResponse, error => error ? reject(error) : resolve());
+      });
     });
   }
 
-  this._noble.broadcast(
-    this._peripheralId,
-    this._serviceUuid,
-    this.uuid,
-    broadcast
-  );
-};
+  broadcast (broadcast, callback) {
+    if (callback) {
+      this.once('broadcast', error => callback(error));
+    }
 
-Characteristic.prototype.broadcast = broadcast;
-Characteristic.prototype.broadcastAsync = util.promisify(broadcast);
+    this._noble.broadcast(
+      this._peripheralId,
+      this._serviceUuid,
+      this.uuid,
+      broadcast
+    );
+  }
 
-// deprecated in favour of subscribe/unsubscribe
-const notify = function (notify, callback) {
-  if (callback) {
-    this.once('notify', () => {
-      callback(null);
+  async broadcastAsync (broadcast) {
+    return this._noble._withDisconnectHandler(this._peripheralId, () => {
+      return new Promise((resolve, reject) => {
+        this.broadcast(broadcast, (state, error) => error ? reject(error) : resolve(state));
+      });
     });
   }
 
-  this._noble.notify(
-    this._peripheralId,
-    this._serviceUuid,
-    this.uuid,
-    notify
-  );
-};
+  notify (notify, callback) {
+    if (callback) {
+      this.once('notify', (state, error) => callback(error, state));
+    }
 
-Characteristic.prototype.notify = notify;
-Characteristic.prototype.notifyAsync = util.promisify(notify);
+    this._noble.notify(
+      this._peripheralId,
+      this._serviceUuid,
+      this.uuid,
+      notify
+    );
+  }
 
-const subscribe = function (callback) {
-  this.notify(true, callback);
-};
+  async notifyAsync (notify) {
+    return this._noble._withDisconnectHandler(this._peripheralId, () => {
+      return new Promise((resolve, reject) => {
+        this.notify(notify, (error, state) => error ? reject(error) : resolve(state));
+      });
+    });
+  }
 
-Characteristic.prototype.subscribe = subscribe;
-Characteristic.prototype.subscribeAsync = util.promisify(subscribe);
+  subscribe (callback) {
+    this.notify(true, callback);
+  }
 
-const unsubscribe = function (callback) {
-  this.notify(false, callback);
-};
+  async subscribeAsync () {
+    return this._noble._withDisconnectHandler(this._peripheralId, () => {
+      return new Promise((resolve, reject) => {
+        this.subscribe((error, state) => error ? reject(error) : resolve(state));
+      });
+    });
+  }
 
-Characteristic.prototype.unsubscribe = unsubscribe;
-Characteristic.prototype.unsubscribeAsync = util.promisify(unsubscribe);
+  unsubscribe (callback) {
+    this.notify(false, callback);
+  }
 
-const discoverDescriptors = function (callback) {
-  if (callback) {
-    this.once('descriptorsDiscover', descriptors => {
-      callback(null, descriptors);
+  async unsubscribeAsync () {
+    return this._noble._withDisconnectHandler(this._peripheralId, () => {
+      return new Promise((resolve, reject) => {
+        this.unsubscribe(error => error ? reject(error) : resolve());
+      });
     });
   }
 
-  this._noble.discoverDescriptors(
-    this._peripheralId,
-    this._serviceUuid,
-    this.uuid
-  );
-};
+  discoverDescriptors (callback) {
+    if (callback) {
+      this.once('descriptorsDiscover', (descriptors, error) => callback(error, descriptors));
+    }
+
+    this._noble.discoverDescriptors(
+      this._peripheralId,
+      this._serviceUuid,
+      this.uuid
+    );
+  }
 
-Characteristic.prototype.discoverDescriptors = discoverDescriptors;
-Characteristic.prototype.discoverDescriptorsAsync = util.promisify(discoverDescriptors);
+  async discoverDescriptorsAsync () {
+    return this._noble._withDisconnectHandler(this._peripheralId, () => {
+      return new Promise((resolve, reject) => {
+        this.discoverDescriptors((error, descriptors) => error ? reject(error) : resolve(descriptors));
+      });
+    });
+  }
+}
 
 module.exports = Characteristic;

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

@@ -1,9 +1,11 @@
 #pragma once
 
 #include <napi.h>
-#include "peripheral.h"
+#include <vector>
+#include <string>
 
-class ThreadSafeCallback;
+#include "Peripheral.h"
+#include "ThreadSafeCallback.h"
 
 class Emit
 {
@@ -11,22 +13,23 @@ public:
     // clang-format off
     void Wrap(const Napi::Value& receiver, const Napi::Function& callback);
     void RadioState(const std::string& status);
+    void Address(const std::string& address);
     void ScanState(bool start);
     void Scan(const std::string& uuid, int rssi, const Peripheral& peripheral);
     void Connected(const std::string& uuid, const std::string& error = "");
     void Disconnected(const std::string& uuid);
-    void RSSI(const std::string& uuid, int rssi);
-    void ServicesDiscovered(const std::string& uuid, const std::vector<std::string>& serviceUuids);
-    void IncludedServicesDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::vector<std::string>& serviceUuids);
-    void CharacteristicsDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::vector<std::pair<std::string, std::vector<std::string>>>& characteristics);
-    void Read(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const Data& data, bool isNotification);
-    void Write(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid);
-    void Notify(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, bool state);
-    void DescriptorsDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::vector<std::string>& descriptorUuids);
-    void ReadValue(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::string& descriptorUuid, const Data& data);
-    void WriteValue(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::string& descriptorUuid);
-    void ReadHandle(const std::string& uuid, int descriptorHandle, const Data& data);
-    void WriteHandle(const std::string& uuid, int descriptorHandle);
+    void RSSI(const std::string& uuid, int rssi, const std::string& error = "");
+    void ServicesDiscovered(const std::string& uuid, const std::vector<std::string>& serviceUuids, const std::string& error = "");
+    void IncludedServicesDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::vector<std::string>& serviceUuids, const std::string& error = "");
+    void CharacteristicsDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::vector<std::pair<std::string, std::vector<std::string>>>& characteristics, const std::string& error = "");
+    void Read(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const Data& data, bool isNotification, const std::string& error = "");
+    void Write(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::string& error = "");
+    void Notify(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, bool state, const std::string& error = "");
+    void DescriptorsDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::vector<std::string>& descriptorUuids, const std::string& error = "");
+    void ReadValue(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::string& descriptorUuid, const Data& data, const std::string& error = "");
+    void WriteValue(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::string& descriptorUuid, const std::string& error = "");
+    void ReadHandle(const std::string& uuid, int descriptorHandle, const Data& data, const std::string& error = "");
+    void WriteHandle(const std::string& uuid, int descriptorHandle, const std::string& error = "");
     // clang-format on
 protected:
     std::shared_ptr<ThreadSafeCallback> mCallback;

package/lib/common/include/Peripheral.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <optional>
+
+using Data = std::vector<uint8_t>;
+
+enum AddressType {
+    PUBLIC,
+    RANDOM,
+    UNKNOWN,
+};
+
+class Peripheral {
+public:
+    Peripheral(): 
+        address("unknown"), 
+        addressType(UNKNOWN), 
+        connectable(false) {}
+
+    std::string address;
+    AddressType addressType;
+    bool connectable;
+    
+    std::optional<std::string> name;
+    std::optional<int> txPowerLevel;
+    std::optional<Data> manufacturerData;
+    std::optional<std::vector<std::pair<std::string, Data>>> serviceData;
+    std::optional<std::vector<std::string>> serviceUuids;
+};

package/lib/common/include/ThreadSafeCallback.h

@@ -0,0 +1,95 @@
+#pragma once
+
+#include <napi.h>
+#include <vector>
+#include <functional>
+
+class ThreadSafeCallback {
+public:
+    // More descriptive type aliases
+    using ArgumentVector = std::vector<napi_value>;
+    using ArgumentFunction = std::function<void(napi_env, ArgumentVector&)>;
+
+    // Constructor with validation
+    ThreadSafeCallback(const Napi::Value& receiver, const Napi::Function& jsCallback);
+    
+    // Destructor
+    ~ThreadSafeCallback();
+
+    // Delete copy and move operations explicitly
+    ThreadSafeCallback(const ThreadSafeCallback&) = delete;
+    ThreadSafeCallback& operator=(const ThreadSafeCallback&) = delete;
+    ThreadSafeCallback& operator=(ThreadSafeCallback&&) = delete;
+
+    // Public interface
+    void call(ArgumentFunction argFunction);
+
+private:
+    // Static callback handler
+    static void callJsCallback(Napi::Env env,
+                             Napi::Function jsCallback,
+                             Napi::Reference<Napi::Value>* context,
+                             ArgumentFunction* argFn);
+
+    // Type alias for the thread-safe function
+    using ThreadSafeFunc = Napi::TypedThreadSafeFunction<
+        Napi::Reference<Napi::Value>,
+        ArgumentFunction,
+        callJsCallback>;
+
+    // Member variables
+    Napi::Reference<Napi::Value> receiver_;
+    ThreadSafeFunc threadSafeFunction_;
+};
+
+// Implementation
+
+inline ThreadSafeCallback::ThreadSafeCallback(
+    const Napi::Value& receiver,
+    const Napi::Function& jsCallback) {
+    
+    if (!(receiver.IsObject() || receiver.IsFunction())) {
+        throw Napi::Error::New(jsCallback.Env(),
+            "Callback receiver must be an object or function");
+    }
+    if (!jsCallback.IsFunction()) {
+        throw Napi::Error::New(jsCallback.Env(),
+            "Callback must be a function");
+    }
+
+    receiver_ = Napi::Persistent(receiver);
+    threadSafeFunction_ = ThreadSafeFunc::New(
+        jsCallback.Env(),
+        jsCallback,
+        "ThreadSafeCallback callback",
+        0, 1,
+        &receiver_);
+}
+
+inline ThreadSafeCallback::~ThreadSafeCallback() {
+    threadSafeFunction_.Abort();
+}
+
+inline void ThreadSafeCallback::call(ArgumentFunction argFunction) {
+    auto argFn = new ArgumentFunction(argFunction);
+    if (threadSafeFunction_.BlockingCall(argFn) != napi_ok) {
+        delete argFn;
+    }
+}
+
+inline void ThreadSafeCallback::callJsCallback(
+    Napi::Env env,
+    Napi::Function jsCallback,
+    Napi::Reference<Napi::Value>* context,
+    ArgumentFunction* argFn) {
+    
+    if (argFn != nullptr) {
+        ArgumentVector args;
+        (*argFn)(env, args);
+        delete argFn;
+
+        if (env != nullptr && jsCallback != nullptr) {
+            jsCallback.Call(context->Value(), args);
+        }
+    }
+}