@stoprocent/noble 1.19.0 → 2.0.0

package/lib/mac/src/ble_manager.mm

@@ -1,17 +1,13 @@
-//
-//  ble_manager.mm
-//  noble-mac-native
-//
-//  Created by Georg Vienna on 28.08.18.
-//
 #include "ble_manager.h"
+#include "objc_cpp.h"
+#include "Peripheral.h"
 
 #import <Foundation/Foundation.h>
 
-#include "objc_cpp.h"
-
 @implementation BLEManager
-- (instancetype)init: (const Napi::Value&) receiver with: (const Napi::Function&) callback {
+
+- (instancetype)init: (const Napi::Value&) receiver with: (const Napi::Function&) callback
+{
     if (self = [super init]) {
         pendingRead = false;
         // wrap cb before creating the CentralManager as it may call didUpdateState immediately
@@ -24,69 +20,90 @@
     return self;
 }
 
-- (void)centralManagerDidUpdateState:(CBCentralManager *)central {
+- (void)centralManagerDidUpdateState:(CBCentralManager *)central 
+{
     auto state = stateToString(central.state);
     emit.RadioState(state);
 }
 
-- (void)scan: (NSArray<NSString*> *)serviceUUIDs allowDuplicates: (BOOL)allowDuplicates {
+- (void)scan:(NSArray<NSString*> *)serviceUUIDs allowDuplicates:(BOOL)allowDuplicates {
+    [self.discovered removeAllObjects];
     NSMutableArray* advServicesUuid = [NSMutableArray arrayWithCapacity:[serviceUUIDs count]];
     [serviceUUIDs enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
         [advServicesUuid addObject:[CBUUID UUIDWithString:obj]];
     }];
+    
     NSDictionary *options = @{CBCentralManagerScanOptionAllowDuplicatesKey:[NSNumber numberWithBool:allowDuplicates]};
     [self.centralManager scanForPeripheralsWithServices:advServicesUuid options:options];
     emit.ScanState(true);
 }
 
-- (void)stopScan {
+- (void)stopScan 
+{
     [self.centralManager stopScan];
-    [self.discovered removeAllObjects];
     emit.ScanState(false);
 }
 
-- (void) centralManager:(CBCentralManager *)central didDiscoverPeripheral:(CBPeripheral *)peripheral advertisementData:(NSDictionary<NSString *,id> *)advertisementData RSSI:(NSNumber *)RSSI {
+- (void) centralManager:(CBCentralManager *)central 
+  didDiscoverPeripheral:(CBPeripheral *)peripheral 
+      advertisementData:(NSDictionary<NSString *,id> *)advertisementData 
+                   RSSI:(NSNumber *)RSSI 
+{
     std::string uuid = getUuid(peripheral);
     [self.discovered addObject:getNSUuid(peripheral)];
 
     Peripheral p;
     p.address = getAddress(uuid, &p.addressType);
+    
     IF(NSNumber*, connect, [advertisementData objectForKey:CBAdvertisementDataIsConnectable]) {
         p.connectable = [connect boolValue];
     }
+    
     IF(NSString*, dataLocalName, [advertisementData objectForKey:CBAdvertisementDataLocalNameKey]) {
-        p.name = std::make_pair([dataLocalName UTF8String], true);
+        p.name = std::string([dataLocalName UTF8String]);
     }
-    if(!std::get<1>(p.name)) {
+    
+    if (!p.name) {
         IF(NSString*, name, [peripheral name]) {
-            p.name = std::make_pair([name UTF8String], true);
+            p.name = std::string([name UTF8String]);
         }
     }
+    
     IF(NSNumber*, txLevel, [advertisementData objectForKey:CBAdvertisementDataTxPowerLevelKey]) {
-        p.txPowerLevel = std::make_pair([txLevel intValue], true);
+        p.txPowerLevel = [txLevel intValue];
     }
+    
     IF(NSData*, data, [advertisementData objectForKey:CBAdvertisementDataManufacturerDataKey]) {
         const UInt8* bytes = (UInt8 *)[data bytes];
-        std::get<0>(p.manufacturerData).assign(bytes, bytes+[data length]);
-        std::get<1>(p.manufacturerData) = true;
+        Data manufacturerData;
+        manufacturerData.assign(bytes, bytes + [data length]);
+        p.manufacturerData = manufacturerData;
     }
+    
     IF(NSDictionary*, dictionary, [advertisementData objectForKey:CBAdvertisementDataServiceDataKey]) {
+        std::vector<std::pair<std::string, Data>> serviceData;
         for (CBUUID* key in dictionary) {
             IF(NSData*, value, dictionary[key]) {
                 auto serviceUuid = [[key UUIDString] UTF8String];
                 Data sData;
                 const UInt8* bytes = (UInt8 *)[value bytes];
-                sData.assign(bytes, bytes+[value length]);
-                std::get<0>(p.serviceData).push_back(std::make_pair(serviceUuid, sData));
+                sData.assign(bytes, bytes + [value length]);
+                serviceData.push_back(std::make_pair(serviceUuid, sData));
             }
         }
-        std::get<1>(p.serviceData) = true;
+        if (!serviceData.empty()) {
+            p.serviceData = serviceData;
+        }
     }
+    
     IF(NSArray*, services, [advertisementData objectForKey:CBAdvertisementDataServiceUUIDsKey]) {
+        std::vector<std::string> serviceUuids;
         for (CBUUID* service in services) {
-            std::get<0>(p.serviceUuids).push_back([[service UUIDString] UTF8String]);
+            serviceUuids.push_back([[service UUIDString] UTF8String]);
+        }
+        if (!serviceUuids.empty()) {
+            p.serviceUuids = serviceUuids;
         }
-        std::get<1>(p.serviceUuids) = true;
     }
 
     int rssi = [RSSI intValue];
@@ -157,17 +174,18 @@
     return NO;
 }
 
-- (void)peripheralDidUpdateRSSI:(CBPeripheral *)peripheral error:(NSError *)error {
+- (void) peripheral:(CBPeripheral *) peripheral 
+        didReadRSSI:(NSNumber *) RSSI 
+              error:(NSError *) error
+{
     std::string uuid = getUuid(peripheral);
-    NSNumber* rssi = peripheral.RSSI;
-    if(!error && rssi) {
-        emit.RSSI(uuid, [rssi longValue]);
-    }
+    int16_t rssi = [RSSI intValue];
+    emit.RSSI(uuid, rssi, error ? error.localizedDescription.UTF8String : "");
 }
 
 #pragma mark - Services
 
--(BOOL) discoverServices:(NSString*) uuid serviceUuids:(NSArray<NSString*>*) services {
+- (BOOL)discoverServices:(NSString*) uuid serviceUuids:(NSArray<NSString*>*) services {
     IF(CBPeripheral*, peripheral, [self.peripherals objectForKey:uuid]) {
         NSMutableArray* servicesUuid = nil;
         if(services) {
@@ -182,10 +200,10 @@
     return NO;
 }
 
-- (void) peripheral:(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error {
+- (void)peripheral:(CBPeripheral *)peripheral didDiscoverServices:(NSError *)error {
     std::string uuid = getUuid(peripheral);
     std::vector<std::string> services = getServices(peripheral.services);
-    emit.ServicesDiscovered(uuid, services);
+    emit.ServicesDiscovered(uuid, services, error ? error.localizedDescription.UTF8String : "");
 }
 
 - (BOOL)discoverIncludedServices:(NSString*) uuid forService:(NSString*) serviceUuid services:(NSArray<NSString*>*) serviceUuids {
@@ -209,7 +227,7 @@
     std::string uuid = getUuid(peripheral);
     auto serviceUuid = [[service.UUID UUIDString] UTF8String];
     std::vector<std::string> services = getServices(service.includedServices);
-    emit.IncludedServicesDiscovered(uuid, serviceUuid, services);
+    emit.IncludedServicesDiscovered(uuid, serviceUuid, services, error ? error.localizedDescription.UTF8String : "");
 }
 
 #pragma mark - Characteristics
@@ -218,7 +236,7 @@
     IF(CBPeripheral *, peripheral, [self.peripherals objectForKey:uuid]) {
         IF(CBService*, service, [self getService:peripheral service:serviceUuid]) {
             NSMutableArray* characteristicsUuid = nil;
-            if(characteristics) {
+            if([characteristics count] > 0) {
                 characteristicsUuid = [NSMutableArray arrayWithCapacity:[characteristics count]];
                 [characteristics enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
                     [characteristicsUuid addObject:[CBUUID UUIDWithString:obj]];
@@ -235,7 +253,7 @@
     std::string uuid = getUuid(peripheral);
     std::string serviceUuid = std::string([service.UUID.UUIDString UTF8String]);
     auto characteristics = getCharacteristics(service.characteristics);
-    emit.CharacteristicsDiscovered(uuid, serviceUuid, characteristics);
+    emit.CharacteristicsDiscovered(uuid, serviceUuid, characteristics, error ? error.localizedDescription.UTF8String : "");
 }
 
 - (BOOL)read:(NSString*) uuid service:(NSString*) serviceUuid characteristic:(NSString*) characteristicUuid {
@@ -258,7 +276,7 @@
     data.assign(bytes, bytes+[characteristic.value length]);
     bool isNotification = !pendingRead && characteristic.isNotifying;
     pendingRead = false;
-    emit.Read(uuid, serviceUuid, characteristicUuid, data, isNotification);
+    emit.Read(uuid, serviceUuid, characteristicUuid, data, isNotification, error ? error.localizedDescription.UTF8String : "");
 }
 
 - (BOOL)write:(NSString*) uuid service:(NSString*) serviceUuid characteristic:(NSString*) characteristicUuid data:(NSData*) data withoutResponse:(BOOL)withoutResponse {
@@ -279,7 +297,7 @@
     std::string uuid = getUuid(peripheral);
     std::string serviceUuid = [characteristic.service.UUID.UUIDString UTF8String];
     std::string characteristicUuid = [characteristic.UUID.UUIDString UTF8String];
-    emit.Write(uuid, serviceUuid, characteristicUuid);
+    emit.Write(uuid, serviceUuid, characteristicUuid, error ? error.localizedDescription.UTF8String : "");
 }
 
 - (BOOL)notify:(NSString*) uuid service:(NSString*) serviceUuid characteristic:(NSString*) characteristicUuid on:(BOOL)on {
@@ -296,7 +314,7 @@
     std::string uuid = getUuid(peripheral);
     std::string serviceUuid = [characteristic.service.UUID.UUIDString UTF8String];
     std::string characteristicUuid = [characteristic.UUID.UUIDString UTF8String];
-    emit.Notify(uuid, serviceUuid, characteristicUuid, characteristic.isNotifying);
+    emit.Notify(uuid, serviceUuid, characteristicUuid, characteristic.isNotifying, error ? error.localizedDescription.UTF8String : "");
 }
 
 #pragma mark - Descriptors
@@ -316,7 +334,7 @@
     std::string serviceUuid = [characteristic.service.UUID.UUIDString UTF8String];
     std::string characteristicUuid = [characteristic.UUID.UUIDString UTF8String];
     std::vector<std::string> descriptors = getDescriptors(characteristic.descriptors);
-    emit.DescriptorsDiscovered(uuid, serviceUuid, characteristicUuid, descriptors);
+    emit.DescriptorsDiscovered(uuid, serviceUuid, characteristicUuid, descriptors, error ? error.localizedDescription.UTF8String : "");
 }
 
 - (BOOL)readValue:(NSString*) uuid service:(NSString*) serviceUuid characteristic:(NSString*) characteristicUuid descriptor:(NSString*) descriptorUuid {
@@ -334,13 +352,37 @@
     std::string serviceUuid = [descriptor.characteristic.service.UUID.UUIDString UTF8String];
     std::string characteristicUuid = [descriptor.characteristic.UUID.UUIDString UTF8String];
     std::string descriptorUuid = [descriptor.UUID.UUIDString UTF8String];
-    const UInt8* bytes = (UInt8 *)[descriptor.value bytes];
+    
     Data data;
-    data.assign(bytes, bytes+[descriptor.value length]);
+    
+    if (descriptor.value != nil) {
+        if ([descriptor.value isKindOfClass:[NSData class]]) {
+            // Handle NSData directly
+            NSData *valueData = (NSData *)descriptor.value;
+            const UInt8* bytes = (UInt8 *)[valueData bytes];
+            data.assign(bytes, bytes + [valueData length]);
+        } 
+        else if ([descriptor.value isKindOfClass:[NSString class]]) {
+            // Convert NSString to bytes
+            NSString *valueString = (NSString *)descriptor.value;
+            NSData *valueData = [valueString dataUsingEncoding:NSUTF8StringEncoding];
+            const UInt8* bytes = (UInt8 *)[valueData bytes];
+            data.assign(bytes, bytes + [valueData length]);
+        }
+        else if ([descriptor.value isKindOfClass:[NSNumber class]]) {
+            // Convert NSNumber to bytes
+            NSNumber *valueNumber = (NSNumber *)descriptor.value;
+            NSData *valueData = [NSData dataWithBytes:valueNumber.stringValue.UTF8String 
+                                             length:strlen(valueNumber.stringValue.UTF8String)];
+            const UInt8* bytes = (UInt8 *)[valueData bytes];
+            data.assign(bytes, bytes + [valueData length]);
+        }
+    }
+    
     IF(NSNumber*, handle, [self getDescriptorHandle:descriptor]) {
         emit.ReadHandle(uuid, [handle intValue], data);
     }
-    emit.ReadValue(uuid, serviceUuid, characteristicUuid, descriptorUuid, data);
+    emit.ReadValue(uuid, serviceUuid, characteristicUuid, descriptorUuid, data, error ? error.localizedDescription.UTF8String : "");
 }
 
 - (BOOL)writeValue:(NSString*) uuid service:(NSString*) serviceUuid characteristic:(NSString*) characteristicUuid descriptor:(NSString*) descriptorUuid data:(NSData*) data {
@@ -361,7 +403,7 @@
     IF(NSNumber*, handle, [self getDescriptorHandle:descriptor]) {
         emit.WriteHandle(uuid, [handle intValue]);
     }
-    emit.WriteValue(uuid, serviceUuid, characteristicUuid, descriptorUuid);
+    emit.WriteValue(uuid, serviceUuid, characteristicUuid, descriptorUuid, error ? error.localizedDescription.UTF8String : "");
 }
 
 - (BOOL)readHandle:(NSString*) uuid handle:(NSNumber*) handle {
@@ -450,3 +492,4 @@
 }
 
 @end
+

package/lib/mac/src/napi_objc.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <napi.h>
+
 #import <Foundation/Foundation.h>
 
 NSArray* getUuidArray(const Napi::Value& value);

package/lib/mac/src/napi_objc.mm

@@ -1,9 +1,3 @@
-//
-//  napi_objc.mm
-//  noble-mac-native
-//
-//  Created by Georg Vienna on 30.08.18.
-//
 #include "napi_objc.h"
 
 NSString* napiToUuidString(Napi::String string) {

package/lib/mac/src/noble_mac.h

@@ -8,11 +8,13 @@ class NobleMac : public Napi::ObjectWrap<NobleMac>
 {
 public:
     NobleMac(const Napi::CallbackInfo&);
-    Napi::Value Init(const Napi::CallbackInfo&);
+    Napi::Value Start(const Napi::CallbackInfo&);
+    Napi::Value Stop(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 CancelConnect(const Napi::CallbackInfo&);
     Napi::Value UpdateRSSI(const Napi::CallbackInfo&);
     Napi::Value DiscoverServices(const Napi::CallbackInfo&);
     Napi::Value DiscoverIncludedServices(const Napi::CallbackInfo& info);
@@ -25,9 +27,9 @@ public:
     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&);
+    Napi::Value AddressToId(const Napi::CallbackInfo& info);
 
-    static Napi::Function GetClass(Napi::Env);
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
 
 private:
     BLEManager* manager;

package/lib/mac/src/noble_mac.mm

@@ -1,11 +1,4 @@
-//
-//  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) \
@@ -39,107 +32,134 @@ if (!info[0].Is##type1() || !info[1].Is##type2() || !info[2].Is##type3() || !inf
 
 #define CHECK_MANAGER() \
 if(!manager) { \
-    THROW("BLEManager has already been cleaned up"); \
+    THROW(std::string(__FUNCTION__) + ": BLEManager has already been cleaned up"); \
 }
 
-NobleMac::NobleMac(const Napi::CallbackInfo& info) : ObjectWrap(info) {
-}
+NobleMac::NobleMac(const Napi::CallbackInfo& info) : ObjectWrap(info) {}
 
-Napi::Value NobleMac::Init(const Napi::CallbackInfo& info) {
+Napi::Value NobleMac::Start(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();
 }
 
+Napi::Value NobleMac::Stop(const Napi::CallbackInfo& info) 
+{
+    CHECK_MANAGER()
+    manager = nil;
+    return info.Env().Undefined();
+}
+
 // startScanning(serviceUuids, allowDuplicates)
-Napi::Value NobleMac::Scan(const Napi::CallbackInfo& info) {
+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();
+    return info.Env().Undefined();
 }
 
 // stopScanning()
-Napi::Value NobleMac::StopScan(const Napi::CallbackInfo& info) {
+Napi::Value NobleMac::StopScan(const Napi::CallbackInfo& info) 
+{
     CHECK_MANAGER()
     [manager stopScan];
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // connect(deviceUuid)
-Napi::Value NobleMac::Connect(const Napi::CallbackInfo& info) {
+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();
+    return info.Env().Undefined();
 }
 
 // disconnect(deviceUuid)
-Napi::Value NobleMac::Disconnect(const Napi::CallbackInfo& info) {
+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();
+    return info.Env().Undefined();
+}
+
+// cancelConnect(deviceUuid)
+Napi::Value NobleMac::CancelConnect(const Napi::CallbackInfo& info)
+{
+    CHECK_MANAGER()
+    ARG1(String)
+    auto uuid = napiToUuidString(info[0].As<Napi::String>());
+    [manager disconnect:uuid];
+    return info.Env().Undefined();
 }
 
 // updateRssi(deviceUuid)
-Napi::Value NobleMac::UpdateRSSI(const Napi::CallbackInfo& info) {
+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();
+    return info.Env().Undefined();
 }
 
 // discoverServices(deviceUuid, uuids)
-Napi::Value NobleMac::DiscoverServices(const Napi::CallbackInfo& info) {
+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();
+    return info.Env().Undefined();
 }
 
 // discoverIncludedServices(deviceUuid, serviceUuid, serviceUuids)
-Napi::Value NobleMac::DiscoverIncludedServices(const Napi::CallbackInfo& info) {
+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();
+    return info.Env().Undefined();
 }
 
 // discoverCharacteristics(deviceUuid, serviceUuid, characteristicUuids)
-Napi::Value NobleMac::DiscoverCharacteristics(const Napi::CallbackInfo& info) {
+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();
+    return info.Env().Undefined();
 }
 
 // read(deviceUuid, serviceUuid, characteristicUuid)
-Napi::Value NobleMac::Read(const Napi::CallbackInfo& info) {
+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();
+    return info.Env().Undefined();
 }
 
 // write(deviceUuid, serviceUuid, characteristicUuid, data, withoutResponse)
-Napi::Value NobleMac::Write(const Napi::CallbackInfo& info) {
+Napi::Value NobleMac::Write(const Napi::CallbackInfo& info) 
+{
     CHECK_MANAGER()
     ARG4(String, String, String, Buffer /*, Boolean */)
     auto uuid = napiToUuidString(info[0].As<Napi::String>());
@@ -153,11 +173,12 @@ Napi::Value NobleMac::Write(const Napi::CallbackInfo& info) {
     }
 
     [manager write:uuid service:service characteristic:characteristic data:data withoutResponse:withoutResponse];
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 // notify(deviceUuid, serviceUuid, characteristicUuid, notify)
-Napi::Value NobleMac::Notify(const Napi::CallbackInfo& info) {
+Napi::Value NobleMac::Notify(const Napi::CallbackInfo& info) 
+{
     CHECK_MANAGER()
     ARG4(String, String, String, Boolean)
     auto uuid = napiToUuidString(info[0].As<Napi::String>());
@@ -165,22 +186,24 @@ Napi::Value NobleMac::Notify(const Napi::CallbackInfo& info) {
     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();
+    return info.Env().Undefined();
 }
 
 // discoverDescriptors(deviceUuid, serviceUuid, characteristicUuid)
-Napi::Value NobleMac::DiscoverDescriptors(const Napi::CallbackInfo& info) {
+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();
+    return info.Env().Undefined();
 }
 
 // readValue(deviceUuid, serviceUuid, characteristicUuid, descriptorUuid)
-Napi::Value NobleMac::ReadValue(const Napi::CallbackInfo& info) {
+Napi::Value NobleMac::ReadValue(const Napi::CallbackInfo& info) 
+{
     CHECK_MANAGER()
     ARG4(String, String, String, String)
     auto uuid = napiToUuidString(info[0].As<Napi::String>());
@@ -188,11 +211,12 @@ Napi::Value NobleMac::ReadValue(const Napi::CallbackInfo& info) {
     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();
+    return info.Env().Undefined();
 }
 
 // writeValue(deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data)
-Napi::Value NobleMac::WriteValue(const Napi::CallbackInfo& info) {
+Napi::Value NobleMac::WriteValue(const Napi::CallbackInfo& info) 
+{
     CHECK_MANAGER()
     ARG5(String, String, String, String, Buffer)
     auto uuid = napiToUuidString(info[0].As<Napi::String>());
@@ -201,44 +225,61 @@ Napi::Value NobleMac::WriteValue(const Napi::CallbackInfo& info) {
     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();
+    return info.Env().Undefined();
 }
 
 // readHandle(deviceUuid, handle)
-Napi::Value NobleMac::ReadHandle(const Napi::CallbackInfo& info) {
+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();
+    return info.Env().Undefined();
 }
 
 // writeHandle(deviceUuid, handle, data, (unused)withoutResponse)
-Napi::Value NobleMac::WriteHandle(const Napi::CallbackInfo& info) {
+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();
+    return info.Env().Undefined();
 }
 
-Napi::Value NobleMac::Stop(const Napi::CallbackInfo& info) {
-    CHECK_MANAGER()
-    CFRelease((__bridge CFTypeRef)manager);
-    manager = nil;
-    return Napi::Value();
+// addressToId(address)
+Napi::Value NobleMac::AddressToId(const Napi::CallbackInfo& info) 
+{
+    ARG1(String)
+    auto address = info[0].As<Napi::String>().Utf8Value();
+    NSMutableString * uuidString = [[NSMutableString alloc] initWithCString:address.c_str() encoding:NSASCIIStringEncoding];
+    if ([uuidString containsString:@"-"]) {
+        NSUUID* uuid = [[NSUUID alloc] initWithUUIDString:uuidString];
+        if (uuid) {
+            NSString* canonical = uuid.UUIDString;
+            NSString* result = [[canonical stringByReplacingOccurrencesOfString:@"-" withString:@""] lowercaseString];
+            return Napi::String::New(info.Env(), [result UTF8String]);
+        }
+    }
+    return info.Env().Null();
 }
 
-Napi::Function NobleMac::GetClass(Napi::Env env) {
-    return DefineClass(env, "NobleMac", {
-        NobleMac::InstanceMethod("init", &NobleMac::Init),
+Napi::Object NobleMac::Init(Napi::Env env, Napi::Object exports) 
+{
+    Napi::HandleScope scope(env);
+
+    Napi::Function func = DefineClass(env, "NobleMac", {
+        NobleMac::InstanceMethod("start", &NobleMac::Start),
+        NobleMac::InstanceMethod("stop", &NobleMac::Stop),
         NobleMac::InstanceMethod("startScanning", &NobleMac::Scan),
         NobleMac::InstanceMethod("stopScanning", &NobleMac::StopScan),
         NobleMac::InstanceMethod("connect", &NobleMac::Connect),
         NobleMac::InstanceMethod("disconnect", &NobleMac::Disconnect),
+        NobleMac::InstanceMethod("cancelConnect", &NobleMac::CancelConnect),
         NobleMac::InstanceMethod("updateRssi", &NobleMac::UpdateRSSI),
         NobleMac::InstanceMethod("discoverServices", &NobleMac::DiscoverServices),
         NobleMac::InstanceMethod("discoverIncludedServices", &NobleMac::DiscoverIncludedServices),
@@ -251,14 +292,15 @@ Napi::Function NobleMac::GetClass(Napi::Env env) {
         NobleMac::InstanceMethod("writeValue", &NobleMac::WriteValue),
         NobleMac::InstanceMethod("readHandle", &NobleMac::ReadHandle),
         NobleMac::InstanceMethod("writeHandle", &NobleMac::WriteHandle),
-        NobleMac::InstanceMethod("stop", &NobleMac::Stop),
+        NobleMac::InstanceMethod("addressToId", &NobleMac::AddressToId),
     });
-}
 
-Napi::Object Init(Napi::Env env, Napi::Object exports) {
-    Napi::String name = Napi::String::New(env, "NobleMac");
-    exports.Set(name, NobleMac::GetClass(env));
+    Napi::FunctionReference* constructor = new Napi::FunctionReference();
+    *constructor = Napi::Persistent(func);
+    env.SetInstanceData(constructor);
+
+    exports.Set("NobleMac", func);
     return exports;
 }
 
-NODE_API_MODULE(addon, Init)
+NODE_API_NAMED_ADDON(addon, NobleMac);

package/lib/mac/src/objc_cpp.h

@@ -2,9 +2,11 @@
 
 #include <string>
 #include <vector>
+
+#include "Peripheral.h"
+
 #import <Foundation/Foundation.h>
 #import <CoreBluetooth/CoreBluetooth.h>
-#include "peripheral.h"
 
 #define IF(type, var, code) type var = code; if(var)
 
@@ -17,7 +19,6 @@
     std::string stateToString(CBCentralManagerState state);
 #endif
 
-
 NSString* getNSUuid(CBPeripheral* peripheral);
 std::string getUuid(CBPeripheral* peripheral);
 std::string getAddress(std::string uuid, AddressType* addressType);