@magicred-1/react-native-lxmf 0.2.1 → 0.2.2

package/android/src/main/kotlin/expo/modules/lxmf/BleManager.kt

@@ -53,6 +53,7 @@ class BleManager(
     private var advertiser: BluetoothLeAdvertiser? = null
     private var isScanning = false
     private var isAdvertising = false
+    private var isRunning = false
 
     // GATT server (peripheral role) — accepts inbound writes from remote centrals
     // and pushes outbound notifications to subscribed centrals.
@@ -82,20 +83,29 @@ class BleManager(
     // ── Lifecycle ────────────────────────────────────────────────────────────
 
     fun start() {
+        if (isRunning) {
+            Log.d(TAG, "BleManager already running — skipping duplicate start()")
+            return
+        }
         if (adapter == null || !adapter!!.isEnabled) {
             Log.w(TAG, "Bluetooth not available or not enabled")
             return
         }
+        isRunning = true
         // GATT server must be opened (and service added) before advertising,
         // otherwise centrals connect and find no service. startAdvertising()
         // is invoked from onServiceAdded once the service is registered.
         openGattServer()
         startScanning()
+        // Remove any stale callbacks before scheduling — guards against duplicate
+        // poll loops if start() is somehow called more than once.
+        mainHandler.removeCallbacks(txPollRunnable)
         mainHandler.postDelayed(txPollRunnable, TX_POLL_INTERVAL_MS)
         Log.i(TAG, "BleManager started")
     }
 
     fun stop() {
+        isRunning = false
         stopScanning()
         stopAdvertising()
         closeGattServer()
@@ -441,7 +451,8 @@ class BleManager(
             val effectiveMtu = if (status == BluetoothGatt.GATT_SUCCESS) mtu else 23
             Log.i(TAG, "BLE MTU negotiated: $mac -> ${effectiveMtu}B")
             module.nativeOnMtuNegotiated(macToBytes(mac), effectiveMtu)
-            // Now safe to subscribe — each segment will fit in one ATT PDU.
+            // Subscribe to peer's TX notifications; nativeBleConnected fires in onDescriptorWrite
+            // after the CCCD write completes — writing before then returns ok=false.
             val service = gatt.getService(RNS_SERVICE_UUID) ?: return
             val peerTxChar = service.getCharacteristic(RNS_TX_CHAR_UUID) ?: return
             gatt.setCharacteristicNotification(peerTxChar, true)
@@ -450,22 +461,51 @@ class BleManager(
             cccd.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
             @Suppress("DEPRECATION")
             gatt.writeDescriptor(cccd)
-            module.nativeBleConnected(macToBytes(mac))
-            Log.i(TAG, "BLE peer ready: $mac")
         }
 
+        override fun onDescriptorWrite(gatt: BluetoothGatt, descriptor: BluetoothGattDescriptor, status: Int) {
+            val mac = gatt.device.address
+            if (descriptor.uuid == CCCD_UUID && descriptor.characteristic?.uuid == RNS_TX_CHAR_UUID) {
+                if (status == BluetoothGatt.GATT_SUCCESS) {
+                    // GATT setup complete — subscribed to peer TX notifications, safe to write now.
+                    Log.i(TAG, "BLE peer ready (client): $mac")
+                    module.nativeBleConnected(macToBytes(mac))
+                } else {
+                    // CCCD write failed — can't subscribe to their notifications from client role,
+                    // but if they already connected to our server and subscribed, the server-side
+                    // path handles full duplex. Don't disconnect — keep the connection open.
+                    Log.w(TAG, "BLE CCCD write failed ($status) on $mac — continuing via server role if available")
+                }
+            }
+        }
+
+        // API 33+: platform delivers value directly — characteristic.value is null here.
+        @Suppress("OVERRIDE_DEPRECATION")
         override fun onCharacteristicChanged(
             gatt: BluetoothGatt,
             characteristic: BluetoothGattCharacteristic,
         ) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) return
             if (characteristic.uuid == RNS_TX_CHAR_UUID) {
                 @Suppress("DEPRECATION")
                 val data = characteristic.value ?: return
-                Log.d(TAG, "BLE RX ${data.size}B from ${gatt.device.address}")
+                Log.d(TAG, "BLE RX(compat) ${data.size}B from ${gatt.device.address}")
                 module.nativeBleReceive(macToBytes(gatt.device.address), data)
             }
         }
 
+        @androidx.annotation.RequiresApi(Build.VERSION_CODES.TIRAMISU)
+        override fun onCharacteristicChanged(
+            gatt: BluetoothGatt,
+            characteristic: BluetoothGattCharacteristic,
+            value: ByteArray,
+        ) {
+            if (characteristic.uuid == RNS_TX_CHAR_UUID) {
+                Log.d(TAG, "BLE RX ${value.size}B from ${gatt.device.address}")
+                module.nativeBleReceive(macToBytes(gatt.device.address), value)
+            }
+        }
+
         override fun onCharacteristicWrite(
             gatt: BluetoothGatt,
             characteristic: BluetoothGattCharacteristic,
@@ -479,41 +519,42 @@ class BleManager(
 
     // ── TX drain — poll Rust and write to peer characteristics ───────────────
 
+    // Android GATT is single-op: concurrent writeCharacteristic() calls return
+    // false and drop the packet. Send one frame per 50ms poll tick instead of
+    // draining all pending frames at once.
     private fun drainTxQueue() {
-        while (true) {
-            val json = module.nativeBlePollTx() ?: break
-            try {
-                val obj = org.json.JSONObject(json)
-                val peerHex = obj.getString("peer")           // "aabbccddeeff"
-                val dataB64 = obj.getString("data")
-                val data = android.util.Base64.decode(dataB64, android.util.Base64.DEFAULT)
-                val mac = hexToMacString(peerHex)             // "AA:BB:CC:DD:EE:FF"
-
-                // Peripheral (server) role: peer subscribed to our TX char →
-                // push via NOTIFY. Mirrors iOS peripheralManager.updateValue.
-                val subscriber = serverSubscribers[mac]
-                val txChar = serverTxChar
-                if (subscriber != null && txChar != null) {
-                    val ok = notifyServerSubscriber(subscriber, txChar, data)
-                    Log.d(TAG, "BLE NOTIFY ${data.size}B to $mac ok=$ok")
-                    continue
-                }
-
-                // Central (client) role: write to peer's RX characteristic.
-                // RX has WRITE properties; TX is notify-only (writes there
-                // would be rejected by the peer). Matches iOS convention.
-                val gatt = connections[mac] ?: continue
-                val service = gatt.getService(RNS_SERVICE_UUID) ?: continue
-                val peerRxChar = service.getCharacteristic(RNS_RX_CHAR_UUID) ?: continue
-                @Suppress("DEPRECATION")
-                peerRxChar.value = data
-                peerRxChar.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
-                @Suppress("DEPRECATION")
-                val ok = gatt.writeCharacteristic(peerRxChar)
-                Log.d(TAG, "BLE TX ${data.size}B to $mac ok=$ok")
-            } catch (e: Exception) {
-                Log.e(TAG, "drainTxQueue parse error: ${e.message}")
+        val json = module.nativeBlePollTx() ?: return
+        try {
+            val obj = org.json.JSONObject(json)
+            val peerHex = obj.getString("peer")           // "aabbccddeeff"
+            val dataB64 = obj.getString("data")
+            val data = android.util.Base64.decode(dataB64, android.util.Base64.DEFAULT)
+            val mac = hexToMacString(peerHex)             // "AA:BB:CC:DD:EE:FF"
+
+            // Peripheral (server) role: peer subscribed to our TX char →
+            // push via NOTIFY. Mirrors iOS peripheralManager.updateValue.
+            val subscriber = serverSubscribers[mac]
+            val txChar = serverTxChar
+            if (subscriber != null && txChar != null) {
+                val ok = notifyServerSubscriber(subscriber, txChar, data)
+                Log.d(TAG, "BLE NOTIFY ${data.size}B to $mac ok=$ok")
+                return
             }
+
+            // Central (client) role: write to peer's RX characteristic.
+            // RX has WRITE properties; TX is notify-only (writes there
+            // would be rejected by the peer). Matches iOS convention.
+            val gatt = connections[mac] ?: return
+            val service = gatt.getService(RNS_SERVICE_UUID) ?: return
+            val peerRxChar = service.getCharacteristic(RNS_RX_CHAR_UUID) ?: return
+            @Suppress("DEPRECATION")
+            peerRxChar.value = data
+            peerRxChar.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
+            @Suppress("DEPRECATION")
+            val ok = gatt.writeCharacteristic(peerRxChar)
+            Log.d(TAG, "BLE TX ${data.size}B to $mac ok=$ok")
+        } catch (e: Exception) {
+            Log.e(TAG, "drainTxQueue parse error: ${e.message}")
         }
     }
 

package/example/app/(tabs)/index.tsx

@@ -11,7 +11,7 @@ import {
   View,
 } from 'react-native';
 import * as SecureStore from 'expo-secure-store';
-import { LxmfNodeMode, type LxmfEvent, useLxmf } from '@magicred-1/react-native-lxmf';
+import { LxmfModule, LxmfNodeMode, type LxmfEvent, useLxmf } from '@magicred-1/react-native-lxmf';
 
 // Persisted identity blob schema (versioned). Stored in expo-secure-store under
 // IDENTITY_KEY — encrypted at rest on iOS (Keychain) and Android (Keystore-backed).
@@ -215,6 +215,7 @@ export default function HomeScreen() {
   const [sendResult, setSendResult] = useState('');
 
   const [unpairedRNodes, setUnpairedRNodes] = useState(0);
+  const [liveBleCount, setLiveBleCount] = useState(0);
 
   // Identity hydration: read once from secure store on mount. Until hydrated,
   // we pass 'new' so Rust generates a fresh identity (which we'll then persist
@@ -305,7 +306,21 @@ export default function HomeScreen() {
 
   const announceEvts = useMemo(() => events.filter(e => e.type === 'announceReceived').slice(0, 20), [events]);
   const msgEvts = useMemo(() => events.filter(e => e.type === 'messageReceived').slice(0, 20), [events]);
-  const logEvts = useMemo(() => events.filter(e => e.type === 'log').slice(0, 30), [events]);
+  const logEvts = useMemo(() => events.filter(e => e.type === 'log').slice(0, 100), [events]);
+
+  // Deduped peer identity hashes from all announce events (any interface)
+  const knownPeerHashes = useMemo(() => {
+    const map = new Map<string, { hash: string; name: string; lastSeen: string }>();
+    for (const e of events) {
+      if (e.type !== 'announceReceived') continue;
+      const hash = String(e.destHash ?? e.address ?? '');
+      if (!hash) continue;
+      if (!map.has(hash)) {
+        map.set(hash, { hash, name: e.appData ? String(e.appData) : '', lastSeen: fmtTime(e) });
+      }
+    }
+    return Array.from(map.values());
+  }, [events]);
   const allEvts = useMemo(() => events.slice(0, 30), [events]);
 
   // ── Actions ───────────────────────────────────────────────────────────────
@@ -392,6 +407,15 @@ export default function HomeScreen() {
     return () => clearInterval(id);
   }, [bleActive, bleUnpairedRNodeCount]);
 
+  // Live BLE peer count — poll every second
+  useEffect(() => {
+    if (!bleActive) { setLiveBleCount(0); return; }
+    const tick = () => { try { setLiveBleCount(LxmfModule.blePeerCount()); } catch {} };
+    tick();
+    const id = setInterval(tick, 1000);
+    return () => clearInterval(id);
+  }, [bleActive]);
+
   const onSend = useCallback(async () => {
     const d = dest.trim().toLowerCase();
     if (!/^[0-9a-f]{32}$/.test(d)) { setSendResult('Dest = 32 hex chars.'); return; }
@@ -492,7 +516,7 @@ export default function HomeScreen() {
       <Accordion title="BLE Mesh" defaultOpen>
         <Text style={S.hint}>Pair RNodes in iOS Settings &gt; Bluetooth first, then start BLE.</Text>
         <Row label="BLE active" value={bleActive ? 'Yes' : 'No'} />
-        <Row label="BLE peers" value={String(status?.blePeerCount ?? 0)} />
+        <Row label="Connected peers" value={String(liveBleCount)} />
         {unpairedRNodes > 0 && (
           <Text style={S.warn}>
             Found {unpairedRNodes} unpaired RNode{unpairedRNodes > 1 ? 's' : ''}. Open Settings &gt; Bluetooth, pair the device, then restart BLE.
@@ -504,15 +528,27 @@ export default function HomeScreen() {
         </View>
       </Accordion>
 
-      {/* ── Peers / Beacons ──────────────────────────────────────────────── */}
-      <Accordion title="Peers / Beacons" badge={beacons.length} defaultOpen={false}>
-        {beacons.length === 0 ? (
-          <Text style={S.muted}>No peers yet.</Text>
+      {/* ── BLE Peers ────────────────────────────────────────────────────── */}
+      <Accordion title="BLE Peers" badge={liveBleCount} defaultOpen>
+        <Text style={S.hint}>
+          Live BLE connections: {liveBleCount}. LXMF identity hashes appear after peer announces.
+        </Text>
+        {knownPeerHashes.length === 0 ? (
+          <Text style={S.muted}>No peer announces received yet.</Text>
         ) : (
-          beacons.map((b, i) => (
-            <View key={`${b.destHash}-${i}`} style={S.itemCard}>
-              <Text selectable style={S.itemTitle}>{shortHex(b.destHash)}</Text>
-              <Text style={S.itemMeta}>state: {b.state} · reconnects: {b.reconnectAttempts}</Text>
+          knownPeerHashes.map((p) => (
+            <View key={p.hash} style={S.itemCard}>
+              {p.name ? <Text style={S.itemTitle}>{p.name}</Text> : null}
+              <Text selectable style={S.itemBody}>{p.hash}</Text>
+              <Text style={S.itemMeta}>last seen: {p.lastSeen}</Text>
+              <View style={S.announceActions}>
+                <Pressable style={S.copyBtn} onPress={() => copyToClipboard(p.hash)}>
+                  <Text style={S.copyBtnText}>⎘</Text>
+                </Pressable>
+                <Pressable style={S.sendToBtn} onPress={() => { setDest(p.hash); setSendResult(''); }}>
+                  <Text style={S.sendToBtnText}>→ Send</Text>
+                </Pressable>
+              </View>
             </View>
           ))
         )}
@@ -637,14 +673,15 @@ export default function HomeScreen() {
       </Accordion>
 
       {/* ── Debug Logs ───────────────────────────────────────────────────── */}
-      <Accordion title="Debug Logs" badge={counts.logs} defaultOpen={false}>
+      <Accordion title="Debug Logs" badge={counts.logs} defaultOpen>
         {logEvts.length === 0 ? (
           <Text style={S.muted}>No logs yet.</Text>
         ) : (
           logEvts.map((e, i) => (
-            <Text key={`${evtKey(e, 'lg-')}-${i}`} selectable style={S.logLine} numberOfLines={3}>
-              [{fmtTime(e)}] {evtSummary(e)}
-            </Text>
+            <View key={`${evtKey(e, 'lg-')}-${i}`} style={S.logRow}>
+              <Text style={S.logTime}>{fmtTime(e)}</Text>
+              <Text selectable style={S.logLine}>{String(e.message ?? e.msg ?? evtSummary(e))}</Text>
+            </View>
           ))
         )}
       </Accordion>

package/ios/BLEManager.swift

@@ -53,6 +53,10 @@ class BLEManager: NSObject {
 
     private var isRunning = false
 
+    /// Called when CoreBluetooth signals it is ready to accept more writes.
+    /// LxmfModule sets this to re-trigger drainOutgoing() without a timer.
+    var onReadyToSend: (() -> Void)?
+
     /// Per-launch random token embedded in our advertisement's local name, so
     /// our central role can detect and skip our own peripheral advertisement
     /// (CoreBluetooth does not auto-filter self when running both roles).
@@ -176,20 +180,30 @@ class BLEManager: NSObject {
     }
 
     /// Send data to a specific peer by 6-byte pseudo-MAC address.
-    /// Used by drainOutgoing() to route frames from lxmf_ble_poll_tx.
-    func sendToPeerAddr(_ addr: Data, data: Data) {
-        // Try peripheral role: send notification to a subscribed central
+    /// Returns false when CoreBluetooth's TX buffer is full — caller should stop
+    /// draining and wait for onReadyToSend before resuming.
+    @discardableResult
+    func sendToPeerAddr(_ addr: Data, data: Data) -> Bool {
+        // Peripheral role: push notification to subscribed central.
+        // updateValue returns false when the subscriber's buffer is full;
+        // peripheralManagerIsReady(toUpdateSubscribers:) fires when it drains.
         if let central = addrToCentral[addr], let txChar = txCharacteristic {
-            peripheralManager?.updateValue(data, for: txChar, onSubscribedCentrals: [central])
-            return
+            let ok = peripheralManager?.updateValue(data, for: txChar, onSubscribedCentrals: [central]) ?? false
+            return ok
         }
 
-        // Try central role: write to connected peripheral's RX characteristic
+        // Central role: write to peer's RX characteristic.
+        // canSendWriteWithoutResponse goes false when the internal queue is full;
+        // peripheral(_:isReadyToSendWriteWithoutResponse:) fires when it drains.
         if let peripheralUUID = addrToPeripheralUUID[addr],
            let peripheral = connectedPeripherals[peripheralUUID],
            let char = txCharacteristics[peripheralUUID] {
+            guard peripheral.canSendWriteWithoutResponse else { return false }
             peripheral.writeValue(data, for: char, type: .withoutResponse)
+            return true
         }
+
+        return true // peer not found — frame consumed, no retry needed
     }
 
     /// Write KISS-framed data to all connected RNodes via NUS TX characteristic.
@@ -471,6 +485,12 @@ extension BLEManager: CBPeripheralDelegate {
             }
         }
     }
+
+    // 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) {
+        onReadyToSend?()
+    }
 }
 
 // MARK: - CBPeripheralManagerDelegate
@@ -537,6 +557,11 @@ extension BLEManager: CBPeripheralManagerDelegate {
         }
     }
 
+    // Called when updateValue returned false and the subscriber buffer has drained.
+    func peripheralManagerIsReady(toUpdateSubscribers peripheral: CBPeripheralManager) {
+        onReadyToSend?()
+    }
+
     // Background restoration
     func peripheralManager(_ peripheral: CBPeripheralManager, willRestoreState dict: [String: Any]) {
         // Re-setup services on restoration

package/ios/LxmfModule.swift

@@ -141,7 +141,11 @@ public class LxmfModule: Module {
     private var txDrainTimer: Timer?
 
     // BLE manager for phone-to-phone mesh
-    private lazy var bleManager = BLEManager()
+    private lazy var bleManager: BLEManager = {
+        let mgr = BLEManager()
+        mgr.onReadyToSend = { [weak self] in DispatchQueue.main.async { self?.drainOutgoing() } }
+        return mgr
+    }()
 
     public func definition() -> ModuleDefinition {
         Name("LxmfModule")
@@ -391,7 +395,8 @@ public class LxmfModule: Module {
 
             let frameData = Data(dataBuf[0..<Int(len)])
             let addr = Data(peerAddr)
-            bleManager.sendToPeerAddr(addr, data: frameData)
+            // Stop draining if CoreBluetooth buffer is full — onReadyToSend re-triggers us.
+            guard bleManager.sendToPeerAddr(addr, data: frameData) else { break }
         }
 
         // --- NUS: poll for KISS-framed RNode data ---

package/package.json

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