@stoprocent/bleno 0.11.4 → 0.12.0

package/lib/bleno.js

@@ -296,6 +296,9 @@ class Bleno extends EventEmitter {
   stop () {
     debug('stop');
     this._bindings.stop();
+    // Reset initialized flag so we can restart
+    this.initialized = false;
+    this.state = 'unknown';
   }
 
   updateRssi (callback) {

package/lib/mac/src/ble_peripheral_manager.h

@@ -8,20 +8,30 @@
 #pragma once
 
 #include <map>
+#include <set>
 #include "callbacks.h"
 
 #import <CoreBluetooth/CoreBluetooth.h>
 
+// Restoration identifier for state restoration across restarts
+static NSString * _Nonnull const kBlenoRestorationIdentifier = @"com.bleno.peripheral.manager";
+
 @interface BLEPeripheralManager : NSObject {
     @public Emit emit;
     @public std::map<CBUUID *, EmitCharacteristic> emitters;
 }
 
+// Track connected centrals by their identifier
+@property (nonatomic, strong, readonly) NSMutableSet<NSUUID *> * _Nullable connectedCentrals;
+// Track current services for proper cleanup
+@property (nonatomic, strong, readonly) NSMutableArray<CBMutableService *> * _Nullable currentServices;
+
 - (nonnull instancetype)init NS_DESIGNATED_INITIALIZER;
 - (void)start;
 - (void)startAdvertising:(NSString * _Nonnull)name serviceUUIDs:(NSArray<CBUUID *> * _Nonnull)serviceUUIDs;
 - (void)stopAdvertising;
 - (void)setServices:(NSArray<CBMutableService *> * _Nonnull)services;
+- (void)removeAllServices;
 - (void)disconnect;
 - (void)updateRssi;
 

package/lib/mac/src/ble_peripheral_manager.mm

@@ -14,6 +14,10 @@
 @property (nonatomic, strong) dispatch_queue_t processingQueue;
 @property (nonatomic, strong) NSMutableArray<NSDictionary *> *pendingNotifications;
 @property (nonatomic, strong) CBPeripheralManager *peripheralManager;
+@property (nonatomic, strong, readwrite) NSMutableSet<NSUUID *> *connectedCentrals;
+@property (nonatomic, strong, readwrite) NSMutableArray<CBMutableService *> *currentServices;
+@property (nonatomic, assign) BOOL triedWithRestoration;
+@property (nonatomic, assign) BOOL retriedWithoutRestoration;
 @end
 
 @implementation BLEPeripheralManager
@@ -23,14 +27,19 @@
     if (self = [super init]) {
         self.processingQueue = dispatch_queue_create("com.bleno.processing.queue", DISPATCH_QUEUE_SERIAL);
         self.pendingNotifications = [NSMutableArray array];
+        self.connectedCentrals = [NSMutableSet set];
+        self.currentServices = [NSMutableArray array];
     }
     return self;
 }
 
 - (void)dealloc 
 {
+    [self removeAllServices];
     self.peripheralManager.delegate = nil;
     [self.pendingNotifications removeAllObjects];
+    [self.connectedCentrals removeAllObjects];
+    [self.currentServices removeAllObjects];
 }
 
 #pragma mark - Notification Management
@@ -76,8 +85,36 @@
 
 - (void)start 
 {
+    [self startWithRestoration:YES];
+}
+
+- (void)startWithRestoration:(BOOL)useRestoration 
+{
+    // Clean up any existing peripheral manager
+    if (self.peripheralManager) {
+        self.peripheralManager.delegate = nil;
+        self.peripheralManager = nil;
+    }
+    
+    NSDictionary *options;
+    if (useRestoration) {
+        // Initialize with state restoration to recover from previous state
+        options = @{
+            CBPeripheralManagerOptionRestoreIdentifierKey: kBlenoRestorationIdentifier,
+            CBPeripheralManagerOptionShowPowerAlertKey: @YES
+        };
+        self.triedWithRestoration = YES;
+    } else {
+        // Initialize without state restoration
+        options = @{
+            CBPeripheralManagerOptionShowPowerAlertKey: @YES
+        };
+        self.triedWithRestoration = NO;
+    }
+    
     self.peripheralManager = [[CBPeripheralManager alloc] initWithDelegate:self
-                                                                     queue:self.processingQueue];
+                                                                     queue:self.processingQueue
+                                                                   options:options];
 }
 
 - (void)startAdvertising:(nonnull NSString *)name serviceUUIDs:(nonnull NSArray<CBUUID *> *)serviceUUIDs 
@@ -99,11 +136,23 @@
 
 - (void)setServices:(NSArray<CBMutableService *> *)services 
 {
+    // Store services for cleanup later
+    [self.currentServices addObjectsFromArray:services];
+    
     for (CBMutableService *service in services) {
         [self.peripheralManager addService:service];
     }
 }
 
+- (void)removeAllServices 
+{
+    if (self.peripheralManager) {
+        [self.peripheralManager removeAllServices];
+    }
+    [self.currentServices removeAllObjects];
+    emitters.clear();
+}
+
 - (void)disconnect 
 {
 
@@ -117,7 +166,20 @@
 #pragma mark - CBPeripheralManagerDelegate
 
 - (void)peripheralManagerDidUpdateState:(CBPeripheralManager *)peripheral 
-{
+{   
+    // Check if state is unsupported and we tried with restoration - retry without it
+    if (peripheral.state == CBManagerStateUnsupported && 
+        self.triedWithRestoration && 
+        !self.retriedWithoutRestoration) {
+        self.retriedWithoutRestoration = YES;
+        
+        // Dispatch async to avoid modifying peripheral manager during delegate callback
+        dispatch_async(self.processingQueue, ^{
+            [self startWithRestoration:NO];
+        });
+        return;
+    }
+    
     auto state = StringFromCBPeripheralState(peripheral.state);
     emit.StateChange(state);
 }
@@ -137,6 +199,13 @@
 
 - (void)peripheralManager:(CBPeripheralManager *)peripheral central:(CBCentral *)central didSubscribeToCharacteristic:(CBMutableCharacteristic *)characteristic 
 {
+    // Track connected centrals and emit accept event for new connections
+    BOOL isNewConnection = ![self.connectedCentrals containsObject:central.identifier];
+    if (isNewConnection) {
+        [self.connectedCentrals addObject:central.identifier];
+        emit.Accept(central.identifier);
+    }
+    
     for (auto it = emitters.begin(); it != emitters.end(); ++it) {
         if ([it->first isEqual:characteristic.UUID] == NO) { continue; }
         auto cb = [weakSelf = self, characteristic, central](NSData *data) {
@@ -156,6 +225,13 @@
 
 - (void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveReadRequest:(CBATTRequest *)request 
 {
+    // Track connected centrals on read requests too
+    BOOL isNewConnection = ![self.connectedCentrals containsObject:request.central.identifier];
+    if (isNewConnection) {
+        [self.connectedCentrals addObject:request.central.identifier];
+        emit.Accept(request.central.identifier);
+    }
+    
     for (auto it = emitters.begin(); it != emitters.end(); ++it) {
         if ([it->first isEqual:request.characteristic.UUID] == NO) { continue; }
         auto cb = [peripheral, request](int result, NSData *data) {
@@ -169,6 +245,13 @@
 - (void)peripheralManager:(CBPeripheralManager *)peripheral didReceiveWriteRequests:(NSArray<CBATTRequest *> *)requests 
 {
     for (CBATTRequest *request in requests) {
+        // Track connected centrals on write requests too
+        BOOL isNewConnection = ![self.connectedCentrals containsObject:request.central.identifier];
+        if (isNewConnection) {
+            [self.connectedCentrals addObject:request.central.identifier];
+            emit.Accept(request.central.identifier);
+        }
+        
         CBCharacteristic *characteristic = request.characteristic;
         for (auto it = emitters.begin(); it != emitters.end(); ++it) {
             if ([it->first isEqual:characteristic.UUID] == NO) { continue; }
@@ -193,4 +276,33 @@
     [self processNotificationQueue];
 }
 
+#pragma mark - State Restoration
+
+- (void)peripheralManager:(CBPeripheralManager *)peripheral willRestoreState:(NSDictionary<NSString *, id> *)dict 
+{
+    // Restore services that were previously registered
+    NSArray<CBMutableService *> *restoredServices = dict[CBPeripheralManagerRestoredStateServicesKey];
+    if (restoredServices) {
+        [self.currentServices addObjectsFromArray:restoredServices];
+        
+        // Iterate through restored services to find subscribed centrals
+        for (CBMutableService *service in restoredServices) {
+            if (service.characteristics) {
+                for (CBMutableCharacteristic *characteristic in service.characteristics) {
+                    // Check for subscribed centrals on this characteristic
+                    if (characteristic.subscribedCentrals && characteristic.subscribedCentrals.count > 0) {
+                        for (CBCentral *central in characteristic.subscribedCentrals) {
+                            if (![self.connectedCentrals containsObject:central.identifier]) {
+                                [self.connectedCentrals addObject:central.identifier];
+                                // Emit accept event for the restored connection
+                                emit.Accept(central.identifier);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
 @end

package/lib/mac/src/bleno_mac.mm

@@ -54,6 +54,9 @@ Napi::Value BlenoMac::Init(const Napi::CallbackInfo& info) {
 
 Napi::Value BlenoMac::Stop(const Napi::CallbackInfo& info) {
     CHECK_MANAGER()
+    // Properly clean up: stop advertising, remove all services
+    [peripheralManager stopAdvertising];
+    [peripheralManager removeAllServices];
     peripheralManager = nil;
     return info.Env().Undefined();
 }

package/lib/mac/src/callbacks.h

@@ -15,6 +15,8 @@ public:
     void AdvertisingStop();
     void ServicesSet(NSError * _Nullable error);
     void StateChange(const std::string& state);
+    void Accept(NSUUID *centralUuid);
+    void Disconnect(NSUUID *centralUuid);
 protected:
     std::shared_ptr<ThreadSafeCallback> mCallback;
 };

package/lib/mac/src/callbacks.mm

@@ -60,6 +60,18 @@ void Emit::StateChange(const std::string& state) {
     });
 }
 
+void Emit::Accept(NSUUID *centralUuid) {
+    mCallback->call([centralUuid](Napi::Env env, std::vector<napi_value>& args) {
+        args = { _s("accept"), _a(centralUuid), _a(centralUuid) };
+    });
+}
+
+void Emit::Disconnect(NSUUID *centralUuid) {
+    mCallback->call([centralUuid](Napi::Env env, std::vector<napi_value>& args) {
+        args = { _s("disconnect"), _a(centralUuid) };
+    });
+}
+
 void EmitCharacteristic::Wrap(const Napi::Value& receiver, const Napi::Function& callback) {
     mCallback = std::make_shared<ThreadSafeCallback>(receiver, callback);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stoprocent/bleno",
-  "version": "0.11.4",
+  "version": "0.12.0",
   "description": "A Node.js module for implementing BLE (Bluetooth Low Energy) peripherals",
   "main": "./index.js",
   "types": "./index.d.ts",