@stoprocent/bleno 0.8.6 → 0.9.0

package/lib/mac/src/callbacks.mm

@@ -4,12 +4,12 @@
 //
 //  Created by Georg Vienna on 30.08.18.
 //
+#include <napi-thread-safe-callback.hpp>
 #include "callbacks.h"
-
-#import <napi-thread-safe-callback.hpp>
-
 #include "napi_objc.h"
+#include "objc_cpp.h"
 
+#define _a(val) Napi::String::New(env, convertToBlenoAddress(val))
 #define _s(val) Napi::String::New(env, val)
 #define _b(val) Napi::Boolean::New(env, val)
 #define _n(val) Napi::Number::New(env, val)
@@ -33,23 +33,28 @@ 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::AdvertisingStart(NSError * _Nullable error) {
+    mCallback->call([error](Napi::Env env, std::vector<napi_value>& args) {
+        const char *cerror = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
+        args = { _s("advertisingStart"), error ? Napi::Error::New(env, cerror).Value() : env.Null() };
     });
 }
 
-void Emit::ServicesSet() {
+void Emit::AdvertisingStop() {
     mCallback->call([](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('servicesSet',  this._setServicesError)
-        args = { _s("servicesSet") };
+        args = { _s("advertisingStop") };
+    });
+}
+
+void Emit::ServicesSet(NSError * _Nullable error) {
+    mCallback->call([error](Napi::Env env, std::vector<napi_value>& args) {
+        const char *cerror = [error.localizedDescription cStringUsingEncoding:NSUTF8StringEncoding];
+        args = { _s("servicesSet"), error ? Napi::Error::New(env, cerror).Value() : env.Null() };
     });
 }
 
 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) };
     });
 }
@@ -58,67 +63,51 @@ void EmitCharacteristic::Wrap(const Napi::Value& receiver, const Napi::Function&
     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)
+void EmitCharacteristic::ReadRequest(NSUUID *handle, uint16_t offset, std::function<void (uint16_t, NSData *)> completion) {
+    mCallback->call([handle, offset, completion](Napi::Env env, std::vector<napi_value>& args) {
         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 };
+        args = { _s("readRequest"), _a(handle), _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)
+void EmitCharacteristic::WriteRequest(NSUUID *handle, NSData *data, uint16_t offset, bool ignoreResponse, std::function<void (uint16_t)> completion) {
+    mCallback->call([handle, data, offset, ignoreResponse, completion](Napi::Env env, std::vector<napi_value>& args) {
         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 };
+        args = { _s("writeRequest"), _a(handle), 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)
+void EmitCharacteristic::Subscribe(NSUUID *handle, uint16_t maxValueSize, std::function<void (NSData *)> completion) {
+    mCallback->call([handle, maxValueSize, completion](Napi::Env env, std::vector<napi_value>& args) {
         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 };
+        args = { _s("subscribe"), _a(handle), _n(maxValueSize), cb };
     });
 }
 
-void EmitCharacteristic::Unsubscribe() {
-    mCallback->call([](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('unsubscribe')
-        args = { _s("unsubscribe") };
+void EmitCharacteristic::Unsubscribe(NSUUID *handle) {
+    mCallback->call([handle](Napi::Env env, std::vector<napi_value>& args) {
+        args = { _s("unsubscribe"), _a(handle) };
     });
 }
 
-void EmitCharacteristic::Notify() {
-    mCallback->call([](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('notify')
-        args = { _s("notify") };
+void EmitCharacteristic::Notify(NSUUID *handle) {
+    mCallback->call([handle](Napi::Env env, std::vector<napi_value>& args) {
+        args = { _s("notify"), _a(handle) };
     });
 }
 
-void EmitCharacteristic::Indicate() {
-    mCallback->call([](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('indicate')
-        args = { _s("indicate") };
+void EmitCharacteristic::Indicate(NSUUID *handle) {
+    mCallback->call([handle](Napi::Env env, std::vector<napi_value>& args) {
+        args = { _s("indicate"), _a(handle) };
     });
 }
-
-
-// emit('notify');
-// emit('indicate');

package/lib/mac/src/napi_objc.mm

@@ -25,7 +25,7 @@ NSString* napiToUuidString(Napi::String string) {
 
 NSArray* napiToUuidArray(Napi::Array array) {
     NSMutableArray* serviceUuids = [NSMutableArray arrayWithCapacity:array.Length()];
-    for(size_t i = 0;  i < array.Length(); i++) {
+    for(uint32_t i = 0;  i < array.Length(); i++) {
         Napi::Value val = array[i];
         [serviceUuids addObject:napiToUuidString(val.As<Napi::String>())];
     }
@@ -37,15 +37,14 @@ NSData* napiToData(Napi::Buffer<Byte> buffer) {
 }
 
 NSNumber* napiToNumber(Napi::Number number) {
-    return [NSNumber numberWithInt:number.Int64Value()];
+    return [NSNumber numberWithLong:number.Int64Value()];
 }
 
 NSArray<CBMutableService *> *napiArrayToCBMutableServices(Napi::Array array) {
-    // NSLog(@"napiArrayToCBMutableServices");
 
     NSMutableArray *services = [NSMutableArray array];
 
-    for (size_t i = 0;  i < array.Length(); i++) {
+    for (uint32_t i = 0;  i < array.Length(); i++) {
         Napi::Value v = array[i];
         Napi::Object obj = v.As<Napi::Object>();
 
@@ -56,12 +55,8 @@ NSArray<CBMutableService *> *napiArrayToCBMutableServices(Napi::Array array) {
 }
 
 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];
 
@@ -73,11 +68,9 @@ CBMutableService *napiToCBMutableService(Napi::Object obj) {
 
 
 NSArray<CBMutableCharacteristic *> *napiArrayToCBMutableCharacteristics(Napi::Array array) {
-    // NSLog(@"napiArrayToCBMutableCharacteristics");
-
     NSMutableArray *characteristics = [NSMutableArray array];
 
-    for (size_t i = 0; i < array.Length(); i++) {
+    for (uint32_t i = 0; i < array.Length(); i++) {
         Napi::Value v = array[i];
         Napi::Object obj = v.As<Napi::Object>();
 
@@ -88,13 +81,9 @@ NSArray<CBMutableCharacteristic *> *napiArrayToCBMutableCharacteristics(Napi::Ar
 }
 
 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>();
@@ -112,8 +101,6 @@ CBMutableCharacteristic *napiToCBMutableCharacteristic(Napi::Object obj) {
 }
 
 CBCharacteristicProperties napiToCBCharacteristicProperties(Napi::Array properties, Napi::Array secure) {
-    // NSLog(@"napiToCBCharacteristicProperties");
-
     NSArray<NSString *> *p = napiToStringArray(properties);
     NSArray<NSString *> *s = napiToStringArray(secure);
 
@@ -151,8 +138,6 @@ CBCharacteristicProperties napiToCBCharacteristicProperties(Napi::Array properti
 }
 
 CBAttributePermissions napiToCBAttributePermissions(Napi::Array properties, Napi::Array secure) {
-    // NSLog(@"napiToCBAttributePermissions");
-
     NSArray<NSString *> *p = napiToStringArray(properties);
     NSArray<NSString *> *s = napiToStringArray(secure);
 
@@ -186,11 +171,9 @@ CBAttributePermissions napiToCBAttributePermissions(Napi::Array properties, Napi
 }
 
 NSArray<CBDescriptor *> *napiArrayToCBDescriptors(Napi::Array array) {
-    // NSLog(@"napiArrayToCBDescriptors");
-
     NSMutableArray *descriptors = [NSMutableArray array];
 
-    for (size_t i = 0; i < array.Length(); i++) {
+    for (uint32_t i = 0; i < array.Length(); i++) {
         Napi::Value v = array[i];
         Napi::Object obj = v.As<Napi::Object>();
 
@@ -204,8 +187,6 @@ 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];
 }
@@ -213,7 +194,7 @@ CBDescriptor *napiToCBDescriptor(Napi::Object obj) {
 NSArray<NSString *> *napiToStringArray(Napi::Array array) {
     NSMutableArray *ret = [NSMutableArray arrayWithCapacity:array.Length()];
 
-    for (size_t i = 0; i < array.Length(); i++) {
+    for (uint32_t i = 0; i < array.Length(); i++) {
         Napi::Value v = array[i];
         Napi::String str = v.ToString();
 
@@ -224,11 +205,9 @@ NSArray<NSString *> *napiToStringArray(Napi::Array array) {
 }
 
 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++) {
+    for (uint32_t i = 0;  i < services.Length(); i++) {
         Napi::Value vS = services[i];
         Napi::Object objS = vS.As<Napi::Object>();
 
@@ -237,7 +216,7 @@ std::map<Napi::String, Napi::Object> napiArrayToUUIDEmitters(Napi::Array service
         map[uuidS] = objS;
 
         Napi::Array characteristics = objS.Get("characteristics").As<Napi::Array>();
-        for (size_t j = 0;  j < characteristics.Length(); j++) {
+        for (uint32_t j = 0;  j < characteristics.Length(); j++) {
             Napi::Value vC = characteristics[j];
             Napi::Object objC = vC.As<Napi::Object>();
 
@@ -266,7 +245,7 @@ BOOL getBool(const Napi::Value& value, BOOL def) {
 
 NSArray* napiToCBUuidArray(Napi::Array array) {
     NSMutableArray* serviceUuids = [NSMutableArray arrayWithCapacity:array.Length()];
-    for(size_t i = 0;  i < array.Length(); i++) {
+    for(uint32_t i = 0;  i < array.Length(); i++) {
         Napi::Value val = array[i];
         [serviceUuids addObject:napiToCBUuidString(val.As<Napi::String>())];
     }

package/lib/mac/src/objc_cpp.h

@@ -2,9 +2,9 @@
 
 #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)
 
@@ -21,7 +21,7 @@ std::string StringFromCBPeripheralState(CBManagerState state);
 
 NSString* getNSUuid(CBPeripheral* peripheral);
 std::string getUuid(CBPeripheral* peripheral);
-std::string getAddress(std::string uuid, AddressType* addressType);
+std::string convertToBlenoAddress(NSUUID* uuid);
 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);

package/lib/mac/src/objc_cpp.mm

@@ -7,28 +7,6 @@
 #include "objc_cpp.h"
 
 #if defined(MAC_OS_X_VERSION_10_13)
-//#pragma clang diagnostic push
-//#pragma clang diagnostic ignored "-Wunguarded-availability"
-//std::string stateToString(CBManagerState state)
-//{
-//    switch(state) {
-//        case CBManagerStatePoweredOff:
-//            return "poweredOff";
-//        case CBManagerStatePoweredOn:
-//            return "poweredOn";
-//        case CBManagerStateResetting:
-//            return "resetting";
-//        case CBManagerStateUnauthorized:
-//            return "unauthorized";
-//        case CBManagerStateUnknown:
-//            return "unknown";
-//        case CBManagerStateUnsupported:
-//            return "unsupported";
-//    }
-//    return "unknown";
-//}
-//#pragma clang diagnostic pop
-
 // In the 10.13 SDK, CBPeripheral became a subclass of CBPeer, which defines
 // -[CBPeer identifier] as partially available. Pretend it still exists on
 // CBPeripheral. At runtime the implementation on CBPeer will be invoked.
@@ -82,21 +60,9 @@ std::string getUuid(CBPeripheral* peripheral) {
     return std::string([peripheral.identifier.UUIDString UTF8String]);
 }
 
-std::string getAddress(std::string uuid, AddressType* addressType) {
-    NSString* deviceUuid = [[NSString alloc] initWithCString:uuid.c_str() encoding:NSASCIIStringEncoding];
-    IF(NSDictionary*, plist, [NSDictionary dictionaryWithContentsOfFile:@"/Library/Preferences/com.apple.Bluetooth.plist"]) {
-        IF(NSDictionary*, cache, [plist objectForKey:@"CoreBluetoothCache"]) {
-            IF(NSDictionary*, entry, [cache objectForKey:deviceUuid]) {
-                IF(NSNumber*, type, [entry objectForKey:@"DeviceAddressType"]) {
-                    *addressType = [type boolValue] ? RANDOM : PUBLIC;
-                }
-                IF(NSString*, address, [entry objectForKey:@"DeviceAddress"]) {
-                    return [address UTF8String];
-                }
-            }
-        }
-    }
-    return "";
+std::string convertToBlenoAddress(NSUUID* uuid) {
+    NSString* addressString = [[uuid.UUIDString stringByReplacingOccurrencesOfString:@"-" withString:@""] lowercaseString];
+    return std::string([addressString UTF8String]);
 }
 
 std::vector<std::string> getServices(NSArray<CBService*>* services) {

package/lib/resolve-bindings.js

@@ -1,19 +1,40 @@
 const os = require('os');
+const platform = os.platform();
 
-module.exports = function (options = {}) {
-  const platform = os.platform();
+const Bleno = require('./bleno');
 
+function loadBindings (bindingType = null, options = {}) {
+  switch (bindingType) {
+    case 'hci':
+      return new (require('./hci-socket/bindings'))(options);
+    case 'mac':
+      return new (require('./mac/bindings'))(options);
+    default:
+      throw new Error('Unsupported binding type: ' + bindingType);
+  }
+}
+
+// Default binding selection logic
+function getDefaultBindings (options = {}) {
   if (
     platform === 'linux' ||
-    platform === 'freebsd' ||
+    platform === 'freebsd' || 
     platform === 'win32' ||
     platform === 'android' ||
     process.env.BLUETOOTH_HCI_SOCKET_UART_PORT ||
-    process.env.BLUETOOTH_HCI_SOCKET_FORCE_UART) {
-    return new (require('./hci-socket/bindings'))(options);
+    process.env.BLUETOOTH_HCI_SOCKET_FORCE_UART
+  ) {
+    return loadBindings('hci', options);
   } else if (platform === 'darwin') {
-    return new (require('./mac/bindings'))(options);
+    return loadBindings('mac', options);
   } else {
     throw new Error('Unsupported platform ' + platform);
   }
+}
+
+module.exports = function (bindingType = 'default', options = {}) {
+  if (bindingType === 'default') {
+    return new Bleno(getDefaultBindings(options));
+  }
+  return new Bleno(loadBindings(bindingType, options));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stoprocent/bleno",
-  "version": "0.8.6",
+  "version": "0.9.0",
   "description": "A Node.js module for implementing BLE (Bluetooth Low Energy) peripherals",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -49,7 +49,7 @@
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/exec": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^10.1.1",
+    "@semantic-release/github": "^11.0.1",
     "jshint": "^2.13.6",
     "cross-env": "^7.0.3",
     "eslint": "^8.57.1",
@@ -60,19 +60,17 @@
     "mocha": "^10.7.0",
     "nyc": "^17.0.0",
     "prebuildify": "^6.0.1",
-    "prebuildify-cross": "thegecko/prebuildify-cross#fix-docker",
+    "prebuildify-cross": "^5.1.1",
     "should": "^13.2.3"
   },
   "dependencies": {
-    "debug": "^4.3.7",
+    "debug": "^4.4.0",
     "napi-thread-safe-callback": "^0.0.6",
-    "node-addon-api": "^8.1.0",
-    "node-gyp-build": "^4.8.1"
+    "node-addon-api": "^8.3.1",
+    "node-gyp-build": "^4.8.4"
   },
   "optionalDependencies": {
-    "@stoprocent/bluetooth-hci-socket": "^1.5.2",
-    "bplist-parser": "0.3.2",
-    "xpc-connect": "^3.0.0"
+    "@stoprocent/bluetooth-hci-socket": "^2.1.0"
   },
   "publishConfig": {
     "access": "public"

package/test/characteristic.test.js

@@ -3,6 +3,7 @@
 const should = require('should');
 
 const Characteristic = require('../lib/characteristic');
+Characteristic.RESULT_SUCCESS = 0x99; // override default value as 0x00 isnt the best value for this test
 
 describe('Characteristic', function () {
   const mockUuid = 'mockuuid';
@@ -141,34 +142,180 @@ describe('Characteristic', function () {
 
   it('should handle read request', function (done) {
     const characteristic = new Characteristic({});
+    const handle = 0;
 
-    characteristic.emit('readRequest', 0, function (result, data) {
-      result.should.equal(0x0e);
+    characteristic.emit('readRequest', handle, 0, function (result, data) {
+      result.should.equal(Characteristic.RESULT_UNLIKELY_ERROR);
       should(data).equal(null);
-
       done();
     });
   });
 
   it('should handle write request', function (done) {
     const characteristic = new Characteristic({});
+    const handle = 0;
 
-    characteristic.emit('writeRequest', Buffer.alloc(0), 0, false, function (result) {
-      result.should.equal(0x0e);
-
+    characteristic.emit('writeRequest', handle, Buffer.alloc(0), 0, false, function (result) {
+      result.should.equal(Characteristic.RESULT_UNLIKELY_ERROR);
       done();
     });
   });
 
   it('should handle unsubscribe', function () {
     const characteristic = new Characteristic({});
+    const handle = 0;
+
+    characteristic._maxValueSizes.set(handle, mockMaxValueSize);
+    characteristic._updateValueCallbacks.set(handle, mockUpdateValueCallback);
+
+    characteristic.emit('unsubscribe', handle);
+    
+    should(characteristic.getMaxValueSize(handle)).equal(undefined);
+    should(characteristic._maxValueSizes.has(handle)).equal(false);
+    should(characteristic._updateValueCallbacks.has(handle)).equal(false);
+  });
+
+  describe('Handle-based updates', function () {
+    it('should handle subscribe with different handles', function () {
+      const characteristic = new Characteristic({});
+      const handle1 = 1;
+      const handle2 = 2;
+      const maxValueSize1 = 20;
+      const maxValueSize2 = 30;
+      let updateCallback1Called = false;
+      let updateCallback2Called = false;
+
+      const updateCallback1 = (data) => {
+        updateCallback1Called = true;
+        should(data).equal('test1');
+      };
+
+      const updateCallback2 = (data) => {
+        updateCallback2Called = true;
+        should(data).equal('test2');
+      };
+
+      // Subscribe first client
+      characteristic.emit('subscribe', handle1, maxValueSize1, updateCallback1);
+      should(characteristic.getMaxValueSize(handle1)).equal(maxValueSize1);
+      should(characteristic._updateValueCallbacks.has(handle1)).equal(true);
+      should(characteristic._updateValueCallbacks.get(handle1)).equal(updateCallback1);
+
+      // Subscribe second client
+      characteristic.emit('subscribe', handle2, maxValueSize2, updateCallback2);
+      should(characteristic.getMaxValueSize(handle2)).equal(maxValueSize2);
+      should(characteristic._updateValueCallbacks.has(handle2)).equal(true);
+      should(characteristic._updateValueCallbacks.get(handle2)).equal(updateCallback2);
+
+      // Test updates for each handle
+      characteristic._updateValueCallbacks.get(handle1)('test1');
+      should(updateCallback1Called).equal(true);
+
+      characteristic._updateValueCallbacks.get(handle2)('test2');
+      should(updateCallback2Called).equal(true);
+    });
+
+    it('should handle unsubscribe for specific handle', function () {
+      const characteristic = new Characteristic({});
+      const handle1 = 1;
+      const handle2 = 2;
+      const maxValueSize = 20;
+
+      // Subscribe both clients
+      characteristic.emit('subscribe', handle1, maxValueSize, () => {});
+      characteristic.emit('subscribe', handle2, maxValueSize, () => {});
+
+      // Unsubscribe first client
+      characteristic.emit('unsubscribe', handle1);
+      
+      // First client should be removed
+      should(characteristic.getMaxValueSize(handle1)).equal(undefined);
+      should(characteristic._updateValueCallbacks.has(handle1)).equal(false);
+      
+      // Second client should still be subscribed
+      should(characteristic.getMaxValueSize(handle2)).equal(maxValueSize);
+      should(characteristic._updateValueCallbacks.has(handle2)).equal(true);
+
+      // Unsubscribe second client
+      characteristic.emit('unsubscribe', handle2);
+      
+      // Both clients should be removed
+      should(characteristic.getMaxValueSize(handle1)).equal(undefined);
+      should(characteristic.getMaxValueSize(handle2)).equal(undefined);
+      should(characteristic._updateValueCallbacks.has(handle1)).equal(false);
+      should(characteristic._updateValueCallbacks.has(handle2)).equal(false);
+    });
 
-    characteristic.maxValueSize = mockMaxValueSize;
-    characteristic.updateValueCallback = mockUpdateValueCallback;
+    it('should handle read requests for different handles', function (done) {
+      const handle1 = 1;
+      const handle2 = 2;
+
+      let readCallback1Called = false;
+      let readCallback2Called = false;
+
+      const characteristic = new Characteristic({ 
+        onReadRequest: (handle, offset, callback) => {
+          if (handle === handle1) {
+            readCallback1Called = true;
+            callback(Characteristic.RESULT_SUCCESS, Buffer.from('test1'));
+          } else if (handle === handle2) {
+            readCallback2Called = true;
+            callback(Characteristic.RESULT_SUCCESS, Buffer.from('test2'));
+          }
+        }
+      });
 
-    characteristic.emit('unsubscribe');
+      // Test read request for first handle
+      characteristic.emit('readRequest', handle1, 0, (result, data) => {
+        should(result).equal(Characteristic.RESULT_SUCCESS);
+        should(data.toString()).equal('test1');
+        should(readCallback1Called).equal(true);
+      });
 
-    should(characteristic.maxValueSize).equal(null);
-    should(characteristic.updateValueCallback).equal(null);
+      // Test read request for second handle
+      characteristic.emit('readRequest', handle2, 0, (result, data) => {
+        should(result).equal(Characteristic.RESULT_SUCCESS);
+        should(data.toString()).equal('test2');
+        should(readCallback2Called).equal(true);
+        done();
+      });
+    });
+
+    it('should handle write requests for different handles', function (done) {
+      const handle1 = 1;
+      const handle2 = 2;
+
+      const data1 = Buffer.from('test1');
+      const data2 = Buffer.from('test2');
+
+      let writeCallback1Called = false;
+      let writeCallback2Called = false;
+
+      const characteristic = new Characteristic({
+        onWriteRequest: (handle, data, offset, withoutResponse, callback) => {
+          if (handle === handle1) {
+            writeCallback1Called = true;
+            should(data).equal(data1);
+            callback(Characteristic.RESULT_SUCCESS);
+          } else if (handle === handle2) {
+            writeCallback2Called = true;
+            should(data).equal(data2);
+            callback(Characteristic.RESULT_SUCCESS);
+          }
+        }
+      });
+      // Test write request for first handle
+      characteristic.emit('writeRequest', handle1, data1, 0, false, (result) => {
+        should(result).equal(Characteristic.RESULT_SUCCESS);
+        should(writeCallback1Called).equal(true);
+      });
+
+      // Test write request for second handle
+      characteristic.emit('writeRequest', handle2, data2, 0, false, (result) => {
+        should(result).equal(Characteristic.RESULT_SUCCESS);
+        should(writeCallback2Called).equal(true);
+        done();
+      });
+    });
   });
 });

package/examples/battery-service/README.md

@@ -1,14 +0,0 @@
-# BLE Battery Service
-
-This example provides a BLE battery service (0x180F) for your Mac.
-
-Install dependencies
-
-    npm install
-
-Run the example
-
-    node main.js
-
-
-NOTE: This example no longer works on OSX starting in 10.10 (Yosemite). Apple has apparently blacklisted the battery uuid.