@magicred-1/react-native-lxmf 0.1.0

package/LxmfReactNative.podspec

@@ -0,0 +1,25 @@
+Pod::Spec.new do |s|
+  s.name           = 'LxmfReactNative'
+  s.version        = '0.1.0'
+  s.summary        = 'LXMF Reticulum mesh networking for React Native'
+  s.homepage       = 'https://github.com/anon0mesh/lxmf_react_native_rust'
+  s.license        = { type: 'MIT' }
+  s.author         = { 'anon0mesh' => 'anon0mesh@example.com' }
+  s.source         = { git: 'https://github.com/anon0mesh/lxmf_react_native_rust.git' }
+
+  s.platform       = :ios, '13.0'
+  s.requires_arc   = true
+  s.swift_version  = '5.5'
+
+  s.source_files   = 'ios/**/*.swift'
+  s.public_header_files = 'ios/**/*.h'
+
+  # Link the Rust static library (XCFramework built by scripts/build-rust-ios.sh)
+  s.vendored_frameworks = 'ios/RustCore/liblxmf_rn.xcframework'
+  s.libraries      = 'c++'
+
+  s.dependency 'ExpoModulesCore'
+
+  # BLE framework
+  s.frameworks = 'CoreBluetooth', 'Foundation'
+end

package/README.md

@@ -0,0 +1,57 @@
+# @magicred-1/react-native-lxmf
+
+LXMF Reticulum mesh networking module for React Native + Expo.
+
+## Install
+
+```bash
+npm install @magicred-1/react-native-lxmf
+```
+
+## Usage
+
+```ts
+import { useLxmf, LxmfNodeMode } from '@magicred-1/react-native-lxmf';
+
+const lxmf = useLxmf({
+  identityHex: 'new',
+  lxmfAddressHex: 'new',
+  mode: LxmfNodeMode.BleOnly,
+});
+```
+
+## Package Contents
+
+Published package includes:
+
+- `build/` JavaScript + TypeScript declarations
+- `android/` native Android module sources and JNI library artifacts
+- `ios/` native iOS Swift sources
+- `LxmfReactNative.podspec`
+- Expo plugin files (`app.plugin.js`, `expo-module.config.json`)
+
+## Build
+
+```bash
+npm run build
+```
+
+## Verify Package
+
+```bash
+npm run pack:check
+```
+
+## Publish
+
+```bash
+npm publish
+```
+
+## Important Native Note
+
+The iOS podspec currently references a Rust static library outside the package directory:
+
+- `../../rust-core/target/release/liblxmf_rn.a`
+
+For public npm distribution, this static library must be bundled into the package (or built during pod install), otherwise iOS consumers will fail to link.

package/android/build.gradle.kts

@@ -0,0 +1,33 @@
+plugins {
+    id("com.android.library")
+    id("expo-module-gradle-plugin")
+}
+
+android {
+    namespace = "expo.modules.lxmf"
+    compileSdk = 36
+
+    defaultConfig {
+        minSdk = 24
+        versionCode = 1
+        versionName = "1.0.0"
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+
+    kotlinOptions {
+        jvmTarget = "11"
+    }
+
+    sourceSets {
+        getByName("main").java.srcDirs("src/main/kotlin")
+    }
+}
+
+dependencies {
+    compileOnly(project(":expo-modules-core"))
+}
+

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

@@ -0,0 +1,282 @@
+package expo.modules.lxmf
+
+import android.bluetooth.*
+import android.bluetooth.le.*
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.os.ParcelUuid
+import android.util.Log
+import java.util.UUID
+
+private const val TAG = "LxmfBle"
+
+// UUIDs must match ble_iface.rs constants exactly
+val RNS_SERVICE_UUID: UUID = UUID.fromString("5f3bafcd-2bb7-4de0-9c6f-2c5f88b6b8f2")
+val RNS_RX_CHAR_UUID: UUID = UUID.fromString("3b28e4f6-5a30-4a5f-b700-68bb74d1b036")
+val RNS_TX_CHAR_UUID: UUID = UUID.fromString("8b6ded1a-ea65-4a1e-a1f0-5cf69d5dc2ad")
+
+// GATT descriptor for enabling notifications
+val CCCD_UUID: UUID = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb")
+
+/**
+ * BleManager — owns all Android BLE hardware access for the LXMF BLE interface.
+ *
+ * Responsibilities:
+ *   - Scan for Reticulum BLE peers (service UUID filter)
+ *   - Advertise our service UUID so peers can find us
+ *   - Connect to discovered peers via GATT
+ *   - Enable notifications on the RX characteristic
+ *   - Pass received bytes to Rust via nativeBleReceive()
+ *   - Poll nativeBlePollTx() and write results to TX characteristic
+ *   - Notify Rust of connect/disconnect events
+ *
+ * Rust handles: HDLC framing, segmentation, Reticulum packet routing.
+ */
+class BleManager(
+    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 keyed by MAC address string
+    private val connections = mutableMapOf<String, BluetoothGatt>()
+    // MACs we are currently trying to connect (avoid duplicate attempts)
+    private val connecting = mutableSetOf<String>()
+    // Timestamp (ms) when each MAC last disconnected — enforces reconnect cooldown
+    private val disconnectedAt = mutableMapOf<String, Long>()
+
+    private var scanner: BluetoothLeScanner? = null
+    private var advertiser: BluetoothLeAdvertiser? = null
+    private var isScanning = false
+    private var isAdvertising = false
+
+    // TX polling — every 50 ms drain the Rust TX queue and write to peers
+    private val txPollRunnable = object : Runnable {
+        override fun run() {
+            drainTxQueue()
+            mainHandler.postDelayed(this, TX_POLL_INTERVAL_MS)
+        }
+    }
+
+    companion object {
+        private const val TX_POLL_INTERVAL_MS = 50L
+        private const val SCAN_RESTART_DELAY_MS = 30_000L
+        /** How long to wait before reconnecting to a peer that just disconnected. */
+        private const val RECONNECT_COOLDOWN_MS = 15_000L
+    }
+
+    // ── Lifecycle ────────────────────────────────────────────────────────────
+
+    fun start() {
+        if (adapter == null || !adapter!!.isEnabled) {
+            Log.w(TAG, "Bluetooth not available or not enabled")
+            return
+        }
+        startAdvertising()
+        startScanning()
+        mainHandler.postDelayed(txPollRunnable, TX_POLL_INTERVAL_MS)
+        Log.i(TAG, "BleManager started")
+    }
+
+    fun stop() {
+        stopScanning()
+        stopAdvertising()
+        mainHandler.removeCallbacks(txPollRunnable)
+        connections.values.forEach { it.disconnect(); it.close() }
+        connections.clear()
+        connecting.clear()
+        Log.i(TAG, "BleManager stopped")
+    }
+
+    fun connectedPeerCount(): Int = module.nativeBlePeerCount()
+
+    // ── Advertising (so peers can find us) ───────────────────────────────────
+
+    private fun startAdvertising() {
+        advertiser = adapter?.bluetoothLeAdvertiser ?: return
+        val settings = AdvertiseSettings.Builder()
+            .setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_BALANCED)
+            .setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_MEDIUM)
+            .setConnectable(true)
+            .build()
+        val data = AdvertiseData.Builder()
+            .addServiceUuid(ParcelUuid(RNS_SERVICE_UUID))
+            .setIncludeDeviceName(false)
+            .build()
+        advertiser?.startAdvertising(settings, data, advertiseCallback)
+        isAdvertising = true
+        Log.d(TAG, "BLE advertising started")
+    }
+
+    private fun stopAdvertising() {
+        if (isAdvertising) {
+            advertiser?.stopAdvertising(advertiseCallback)
+            isAdvertising = false
+        }
+    }
+
+    private val advertiseCallback = object : AdvertiseCallback() {
+        override fun onStartSuccess(settingsInEffect: AdvertiseSettings?) {
+            Log.i(TAG, "BLE advertise started")
+        }
+        override fun onStartFailure(errorCode: Int) {
+            Log.e(TAG, "BLE advertise failed: $errorCode")
+        }
+    }
+
+    // ── Scanning (find peers) ─────────────────────────────────────────────────
+
+    private fun startScanning() {
+        if (isScanning) return
+        scanner = adapter?.bluetoothLeScanner ?: return
+        val filter = ScanFilter.Builder()
+            .setServiceUuid(ParcelUuid(RNS_SERVICE_UUID))
+            .build()
+        val settings = ScanSettings.Builder()
+            .setScanMode(ScanSettings.SCAN_MODE_BALANCED)
+            .build()
+        scanner?.startScan(listOf(filter), settings, scanCallback)
+        isScanning = true
+        Log.d(TAG, "BLE 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
+            val lastDisconnect = disconnectedAt[mac] ?: 0L
+            if (System.currentTimeMillis() - lastDisconnect < RECONNECT_COOLDOWN_MS) return
+            Log.i(TAG, "BLE: found peer $mac, connecting")
+            connecting.add(mac)
+            device.connectGatt(context, false, gattCallback, BluetoothDevice.TRANSPORT_LE)
+        }
+        override fun onScanFailed(errorCode: Int) {
+            Log.e(TAG, "BLE scan failed: $errorCode")
+            isScanning = false
+            // Restart scan after delay
+            mainHandler.postDelayed({ startScanning() }, SCAN_RESTART_DELAY_MS)
+        }
+    }
+
+    // ── GATT callbacks ────────────────────────────────────────────────────────
+
+    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(TAG, "BLE GATT connected: $mac")
+                    connections[mac] = gatt
+                    connecting.remove(mac)
+                    gatt.discoverServices()
+                }
+                BluetoothProfile.STATE_DISCONNECTED -> {
+                    // Guard against double-fire (Android BLE can call this twice)
+                    if (mac !in connections && mac !in connecting) return
+                    Log.i(TAG, "BLE GATT disconnected: $mac (status=$status)")
+                    connections.remove(mac)
+                    connecting.remove(mac)
+                    disconnectedAt[mac] = System.currentTimeMillis()
+                    gatt.close()
+                    // Notify Rust
+                    module.nativeBleDisconnected(macToBytes(mac))
+                }
+            }
+        }
+
+        override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
+            if (status != BluetoothGatt.GATT_SUCCESS) {
+                Log.w(TAG, "Service discovery failed on ${gatt.device.address}: $status")
+                gatt.disconnect()
+                return
+            }
+            val service = gatt.getService(RNS_SERVICE_UUID)
+            if (service == null) {
+                Log.w(TAG, "RNS service not found on ${gatt.device.address}")
+                gatt.disconnect()
+                return
+            }
+            // Enable notifications on RX characteristic
+            val rxChar = service.getCharacteristic(RNS_RX_CHAR_UUID)
+            if (rxChar != null) {
+                gatt.setCharacteristicNotification(rxChar, true)
+                val cccd = rxChar.getDescriptor(CCCD_UUID)
+                cccd?.let {
+                    it.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
+                    gatt.writeDescriptor(it)
+                }
+            }
+            // Notify Rust of new peer
+            module.nativeBleConnected(macToBytes(gatt.device.address))
+            Log.i(TAG, "BLE peer ready: ${gatt.device.address}")
+        }
+
+        override fun onCharacteristicChanged(
+            gatt: BluetoothGatt,
+            characteristic: BluetoothGattCharacteristic,
+        ) {
+            if (characteristic.uuid == RNS_RX_CHAR_UUID) {
+                val data = characteristic.value ?: return
+                Log.d(TAG, "BLE RX ${data.size}B from ${gatt.device.address}")
+                module.nativeBleReceive(macToBytes(gatt.device.address), data)
+            }
+        }
+
+        override fun onCharacteristicWrite(
+            gatt: BluetoothGatt,
+            characteristic: BluetoothGattCharacteristic,
+            status: Int,
+        ) {
+            if (status != BluetoothGatt.GATT_SUCCESS) {
+                Log.w(TAG, "BLE TX write failed: $status on ${gatt.device.address}")
+            }
+        }
+    }
+
+    // ── TX drain — poll Rust and write to peer characteristics ───────────────
+
+    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"
+                val gatt = connections[mac] ?: continue
+                val service = gatt.getService(RNS_SERVICE_UUID) ?: continue
+                val txChar = service.getCharacteristic(RNS_TX_CHAR_UUID) ?: continue
+                txChar.value = data
+                txChar.writeType = BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
+                val ok = gatt.writeCharacteristic(txChar)
+                Log.d(TAG, "BLE TX ${data.size}B to $mac ok=$ok")
+            } catch (e: Exception) {
+                Log.e(TAG, "drainTxQueue parse error: ${e.message}")
+            }
+        }
+    }
+
+    // ── Helpers ───────────────────────────────────────────────────────────────
+
+    /** Convert "AA:BB:CC:DD:EE:FF" → ByteArray(6) */
+    private fun macToBytes(mac: String): ByteArray {
+        return mac.split(":").map { it.toInt(16).toByte() }.toByteArray()
+    }
+
+    /** Convert "aabbccddeeff" → "AA:BB:CC:DD:EE:FF" */
+    private fun hexToMacString(hex: String): String {
+        return hex.chunked(2).joinToString(":") { it.uppercase() }
+    }
+}

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

@@ -0,0 +1,232 @@
+package expo.modules.lxmf
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import org.json.JSONArray
+
+private const val TAG = "LxmfModule"
+private const val POLL_INTERVAL_MS = 500L
+
+class LxmfModule : Module() {
+  private val pollHandler = Handler(Looper.getMainLooper())
+  private val pollRunnable = object : Runnable {
+    override fun run() {
+      drainAndEmitEvents()
+      pollHandler.postDelayed(this, POLL_INTERVAL_MS)
+    }
+  }
+
+  // BleManager is created lazily when the app context is available
+  private var bleManager: BleManager? = null
+
+  override fun definition() = ModuleDefinition {
+    Name("LxmfModule")
+
+    Events(
+      "onPacketReceived",
+      "onTxReceived",
+      "onBeaconDiscovered",
+      "onMessageReceived",
+      "onAnnounceReceived",
+      "onStatusChanged",
+      "onLog",
+      "onError",
+      "onOutgoingPacket"
+    )
+
+    OnCreate {
+      if (isNativeLibraryLoaded()) {
+        pollHandler.postDelayed(pollRunnable, POLL_INTERVAL_MS)
+      } else {
+        Log.w(TAG, "Skipping event polling because liblxmf_rn is not loaded")
+      }
+      // Create BleManager with whatever Android context is available in this lifecycle phase
+      val ctx = appContext.reactContext?.applicationContext
+        ?: appContext.currentActivity?.applicationContext
+      if (ctx != null) {
+        bleManager = BleManager(ctx, this@LxmfModule)
+      }
+    }
+
+    OnDestroy {
+      pollHandler.removeCallbacks(pollRunnable)
+      bleManager?.stop()
+      bleManager = null
+    }
+
+    // Lifecycle
+    Function("init") { dbPath: String? ->
+      val rc = nativeInit(dbPath)
+      if (rc != 0) throw RuntimeException("nativeInit returned $rc")
+      true
+    }
+
+    AsyncFunction("start") { identityHex: String, lxmfAddressHex: String, mode: Int,
+                              announceIntervalMs: Double, bleMtuHint: Int,
+                              tcpInterfaces: List<Map<String, Any>>, displayName: String ->
+      Log.d(TAG, "start() mode=$mode interfaces=$tcpInterfaces name=$displayName")
+      val interfacesJson = org.json.JSONArray(tcpInterfaces.map { iface ->
+        org.json.JSONObject().apply {
+          put("host", iface["host"] ?: "")
+          put("port", iface["port"] ?: 0)
+        }
+      }).toString()
+      val rc = nativeStart(identityHex, lxmfAddressHex, mode, announceIntervalMs.toLong(),
+                  bleMtuHint.toShort(), interfacesJson, displayName)
+      if (rc != 0) throw RuntimeException("nativeStart returned $rc")
+      true
+    }
+
+    AsyncFunction("stop") {
+      val rc = nativeStop()
+      if (rc != 0) throw RuntimeException("nativeStop returned $rc")
+      true
+    }
+
+    Function("isRunning") {
+      nativeIsRunning()
+    }
+
+    // Messaging
+    AsyncFunction("send") { destHex: String, bodyBase64: String ->
+      nativeSend(destHex, bodyBase64).toDouble()
+    }
+
+    AsyncFunction("broadcast") { destsHex: List<String>, bodyBase64: String ->
+      val destsJson = org.json.JSONArray(destsHex).toString()
+      nativeBroadcast(destsJson, bodyBase64).toDouble()
+    }
+
+    // Status & State
+    Function("getStatus") {
+      nativeGetStatus()
+    }
+
+    Function("getBeacons") {
+      nativeGetBeacons()
+    }
+
+    Function("fetchMessages") { limit: Int ->
+      nativeFetchMessages(limit)
+    }
+
+    // Configuration
+    Function("setLogLevel") { level: Int ->
+      nativeSetLogLevel(level) == 0
+    }
+
+    Function("abiVersion") {
+      nativeAbiVersion()
+    }
+
+    // BLE Control — starts/stops BLE scan+advertise+GATT bridge to Rust
+    Function("startBLE") {
+      Log.d(TAG, "startBLE()")
+      bleManager?.start()
+      true
+    }
+
+    Function("stopBLE") {
+      Log.d(TAG, "stopBLE()")
+      bleManager?.stop()
+      true
+    }
+
+    Function("blePeerCount") {
+      nativeBlePeerCount()
+    }
+  }
+
+  private fun drainAndEmitEvents() {
+    if (!isNativeLibraryLoaded()) return
+
+    val json = try {
+      nativePollEvents()
+    } catch (e: UnsatisfiedLinkError) {
+      Log.e(TAG, "nativePollEvents unavailable: ${e.message}")
+      pollHandler.removeCallbacks(pollRunnable)
+      return
+    } ?: return
+
+    try {
+      val arr = JSONArray(json)
+      for (i in 0 until arr.length()) {
+        val obj = arr.getJSONObject(i)
+        val type = obj.optString("type")
+        val eventName = when (type) {
+          "statusChanged"    -> "onStatusChanged"
+          "announceReceived" -> "onAnnounceReceived"
+          "messageReceived"  -> "onMessageReceived"
+          "packetReceived"   -> "onPacketReceived"
+          "txReceived"       -> "onTxReceived"
+          "beaconDiscovered" -> "onBeaconDiscovered"
+          "log"              -> "onLog"
+          "error"            -> "onError"
+          else               -> null
+        } ?: continue
+
+        val params = mutableMapOf<String, Any?>()
+        val keys = obj.keys()
+        while (keys.hasNext()) {
+          val key = keys.next()
+          if (key != "type") params[key] = obj.get(key)
+        }
+        sendEvent(eventName, params)
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "drainAndEmitEvents parse error: ${e.message}")
+    }
+  }
+
+  // Native JNI method declarations — types must match Rust JNI signatures exactly
+  private external fun nativeInit(dbPath: String?): Int
+  private external fun nativeStart(
+    identityHex: String,
+    lxmfAddressHex: String,
+    mode: Int,
+    announceIntervalMs: Long,
+    bleMtuHint: Short,
+    tcpInterfacesJson: String,
+    displayName: String
+  ): Int
+  private external fun nativeStop(): Int
+  private external fun nativeIsRunning(): Boolean
+  private external fun nativePollEvents(): String?
+  private external fun nativeSend(destHex: String, bodyBase64: String): Long
+  private external fun nativeBroadcast(destsJson: String, bodyBase64: String): Long
+  private external fun nativeGetStatus(): String?
+  private external fun nativeGetBeacons(): String?
+  private external fun nativeFetchMessages(limit: Int): String?
+  private external fun nativeSetLogLevel(level: Int): Int
+  private external fun nativeAbiVersion(): Int
+
+  // 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).
+  external fun nativeBleReceive(peerAddr: ByteArray, data: ByteArray)
+  external fun nativeBlePollTx(): String?
+  external fun nativeBleConnected(peerAddr: ByteArray)
+  external fun nativeBleDisconnected(peerAddr: ByteArray)
+  external fun nativeBlePeerCount(): Int
+
+  companion object {
+    @Volatile
+    private var nativeLibraryLoaded = false
+
+    fun isNativeLibraryLoaded(): Boolean = nativeLibraryLoaded
+
+    init {
+      try {
+        System.loadLibrary("lxmf_rn")
+        nativeLibraryLoaded = true
+        Log.i(TAG, "liblxmf_rn loaded successfully")
+      } catch (e: UnsatisfiedLinkError) {
+        nativeLibraryLoaded = false
+        Log.e(TAG, "Failed to load liblxmf_rn: ${e.message}")
+      }
+    }
+  }
+}

package/app.plugin.js

@@ -0,0 +1,40 @@
+const { withInfoPlist, withAndroidManifest } = require('@expo/config-plugins');
+
+function withLxmfPermissions(config) {
+  // Android BLE permissions
+  config = withAndroidManifest(config, (c) => {
+    const manifest = c.modResults.manifest;
+    const permissions = manifest['uses-permission'] || [];
+    const blePermissions = [
+      'android.permission.BLUETOOTH',
+      'android.permission.BLUETOOTH_ADMIN',
+      'android.permission.BLUETOOTH_SCAN',
+      'android.permission.BLUETOOTH_CONNECT',
+      'android.permission.BLUETOOTH_ADVERTISE',
+      'android.permission.ACCESS_FINE_LOCATION',
+      'android.permission.ACCESS_COARSE_LOCATION',
+    ];
+    for (const perm of blePermissions) {
+      if (!permissions.some((p) => p.$['android:name'] === perm)) {
+        permissions.push({ $: { 'android:name': perm } });
+      }
+    }
+    manifest['uses-permission'] = permissions;
+    return c;
+  });
+
+  // iOS BLE usage descriptions
+  config = withInfoPlist(config, (c) => {
+    c.modResults.NSBluetoothAlwaysUsageDescription =
+      c.modResults.NSBluetoothAlwaysUsageDescription ||
+      'Used for LXMF mesh networking via BLE';
+    c.modResults.NSBluetoothPeripheralUsageDescription =
+      c.modResults.NSBluetoothPeripheralUsageDescription ||
+      'Used for LXMF mesh networking via BLE';
+    return c;
+  });
+
+  return config;
+}
+
+module.exports = withLxmfPermissions;