@magicred-1/react-native-lxmf 0.2.30 → 0.2.32

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

@@ -48,8 +48,6 @@ class BleManager(
     private val connecting = mutableSetOf<String>()
     // Timestamp (ms) when each MAC last disconnected — enforces reconnect cooldown
     private val disconnectedAt = mutableMapOf<String, Long>()
-    // MACs seen in scan results but not yet GATT-connected (mirrors iOS discoveredUnpairedRNodes)
-    private val discoveredUnpaired = mutableSetOf<String>()
 
     private var scanner: BluetoothLeScanner? = null
     private var advertiser: BluetoothLeAdvertiser? = null
@@ -115,12 +113,10 @@ class BleManager(
         connections.values.forEach { it.disconnect(); it.close() }
         connections.clear()
         connecting.clear()
-        discoveredUnpaired.clear()
         Log.i(TAG, "BleManager stopped")
     }
 
     fun connectedPeerCount(): Int = module.nativeBlePeerCount()
-    fun unpairedRNodeCount(): Int = discoveredUnpaired.size
 
     // ── Advertising (so peers can find us) ───────────────────────────────────
 
@@ -396,7 +392,6 @@ class BleManager(
             val lastDisconnect = disconnectedAt[mac] ?: 0L
             if (System.currentTimeMillis() - lastDisconnect < RECONNECT_COOLDOWN_MS) return
             Log.i(TAG, "BLE: found peer $mac, connecting")
-            discoveredUnpaired.add(mac)
             connecting.add(mac)
             device.connectGatt(context, false, gattCallback, BluetoothDevice.TRANSPORT_LE)
         }
@@ -418,7 +413,6 @@ class BleManager(
                     Log.i(TAG, "BLE GATT connected: $mac")
                     connections[mac] = gatt
                     connecting.remove(mac)
-                    discoveredUnpaired.remove(mac)
                     gatt.discoverServices()
                 }
                 BluetoothProfile.STATE_DISCONNECTED -> {
@@ -427,7 +421,6 @@ class BleManager(
                     Log.i(TAG, "BLE GATT disconnected: $mac (status=$status)")
                     connections.remove(mac)
                     connecting.remove(mac)
-                    discoveredUnpaired.remove(mac)
                     disconnectedAt[mac] = System.currentTimeMillis()
                     gatt.close()
                     // Notify Rust

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

@@ -15,12 +15,13 @@ class LxmfModule : Module() {
   private val pollRunnable = object : Runnable {
     override fun run() {
       drainAndEmitEvents()
+      nusManager?.pollTxAndWrite()
       pollHandler.postDelayed(this, POLL_INTERVAL_MS)
     }
   }
 
-  // BleManager is created lazily when the app context is available
   private var bleManager: BleManager? = null
+  private var nusManager: NusManager? = null
 
   override fun definition() = ModuleDefinition {
     Name("LxmfModule")
@@ -48,6 +49,7 @@ class LxmfModule : Module() {
         ?: appContext.currentActivity?.applicationContext
       if (ctx != null) {
         bleManager = BleManager(ctx, this@LxmfModule)
+        nusManager = NusManager(ctx, this@LxmfModule)
       }
     }
 
@@ -55,6 +57,8 @@ class LxmfModule : Module() {
       pollHandler.removeCallbacks(pollRunnable)
       bleManager?.stop()
       bleManager = null
+      nusManager?.stop()
+      nusManager = null
     }
 
     // Lifecycle
@@ -79,11 +83,13 @@ class LxmfModule : Module() {
                   bleMtuHint.toShort(), interfacesJson, displayName, isBeacon)
       if (rc != 0) throw RuntimeException("nativeStart returned $rc")
       bleManager?.start()
+      nusManager?.start()
       true
     }
 
     AsyncFunction("stop") {
       bleManager?.stop()
+      nusManager?.stop()
       val rc = nativeStop()
       if (rc != 0) throw RuntimeException("nativeStop returned $rc")
       true
@@ -134,12 +140,14 @@ class LxmfModule : Module() {
     Function("startBLE") {
       Log.d(TAG, "startBLE()")
       bleManager?.start()
+      nusManager?.start()
       true
     }
 
     Function("stopBLE") {
       Log.d(TAG, "stopBLE()")
       bleManager?.stop()
+      nusManager?.stop()
       true
     }
 
@@ -148,7 +156,7 @@ class LxmfModule : Module() {
     }
 
     Function("bleUnpairedRNodeCount") {
-      bleManager?.unpairedRNodeCount() ?: 0
+      nusManager?.unpairedRNodeCount() ?: 0
     }
   }
 
@@ -217,6 +225,10 @@ class LxmfModule : Module() {
   private external fun nativeSetLogLevel(level: Int): Int
   private external fun nativeAbiVersion(): Int
 
+  // NUS JNI — called by NusManager (same package)
+  external fun nativeNusReceive(data: ByteArray)
+  external fun nativeNusPollTx(): ByteArray?
+
   // BLE JNI — called by BleManager (same package)
   // Must NOT be `internal` — Kotlin mangles internal function names in JVM bytecode,
   // which breaks JNI symbol resolution (produces e.g. nativeBlePollTx$lxmf_react_native_debug).

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

@@ -0,0 +1,283 @@
+package expo.modules.lxmf
+
+import android.bluetooth.*
+import android.bluetooth.le.*
+import android.content.Context
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.ParcelUuid
+import android.util.Log
+import java.util.UUID
+
+private const val NUS_TAG = "LxmfNus"
+
+// NUS GATT UUIDs — must match nus_iface.rs constants exactly
+val NUS_SERVICE_UUID: UUID = UUID.fromString("6e400001-b5a3-f393-e0a9-e50e24dcca9e")
+val NUS_TX_CHAR_UUID: UUID = UUID.fromString("6e400002-b5a3-f393-e0a9-e50e24dcca9e") // phone writes TO RNode
+val NUS_RX_CHAR_UUID: UUID = UUID.fromString("6e400003-b5a3-f393-e0a9-e50e24dcca9e") // phone receives FROM RNode
+
+/**
+ * NusManager — Android BLE client for RNode hardware (Heltec V3 etc.) via Nordic UART Service.
+ *
+ * Mirrors iOS BLEManager NUS logic:
+ *   - Scans for NUS service UUID
+ *   - If device is OS-paired (BOND_BONDED): connects and sets up KISS pipe to Rust NusInterface
+ *   - If not paired: tracks as discoveredUnpaired (bleUnpairedRNodeCount returns this count)
+ *   - RX notifications → nativeNusReceive() → Rust NusInterface (KISS deframing + transport)
+ *   - TX polling → nativeNusPollTx() → write chunked to RNode's NUS TX characteristic
+ *
+ * Separate from BleManager (mesh peers) — two different scan filters, two GATT roles.
+ */
+class NusManager(
+    private val context: Context,
+    private val module: LxmfModule,
+) {
+    private val bluetoothManager = context.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager
+    private val adapter: BluetoothAdapter? get() = bluetoothManager?.adapter
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    // Active GATT connections to bonded RNodes, keyed by MAC
+    private val connections = mutableMapOf<String, BluetoothGatt>()
+    // NUS TX characteristics (phone writes TO RNode), keyed by MAC
+    private val txChars = mutableMapOf<String, BluetoothGattCharacteristic>()
+    // Negotiated write MTU per connection — used for TX chunking
+    private val writeMtu = mutableMapOf<String, Int>()
+    // MACs found in scan but not OS-paired — UI should prompt user to pair in Settings
+    private val discoveredUnpaired = mutableSetOf<String>()
+    // MACs currently attempting connection
+    private val connecting = mutableSetOf<String>()
+
+    private var scanner: BluetoothLeScanner? = null
+    private var isScanning = false
+    private var isRunning = false
+
+    companion object {
+        private const val SCAN_RESTART_DELAY_MS = 30_000L
+        private const val RECONNECT_DELAY_MS = 3_000L
+        private const val DEFAULT_WRITE_MTU = 20  // conservative BLE default
+    }
+
+    // ── Lifecycle ────────────────────────────────────────────────────────────
+
+    fun start() {
+        if (isRunning) return
+        isRunning = true
+        startScanning()
+        Log.i(NUS_TAG, "NusManager started")
+    }
+
+    fun stop() {
+        isRunning = false
+        stopScanning()
+        connections.values.forEach { it.disconnect(); it.close() }
+        connections.clear()
+        txChars.clear()
+        writeMtu.clear()
+        connecting.clear()
+        discoveredUnpaired.clear()
+        Log.i(NUS_TAG, "NusManager stopped")
+    }
+
+    /** Number of RNodes visible in scan but not yet OS-paired (mirrors iOS discoveredUnpairedRNodes.count). */
+    fun unpairedRNodeCount(): Int = discoveredUnpaired.size
+
+    /** Number of fully connected and ready RNodes. */
+    fun connectedRNodeCount(): Int = connections.size
+
+    /**
+     * Drain Rust NUS TX queue and write each frame to all connected RNodes.
+     * Called from LxmfModule poll runnable at the same 80ms cadence as event polling.
+     */
+    fun pollTxAndWrite() {
+        if (connections.isEmpty()) return
+        repeat(8) {
+            val data = module.nativeNusPollTx() ?: return
+            for ((mac, char) in txChars) {
+                val gatt = connections[mac] ?: return@repeat
+                writeChunked(gatt, char, data, writeMtu[mac] ?: DEFAULT_WRITE_MTU)
+            }
+        }
+    }
+
+    private fun writeChunked(
+        gatt: BluetoothGatt,
+        char: BluetoothGattCharacteristic,
+        data: ByteArray,
+        mtu: Int,
+    ) {
+        var offset = 0
+        while (offset < data.size) {
+            val end = minOf(offset + mtu, data.size)
+            val chunk = data.copyOfRange(offset, end)
+            @Suppress("DEPRECATION")
+            char.value = chunk
+            char.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
+            @Suppress("DEPRECATION")
+            gatt.writeCharacteristic(char)
+            offset = end
+        }
+    }
+
+    // ── Scanning ─────────────────────────────────────────────────────────────
+
+    private fun startScanning() {
+        if (isScanning) return
+        scanner = adapter?.bluetoothLeScanner ?: return
+        val filter = ScanFilter.Builder()
+            .setServiceUuid(ParcelUuid(NUS_SERVICE_UUID))
+            .build()
+        val settings = ScanSettings.Builder()
+            .setScanMode(ScanSettings.SCAN_MODE_BALANCED)
+            .build()
+        scanner?.startScan(listOf(filter), settings, scanCallback)
+        isScanning = true
+        Log.d(NUS_TAG, "NUS scan started")
+    }
+
+    private fun stopScanning() {
+        if (isScanning) {
+            scanner?.stopScan(scanCallback)
+            isScanning = false
+        }
+    }
+
+    private val scanCallback = object : ScanCallback() {
+        override fun onScanResult(callbackType: Int, result: ScanResult) {
+            val device = result.device ?: return
+            val mac = device.address ?: return
+            if (mac in connections || mac in connecting) return
+
+            when (device.bondState) {
+                BluetoothDevice.BOND_BONDED -> {
+                    // OS-paired — safe to connect and use NUS pipe
+                    discoveredUnpaired.remove(mac)
+                    Log.i(NUS_TAG, "NUS: found bonded RNode $mac, connecting")
+                    connecting.add(mac)
+                    device.connectGatt(context, false, gattCallback, BluetoothDevice.TRANSPORT_LE)
+                }
+                else -> {
+                    // Not paired — track for UI, don't auto-connect
+                    if (discoveredUnpaired.add(mac)) {
+                        Log.i(NUS_TAG, "NUS: found unpaired RNode $mac — pair in Bluetooth Settings first")
+                    }
+                }
+            }
+        }
+
+        override fun onScanFailed(errorCode: Int) {
+            Log.e(NUS_TAG, "NUS scan failed: $errorCode")
+            isScanning = false
+            mainHandler.postDelayed({ startScanning() }, SCAN_RESTART_DELAY_MS)
+        }
+    }
+
+    // ── GATT ─────────────────────────────────────────────────────────────────
+
+    private val gattCallback = object : BluetoothGattCallback() {
+        override fun onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) {
+            val mac = gatt.device.address
+            when (newState) {
+                BluetoothProfile.STATE_CONNECTED -> {
+                    Log.i(NUS_TAG, "NUS GATT connected: $mac")
+                    connections[mac] = gatt
+                    connecting.remove(mac)
+                    discoveredUnpaired.remove(mac)
+                    // Negotiate large MTU before service discovery
+                    gatt.requestMtu(517)
+                }
+                BluetoothProfile.STATE_DISCONNECTED -> {
+                    if (mac !in connections && mac !in connecting) return
+                    Log.i(NUS_TAG, "NUS GATT disconnected: $mac (status=$status)")
+                    connections.remove(mac)
+                    txChars.remove(mac)
+                    writeMtu.remove(mac)
+                    connecting.remove(mac)
+                    gatt.close()
+                    // Auto-reconnect bonded devices
+                    if (isRunning && gatt.device.bondState == BluetoothDevice.BOND_BONDED) {
+                        mainHandler.postDelayed({
+                            if (isRunning && mac !in connections && mac !in connecting) {
+                                Log.i(NUS_TAG, "NUS: reconnecting $mac")
+                                connecting.add(mac)
+                                gatt.device.connectGatt(
+                                    context, false, this, BluetoothDevice.TRANSPORT_LE
+                                )
+                            }
+                        }, RECONNECT_DELAY_MS)
+                    }
+                }
+            }
+        }
+
+        override fun onMtuChanged(gatt: BluetoothGatt, mtu: Int, status: Int) {
+            val mac = gatt.device.address
+            val effective = if (status == BluetoothGatt.GATT_SUCCESS) mtu - 3 else DEFAULT_WRITE_MTU
+            writeMtu[mac] = effective.coerceAtLeast(DEFAULT_WRITE_MTU)
+            Log.i(NUS_TAG, "NUS MTU negotiated: $mac → ${effective}B write limit")
+            gatt.discoverServices()
+        }
+
+        override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
+            val mac = gatt.device.address
+            if (status != BluetoothGatt.GATT_SUCCESS) {
+                Log.w(NUS_TAG, "NUS service discovery failed on $mac: $status")
+                gatt.disconnect()
+                return
+            }
+            val service = gatt.getService(NUS_SERVICE_UUID)
+            if (service == null) {
+                Log.w(NUS_TAG, "NUS service not found on $mac — not an RNode?")
+                gatt.disconnect()
+                return
+            }
+
+            // NUS TX char — phone writes KISS frames TO the RNode
+            val txChar = service.getCharacteristic(NUS_TX_CHAR_UUID)
+            if (txChar != null) txChars[mac] = txChar
+
+            // NUS RX char — subscribe for KISS frame notifications FROM the RNode
+            val rxChar = service.getCharacteristic(NUS_RX_CHAR_UUID)
+            if (rxChar != null) {
+                gatt.setCharacteristicNotification(rxChar, true)
+                val cccd = rxChar.getDescriptor(CCCD_UUID)
+                if (cccd != null) {
+                    @Suppress("DEPRECATION")
+                    cccd.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
+                    @Suppress("DEPRECATION")
+                    gatt.writeDescriptor(cccd)
+                }
+            }
+
+            Log.i(NUS_TAG, "NUS RNode ready: $mac (tx=${txChar != null}, rx=${rxChar != null})")
+        }
+
+        // API < 33 compat override
+        @Suppress("OVERRIDE_DEPRECATION")
+        override fun onCharacteristicChanged(
+            gatt: BluetoothGatt,
+            characteristic: BluetoothGattCharacteristic,
+        ) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) return
+            if (characteristic.uuid == NUS_RX_CHAR_UUID) {
+                @Suppress("DEPRECATION")
+                val data = characteristic.value ?: return
+                Log.d(NUS_TAG, "NUS RX(compat) ${data.size}B from ${gatt.device.address}")
+                module.nativeNusReceive(data)
+            }
+        }
+
+        // API 33+ — value delivered directly, no stale characteristic.value
+        @androidx.annotation.RequiresApi(Build.VERSION_CODES.TIRAMISU)
+        override fun onCharacteristicChanged(
+            gatt: BluetoothGatt,
+            characteristic: BluetoothGattCharacteristic,
+            value: ByteArray,
+        ) {
+            if (characteristic.uuid == NUS_RX_CHAR_UUID) {
+                Log.d(NUS_TAG, "NUS RX ${value.size}B from ${gatt.device.address}")
+                module.nativeNusReceive(value)
+            }
+        }
+    }
+}

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

@@ -207,6 +207,7 @@ export default function HomeScreen() {
 
   const [unpairedRNodes, setUnpairedRNodes] = useState(0);
   const [liveBleCount, setLiveBleCount] = useState(0);
+  const [storedMsgs, setStoredMsgs] = useState<any[]>([]);
 
   // 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
@@ -218,20 +219,13 @@ export default function HomeScreen() {
     (async () => {
       try {
         const raw = await SecureStore.getItemAsync(IDENTITY_KEY);
-        // TODO(sentinel): remove debug logs before merge — lengths/booleans only, no key material
-        console.log('[persist] hydrate', { hasRaw: !!raw, rawLen: raw?.length ?? 0 });
         if (cancelled) return;
         if (raw) {
           const parsed = JSON.parse(raw);
-          const valid = isValidIdentity(parsed);
-          console.log('[persist] parsed', { valid, hasIdHex: typeof parsed?.identity_hex === 'string', hasAddrHex: typeof parsed?.address_hex === 'string' });
-          if (valid) {
-            setStoredIdentity(parsed);
-          }
+          if (isValidIdentity(parsed)) setStoredIdentity(parsed);
         }
-      } catch (e: any) {
-        console.log('[persist] hydrate FAIL', e?.message ?? 'unknown');
-        // Corrupt blob or storage error — fall through; we'll generate fresh.
+      } catch {
+        // Corrupt blob or storage error — fall through; generate fresh identity.
       } finally {
         if (!cancelled) setIdentityHydrated(true);
       }
@@ -240,31 +234,23 @@ export default function HomeScreen() {
   }, []);
 
   const {
-    isNativeAvailable, isRunning, status, error, events, beacons,
-    start, stop, send, getStatus, getIdentityHex,
-    startBLE, stopBLE, bleUnpairedRNodeCount,
+    isNativeAvailable, isRunning, status, error, events,
+    start, stop, send, broadcast, getStatus, getIdentityHex, fetchMessages,
+    bleUnpairedRNodeCount,
   } = useLxmf({
     identityHex: storedIdentity?.identity_hex ?? 'new',
     lxmfAddressHex: storedIdentity?.address_hex ?? 'new',
     logLevel: 3,
   });
 
-  // Persist identity after node starts successfully (only if not already stored,
-  // or if the running identity differs — defensive against schema migrations).
+  // Persist identity after node starts (only when identity changes from stored copy).
   useEffect(() => {
     if (!isRunning) return;
     const idHex = getIdentityHex();
     const addrHex = status?.addressHex;
-    // TODO(sentinel): remove debug logs before merge — lengths/booleans only, no key material
-    console.log('[persist] save check', {
-      idHexLen: idHex?.length ?? 0,
-      addrHexLen: addrHex?.length ?? 0,
-      alreadyStoredSame: storedIdentity?.identity_hex === idHex && storedIdentity?.address_hex === addrHex,
-    });
     if (!idHex || idHex.length !== 128) return;
     if (!addrHex || !/^[0-9a-fA-F]{32}$/.test(addrHex)) return;
     if (storedIdentity?.identity_hex === idHex && storedIdentity?.address_hex === addrHex) return;
-
     const blob: StoredIdentity = {
       version: IDENTITY_SCHEMA_VERSION,
       identity_hex: idHex,
@@ -272,16 +258,15 @@ export default function HomeScreen() {
       created_at: new Date().toISOString(),
     };
     SecureStore.setItemAsync(IDENTITY_KEY, JSON.stringify(blob))
-      .then(() => {
-        console.log('[persist] save OK');
-        setStoredIdentity(blob);
-      })
-      .catch((e: any) => {
-        console.log('[persist] save FAIL', e?.message ?? 'unknown');
-        /* persistence failure is non-fatal for the running session */
-      });
+      .then(() => setStoredIdentity(blob))
+      .catch(() => { /* non-fatal */ });
   }, [isRunning, status?.addressHex, storedIdentity, getIdentityHex]);
 
+  // Load persisted messages from SQLite whenever node starts.
+  useEffect(() => {
+    if (isRunning) setStoredMsgs(fetchMessages(50));
+  }, [isRunning, fetchMessages]);
+
   // ── Derived ───────────────────────────────────────────────────────────────
 
   const counts = useMemo(() => {
@@ -326,21 +311,18 @@ export default function HomeScreen() {
       mode: LxmfNodeMode.ReticulumAndBle,
       tcpInterfaces: [{ host, port }],
       displayName: displayName.trim() || 'lxmf-mobile',
-      isBeacon,
     });
     if (ok) {
       setTcpActive(true);
-      startBLE();
       setBleActive(true);
     }
-  }, [tcpHost, tcpPort, displayName, isBeacon, start, startBLE]);
+  }, [tcpHost, tcpPort, displayName, start]);
 
   const onStopTcp = useCallback(async () => {
-    stopBLE();
     await stop();
     setTcpActive(false);
     setBleActive(false);
-  }, [stop, stopBLE]);
+  }, [stop]);
 
   const onStartBle = useCallback(async () => {
     setTransportMsg('');
@@ -353,43 +335,31 @@ export default function HomeScreen() {
           ]
         : [PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION];
       const results = await PermissionsAndroid.requestMultiple(perms);
-      const denied = Object.values(results).some(r => r !== PermissionsAndroid.RESULTS.GRANTED);
-      if (denied) {
+      if (Object.values(results).some(r => r !== PermissionsAndroid.RESULTS.GRANTED)) {
         setTransportMsg('BLE permissions denied.');
         return;
       }
     }
-    // If node already running (started via TCP), just enable BLE hardware.
-    // Otherwise start mode 4 (TCP+BLE) using the configured TCP host/port.
-    if (!isRunning) {
-      const host = tcpHost.trim();
-      const port = Number(tcpPort);
-      if (!host) { setTransportMsg('Host required for TCP+BLE mode.'); return; }
-      if (!Number.isInteger(port) || port < 1 || port > 65535) { setTransportMsg('Port 1–65535.'); return; }
-      const ok = await start({
-        mode: LxmfNodeMode.ReticulumAndBle,
-        tcpInterfaces: [{ host, port }],
-        displayName: displayName.trim() || 'lxmf-mobile',
-        isBeacon,
-      });
-      if (!ok) {
-        setTransportMsg('Failed to start node.');
-        return;
-      }
-      setTcpActive(true);
-    }
-    startBLE();
+    const ok = await start({
+      mode: LxmfNodeMode.BleOnly,
+      displayName: displayName.trim() || 'lxmf-mobile',
+    });
+    if (!ok) { setTransportMsg('Failed to start BLE node.'); return; }
     setBleActive(true);
-  }, [isRunning, tcpHost, tcpPort, isBeacon, start, startBLE, displayName]);
+  }, [start, displayName]);
 
   const onStopBle = useCallback(async () => {
-    stopBLE();
+    await stop();
     setBleActive(false);
     setUnpairedRNodes(0);
-    if (isRunning) {
-      await stop();
-    }
-  }, [stopBLE, stop, isRunning]);
+  }, [stop]);
+
+  const onBroadcast = useCallback(async () => {
+    if (!knownPeerHashes.length) { setSendResult('No known peers.'); return; }
+    const dests = knownPeerHashes.map(p => p.hash);
+    const r = await broadcast(dests, utf8ToBase64(msgText));
+    setSendResult(r >= 0 ? `Broadcast #${r} → ${dests.length} peers` : 'Broadcast failed.');
+  }, [knownPeerHashes, msgText, broadcast]);
 
   // Poll for unpaired RNodes while BLE is active
   useEffect(() => {
@@ -617,13 +587,51 @@ export default function HomeScreen() {
         />
         <View style={S.btnRow}>
           <Btn label="Send" onPress={onSend} disabled={!isRunning} />
+          <Btn label="Broadcast" onPress={onBroadcast} disabled={!isRunning || !knownPeerHashes.length} />
         </View>
         {sendResult ? <Text style={S.feedback}>{sendResult}</Text> : null}
       </Accordion>
 
       {/* ── Messages ─────────────────────────────────────────────────────── */}
-      <Accordion title="Messages" badge={counts.messages} defaultOpen>
-        {msgEvts.length === 0 ? (
+      <Accordion title="Messages" badge={counts.messages + storedMsgs.length} defaultOpen>
+        {/* Persisted (SQLite) */}
+        {storedMsgs.length > 0 && (
+          <>
+            <Text style={S.sectionLabel}>Persisted ({storedMsgs.length})</Text>
+            {storedMsgs.map((m: any, i: number) => {
+              const bodyText = base64ToUtf8(m.body ?? '');
+              const titleText = m.title ? base64ToUtf8(m.title) : '';
+              const sender = m.source ?? m.source_hash ?? '';
+              const t = m.timestamp ? new Date(m.timestamp > 10_000_000_000 ? m.timestamp : m.timestamp * 1000).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) : '';
+              return (
+                <View key={`stored-${i}-${sender}`} style={[S.itemCard, S.storedCard]}>
+                  <View style={S.announceHeader}>
+                    <View style={S.announceInfo}>
+                      <Text selectable style={S.itemTitle}>From: {shortHex(sender)}</Text>
+                      {titleText ? <Text selectable style={S.msgTitle}>{titleText}</Text> : null}
+                      {bodyText ? <Text selectable style={S.itemBody}>{bodyText}</Text> : null}
+                      {t ? <Text style={S.itemMeta}>{t}</Text> : null}
+                    </View>
+                    {sender ? (
+                      <View style={S.announceActions}>
+                        <Pressable style={S.copyBtn} onPress={() => copyToClipboard(sender)}>
+                          <Text style={S.copyBtnText}>⎘</Text>
+                        </Pressable>
+                        <Pressable style={S.sendToBtn} onPress={() => { setDest(sender); setSendResult(''); }}>
+                          <Text style={S.sendToBtnText}>↩ Reply</Text>
+                        </Pressable>
+                      </View>
+                    ) : null}
+                  </View>
+                </View>
+              );
+            })}
+          </>
+        )}
+
+        {/* Live (in-session) */}
+        {msgEvts.length > 0 && <Text style={S.sectionLabel}>Live session</Text>}
+        {msgEvts.length === 0 && storedMsgs.length === 0 ? (
           <Text style={S.muted}>No messages yet.</Text>
         ) : (
           msgEvts.map((e, i) => {
@@ -885,4 +893,6 @@ const S = StyleSheet.create({
   // Message card extras
   msgTitle: { color: C.text, fontSize: 13, fontWeight: '600', fontStyle: 'italic' },
   mediaBadge: { color: C.accentBright, fontSize: 11, fontFamily: 'monospace', marginTop: 2 },
+  sectionLabel: { color: C.textDim, fontSize: 11, fontWeight: '600', textTransform: 'uppercase', letterSpacing: 0.8, marginTop: 4 },
+  storedCard: { borderColor: '#253d50', backgroundColor: '#0b1a25' },
 });

package/package.json

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