@magicred-1/react-native-lxmf 0.2.29 → 0.2.31

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

@@ -8,19 +8,20 @@ import expo.modules.kotlin.modules.ModuleDefinition
 import org.json.JSONArray
 
 private const val TAG = "LxmfModule"
-private const val POLL_INTERVAL_MS = 500L
+private const val POLL_INTERVAL_MS = 80L
 
 class LxmfModule : Module() {
   private val pollHandler = Handler(Looper.getMainLooper())
   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
@@ -78,10 +82,14 @@ class LxmfModule : Module() {
       val rc = nativeStart(identityHex, lxmfAddressHex, mode, announceIntervalMs.toLong(),
                   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
@@ -132,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
     }
 
@@ -146,7 +156,7 @@ class LxmfModule : Module() {
     }
 
     Function("bleUnpairedRNodeCount") {
-      bleManager?.unpairedRNodeCount() ?: 0
+      nusManager?.unpairedRNodeCount() ?: 0
     }
   }
 
@@ -215,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/ios/RustCore/liblxmf_rn.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>liblxmf_rn.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>liblxmf_rn.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>liblxmf_rn.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>liblxmf_rn.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/package.json

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