@stoprocent/bleno 0.7.0

package/lib/mac/src/napi_objc.mm

@@ -0,0 +1,286 @@
+//
+//  napi_objc.mm
+//  bleno-mac-native
+//
+//  Created by Georg Vienna on 30.08.18.
+//
+#include "napi_objc.h"
+
+NSString *napiToString(Napi::String string) {
+    std::string str = string.Utf8Value();
+    return [NSString stringWithUTF8String:str.c_str()];
+}
+
+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<CBMutableService *> *napiArrayToCBMutableServices(Napi::Array array) {
+    NSLog(@"napiArrayToCBMutableServices");
+
+    NSMutableArray *services = [NSMutableArray array];
+
+    for (size_t i = 0;  i < array.Length(); i++) {
+        Napi::Value v = array[i];
+        Napi::Object obj = v.As<Napi::Object>();
+
+        [services addObject:napiToCBMutableService(obj)];
+    }
+
+    return [services copy];
+}
+
+CBMutableService *napiToCBMutableService(Napi::Object obj) {
+    NSLog(@"napiToCBMutableService");
+
+    NSString *uuid = napiToUuidString(obj.Get("uuid").ToString());
+
+    NSLog(@"napiArrayToCBMutableService: uuid:%@", uuid);
+
+    CBMutableService *service = [[CBMutableService alloc] initWithType:[CBUUID UUIDWithString:uuid]
+                                                               primary:YES];
+
+    service.characteristics = napiArrayToCBMutableCharacteristics(obj.Get("characteristics").As<Napi::Array>());
+
+    return service;
+}
+
+
+
+NSArray<CBMutableCharacteristic *> *napiArrayToCBMutableCharacteristics(Napi::Array array) {
+    NSLog(@"napiArrayToCBMutableCharacteristics");
+
+    NSMutableArray *characteristics = [NSMutableArray array];
+
+    for (size_t i = 0; i < array.Length(); i++) {
+        Napi::Value v = array[i];
+        Napi::Object obj = v.As<Napi::Object>();
+
+        [characteristics addObject:napiToCBMutableCharacteristic(obj)];
+    }
+
+    return [characteristics copy];
+}
+
+CBMutableCharacteristic *napiToCBMutableCharacteristic(Napi::Object obj) {
+    NSLog(@"napiToCBMutableCharacteristic");
+
+    NSString *uuid = napiToUuidString(obj.Get("uuid").ToString());
+    NSLog(@"napiToCBMutableCharacteristic: cUUID:%@", uuid);
+
+    NSData *value = obj.Get("value").IsBuffer() ? napiToData(obj.Get("value").As<Napi::Buffer<Byte>>()) : nil;
+    NSLog(@"napiToCBMutableCharacteristic: value:%@", value);
+
+    auto properties = obj.Get("properties").As<Napi::Array>();
+    auto secure = obj.Get("secure").As<Napi::Array>();
+
+    auto descriptors = obj.Get("descriptors").As<Napi::Array>();
+
+    CBMutableCharacteristic *characteristic = [[CBMutableCharacteristic alloc] initWithType:[CBUUID UUIDWithString:uuid]
+                                                                                 properties:napiToCBCharacteristicProperties(properties, secure)
+                                                                                      value:value
+                                                                                permissions:napiToCBAttributePermissions(properties, secure)];
+
+    characteristic.descriptors = napiArrayToCBDescriptors(descriptors);
+
+    return characteristic;
+}
+
+CBCharacteristicProperties napiToCBCharacteristicProperties(Napi::Array properties, Napi::Array secure) {
+    NSLog(@"napiToCBCharacteristicProperties");
+
+    NSArray<NSString *> *p = napiToStringArray(properties);
+    NSArray<NSString *> *s = napiToStringArray(secure);
+
+    CBCharacteristicProperties ret = 0;
+
+    if ([p containsObject:@"read"]) {
+        ret |= CBCharacteristicPropertyRead;
+    }
+
+    if ([p containsObject:@"write"]) {
+        ret |= CBCharacteristicPropertyWrite;
+    }
+
+    if ([p containsObject:@"writeWithoutResponse"]) {
+        ret |= CBCharacteristicPropertyWriteWithoutResponse;
+    }
+
+    if ([p containsObject:@"notify"]) {
+        if ([s containsObject:@"notify"]) {
+            ret |= CBCharacteristicPropertyNotifyEncryptionRequired;
+        } else {
+            ret |= CBCharacteristicPropertyNotify;
+        }
+    }
+
+    if ([p containsObject:@"indicate"]) {
+        if ([s containsObject:@"indicate"]) {
+            ret |= CBCharacteristicPropertyIndicateEncryptionRequired;
+        } else {
+            ret |= CBCharacteristicPropertyIndicate;
+        }
+    }
+
+    return ret;
+}
+
+CBAttributePermissions napiToCBAttributePermissions(Napi::Array properties, Napi::Array secure) {
+    NSLog(@"napiToCBAttributePermissions");
+
+    NSArray<NSString *> *p = napiToStringArray(properties);
+    NSArray<NSString *> *s = napiToStringArray(secure);
+
+    CBAttributePermissions ret = 0;
+
+    if ([p containsObject:@"read"]) {
+        if ([s containsObject:@"read"]) {
+            ret |= CBAttributePermissionsReadEncryptionRequired;
+        } else {
+            ret |= CBAttributePermissionsReadable;
+        }
+    }
+
+    if ([p containsObject:@"write"]) {
+        if ([s containsObject:@"write"]) {
+            ret |= CBAttributePermissionsWriteEncryptionRequired;
+        } else {
+            ret |= CBAttributePermissionsWriteable;
+        }
+    }
+
+    if ([p containsObject:@"writeWithoutResponse"]) {
+        if ([s containsObject:@"writeWithoutResponse"]) {
+            ret |= CBAttributePermissionsWriteEncryptionRequired;
+        } else {
+            ret |= CBAttributePermissionsWriteable;
+        }
+    }
+
+    return ret;
+}
+
+NSArray<CBDescriptor *> *napiArrayToCBDescriptors(Napi::Array array) {
+    NSLog(@"napiArrayToCBDescriptors");
+
+    NSMutableArray *descriptors = [NSMutableArray array];
+
+    for (size_t i = 0; i < array.Length(); i++) {
+        Napi::Value v = array[i];
+        Napi::Object obj = v.As<Napi::Object>();
+
+        [descriptors addObject:napiToCBDescriptor(obj)];
+    }
+
+    return [descriptors copy];
+}
+
+CBDescriptor *napiToCBDescriptor(Napi::Object obj) {
+    NSString *uuid = napiToUuidString(obj.Get("uuid").ToString());
+    NSString *value = napiToString(obj.Get("value").ToString());
+
+    NSLog(@"napiToCBDescriptor uuid:%@ value:%@", uuid, value);
+
+    return [[CBMutableDescriptor alloc] initWithType:[CBUUID UUIDWithString:uuid]
+                                               value:value];
+}
+
+NSArray<NSString *> *napiToStringArray(Napi::Array array) {
+    NSMutableArray *ret = [NSMutableArray arrayWithCapacity:array.Length()];
+
+    for (size_t i = 0; i < array.Length(); i++) {
+        Napi::Value v = array[i];
+        Napi::String str = v.ToString();
+
+        [ret addObject:napiToString(str)];
+    }
+
+    return [ret copy];
+}
+
+std::map<Napi::String, Napi::Object> napiArrayToUUIDEmitters(Napi::Array services) {
+    NSLog(@"napiArrayToUUIDEmitters");
+
+    std::map<Napi::String, Napi::Object> map;
+
+    for (size_t i = 0;  i < services.Length(); i++) {
+        Napi::Value vS = services[i];
+        Napi::Object objS = vS.As<Napi::Object>();
+
+        Napi::String uuidS = objS.Get("uuid").ToString();
+
+        map[uuidS] = objS;
+
+        Napi::Array characteristics = objS.Get("characteristics").As<Napi::Array>();
+        for (size_t j = 0;  j < characteristics.Length(); j++) {
+            Napi::Value vC = characteristics[j];
+            Napi::Object objC = vC.As<Napi::Object>();
+
+            Napi::String uuidC = objC.Get("uuid").ToString();
+
+            map[uuidC] = objC;
+        }
+    }
+
+    return map;
+}
+
+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;
+}
+
+NSArray* napiToCBUuidArray(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:napiToCBUuidString(val.As<Napi::String>())];
+    }
+    return serviceUuids;
+}
+
+CBUUID* napiToCBUuidString(Napi::String string) {
+    NSString* uuidString = napiToUuidString(string);
+    return [CBUUID UUIDWithString:uuidString];
+}
+
+NSArray* getCBUuidArray(const Napi::Value& value) {
+    if (value.IsArray()) {
+        return napiToCBUuidArray(value.As<Napi::Array>());
+    }
+    return nil;
+}

package/lib/mac/src/noble_mac.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <napi.h>
+
+#include "ble_manager.h"
+
+class BlenoMac : public Napi::ObjectWrap<BlenoMac>
+{
+public:
+    BlenoMac(const Napi::CallbackInfo&);
+    Napi::Value Init(const Napi::CallbackInfo&);
+    Napi::Value CleanUp(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);
+
+    static Napi::Function GetClass(Napi::Env);
+
+private:
+    BLEManager* manager;
+};

package/lib/mac/src/noble_mac.mm

@@ -0,0 +1,260 @@
+//
+//  bleno_mac.mm
+//  bleno-mac-native
+//
+//  Created by Georg Vienna on 28.08.18.
+//
+#include "bleno_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"); \
+}
+
+BlenoMac::BlenoMac(const Napi::CallbackInfo& info) : ObjectWrap(info) {
+}
+
+Napi::Value BlenoMac::Init(const Napi::CallbackInfo& info) {
+    Napi::Function emit = info.This().As<Napi::Object>().Get("emit").As<Napi::Function>();
+    manager = [[BLEManager alloc] init];
+    manager->emit.Wrap(info.This(), emit);
+    return Napi::Value();
+}
+
+// startScanning(serviceUuids, allowDuplicates)
+Napi::Value BlenoMac::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 BlenoMac::StopScan(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    [manager stopScan];
+    return Napi::Value();
+}
+
+// connect(deviceUuid)
+Napi::Value BlenoMac::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 BlenoMac::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 BlenoMac::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 BlenoMac::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 BlenoMac::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 BlenoMac::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 BlenoMac::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 BlenoMac::Write(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    ARG5(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 = 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 BlenoMac::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 BlenoMac::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 BlenoMac::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 BlenoMac::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 BlenoMac::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 BlenoMac::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 BlenoMac::CleanUp(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    CFRelease((__bridge CFTypeRef)manager);
+    manager = nil;
+    return Napi::Value();
+}
+
+Napi::Function BlenoMac::GetClass(Napi::Env env) {
+    return DefineClass(env, "BlenoMac", {
+        BlenoMac::InstanceMethod("init", &BlenoMac::Init),
+        BlenoMac::InstanceMethod("startScanning", &BlenoMac::Scan),
+        BlenoMac::InstanceMethod("stopScanning", &BlenoMac::StopScan),
+        BlenoMac::InstanceMethod("connect", &BlenoMac::Connect),
+        BlenoMac::InstanceMethod("disconnect", &BlenoMac::Disconnect),
+        BlenoMac::InstanceMethod("updateRssi", &BlenoMac::UpdateRSSI),
+        BlenoMac::InstanceMethod("discoverServices", &BlenoMac::DiscoverServices),
+        BlenoMac::InstanceMethod("discoverIncludedServices", &BlenoMac::DiscoverIncludedServices),
+        BlenoMac::InstanceMethod("discoverCharacteristics", &BlenoMac::DiscoverCharacteristics),
+        BlenoMac::InstanceMethod("read", &BlenoMac::Read),
+        BlenoMac::InstanceMethod("write", &BlenoMac::Write),
+        BlenoMac::InstanceMethod("notify", &BlenoMac::Notify),
+        BlenoMac::InstanceMethod("discoverDescriptors", &BlenoMac::DiscoverDescriptors),
+        BlenoMac::InstanceMethod("readValue", &BlenoMac::ReadValue),
+        BlenoMac::InstanceMethod("writeValue", &BlenoMac::WriteValue),
+        BlenoMac::InstanceMethod("readHandle", &BlenoMac::ReadValue),
+        BlenoMac::InstanceMethod("writeHandle", &BlenoMac::WriteValue),
+        BlenoMac::InstanceMethod("cleanUp", &BlenoMac::CleanUp),
+    });
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    Napi::String name = Napi::String::New(env, "BlenoMac");
+    exports.Set(name, BlenoMac::GetClass(env));
+    return exports;
+}
+
+NODE_API_MODULE(addon, Init)

package/lib/mac/src/objc_cpp.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#import <Foundation/Foundation.h>
+#import <CoreBluetooth/CoreBluetooth.h>
+#include "peripheral.h"
+
+#define IF(type, var, code) type var = code; if(var)
+
+#if defined(MAC_OS_X_VERSION_10_13)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability"
+    std::string stateToString(CBManagerState state);
+#pragma clang diagnostic pop
+#else
+    std::string stateToString(CBCentralManagerState state);
+#endif
+
+std::string StringFromCBPeripheralState(CBManagerState state);
+
+NSString* getNSUuid(CBPeripheral* peripheral);
+std::string getUuid(CBPeripheral* peripheral);
+std::string getAddress(std::string uuid, AddressType* addressType);
+std::vector<std::string> getServices(NSArray<CBService*>* services);
+std::vector<std::pair<std::string, std::vector<std::string>>> getCharacteristics(NSArray<CBCharacteristic*>* characteristics);
+std::vector<std::string> getDescriptors(NSArray<CBDescriptor*>* descriptors);