@stoprocent/bleno 0.8.5 → 0.9.0

package/lib/hci-socket/smp.js

@@ -1,6 +1,6 @@
 const { EventEmitter } = require('events');
 const crypto = require('./crypto');
-const mgmt = require('./mgmt');
+const Mgmt = require('./mgmt');
 
 const SMP_CID = 0x0006;
 
@@ -17,9 +17,10 @@ const SMP_UNSPECIFIED = 0x08;
 class Smp extends EventEmitter {
   constructor (aclStream, localAddressType, localAddress, remoteAddressType, remoteAddress) {
     super();
-
+    
     this._aclStream = aclStream;
-
+    this._mgmt = new Mgmt();
+    
     this._iat = Buffer.from([(remoteAddressType === 'random') ? 0x01 : 0x00]);
     this._ia = Buffer.from(remoteAddress.split(':').reverse().join(''), 'hex');
     this._rat = Buffer.from([(localAddressType === 'random') ? 0x01 : 0x00]);
@@ -132,7 +133,7 @@ class Smp extends EventEmitter {
       this._random = Buffer.from('0000000000000000', 'hex');
       this._stk = crypto.s1(this._tk, this._r, r);
 
-      mgmt.addLongTermKey(this._ia, this._iat, 0, 0, this._diversifier, this._random, this._stk);
+      this._mgmt.addLongTermKey(this._ia, this._iat, 0, 0, this._diversifier, this._random, this._stk);
 
       this.write(Buffer.concat([
         Buffer.from([SMP_PAIRING_RANDOM]),

package/lib/mac/src/ble_peripheral_manager.h

@@ -7,11 +7,10 @@
 
 #pragma once
 
-#import <CoreBluetooth/CoreBluetooth.h>
-
-#import "callbacks.h"
+#include <map>
+#include "callbacks.h"
 
-#import <map>
+#import <CoreBluetooth/CoreBluetooth.h>
 
 @interface BLEPeripheralManager : NSObject {
     @public Emit emit;
@@ -19,11 +18,8 @@
 }
 
 - (nonnull instancetype)init NS_DESIGNATED_INITIALIZER;
-
 - (void)start;
 - (void)startAdvertising:(NSString * _Nonnull)name serviceUUIDs:(NSArray<CBUUID *> * _Nonnull)serviceUUIDs;
-- (void)startAdvertisingIBeacon:(NSData * _Nullable)data;
-- (void)startAdvertisingWithEIRData:(NSData * _Nullable)data;
 - (void)stopAdvertising;
 - (void)setServices:(NSArray<CBMutableService *> * _Nonnull)services;
 - (void)disconnect;

package/lib/mac/src/ble_peripheral_manager.mm

@@ -11,231 +11,186 @@
 #include "objc_cpp.h"
 
 @interface BLEPeripheralManager () <CBPeripheralManagerDelegate>
-
-@property (nonatomic, strong) dispatch_queue_t queue;
+@property (nonatomic, strong) dispatch_queue_t processingQueue;
+@property (nonatomic, strong) NSMutableArray<NSDictionary *> *pendingNotifications;
 @property (nonatomic, strong) CBPeripheralManager *peripheralManager;
-
 @end
 
 @implementation BLEPeripheralManager
 
-- (instancetype)init {
+- (instancetype)init 
+{
     if (self = [super init]) {
-        // NSLog(@"-[BLEPeripheralManager init]");
-
-        self.queue = dispatch_queue_create("CBqueue", 0);
+        self.processingQueue = dispatch_queue_create("com.bleno.processing.queue", DISPATCH_QUEUE_SERIAL);
+        self.pendingNotifications = [NSMutableArray array];
     }
     return self;
 }
 
+- (void)dealloc 
+{
+    self.peripheralManager.delegate = nil;
+    [self.pendingNotifications removeAllObjects];
+}
+
+#pragma mark - Notification Management
+
+- (void)addNotification:(NSData *)data
+         characteristic:(CBMutableCharacteristic *)characteristic
+                 central:(CBCentral *)central 
+{
+    // All operations are now done on the same serial queue.
+    dispatch_async(self.processingQueue, ^{
+        NSDictionary *notification = @{
+            @"data": data,
+            @"characteristic": characteristic,
+            @"central": central
+        };
+        [self.pendingNotifications addObject:notification];
+        [self processNotificationQueue];
+    });
+}
+
+- (void)processNotificationQueue 
+{
+    // Since this runs on the serial queue, no additional synchronization is needed.
+    while (self.pendingNotifications.count > 0) {
+        NSDictionary *notification = self.pendingNotifications.firstObject;
+        NSData *data = notification[@"data"];
+        CBMutableCharacteristic *characteristic = notification[@"characteristic"];
+        CBCentral *central = notification[@"central"];
+        
+        BOOL success = [self.peripheralManager updateValue:data
+                                         forCharacteristic:characteristic
+                                      onSubscribedCentrals:@[central]];
+        if (success) {
+            [self.pendingNotifications removeObjectAtIndex:0];
+        } else {
+            // Stop processing if updateValue fails; will retry on next callback.
+            break;
+        }
+    }
+}
+
 #pragma mark - API
 
-- (void)start {
+- (void)start 
+{
     self.peripheralManager = [[CBPeripheralManager alloc] initWithDelegate:self
-                                                                    queue:self.queue];
+                                                                     queue:self.processingQueue];
 }
 
-- (void)startAdvertising:(nonnull NSString *)name serviceUUIDs:(nonnull NSArray<CBUUID *> *)serviceUUIDs {
-    // NSLog(@"startAdvertising:%@ serviceUUIDs:%@", name, serviceUUIDs);
+- (void)startAdvertising:(nonnull NSString *)name serviceUUIDs:(nonnull NSArray<CBUUID *> *)serviceUUIDs 
+{
     if (self.peripheralManager.isAdvertising) {
         return;
     }
 
-    [self.peripheralManager startAdvertising:@{
-                                               CBAdvertisementDataLocalNameKey: name,
-                                               CBAdvertisementDataServiceUUIDsKey: serviceUUIDs,
-                                               }];
+    [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");
-
+- (void)stopAdvertising 
+{
     [self.peripheralManager stopAdvertising];
 }
 
-- (void)setServices:(NSArray<CBMutableService *> *)services {
+- (void)setServices:(NSArray<CBMutableService *> *)services 
+{
     for (CBMutableService *service in services) {
         [self.peripheralManager addService:service];
     }
 }
 
-- (void)disconnect {
-    // NSLog(@"disconnect");
+- (void)disconnect 
+{
 
-    // throw new Error('disconnect is not supported on OS X!');
 }
 
-- (void)updateRssi {
-    // NSLog(@"updateRssi");
+- (void)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);
-
+- (void)peripheralManagerDidUpdateState:(CBPeripheralManager *)peripheral 
+{
     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 
+{
+    emit.AdvertisingStart(error);
 }
 
-- (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 
+            didAddService:(CBService *)service 
+                    error:(nullable NSError *)error 
+{
+    emit.ServicesSet(error);
 }
 
-- (void)peripheralManager:(CBPeripheralManager *)peripheral central:(CBCentral *)central didSubscribeToCharacteristic:(CBMutableCharacteristic *)characteristic {
-    // NSLog(@"didSubscribeToCharacteristic");
-
-    CBUUID *uuid = characteristic.UUID;
-
+- (void)peripheralManager:(CBPeripheralManager *)peripheral central:(CBCentral *)central didSubscribeToCharacteristic:(CBMutableCharacteristic *)characteristic 
+{
     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) {
-
-            }
-        }
+        if ([it->first isEqual:characteristic.UUID] == NO) { continue; }
+        auto cb = [weakSelf = self, characteristic, central](NSData *data) {
+            [weakSelf addNotification:data characteristic:characteristic central:central];
+        };
+        it->second.Subscribe(central.identifier, (uint16_t)central.maximumUpdateValueLength, cb);
     }
 }
 
-- (void)peripheralManager:(CBPeripheralManager *)peripheral central:(CBCentral *)central didUnsubscribeFromCharacteristic:(CBCharacteristic *)characteristic {
-    // NSLog(@"didUnsubscribeFromCharacteristic");
-
-    CBUUID *uuid = characteristic.UUID;
-
+- (void)peripheralManager:(CBPeripheralManager *)peripheral central:(CBCentral *)central didUnsubscribeFromCharacteristic:(CBCharacteristic *)characteristic 
+{
     for (auto it = emitters.begin(); it != emitters.end(); ++it) {
-        if ([it->first isEqual:uuid]) {
-            it->second.Unsubscribe();
-        }
+        if ([it->first isEqual:characteristic.UUID] == NO) { continue; }
+        it->second.Unsubscribe(central.identifier);
     }
 }
 
-- (void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveReadRequest:(CBATTRequest *)request {
-    // NSLog(@"didReceiveReadRequest: %@ %@", request.central, request.characteristic.UUID);
-
-    CBCharacteristic *characteristic = request.characteristic;
-    CBUUID *uuid = characteristic.UUID;
-
+- (void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveReadRequest:(CBATTRequest *)request 
+{
     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);
-        }
+        if ([it->first isEqual:request.characteristic.UUID] == NO) { continue; }
+        auto cb = [peripheral, request](int result, NSData *data) {
+            request.value = data;
+            [peripheral respondToRequest:request withResult:(CBATTError)result];
+        };
+        it->second.ReadRequest(request.central.identifier, (uint16_t)request.offset, cb);
     }
 }
 
-- (void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveWriteRequests:(NSArray<CBATTRequest *> *)requests {
+- (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");
-}
+            if ([it->first isEqual:characteristic.UUID] == NO) { continue; }
+            bool sendResponse = (request.characteristic.properties & CBCharacteristicPropertyWrite) == CBCharacteristicPropertyWrite;
 
-- (void)peripheralManager:(CBPeripheralManager *)peripheral didPublishL2CAPChannel:(CBL2CAPPSM)PSM error:(nullable NSError *)error {
-    // NSLog(@"didPublishL2CAPChannel");
-}
+            auto cb = [peripheral, request, sendResponse](int result) {
+                if (!sendResponse) { return; }
+                [peripheral respondToRequest:request withResult:(CBATTError)result];
+            };
 
-- (void)peripheralManager:(CBPeripheralManager *)peripheral didUnpublishL2CAPChannel:(CBL2CAPPSM)PSM error:(nullable NSError *)error {
-    // NSLog(@"didUnpublishL2CAPChannel");
+            it->second.WriteRequest(request.central.identifier,
+                                    request.value,
+                                    (uint16_t)request.offset,
+                                    !sendResponse,
+                                    cb);
+        }
+    }
 }
 
-- (void)peripheralManager:(CBPeripheralManager *)peripheral didOpenL2CAPChannel:(nullable CBL2CAPChannel *)channel error:(nullable NSError *)error {
-    // NSLog(@"didOpenL2CAPChannel");
+- (void)peripheralManagerIsReadyToUpdateSubscribers:(CBPeripheralManager *)peripheral 
+{
+    [self processNotificationQueue];
 }
 
 @end

package/lib/mac/src/bleno_mac.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <napi.h>
-
 #include "ble_peripheral_manager.h"
 
 class BlenoMac : public Napi::ObjectWrap<BlenoMac>

package/lib/mac/src/bleno_mac.mm

@@ -42,30 +42,24 @@ if(!peripheralManager) { \
     THROW("BLEManager has already been cleaned up"); \
 }
 
-BlenoMac::BlenoMac(const Napi::CallbackInfo& info) : ObjectWrap(info) {
-}
+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();
+    return info.Env().Undefined();
 }
 
 Napi::Value BlenoMac::CleanUp(const Napi::CallbackInfo& info) {
     CHECK_MANAGER()
     CFRelease((__bridge CFTypeRef)peripheralManager);
     peripheralManager = nil;
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
-// startAdvertising(name, undashedServiceUuids)
 Napi::Value BlenoMac::StartAdvertising(const Napi::CallbackInfo& info) {
-    // NSLog(@"BlenoMac::StartAdvertising");
-
     CHECK_MANAGER();
     ARG2(String, Array);
 
@@ -75,34 +69,35 @@ Napi::Value BlenoMac::StartAdvertising(const Napi::CallbackInfo& info) {
     [peripheralManager startAdvertising:name
                            serviceUUIDs:array];
 
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
-// startAdvertisingIBeacon(iBeaconData)
 Napi::Value BlenoMac::StartAdvertisingIBeacon(const Napi::CallbackInfo& info) {
-    // NSLog(@"BlenoMac::StartAdvertisingIBeacon");
+    NSError *error = [NSError errorWithDomain:CBErrorDomain code:CBErrorUnknown userInfo:@{
+        NSLocalizedDescriptionKey: @"Function not implemented"
+    }];
+    peripheralManager->emit.AdvertisingStart(error);
 
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
-// startAdvertisingWithEIRData(advertisementData, scanData)
 Napi::Value BlenoMac::StartAdvertisingWithEIRData(const Napi::CallbackInfo& info) {
-    // NSLog(@"BlenoMac::StartAdvertisingWithEIRData");
+    NSError *error = [NSError errorWithDomain:CBErrorDomain code:CBErrorUnknown userInfo:@{
+        NSLocalizedDescriptionKey: @"Function not implemented"
+    }];
+    peripheralManager->emit.AdvertisingStart(error);
 
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
-// stopAdvertising()
 Napi::Value BlenoMac::StopAdvertising(const Napi::CallbackInfo& info) {
-    // NSLog(@"BlenoMac::StopAdvertising");
-
-    return Napi::Value();
+    CHECK_MANAGER();
+    [peripheralManager stopAdvertising];
+    peripheralManager->emit.AdvertisingStop();
+    return info.Env().Undefined();
 }
 
-// setServices(services)
 Napi::Value BlenoMac::SetServices(const Napi::CallbackInfo& info) {
-    // NSLog(@"BlenoMac::SetServices");
-
     CHECK_MANAGER();
     ARG1(Array);
 
@@ -126,28 +121,21 @@ Napi::Value BlenoMac::SetServices(const Napi::CallbackInfo& info) {
 
     peripheralManager->emitters = emitters;
 
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
-// disconnect()
 Napi::Value BlenoMac::Disconnect(const Napi::CallbackInfo& info) {
-    // NSLog(@"BlenoMac::Disconnect");
-
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
-// updateRssi()
 Napi::Value BlenoMac::UpdateRssi(const Napi::CallbackInfo& info) {
-    // NSLog(@"BlenoMac::UpdateRssi");
-
-    return Napi::Value();
+    return info.Env().Undefined();
 }
 
 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),

package/lib/mac/src/callbacks.h

@@ -1,38 +1,20 @@
 #pragma once
 
 #include <napi.h>
-#include "peripheral.h"
 
 #import <Foundation/Foundation.h>
 
 class ThreadSafeCallback;
+using Data = std::vector<uint8_t>;
 
+NS_ASSUME_NONNULL_BEGIN
 class Emit {
 public:
     void Wrap(const Napi::Value& receiver, const Napi::Function& callback);
-
-    void AdvertisingStart();
-    void ServicesSet();
-
+    void AdvertisingStart(NSError * _Nullable error);
+    void AdvertisingStop();
+    void ServicesSet(NSError * _Nullable error);
     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;
 };
@@ -40,31 +22,12 @@ protected:
 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);
+    void ReadRequest(NSUUID *handle, uint16_t offset, std::function<void (uint16_t, NSData *)> completion);
+    void WriteRequest(NSUUID *handle, NSData *data, uint16_t offset, bool ignoreResponse, std::function<void (uint16_t)> completion);
+    void Subscribe(NSUUID *handle, uint16_t maxValueSize, std::function<void (NSData *)> completion);
+    void Unsubscribe(NSUUID *handle);
+    void Notify(NSUUID *handle);
+    void Indicate(NSUUID *handle);
 protected:
     std::shared_ptr<ThreadSafeCallback> mCallback;
 
@@ -74,3 +37,4 @@ private:
 
 Napi::Buffer<uint8_t> toBufferFromNSData(Napi::Env& env, const NSData *data);
 Napi::Buffer<uint8_t> toBuffer(Napi::Env& env, const Data& data);
+NS_ASSUME_NONNULL_END