@stoprocent/noble 1.9.2-16

package/lib/mac/src/callbacks.cc

@@ -0,0 +1,222 @@
+//
+//  callbacks.cc
+//  noble-mac-native
+//
+//  Created by Georg Vienna on 30.08.18.
+//
+#include "callbacks.h"
+
+#define _s(val) Napi::String::New(env, val)
+#define _b(val) Napi::Boolean::New(env, val)
+#define _n(val) Napi::Number::New(env, val)
+#define _u(str) toUuid(env, str)
+
+Napi::String toUuid(Napi::Env& env, const std::string& uuid) {
+    std::string str(uuid);
+    str.erase(std::remove(str.begin(), str.end(), '-'), str.end());
+    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+    return _s(str);
+}
+
+Napi::String toAddressType(Napi::Env& env, const AddressType& type) {
+    if(type == PUBLIC) {
+        return _s("public");
+    } else if (type == RANDOM) {
+        return _s("random");
+    }
+    return _s("unknown");
+}
+
+Napi::Buffer<uint8_t> toBuffer(Napi::Env& env, const Data& data) {
+    if (data.empty()) {
+        return Napi::Buffer<uint8_t>::New(env, 0);
+    }
+    return Napi::Buffer<uint8_t>::Copy(env, &data[0], data.size());
+}
+
+Napi::Array toUuidArray(Napi::Env& env, const std::vector<std::string>& data) {
+    if (data.empty()) {
+        return Napi::Array::New(env);
+    }
+    auto arr = Napi::Array::New(env, data.size());
+    for (size_t i = 0; i < data.size(); i++) {
+        arr.Set(i, _u(data[i]));
+    }
+    return arr;
+}
+
+Napi::Array toArray(Napi::Env& env, const std::vector<std::string>& data) {
+    if (data.empty()) {
+        return Napi::Array::New(env);
+    }
+    auto arr = Napi::Array::New(env, data.size());
+    for (size_t i = 0; i < data.size(); i++) {
+        arr.Set(i, _s(data[i]));
+    }
+    return arr;
+}
+
+void Emit::Wrap(const Napi::Value& receiver, const Napi::Function& callback) {
+    mCallback = std::make_shared<ThreadSafeCallback>(receiver, callback);
+}
+
+void Emit::RadioState(const std::string& state) {
+    mCallback->call([state](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('stateChange', state);
+        args = { _s("stateChange"), _s(state) };
+    });
+}
+
+void Emit::ScanState(bool start) {
+    mCallback->call([start](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('scanStart') emit('scanStop')
+        args = { _s(start ? "scanStart" : "scanStop") };
+    });
+}
+
+void Emit::Scan(const std::string& uuid, int rssi, const Peripheral& peripheral) {
+    auto address = peripheral.address;
+    auto addressType = peripheral.addressType;
+    auto connectable = peripheral.connectable;
+    auto name = peripheral.name;
+    auto txPowerLevel = peripheral.txPowerLevel;
+    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);
+        if (std::get<1>(name)) {
+            advertisment.Set(_s("localName"), _s(std::get<0>(name)));
+        }
+
+        if (std::get<1>(txPowerLevel)) {
+            advertisment.Set(_s("txPowerLevel"), std::get<0>(txPowerLevel));
+        }
+
+        if (std::get<1>(manufacturerData)) {
+            advertisment.Set(_s("manufacturerData"), toBuffer(env, std::get<0>(manufacturerData)));
+        }
+
+        if (std::get<1>(serviceData)) {
+            auto array = std::get<0>(serviceData).empty() ? Napi::Array::New(env) : Napi::Array::New(env, std::get<0>(serviceData).size());
+            for (size_t i = 0; i < std::get<0>(serviceData).size(); i++) {
+                Napi::Object data = Napi::Object::New(env);
+                data.Set(_s("uuid"), _u(std::get<0>(serviceData)[i].first));
+                data.Set(_s("data"), toBuffer(env, std::get<0>(serviceData)[i].second));
+                array.Set(i, data);
+            }
+            advertisment.Set(_s("serviceData"), array);
+        }
+
+        if (std::get<1>(serviceUuids)) {
+            advertisment.Set(_s("serviceUuids"), toUuidArray(env, std::get<0>(serviceUuids)));
+        }
+        // emit('discover', deviceUuid, address, addressType, connectable, advertisement, rssi);
+        args = { _s("discover"), _u(uuid), _s(address), toAddressType(env, addressType), _b(connectable), advertisment, _n(rssi) };
+    });
+}
+
+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) };
+    });
+}
+
+void Emit::Disconnected(const std::string& uuid) {
+    mCallback->call([uuid](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('disconnect', deviceUuid);
+        args = { _s("disconnect"), _u(uuid) };
+    });
+}
+
+void Emit::RSSI(const std::string & uuid, int rssi) {
+    mCallback->call([uuid, rssi](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('rssiUpdate', deviceUuid, rssi);
+        args = { _s("rssiUpdate"), _u(uuid), _n(rssi) };
+    });
+}
+
+void Emit::ServicesDiscovered(const std::string & uuid, const std::vector<std::string>& serviceUuids) {
+    mCallback->call([uuid, serviceUuids](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('servicesDiscover', deviceUuid, serviceUuids)
+        args = { _s("servicesDiscover"), _u(uuid), toUuidArray(env, serviceUuids) };
+    });
+}
+
+void Emit::IncludedServicesDiscovered(const std::string & uuid, const std::string & serviceUuid, const std::vector<std::string>& serviceUuids) {
+    mCallback->call([uuid, serviceUuid, serviceUuids](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('includedServicesDiscover', deviceUuid, serviceUuid, includedServiceUuids)
+        args = { _s("includedServicesDiscover"), _u(uuid), _u(serviceUuid), toUuidArray(env, serviceUuids) };
+    });
+}
+
+void Emit::CharacteristicsDiscovered(const std::string & uuid, const std::string & serviceUuid, const std::vector<std::pair<std::string, std::vector<std::string>>>& characteristics) {
+    mCallback->call([uuid, serviceUuid, characteristics](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++) {
+            Napi::Object characteristic = Napi::Object::New(env);
+            characteristic.Set(_s("uuid"), _u(characteristics[i].first));
+            characteristic.Set(_s("properties"), toArray(env, characteristics[i].second));
+            arr.Set(i, characteristic);
+        }
+        // emit('characteristicsDiscover', deviceUuid, serviceUuid, { uuid, properties: ['broadcast', 'read', ...]})
+        args = { _s("characteristicsDiscover"), _u(uuid), _u(serviceUuid), arr };
+    });
+}
+
+void Emit::Read(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid, const Data& data, bool isNotification) {
+    mCallback->call([uuid, serviceUuid, characteristicUuid, data, isNotification](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) };
+    });
+}
+
+void Emit::Write(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid) {
+    mCallback->call([uuid, serviceUuid, characteristicUuid](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('write', deviceUuid, servicesUuid, characteristicsUuid)
+        args = { _s("write"), _u(uuid), _u(serviceUuid), _u(characteristicUuid) };
+    });
+}
+
+void Emit::Notify(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid, bool state) {
+    mCallback->call([uuid, serviceUuid, characteristicUuid, state](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) };
+    });
+}
+
+void Emit::DescriptorsDiscovered(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid, const std::vector<std::string>& descriptorUuids) {
+    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) };
+    });
+}
+
+void Emit::ReadValue(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid, const std::string& descriptorUuid, const Data& data) {
+    mCallback->call([uuid, serviceUuid, characteristicUuid, descriptorUuid, data](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) };
+    });
+}
+
+void Emit::WriteValue(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid, const std::string& descriptorUuid) {
+    mCallback->call([uuid, serviceUuid, characteristicUuid, descriptorUuid](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) };
+    });
+}
+
+void Emit::ReadHandle(const std::string & uuid, int descriptorHandle, const Data& data) {
+    mCallback->call([uuid, descriptorHandle, data](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('handleRead', deviceUuid, descriptorHandle, data);
+        args = { _s("handleRead"), _u(uuid), _n(descriptorHandle), toBuffer(env, data) };
+    });
+}
+
+void Emit::WriteHandle(const std::string & uuid, int descriptorHandle) {
+    mCallback->call([uuid, descriptorHandle](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('handleWrite', deviceUuid, descriptorHandle);
+        args = { _s("handleWrite"), _u(uuid), _n(descriptorHandle) };
+    });
+}

package/lib/mac/src/callbacks.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <napi.h>
+#include "peripheral.h"
+
+class ThreadSafeCallback {
+  using arg_vector_t = std::vector<napi_value>;
+  using arg_func_t = std::function<void(napi_env, arg_vector_t &)>;
+
+  static void callJsCallback(Napi::Env env,
+                             Napi::Function jsCallback,
+                             Napi::Reference<Napi::Value> *context,
+                             arg_func_t *argfn) {
+    if (argfn != nullptr) {
+      arg_vector_t args;
+
+      (*argfn)(env, args);
+      delete argfn;
+
+      if (env != nullptr && jsCallback != nullptr)
+        jsCallback.Call(context->Value(), args);
+    }
+  };
+  using tsfn_t = Napi::TypedThreadSafeFunction<
+    Napi::Reference<Napi::Value>, arg_func_t, callJsCallback>;
+
+public:
+  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);
+    tsfn_ = tsfn_t::New(jsCallback.Env(),
+                        jsCallback,
+                        "ThreadSafeCallback callback",
+                        0, 1, &receiver_);
+  }
+  ~ThreadSafeCallback() {
+    // No further interaction with the thread safe function allowed.
+    tsfn_.Abort();
+  }
+  void call(arg_func_t arg_function) {
+    arg_func_t *argfn = new arg_func_t(arg_function);
+    if (tsfn_.BlockingCall(argfn) != napi_ok)
+      delete argfn;
+  };
+
+protected:
+  ThreadSafeCallback(const ThreadSafeCallback &) = delete;
+  ThreadSafeCallback& operator=(const ThreadSafeCallback &) = delete;
+  ThreadSafeCallback& operator=(ThreadSafeCallback &&) = delete;
+
+private:
+  Napi::Reference<Napi::Value> receiver_;
+  tsfn_t tsfn_;
+};
+
+class Emit {
+public:
+    void Wrap(const Napi::Value& receiver, const Napi::Function& callback);
+    void RadioState(const std::string& status);
+    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 std::vector<uint8_t>& data);
+    void WriteHandle(const std::string& uuid, int descriptorHandle);
+protected:
+    std::shared_ptr<ThreadSafeCallback> mCallback;
+};

package/lib/mac/src/napi_objc.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <napi.h>
+#import <Foundation/Foundation.h>
+
+NSArray* getUuidArray(const Napi::Value& value);
+BOOL getBool(const Napi::Value& value, BOOL def);
+
+NSString* napiToUuidString(Napi::String string);
+NSArray* napiToUuidArray(Napi::Array array);
+NSData* napiToData(Napi::Buffer<Byte> buffer);
+NSNumber* napiToNumber(Napi::Number number);

package/lib/mac/src/napi_objc.mm

@@ -0,0 +1,50 @@
+//
+//  napi_objc.mm
+//  noble-mac-native
+//
+//  Created by Georg Vienna on 30.08.18.
+//
+#include "napi_objc.h"
+
+NSString* napiToUuidString(Napi::String string) {
+    std::string str = string.Utf8Value();
+    NSMutableString * uuid = [[NSMutableString alloc] initWithCString:str.c_str() encoding:NSASCIIStringEncoding];
+    if([uuid length] == 32) {
+        [uuid insertString: @"-" atIndex: 8];
+        [uuid insertString: @"-" atIndex: 13];
+        [uuid insertString: @"-" atIndex: 18];
+        [uuid insertString: @"-" atIndex: 23];
+    }
+    return [uuid uppercaseString];
+}
+
+NSArray* napiToUuidArray(Napi::Array array) {
+    NSMutableArray* serviceUuids = [NSMutableArray arrayWithCapacity:array.Length()];
+    for(size_t i = 0;  i < array.Length(); i++) {
+        Napi::Value val = array[i];
+        [serviceUuids addObject:napiToUuidString(val.As<Napi::String>())];
+    }
+    return serviceUuids;
+}
+
+NSData* napiToData(Napi::Buffer<Byte> buffer) {
+    return [NSData dataWithBytes:buffer.Data() length:buffer.Length()];
+}
+
+NSNumber* napiToNumber(Napi::Number number) {
+    return [NSNumber numberWithInt:number.Int64Value()];
+}
+
+NSArray* getUuidArray(const Napi::Value& value) {
+    if (value.IsArray()) {
+        return napiToUuidArray(value.As<Napi::Array>());
+    }
+    return nil;
+}
+
+BOOL getBool(const Napi::Value& value, BOOL def) {
+    if (value.IsBoolean()) {
+        return value.As<Napi::Boolean>().Value();
+    }
+    return def;
+}

package/lib/mac/src/noble_mac.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <napi.h>
+
+#include "ble_manager.h"
+
+class NobleMac : public Napi::ObjectWrap<NobleMac>
+{
+public:
+    NobleMac(const Napi::CallbackInfo&);
+    Napi::Value Init(const Napi::CallbackInfo&);
+    Napi::Value Scan(const Napi::CallbackInfo&);
+    Napi::Value StopScan(const Napi::CallbackInfo&);
+    Napi::Value Connect(const Napi::CallbackInfo&);
+    Napi::Value Disconnect(const Napi::CallbackInfo&);
+    Napi::Value UpdateRSSI(const Napi::CallbackInfo&);
+    Napi::Value DiscoverServices(const Napi::CallbackInfo&);
+    Napi::Value DiscoverIncludedServices(const Napi::CallbackInfo& info);
+    Napi::Value DiscoverCharacteristics(const Napi::CallbackInfo& info);
+    Napi::Value Read(const Napi::CallbackInfo& info);
+    Napi::Value Write(const Napi::CallbackInfo& info);
+    Napi::Value Notify(const Napi::CallbackInfo& info);
+    Napi::Value DiscoverDescriptors(const Napi::CallbackInfo& info);
+    Napi::Value ReadValue(const Napi::CallbackInfo& info);
+    Napi::Value WriteValue(const Napi::CallbackInfo& info);
+    Napi::Value ReadHandle(const Napi::CallbackInfo& info);
+    Napi::Value WriteHandle(const Napi::CallbackInfo& info);
+    Napi::Value Stop(const Napi::CallbackInfo&);
+
+    static Napi::Function GetClass(Napi::Env);
+
+private:
+    BLEManager* manager;
+};

package/lib/mac/src/noble_mac.mm

@@ -0,0 +1,264 @@
+//
+//  noble_mac.mm
+//  noble-mac-native
+//
+//  Created by Georg Vienna on 28.08.18.
+//
+#include "noble_mac.h"
+
+#include "napi_objc.h"
+
+#define THROW(msg) \
+Napi::TypeError::New(info.Env(), msg).ThrowAsJavaScriptException(); \
+return Napi::Value();
+
+#define ARG1(type1) \
+if (!info[0].Is##type1()) { \
+    THROW("There should be one argument: (" #type1 ")") \
+}
+
+#define ARG2(type1, type2) \
+if (!info[0].Is##type1() || !info[1].Is##type2()) { \
+    THROW("There should be 2 arguments: (" #type1 ", " #type2 ")"); \
+}
+
+#define ARG3(type1, type2, type3) \
+if (!info[0].Is##type1() || !info[1].Is##type2() || !info[2].Is##type3()) { \
+    THROW("There should be 3 arguments: (" #type1 ", " #type2 ", " #type3 ")"); \
+}
+
+#define ARG4(type1, type2, type3, type4) \
+if (!info[0].Is##type1() || !info[1].Is##type2() || !info[2].Is##type3() || !info[3].Is##type4()) { \
+    THROW("There should be 4 arguments: (" #type1 ", " #type2 ", " #type3 ", " #type4 ")"); \
+}
+
+#define ARG5(type1, type2, type3, type4, type5) \
+if (!info[0].Is##type1() || !info[1].Is##type2() || !info[2].Is##type3() || !info[3].Is##type4() || !info[4].Is##type5()) { \
+    THROW("There should be 5 arguments: (" #type1 ", " #type2 ", " #type3 ", " #type4 ", " #type5 ")"); \
+}
+
+#define CHECK_MANAGER() \
+if(!manager) { \
+    THROW("BLEManager has already been cleaned up"); \
+}
+
+NobleMac::NobleMac(const Napi::CallbackInfo& info) : ObjectWrap(info) {
+}
+
+Napi::Value NobleMac::Init(const Napi::CallbackInfo& info) {
+    Napi::Function emit = info.This().As<Napi::Object>().Get("emit").As<Napi::Function>();
+    manager = [[BLEManager alloc] init:info.This() with:emit];
+    return Napi::Value();
+}
+
+// startScanning(serviceUuids, allowDuplicates)
+Napi::Value NobleMac::Scan(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    NSArray* array = getUuidArray(info[0]);
+    // default value NO
+    auto duplicates = getBool(info[1], NO);
+    [manager scan:array allowDuplicates:duplicates];
+    return Napi::Value();
+}
+
+// stopScanning()
+Napi::Value NobleMac::StopScan(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    [manager stopScan];
+    return Napi::Value();
+}
+
+// connect(deviceUuid)
+Napi::Value NobleMac::Connect(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG1(String)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    [manager connect:uuid];
+    return Napi::Value();
+}
+
+// disconnect(deviceUuid)
+Napi::Value NobleMac::Disconnect(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG1(String)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    [manager disconnect:uuid];
+    return Napi::Value();
+}
+
+// updateRssi(deviceUuid)
+Napi::Value NobleMac::UpdateRSSI(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG1(String)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    [manager updateRSSI:uuid];
+    return Napi::Value();
+}
+
+// discoverServices(deviceUuid, uuids)
+Napi::Value NobleMac::DiscoverServices(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG1(String)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    NSArray* array = getUuidArray(info[1]);
+    [manager discoverServices:uuid serviceUuids:array];
+    return Napi::Value();
+}
+
+// discoverIncludedServices(deviceUuid, serviceUuid, serviceUuids)
+Napi::Value NobleMac::DiscoverIncludedServices(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG2(String, String)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    auto service = napiToUuidString(info[1].As<Napi::String>());
+    NSArray* serviceUuids = getUuidArray(info[2]);
+    [manager discoverIncludedServices:uuid forService:service services:serviceUuids];
+    return Napi::Value();
+}
+
+// discoverCharacteristics(deviceUuid, serviceUuid, characteristicUuids)
+Napi::Value NobleMac::DiscoverCharacteristics(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG2(String, String)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    auto service = napiToUuidString(info[1].As<Napi::String>());
+    NSArray* characteristics = getUuidArray(info[2]);
+    [manager discoverCharacteristics:uuid forService:service characteristics:characteristics];
+    return Napi::Value();
+}
+
+// read(deviceUuid, serviceUuid, characteristicUuid)
+Napi::Value NobleMac::Read(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG3(String, String, String)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    auto service = napiToUuidString(info[1].As<Napi::String>());
+    auto characteristic = napiToUuidString(info[2].As<Napi::String>());
+    [manager read:uuid service:service characteristic:characteristic];
+    return Napi::Value();
+}
+
+// write(deviceUuid, serviceUuid, characteristicUuid, data, withoutResponse)
+Napi::Value NobleMac::Write(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG4(String, String, String, Buffer /*, Boolean */)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    auto service = napiToUuidString(info[1].As<Napi::String>());
+    auto characteristic = napiToUuidString(info[2].As<Napi::String>());
+    auto data = napiToData(info[3].As<Napi::Buffer<Byte>>());
+
+    auto withoutResponse = false;
+    if(info[4] && !(info[4].IsNull() || info[4].IsUndefined())) {
+        withoutResponse = info[4].As<Napi::Boolean>().Value();
+    }
+
+    [manager write:uuid service:service characteristic:characteristic data:data withoutResponse:withoutResponse];
+    return Napi::Value();
+}
+
+// notify(deviceUuid, serviceUuid, characteristicUuid, notify)
+Napi::Value NobleMac::Notify(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG4(String, String, String, Boolean)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    auto service = napiToUuidString(info[1].As<Napi::String>());
+    auto characteristic = napiToUuidString(info[2].As<Napi::String>());
+    auto on = info[3].As<Napi::Boolean>().Value();
+    [manager notify:uuid service:service characteristic:characteristic on:on];
+    return Napi::Value();
+}
+
+// discoverDescriptors(deviceUuid, serviceUuid, characteristicUuid)
+Napi::Value NobleMac::DiscoverDescriptors(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG3(String, String, String)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    auto service = napiToUuidString(info[1].As<Napi::String>());
+    auto characteristic = napiToUuidString(info[2].As<Napi::String>());
+    [manager discoverDescriptors:uuid service:service characteristic:characteristic];
+    return Napi::Value();
+}
+
+// readValue(deviceUuid, serviceUuid, characteristicUuid, descriptorUuid)
+Napi::Value NobleMac::ReadValue(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG4(String, String, String, String)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    auto service = napiToUuidString(info[1].As<Napi::String>());
+    auto characteristic = napiToUuidString(info[2].As<Napi::String>());
+    auto descriptor = napiToUuidString(info[3].As<Napi::String>());
+    [manager readValue:uuid service:service characteristic:characteristic descriptor:descriptor];
+    return Napi::Value();
+}
+
+// writeValue(deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data)
+Napi::Value NobleMac::WriteValue(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG5(String, String, String, String, Buffer)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    auto service = napiToUuidString(info[1].As<Napi::String>());
+    auto characteristic = napiToUuidString(info[2].As<Napi::String>());
+    auto descriptor = napiToUuidString(info[3].As<Napi::String>());
+    auto data = napiToData(info[4].As<Napi::Buffer<Byte>>());
+    [manager writeValue:uuid service:service characteristic:characteristic descriptor:descriptor data: data];
+    return Napi::Value();
+}
+
+// readHandle(deviceUuid, handle)
+Napi::Value NobleMac::ReadHandle(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG2(String, Number)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    auto handle = napiToNumber(info[1].As<Napi::Number>());
+    [manager readHandle:uuid handle:handle];
+    return Napi::Value();
+}
+
+// writeHandle(deviceUuid, handle, data, (unused)withoutResponse)
+Napi::Value NobleMac::WriteHandle(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG3(String, Number, Buffer)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    auto handle = napiToNumber(info[1].As<Napi::Number>());
+    auto data = napiToData(info[2].As<Napi::Buffer<Byte>>());
+    [manager writeHandle:uuid handle:handle data: data];
+    return Napi::Value();
+}
+
+Napi::Value NobleMac::Stop(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    CFRelease((__bridge CFTypeRef)manager);
+    manager = nil;
+    return Napi::Value();
+}
+
+Napi::Function NobleMac::GetClass(Napi::Env env) {
+    return DefineClass(env, "NobleMac", {
+        NobleMac::InstanceMethod("init", &NobleMac::Init),
+        NobleMac::InstanceMethod("startScanning", &NobleMac::Scan),
+        NobleMac::InstanceMethod("stopScanning", &NobleMac::StopScan),
+        NobleMac::InstanceMethod("connect", &NobleMac::Connect),
+        NobleMac::InstanceMethod("disconnect", &NobleMac::Disconnect),
+        NobleMac::InstanceMethod("updateRssi", &NobleMac::UpdateRSSI),
+        NobleMac::InstanceMethod("discoverServices", &NobleMac::DiscoverServices),
+        NobleMac::InstanceMethod("discoverIncludedServices", &NobleMac::DiscoverIncludedServices),
+        NobleMac::InstanceMethod("discoverCharacteristics", &NobleMac::DiscoverCharacteristics),
+        NobleMac::InstanceMethod("read", &NobleMac::Read),
+        NobleMac::InstanceMethod("write", &NobleMac::Write),
+        NobleMac::InstanceMethod("notify", &NobleMac::Notify),
+        NobleMac::InstanceMethod("discoverDescriptors", &NobleMac::DiscoverDescriptors),
+        NobleMac::InstanceMethod("readValue", &NobleMac::ReadValue),
+        NobleMac::InstanceMethod("writeValue", &NobleMac::WriteValue),
+        NobleMac::InstanceMethod("readHandle", &NobleMac::ReadHandle),
+        NobleMac::InstanceMethod("writeHandle", &NobleMac::WriteHandle),
+        NobleMac::InstanceMethod("stop", &NobleMac::Stop),
+    });
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    Napi::String name = Napi::String::New(env, "NobleMac");
+    exports.Set(name, NobleMac::GetClass(env));
+    return exports;
+}
+
+NODE_API_MODULE(addon, Init)