@stoprocent/bleno 0.7.0

package/lib/mac/src/ble_peripheral_manager.mm

@@ -0,0 +1,241 @@
+//
+//  ble_peripheral_manager.mm
+//  bleno-mac-native
+//
+//  Created by Georg Vienna on 28.08.18.
+//
+#include "ble_peripheral_manager.h"
+
+#include <dispatch/dispatch.h>
+
+#include "objc_cpp.h"
+
+@interface BLEPeripheralManager () <CBPeripheralManagerDelegate>
+
+@property (nonatomic, strong) dispatch_queue_t queue;
+@property (nonatomic, strong) CBPeripheralManager *peripheralManager;
+
+@end
+
+@implementation BLEPeripheralManager
+
+- (instancetype)init {
+    if (self = [super init]) {
+        NSLog(@"-[BLEPeripheralManager init]");
+
+        self.queue = dispatch_queue_create("CBqueue", 0);
+    }
+    return self;
+}
+
+#pragma mark - API
+
+- (void)start {
+    self.peripheralManager = [[CBPeripheralManager alloc] initWithDelegate:self
+                                                                    queue:self.queue];
+}
+
+- (void)startAdvertising:(nonnull NSString *)name serviceUUIDs:(nonnull NSArray<CBUUID *> *)serviceUUIDs {
+    NSLog(@"startAdvertising:%@ serviceUUIDs:%@", name, serviceUUIDs);
+    if (self.peripheralManager.isAdvertising) {
+        return;
+    }
+
+    [self.peripheralManager startAdvertising:@{
+                                               CBAdvertisementDataLocalNameKey: name,
+                                               CBAdvertisementDataServiceUUIDsKey: serviceUUIDs,
+                                               }];
+}
+
+- (void)startAdvertisingIBeacon:(NSData *)data {
+    NSLog(@"startAdvertisingIBeacon:%@", data);
+}
+
+- (void)startAdvertisingWithEIRData:(NSData *)data {
+    NSLog(@"startAdvertisingWithEIRData:%@", data);
+
+    if (self.peripheralManager.isAdvertising) {
+        return;
+    }
+}
+
+- (void)stopAdvertising {
+    NSLog(@"stopAdvertising");
+
+    [self.peripheralManager stopAdvertising];
+}
+
+- (void)setServices:(NSArray<CBMutableService *> *)services {
+    for (CBMutableService *service in services) {
+        [self.peripheralManager addService:service];
+    }
+}
+
+- (void)disconnect {
+    NSLog(@"disconnect");
+
+    // throw new Error('disconnect is not supported on OS X!');
+}
+
+- (void)updateRssi {
+    NSLog(@"updateRssi");
+}
+
+#pragma mark - CBPeripheralManagerDelegate
+
+- (void)peripheralManagerDidUpdateState:(CBPeripheralManager *)peripheral {
+    NSString *string = @"Unknown state";
+
+    switch(peripheral.state) {
+        case CBManagerStatePoweredOff:
+            string = @"CoreBluetooth BLE hardware is powered off.";
+            break;
+
+        case CBManagerStatePoweredOn:
+            string = @"CoreBluetooth BLE hardware is powered on and ready.";
+            break;
+
+        case CBManagerStateUnauthorized:
+            string = @"CoreBluetooth BLE state is unauthorized.";
+            break;
+
+        case CBManagerStateUnknown:
+            string = @"CoreBluetooth BLE state is unknown.";
+            break;
+
+        case CBManagerStateUnsupported:
+            string = @"CoreBluetooth BLE hardware is unsupported on this platform.";
+            break;
+
+        default:
+            break;
+    }
+
+    NSLog(@"%@", string);
+
+    auto state = StringFromCBPeripheralState(peripheral.state);
+    emit.StateChange(state);
+}
+
+- (void)peripheralManager:(CBPeripheralManager *)peripheral willRestoreState:(NSDictionary<NSString *, id> *)dict {
+    NSLog(@"willRestoreState");
+}
+
+- (void)peripheralManagerDidStartAdvertising:(CBPeripheralManager *)peripheral error:(nullable NSError *)error {
+    NSLog(@"peripheralManagerDidStartAdvertising: %@", peripheral.description);
+    if (error) {
+        NSLog(@"Error advertising: %@", [error localizedDescription]);
+    }
+
+    emit.AdvertisingStart();
+}
+
+- (void)peripheralManager:(CBPeripheralManager *)peripheral didAddService:(CBService *)service error:(nullable NSError *)error {
+    NSLog(@"peripheralManagerDidAddService: %@ %@", service, error);
+    if (error) {
+        NSLog(@"Error publishing service: %@", [error localizedDescription]);
+    }
+
+    emit.ServicesSet();
+}
+
+- (void)peripheralManager:(CBPeripheralManager *)peripheral central:(CBCentral *)central didSubscribeToCharacteristic:(CBMutableCharacteristic *)characteristic {
+    NSLog(@"didSubscribeToCharacteristic");
+
+    CBUUID *uuid = characteristic.UUID;
+
+    for (auto it = emitters.begin(); it != emitters.end(); ++it) {
+        if ([it->first isEqual:uuid]) {
+            auto cb = [peripheral, central, characteristic](NSData *data) {
+                NSLog(@"subscription note: %@ %@", data, NSStringFromClass(characteristic.class));
+
+                [peripheral updateValue:data
+                      forCharacteristic:characteristic
+                   onSubscribedCentrals:@[central]];
+            };
+
+            it->second.Subscribe(central.maximumUpdateValueLength, cb);
+
+            if ((characteristic.properties & CBCharacteristicPropertyNotify) == CBCharacteristicPropertyNotify) {
+
+            }
+        }
+    }
+}
+
+- (void)peripheralManager:(CBPeripheralManager *)peripheral central:(CBCentral *)central didUnsubscribeFromCharacteristic:(CBCharacteristic *)characteristic {
+    NSLog(@"didUnsubscribeFromCharacteristic");
+
+    CBUUID *uuid = characteristic.UUID;
+
+    for (auto it = emitters.begin(); it != emitters.end(); ++it) {
+        if ([it->first isEqual:uuid]) {
+            it->second.Unsubscribe();
+        }
+    }
+}
+
+- (void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveReadRequest:(CBATTRequest *)request {
+    NSLog(@"didReceiveReadRequest: %@ %@", request.central, request.characteristic.UUID);
+
+    CBCharacteristic *characteristic = request.characteristic;
+    CBUUID *uuid = characteristic.UUID;
+
+    for (auto it = emitters.begin(); it != emitters.end(); ++it) {
+        if ([it->first isEqual:uuid]) {
+            auto cb = [peripheral, request](int result, NSData *data) {
+                request.value = data;
+
+                [peripheral respondToRequest:request
+                                  withResult:(CBATTError)result];
+            };
+
+            it->second.ReadRequest(request.offset, cb);
+        }
+    }
+}
+
+- (void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveWriteRequests:(NSArray<CBATTRequest *> *)requests {
+    for (CBATTRequest *request in requests) {
+        NSLog(@"didReceiveWriteRequest: %@ %@", request.central, request.characteristic.UUID);
+
+        CBCharacteristic *characteristic = request.characteristic;
+        CBUUID *uuid = characteristic.UUID;
+
+        for (auto it = emitters.begin(); it != emitters.end(); ++it) {
+            if ([it->first isEqual:uuid]) {
+                bool sendResponse = (request.characteristic.properties & CBCharacteristicPropertyWrite) == CBCharacteristicPropertyWrite;
+
+                auto cb = [peripheral, request, sendResponse](int result) {
+                    if (sendResponse) {
+                        [peripheral respondToRequest:request
+                                          withResult:(CBATTError)result];
+                    }
+                };
+
+                it->second.WriteRequest(request.value,
+                                        request.offset,
+                                        !sendResponse,
+                                        cb);
+            }
+        }
+    }
+}
+
+- (void)peripheralManagerIsReadyToUpdateSubscribers:(CBPeripheralManager *)peripheral {
+    NSLog(@"peripheralManagerIsReadyToUpdateSubscribers");
+}
+
+- (void)peripheralManager:(CBPeripheralManager *)peripheral didPublishL2CAPChannel:(CBL2CAPPSM)PSM error:(nullable NSError *)error {
+    NSLog(@"didPublishL2CAPChannel");
+}
+
+- (void)peripheralManager:(CBPeripheralManager *)peripheral didUnpublishL2CAPChannel:(CBL2CAPPSM)PSM error:(nullable NSError *)error {
+    NSLog(@"didUnpublishL2CAPChannel");
+}
+
+- (void)peripheralManager:(CBPeripheralManager *)peripheral didOpenL2CAPChannel:(nullable CBL2CAPChannel *)channel error:(nullable NSError *)error {
+    NSLog(@"didOpenL2CAPChannel");
+}
+
+@end

package/lib/mac/src/bleno_mac.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <napi.h>
+
+#include "ble_peripheral_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 StartAdvertising(const Napi::CallbackInfo&);
+    Napi::Value StartAdvertisingIBeacon(const Napi::CallbackInfo&);
+    Napi::Value StartAdvertisingWithEIRData(const Napi::CallbackInfo&);
+    Napi::Value StopAdvertising(const Napi::CallbackInfo&);
+    Napi::Value SetServices(const Napi::CallbackInfo&);
+    Napi::Value Disconnect(const Napi::CallbackInfo&);
+    Napi::Value UpdateRssi(const Napi::CallbackInfo&);
+
+    static Napi::Function GetClass(Napi::Env);
+
+private:
+    BLEPeripheralManager *peripheralManager;
+};

package/lib/mac/src/bleno_mac.mm

@@ -0,0 +1,167 @@
+//
+//  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(!peripheralManager) { \
+    THROW("BLEManager has already been cleaned up"); \
+}
+
+BlenoMac::BlenoMac(const Napi::CallbackInfo& info) : ObjectWrap(info) {
+}
+
+Napi::Value BlenoMac::Init(const Napi::CallbackInfo& info) {
+    NSLog(@"BlenoMac::Init");
+
+    Napi::Function emit = info.This().As<Napi::Object>().Get("emit").As<Napi::Function>();
+    peripheralManager = [BLEPeripheralManager new];
+    peripheralManager->emit.Wrap(info.This(), emit);
+    [peripheralManager start];
+    return Napi::Value();
+}
+
+Napi::Value BlenoMac::CleanUp(const Napi::CallbackInfo& info) {
+    CHECK_MANAGER()
+    CFRelease((__bridge CFTypeRef)peripheralManager);
+    peripheralManager = nil;
+    return Napi::Value();
+}
+
+// startAdvertising(name, undashedServiceUuids)
+Napi::Value BlenoMac::StartAdvertising(const Napi::CallbackInfo& info) {
+    NSLog(@"BlenoMac::StartAdvertising");
+
+    CHECK_MANAGER();
+    ARG2(String, Array);
+
+    auto name = napiToString(info[0].As<Napi::String>());
+    NSArray *array = getCBUuidArray(info[1]);
+
+    [peripheralManager startAdvertising:name
+                           serviceUUIDs:array];
+
+    return Napi::Value();
+}
+
+// startAdvertisingIBeacon(iBeaconData)
+Napi::Value BlenoMac::StartAdvertisingIBeacon(const Napi::CallbackInfo& info) {
+    NSLog(@"BlenoMac::StartAdvertisingIBeacon");
+
+    return Napi::Value();
+}
+
+// startAdvertisingWithEIRData(advertisementData, scanData)
+Napi::Value BlenoMac::StartAdvertisingWithEIRData(const Napi::CallbackInfo& info) {
+    NSLog(@"BlenoMac::StartAdvertisingWithEIRData");
+
+    return Napi::Value();
+}
+
+// stopAdvertising()
+Napi::Value BlenoMac::StopAdvertising(const Napi::CallbackInfo& info) {
+    NSLog(@"BlenoMac::StopAdvertising");
+
+    return Napi::Value();
+}
+
+// setServices(services)
+Napi::Value BlenoMac::SetServices(const Napi::CallbackInfo& info) {
+    NSLog(@"BlenoMac::SetServices");
+
+    CHECK_MANAGER();
+    ARG1(Array);
+
+    auto array = info[0].As<Napi::Array>();
+
+    NSArray<CBMutableService *> *services = napiArrayToCBMutableServices(array);
+    [peripheralManager setServices:services];
+
+    auto pairs = napiArrayToUUIDEmitters(array);
+    std::map<CBUUID *, EmitCharacteristic> emitters;
+    for (auto const& x : pairs) {
+        EmitCharacteristic emit = EmitCharacteristic();
+
+        auto obj = x.second;
+        auto fn = obj.Get("emit").As<Napi::Function>();
+        emit.Wrap(obj, fn);
+
+        CBUUID *uuid = [CBUUID UUIDWithString:napiToUuidString(x.first)];
+        emitters[uuid] = emit;
+    }
+
+    peripheralManager->emitters = emitters;
+
+    return Napi::Value();
+}
+
+// disconnect()
+Napi::Value BlenoMac::Disconnect(const Napi::CallbackInfo& info) {
+    NSLog(@"BlenoMac::Disconnect");
+
+    return Napi::Value();
+}
+
+// updateRssi()
+Napi::Value BlenoMac::UpdateRssi(const Napi::CallbackInfo& info) {
+    NSLog(@"BlenoMac::UpdateRssi");
+
+    return Napi::Value();
+}
+
+Napi::Function BlenoMac::GetClass(Napi::Env env) {
+    return DefineClass(env, "BlenoMac", {
+        BlenoMac::InstanceMethod("init", &BlenoMac::Init),
+        BlenoMac::InstanceMethod("cleanUp", &BlenoMac::CleanUp),
+
+        BlenoMac::InstanceMethod("startAdvertising", &BlenoMac::StartAdvertising),
+        BlenoMac::InstanceMethod("startAdvertisingIBeacon", &BlenoMac::StartAdvertisingIBeacon),
+        BlenoMac::InstanceMethod("startAdvertisingWithEIRData", &BlenoMac::StartAdvertisingWithEIRData),
+        BlenoMac::InstanceMethod("stopAdvertising", &BlenoMac::StopAdvertising),
+        BlenoMac::InstanceMethod("setServices", &BlenoMac::SetServices),
+        BlenoMac::InstanceMethod("disconnect", &BlenoMac::Disconnect),
+        BlenoMac::InstanceMethod("updateRssi", &BlenoMac::UpdateRssi),
+   });
+}
+
+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/callbacks.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <napi.h>
+#include "peripheral.h"
+
+#import <Foundation/Foundation.h>
+
+class ThreadSafeCallback;
+
+class Emit {
+public:
+    void Wrap(const Napi::Value& receiver, const Napi::Function& callback);
+
+    void AdvertisingStart();
+    void ServicesSet();
+
+    void StateChange(const std::string& state);
+
+//    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;
+};
+
+class EmitCharacteristic {
+public:
+    void Wrap(const Napi::Value& receiver, const Napi::Function& callback);
+
+    void ReadRequest(int offset, std::function<void (int, NSData *)> completion);
+    void WriteRequest(NSData *data, int offset, bool ignoreResponse, std::function<void (int)> completion);
+    void Subscribe(int maxValueSize, std::function<void (NSData *)> completion);
+    void Unsubscribe();
+    void Notify();
+    void Indicate();
+
+    //    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;
+
+private:
+    Napi::Buffer<uint8_t> toBuffer(Napi::Env& env, const Data& data);
+};
+
+Napi::Buffer<uint8_t> toBufferFromNSData(Napi::Env& env, const NSData *data);
+Napi::Buffer<uint8_t> toBuffer(Napi::Env& env, const Data& data);

package/lib/mac/src/callbacks.mm

@@ -0,0 +1,124 @@
+//
+//  callbacks.cc
+//  bleno-mac-native
+//
+//  Created by Georg Vienna on 30.08.18.
+//
+#include "callbacks.h"
+
+#import <napi-thread-safe-callback.hpp>
+
+#include "napi_objc.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::Buffer<uint8_t> toBufferFromNSData(Napi::Env& env, const NSData *nsdata) {
+    auto data = Data();
+    const UInt8* bytes = (UInt8 *)[nsdata bytes];
+    data.assign(bytes, bytes + [nsdata length]);
+    return toBuffer(env, data);
+}
+
+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());
+}
+
+void Emit::Wrap(const Napi::Value& receiver, const Napi::Function& callback) {
+    mCallback = std::make_shared<ThreadSafeCallback>(receiver, callback);
+}
+
+void Emit::AdvertisingStart() {
+    mCallback->call([](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('advertisingStart', error)
+        args = { _s("advertisingStart") };
+    });
+}
+
+void Emit::ServicesSet() {
+    mCallback->call([](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('servicesSet',  this._setServicesError)
+        args = { _s("servicesSet") };
+    });
+}
+
+void Emit::StateChange(const std::string& state) {
+    mCallback->call([state](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('stateChange', state);
+        args = { _s("stateChange"), _s(state) };
+    });
+}
+
+void EmitCharacteristic::Wrap(const Napi::Value& receiver, const Napi::Function& callback) {
+    mCallback = std::make_shared<ThreadSafeCallback>(receiver, callback);
+}
+
+void EmitCharacteristic::ReadRequest(int offset, std::function<void (int, NSData *)> completion) {
+    mCallback->call([offset, completion](Napi::Env env, std::vector<napi_value>& args) {
+        // callback(result, data)
+        auto callable = [completion](const Napi::CallbackInfo& info){
+            completion(info[0].As<Napi::Number>().Int32Value(),
+                       napiToData(info[1].As<Napi::Buffer<Byte>>()));
+        };
+        Napi::Function cb = Napi::Function::New(env, callable);
+
+        // emit('readRequest', offset, callback);
+        args = { _s("readRequest"), _n(offset), cb };
+    });
+}
+
+void EmitCharacteristic::WriteRequest(NSData *data, int offset, bool ignoreResponse, std::function<void (int)> completion) {
+    mCallback->call([data, offset, ignoreResponse, completion](Napi::Env env, std::vector<napi_value>& args) {
+        // callback(result)
+        auto callable = [completion](const Napi::CallbackInfo& info){
+            completion(info[0].As<Napi::Number>().Int32Value());
+        };
+        Napi::Function cb = Napi::Function::New(env, callable);
+
+        // emit('writeRequest', data, offset, ignoreResponse, callback)
+        args = { _s("writeRequest"), toBufferFromNSData(env, data), _n(offset), _b(ignoreResponse), cb };
+    });
+}
+
+void EmitCharacteristic::Subscribe(int maxValueSize, std::function<void (NSData *)> completion) {
+    mCallback->call([maxValueSize, completion](Napi::Env env, std::vector<napi_value>& args) {
+        // callback(data)
+        auto callable = [completion](const Napi::CallbackInfo& info){
+            completion(napiToData(info[0].As<Napi::Buffer<Byte>>()));
+        };
+        Napi::Function cb = Napi::Function::New(env, callable);
+
+        // emit('subscribe', maxValueSize, callback)
+        args = { _s("subscribe"), _n(maxValueSize), cb };
+    });
+}
+
+void EmitCharacteristic::Unsubscribe() {
+    mCallback->call([](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('unsubscribe')
+        args = { _s("unsubscribe") };
+    });
+}
+
+void EmitCharacteristic::Notify() {
+    mCallback->call([](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('notify')
+        args = { _s("notify") };
+    });
+}
+
+void EmitCharacteristic::Indicate() {
+    mCallback->call([](Napi::Env env, std::vector<napi_value>& args) {
+        // emit('indicate')
+        args = { _s("indicate") };
+    });
+}
+
+
+// emit('notify');
+// emit('indicate');

package/lib/mac/src/napi_objc.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <napi.h>
+#import <Foundation/Foundation.h>
+#import <CoreBluetooth/CoreBluetooth.h>
+#include <map>
+
+NSArray* getUuidArray(const Napi::Value& value);
+NSArray* getCBUuidArray(const Napi::Value& value);
+BOOL getBool(const Napi::Value& value, BOOL def);
+NSArray* napiToCBUuidArray(Napi::Array array);
+CBUUID* napiToCBUuidString(Napi::String string);
+NSArray<CBMutableService *> *napiArrayToCBMutableServices(Napi::Array array);
+CBMutableService *napiToCBMutableService(Napi::Object obj);
+NSArray<CBMutableCharacteristic *> *napiArrayToCBMutableCharacteristics(Napi::Array array);
+CBMutableCharacteristic *napiToCBMutableCharacteristic(Napi::Object obj);
+CBCharacteristicProperties napiToCBCharacteristicProperties(Napi::Array properties, Napi::Array secure);
+CBAttributePermissions napiToCBAttributePermissions(Napi::Array properties, Napi::Array secure);
+NSArray<CBDescriptor *> *napiArrayToCBDescriptors(Napi::Array array);
+CBDescriptor *napiToCBDescriptor(Napi::Object obj);
+NSArray<NSString *> *napiToStringArray(Napi::Array array);
+
+std::map<Napi::String, Napi::Object> napiArrayToUUIDEmitters(Napi::Array services);
+
+NSString *napiToString(Napi::String string);
+NSString* napiToUuidString(Napi::String string);
+NSArray* napiToUuidArray(Napi::Array array);
+NSData* napiToData(Napi::Buffer<Byte> buffer);
+NSNumber* napiToNumber(Napi::Number number);
+NSArray<NSString *> *napiToStringArray(Napi::Array array);