@magicred-1/react-native-lxmf 0.2.3 → 0.2.5

package/ios/BLEManager.swift

@@ -433,26 +433,18 @@ extension BLEManager: CBPeripheralDelegate {
             return
         }
 
-        // Phone-to-phone mesh characteristics — mark as bonded and register with Rust
+        // Phone-to-phone mesh: store RX char and subscribe to TX notifications.
+        // lxmf_ble_connected is deferred until didUpdateNotificationStateFor confirms
+        // the CCCD write — otherwise Rust tries to TX before the pipe is open.
         bondedPeripherals.insert(peripheral.identifier)
         saveBondedPeripherals()
         let addr = BLEManager.uuidToAddr(peripheral.identifier)
         addrToPeripheralUUID[addr] = peripheral.identifier
-        addr.withUnsafeBytes { ptr in
-            _ = lxmf_ble_connected(ptr.baseAddress?.assumingMemoryBound(to: UInt8.self))
-        }
-        // Report negotiated write limit so Rust segments correctly for this peer.
-        let writeLimit = peripheral.maximumWriteValueLength(for: .withoutResponse)
-        addr.withUnsafeBytes { ptr in
-            _ = lxmf_ble_mtu_negotiated(ptr.baseAddress?.assumingMemoryBound(to: UInt8.self), UInt32(writeLimit))
-        }
 
         for char in chars {
             if char.uuid == BLEManager.rxCharUUID {
-                // This is the peer's RX — we write to it
                 txCharacteristics[peripheral.identifier] = char
             } else if char.uuid == BLEManager.txCharUUID {
-                // This is the peer's TX — subscribe for notifications
                 peripheral.setNotifyValue(true, for: char)
             }
         }
@@ -486,6 +478,28 @@ extension BLEManager: CBPeripheralDelegate {
         }
     }
 
+    // CCCD subscription confirmed (or failed) — now safe to register peer with Rust.
+    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
+        guard characteristic.uuid == BLEManager.txCharUUID else { return }
+
+        if let error = error {
+            NSLog("[BLE] CCCD subscribe failed for %@: %@", peripheral.identifier.uuidString, error.localizedDescription)
+            centralManager?.cancelPeripheralConnection(peripheral)
+            return
+        }
+        guard characteristic.isNotifying else { return }
+
+        let addr = BLEManager.uuidToAddr(peripheral.identifier)
+        addr.withUnsafeBytes { ptr in
+            _ = lxmf_ble_connected(ptr.baseAddress?.assumingMemoryBound(to: UInt8.self))
+        }
+        let writeLimit = peripheral.maximumWriteValueLength(for: .withoutResponse)
+        addr.withUnsafeBytes { ptr in
+            _ = lxmf_ble_mtu_negotiated(ptr.baseAddress?.assumingMemoryBound(to: UInt8.self), UInt32(writeLimit))
+        }
+        NSLog("[BLE] peer ready (client): %@, writeLimit=%d", peripheral.identifier.uuidString, writeLimit)
+    }
+
     // Called when writeValue(.withoutResponse) exhausted the internal queue.
     // Re-trigger TX drain so buffered frames get sent now that there's room.
     func peripheralIsReady(toSendWriteWithoutResponse peripheral: CBPeripheral) {
@@ -524,6 +538,7 @@ extension BLEManager: CBPeripheralManagerDelegate {
                     }
                 }
             }
+            // CoreBluetooth no-ops this for writeWithoutResponse — safe to call unconditionally.
             peripheral.respond(to: request, withResult: .success)
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magicred-1/react-native-lxmf",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "LXMF Reticulum mesh networking for React Native + Expo",
   "main": "build/index.js",
   "types": "build/index.d.ts",