@magicred-1/react-native-lxmf 0.2.41 → 0.2.43

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

@@ -33,6 +33,10 @@ class LxmfModule : Module() {
       "onMessageReceived",
       "onAnnounceReceived",
       "onStatusChanged",
+      "onRpcResponse",
+      "onMessageQueued",
+      "onMessageDelivered",
+      "onMessageFailed",
       "onLog",
       "onError",
       "onOutgoingPacket"
@@ -127,6 +131,11 @@ class LxmfModule : Module() {
       nativeFetchMessages(limit)
     }
 
+    // Beacon RPC
+    AsyncFunction("beaconRpc") { destHashHex: String, method: String, paramsJson: String? ->
+      nativeBeaconRpc(destHashHex, method, paramsJson).toDouble()
+    }
+
     // Configuration
     Function("setLogLevel") { level: Int ->
       nativeSetLogLevel(level) == 0
@@ -158,6 +167,14 @@ class LxmfModule : Module() {
     Function("bleUnpairedRNodeCount") {
       nusManager?.unpairedRNodeCount() ?: 0
     }
+
+    Function("getNusUnpairedRNodes") {
+      nusManager?.unpairedRNodesJson() ?: "[]"
+    }
+
+    Function("pairNusRNode") { mac: String ->
+      nusManager?.pairRNode(mac) ?: false
+    }
   }
 
   private fun drainAndEmitEvents() {
@@ -183,6 +200,10 @@ class LxmfModule : Module() {
           "packetReceived"   -> "onPacketReceived"
           "txReceived"       -> "onTxReceived"
           "beaconDiscovered" -> "onBeaconDiscovered"
+          "rpcResponse"      -> "onRpcResponse"
+          "messageQueued"    -> "onMessageQueued"
+          "messageDelivered" -> "onMessageDelivered"
+          "messageFailed"    -> "onMessageFailed"
           "log"              -> "onLog"
           "error"            -> "onError"
           else               -> null
@@ -222,6 +243,7 @@ class LxmfModule : Module() {
   private external fun nativeGetStatus(): String?
   private external fun nativeGetBeacons(): String?
   private external fun nativeFetchMessages(limit: Int): String?
+  private external fun nativeBeaconRpc(destHashHex: String, method: String, paramsJson: String?): Long
   private external fun nativeSetLogLevel(level: Int): Int
   private external fun nativeAbiVersion(): Int
 

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

@@ -2,12 +2,17 @@ package expo.modules.lxmf
 
 import android.bluetooth.*
 import android.bluetooth.le.*
+import android.content.BroadcastReceiver
 import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
 import android.os.Build
 import android.os.Handler
 import android.os.Looper
 import android.os.ParcelUuid
 import android.util.Log
+import org.json.JSONArray
+import org.json.JSONObject
 import java.util.UUID
 
 private const val NUS_TAG = "LxmfNus"
@@ -43,8 +48,8 @@ class NusManager(
     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>()
+    // Devices found in scan but not OS-paired — keyed by MAC for O(1) lookup
+    private val discoveredUnpaired = mutableMapOf<String, BluetoothDevice>()
     // MACs currently attempting connection
     private val connecting = mutableSetOf<String>()
 
@@ -58,17 +63,49 @@ class NusManager(
         private const val DEFAULT_WRITE_MTU = 20  // conservative BLE default
     }
 
+    // ── Bond state receiver ───────────────────────────────────────────────────
+
+    private val bondReceiver = object : BroadcastReceiver() {
+        override fun onReceive(ctx: Context, intent: Intent) {
+            if (intent.action != BluetoothDevice.ACTION_BOND_STATE_CHANGED) return
+            val device: BluetoothDevice? = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE, BluetoothDevice::class.java)
+            } else {
+                @Suppress("DEPRECATION")
+                intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
+            }
+            val mac = device?.address ?: return
+            val bondState = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE, BluetoothDevice.BOND_NONE)
+            if (bondState == BluetoothDevice.BOND_BONDED) {
+                Log.i(NUS_TAG, "NUS: $mac bonded — connecting")
+                discoveredUnpaired.remove(mac)
+                if (isRunning && mac !in connections && mac !in connecting) {
+                    connecting.add(mac)
+                    device.connectGatt(context, false, gattCallback, BluetoothDevice.TRANSPORT_LE)
+                }
+            }
+        }
+    }
+
     // ── Lifecycle ────────────────────────────────────────────────────────────
 
     fun start() {
         if (isRunning) return
         isRunning = true
+        val filter = IntentFilter(BluetoothDevice.ACTION_BOND_STATE_CHANGED)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            context.registerReceiver(bondReceiver, filter, Context.RECEIVER_NOT_EXPORTED)
+        } else {
+            @Suppress("UnspecifiedRegisterReceiverFlag")
+            context.registerReceiver(bondReceiver, filter)
+        }
         startScanning()
         Log.i(NUS_TAG, "NusManager started")
     }
 
     fun stop() {
         isRunning = false
+        try { context.unregisterReceiver(bondReceiver) } catch (_: Exception) {}
         stopScanning()
         connections.values.forEach { it.disconnect(); it.close() }
         connections.clear()
@@ -79,9 +116,41 @@ class NusManager(
         Log.i(NUS_TAG, "NusManager stopped")
     }
 
-    /** Number of RNodes visible in scan but not yet OS-paired (mirrors iOS discoveredUnpairedRNodes.count). */
+    /** Number of RNodes visible in scan but not yet OS-paired. */
     fun unpairedRNodeCount(): Int = discoveredUnpaired.size
 
+    /** JSON array of unpaired RNodes: [{"mac":"AA:BB:...","name":"RNode_1234"},...] */
+    fun unpairedRNodesJson(): String {
+        val arr = JSONArray()
+        discoveredUnpaired.values.forEach { device ->
+            arr.put(JSONObject().apply {
+                put("mac", device.address)
+                put("name", device.name ?: "")
+            })
+        }
+        return arr.toString()
+    }
+
+    /**
+     * Initiate OS pairing with an unpaired RNode. Shows system Bluetooth pairing dialog.
+     * Returns true if bond initiation succeeded (or device is already bonded and connecting).
+     * Requires BLUETOOTH_CONNECT permission (API 31+).
+     */
+    fun pairRNode(mac: String): Boolean {
+        val device = discoveredUnpaired[mac]
+            ?: try { adapter?.getRemoteDevice(mac) } catch (_: Exception) { null }
+            ?: return false
+        return if (device.bondState == BluetoothDevice.BOND_BONDED) {
+            if (mac !in connections && mac !in connecting) {
+                connecting.add(mac)
+                device.connectGatt(context, false, gattCallback, BluetoothDevice.TRANSPORT_LE)
+            }
+            true
+        } else {
+            device.createBond()
+        }
+    }
+
     /** Number of fully connected and ready RNodes. */
     fun connectedRNodeCount(): Int = connections.size
 
@@ -106,15 +175,27 @@ class NusManager(
         data: ByteArray,
         mtu: Int,
     ) {
+        // Android GATT is single-op — only one writeCharacteristic in flight at a time.
+        // For NUS, packets are bounded by NusInterface.mtu (244 B) so KISS frames fit in
+        // one ATT PDU after MTU negotiation (514 B). The loop is a safety net only.
         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)
+            val ok = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                gatt.writeCharacteristic(char, chunk, BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE) ==
+                    BluetoothGatt.GATT_SUCCESS
+            } else {
+                @Suppress("DEPRECATION")
+                char.value = chunk
+                char.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
+                @Suppress("DEPRECATION")
+                gatt.writeCharacteristic(char)
+            }
+            if (!ok) {
+                Log.w(NUS_TAG, "NUS TX write rejected at offset $offset — ${data.size - offset}B dropped")
+                return
+            }
             offset = end
         }
     }
@@ -157,9 +238,9 @@ class NusManager(
                     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")
+                    // Not paired — track for UI; call pairRNode(mac) to initiate pairing
+                    if (discoveredUnpaired.put(mac, device) == null) {
+                        Log.i(NUS_TAG, "NUS: found unpaired RNode $mac (${device.name ?: "?"}) — call pairRNode()")
                     }
                 }
             }
@@ -252,6 +333,18 @@ class NusManager(
             Log.i(NUS_TAG, "NUS RNode ready: $mac (tx=${txChar != null}, rx=${rxChar != null})")
         }
 
+        override fun onDescriptorWrite(gatt: BluetoothGatt, descriptor: BluetoothGattDescriptor, status: Int) {
+            val mac = gatt.device.address
+            if (descriptor.uuid == CCCD_UUID) {
+                if (status == BluetoothGatt.GATT_SUCCESS) {
+                    Log.i(NUS_TAG, "NUS RX notifications enabled: $mac — RNode ready")
+                } else {
+                    Log.e(NUS_TAG, "NUS CCCD write failed ($status) on $mac — RX notifications NOT enabled, disconnecting")
+                    gatt.disconnect()
+                }
+            }
+        }
+
         // API < 33 compat override
         @Suppress("OVERRIDE_DEPRECATION")
         override fun onCharacteristicChanged(

package/build/LxmfModule.d.ts

@@ -12,12 +12,15 @@ export type NativeModuleType = {
     getStatus(): string | null;
     getBeacons(): string | null;
     fetchMessages(limit: number): string | null;
+    beaconRpc(destHashHex: string, method: string, paramsJson?: string | null): Promise<number>;
     setLogLevel(level: number): boolean;
     abiVersion(): number;
     startBLE(): boolean;
     stopBLE(): boolean;
     blePeerCount(): number;
     bleUnpairedRNodeCount(): number;
+    getNusUnpairedRNodes(): string;
+    pairNusRNode(mac: string): boolean;
 };
 declare const LxmfModuleNative: NativeModuleType | null;
 export declare const isLxmfNativeAvailable: boolean;

package/build/LxmfModule.js

@@ -34,5 +34,8 @@ const missingNativeShim = {
     stopBLE: () => throwMissingNative(),
     blePeerCount: () => throwMissingNative(),
     bleUnpairedRNodeCount: () => throwMissingNative(),
+    beaconRpc: async () => throwMissingNative(),
+    getNusUnpairedRNodes: () => throwMissingNative(),
+    pairNusRNode: () => throwMissingNative(),
 };
 exports.LxmfModule = LxmfModuleNative ?? missingNativeShim;

package/build/useLxmf.d.ts

@@ -33,8 +33,14 @@ export interface LxmfMessageEvent {
         data: string;
     }[];
 }
+export interface RpcResponseEvent {
+    id: number;
+    method: string;
+    resultJson: string;
+    isError: boolean;
+}
 export interface LxmfEvent {
-    type: 'statusChanged' | 'packetReceived' | 'txReceived' | 'beaconDiscovered' | 'messageReceived' | 'announceReceived' | 'messageQueued' | 'messageDelivered' | 'messageFailed' | 'log' | 'error';
+    type: 'statusChanged' | 'packetReceived' | 'txReceived' | 'beaconDiscovered' | 'messageReceived' | 'announceReceived' | 'messageQueued' | 'messageDelivered' | 'messageFailed' | 'log' | 'error' | 'rpcResponse';
     [key: string]: any;
 }
 /** Node transport mode */
@@ -115,4 +121,10 @@ export declare function useLxmf(options?: UseLxmfOptions): {
     startBLE: () => void;
     stopBLE: () => void;
     bleUnpairedRNodeCount: () => number;
+    getNusUnpairedRNodes: () => {
+        mac: string;
+        name: string;
+    }[];
+    pairNusRNode: (mac: string) => boolean;
+    beaconRpc: (destHashHex: string, method: string, params?: unknown) => Promise<number>;
 };

package/build/useLxmf.js

@@ -109,6 +109,19 @@ function useLxmf(options = {}) {
                 pushEvent('error', event);
                 setError(`${String(event.code)}: ${String(event.message)}`);
             }),
+            mod.addListener('onRpcResponse', (event) => {
+                pushEvent('rpcResponse', event);
+            }),
+            mod.addListener('onMessageQueued', (event) => {
+                pushEvent('messageQueued', event);
+            }),
+            mod.addListener('onMessageDelivered', (event) => {
+                pushEvent('messageDelivered', event);
+            }),
+            mod.addListener('onMessageFailed', (event) => {
+                pushEvent('messageFailed', event);
+                setError(`Message ${String(event.seq)} failed: ${String(event.reason ?? 'unknown')}`);
+            }),
         ];
         return () => {
             subscriptions.forEach((sub) => sub.remove());
@@ -253,6 +266,37 @@ function useLxmf(options = {}) {
     const bleUnpairedRNodeCount = (0, react_1.useCallback)(() => {
         return LxmfModule_1.LxmfModule.bleUnpairedRNodeCount();
     }, []);
+    /** List of RNodes visible in scan but not yet OS-paired. */
+    const getNusUnpairedRNodes = (0, react_1.useCallback)(() => {
+        try {
+            return parseJson(LxmfModule_1.LxmfModule.getNusUnpairedRNodes(), []);
+        }
+        catch {
+            return [];
+        }
+    }, []);
+    /**
+     * Initiate OS Bluetooth pairing with an unpaired RNode (mac = "AA:BB:CC:DD:EE:FF").
+     * Shows system pairing dialog. Auto-connects on bond completion via bondReceiver.
+     */
+    const pairNusRNode = (0, react_1.useCallback)((mac) => {
+        return LxmfModule_1.LxmfModule.pairNusRNode(mac);
+    }, []);
+    /**
+     * Queue a JSON-RPC 2.0 call to a beacon.
+     * Returns correlation id; the response arrives as an `rpcResponse` event.
+     * `params` is any JSON-serializable value (usually an array).
+     */
+    const beaconRpc = (0, react_1.useCallback)(async (destHashHex, method, params) => {
+        try {
+            const paramsJson = params === undefined ? null : JSON.stringify(params);
+            return await LxmfModule_1.LxmfModule.beaconRpc(destHashHex, method, paramsJson);
+        }
+        catch (e) {
+            setError(e?.message ?? 'beaconRpc failed');
+            return -1;
+        }
+    }, []);
     return {
         // State
         status,
@@ -274,5 +318,8 @@ function useLxmf(options = {}) {
         startBLE,
         stopBLE,
         bleUnpairedRNodeCount,
+        getNusUnpairedRNodes,
+        pairNusRNode,
+        beaconRpc,
     };
 }

package/ios/BLEManager.swift

@@ -235,6 +235,31 @@ class BLEManager: NSObject {
         return !nusPeripherals.isEmpty
     }
 
+    /// JSON array of discovered-but-not-yet-bonded RNodes.
+    /// Uses CoreBluetooth UUID as "mac" (iOS hides real MACs since iOS 13).
+    func unpairedRNodesJson() -> String {
+        var entries: [[String: String]] = []
+        for (uuid, peripheral) in discoveredUnpairedRNodes {
+            entries.append(["mac": uuid.uuidString, "name": peripheral.name ?? ""])
+        }
+        guard let data = try? JSONSerialization.data(withJSONObject: entries),
+              let str = String(data: data, encoding: .utf8) else { return "[]" }
+        return str
+    }
+
+    /// Initiate connection to a discovered-but-unpaired RNode by its CoreBluetooth UUID string.
+    /// CoreBluetooth handles pairing transparently when the peripheral requires encryption.
+    /// Returns false if the UUID is unknown (device not seen in scan yet).
+    func connectRNode(_ identifierString: String) -> Bool {
+        guard let uuid = UUID(uuidString: identifierString),
+              let peripheral = discoveredUnpairedRNodes[uuid] else { return false }
+        guard connectedPeripherals[uuid] == nil else { return true }
+        connectedPeripherals[uuid] = peripheral
+        peripheral.delegate = self
+        centralManager?.connect(peripheral, options: nil)
+        return true
+    }
+
     /// Derive a 6-byte pseudo-MAC from a CoreBluetooth UUID.
     /// XOR-folds the 16-byte UUID into 6 bytes for stable peer identification.
     static func uuidToAddr(_ uuid: UUID) -> Data {

package/ios/LxmfModule.swift

@@ -134,6 +134,15 @@ func lxmf_nus_poll_tx(
     _ outCapacity: Int
 ) -> Int32
 
+// --- Beacon RPC FFI ---
+
+@_silgen_name("lxmf_beacon_rpc")
+func lxmf_beacon_rpc(
+    _ destHashHex: UnsafePointer<CChar>?,
+    _ method: UnsafePointer<CChar>?,
+    _ paramsJson: UnsafePointer<CChar>?
+) -> Int64
+
 
 public class LxmfModule: Module {
     // Shared JSON buffer for FFI calls (64KB)
@@ -161,6 +170,10 @@ public class LxmfModule: Module {
             "onMessageReceived",
             "onAnnounceReceived",
             "onStatusChanged",
+            "onRpcResponse",
+            "onMessageQueued",
+            "onMessageDelivered",
+            "onMessageFailed",
             "onLog",
             "onError",
             "onOutgoingPacket"
@@ -340,6 +353,34 @@ public class LxmfModule: Module {
         Function("bleUnpairedRNodeCount") { () -> Int in
             return self.bleManager.discoveredUnpairedRNodes.count
         }
+
+        // --- Beacon RPC ---
+
+        AsyncFunction("beaconRpc") { (destHashHex: String, method: String, paramsJson: String?) -> Double in
+            let id = destHashHex.withCString { destPtr in
+                method.withCString { methodPtr in
+                    if let p = paramsJson {
+                        return p.withCString { paramsPtr in
+                            lxmf_beacon_rpc(destPtr, methodPtr, paramsPtr)
+                        }
+                    }
+                    return lxmf_beacon_rpc(destPtr, methodPtr, nil)
+                }
+            }
+            return Double(id)
+        }
+
+        // --- RNode pairing (NUS) ---
+
+        Function("getNusUnpairedRNodes") { () -> String in
+            return self.bleManager.unpairedRNodesJson()
+        }
+
+        // On iOS, "pairing" = connect (CoreBluetooth handles encryption/bonding transparently).
+        // The identifier is a CoreBluetooth UUID string, not a MAC (iOS hides MACs since iOS 13).
+        Function("pairNusRNode") { (identifier: String) -> Bool in
+            return self.bleManager.connectRNode(identifier)
+        }
     }
 
     // MARK: - Polling
@@ -397,6 +438,14 @@ public class LxmfModule: Module {
                 sendEvent("onMessageReceived", event)
             case "announceReceived":
                 sendEvent("onAnnounceReceived", event)
+            case "rpcResponse":
+                sendEvent("onRpcResponse", event)
+            case "messageQueued":
+                sendEvent("onMessageQueued", event)
+            case "messageDelivered":
+                sendEvent("onMessageDelivered", event)
+            case "messageFailed":
+                sendEvent("onMessageFailed", event)
             case "log":
                 sendEvent("onLog", event)
             case "error":

package/package.json

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