@magicred-1/react-native-lxmf 0.1.0

package/build/LxmfModule.d.ts

@@ -0,0 +1,29 @@
+export type NativeModuleType = {
+    init(dbPath?: string | null): boolean;
+    start(identityHex: string, lxmfAddressHex: string, mode: number, announceIntervalMs: number, bleMtuHint: number, tcpInterfaces: {
+        host: string;
+        port: number;
+    }[], displayName: string): Promise<boolean>;
+    stop(): Promise<boolean>;
+    isRunning(): boolean;
+    send(destHex: string, bodyBase64: string): Promise<number>;
+    broadcast(destsHex: string[], bodyBase64: string): Promise<number>;
+    getStatus(): string | null;
+    getBeacons(): string | null;
+    fetchMessages(limit: number): string | null;
+    setLogLevel(level: number): boolean;
+    abiVersion(): number;
+    startBLE(): boolean;
+    stopBLE(): boolean;
+    blePeerCount(): number;
+    bleUnpairedRNodeCount(): number;
+};
+declare const LxmfModuleNative: NativeModuleType | null;
+export declare const isLxmfNativeAvailable: boolean;
+export declare const LxmfModule: NativeModuleType;
+/**
+ * The raw native module instance, or null when unavailable.
+ * In Expo SDK 50+, NativeModule extends the C++ EventEmitter — call addListener() on it directly.
+ * Do NOT use NativeEventEmitter from react-native; it does not wire up to Expo module events.
+ */
+export { LxmfModuleNative };

package/build/LxmfModule.js

@@ -0,0 +1,31 @@
+import { requireOptionalNativeModule } from 'expo-modules-core';
+const MISSING_NATIVE_MESSAGE = "Cannot find native module 'LxmfModule'. Use an Expo development build (not Expo Go) and rebuild native apps after local module changes.";
+const LxmfModuleNative = requireOptionalNativeModule('LxmfModule');
+export const isLxmfNativeAvailable = !!LxmfModuleNative;
+const throwMissingNative = () => {
+    throw new Error(MISSING_NATIVE_MESSAGE);
+};
+const missingNativeShim = {
+    init: () => throwMissingNative(),
+    start: async () => throwMissingNative(),
+    stop: async () => throwMissingNative(),
+    isRunning: () => false,
+    send: async () => throwMissingNative(),
+    broadcast: async () => throwMissingNative(),
+    getStatus: () => throwMissingNative(),
+    getBeacons: () => throwMissingNative(),
+    fetchMessages: () => throwMissingNative(),
+    setLogLevel: () => throwMissingNative(),
+    abiVersion: () => throwMissingNative(),
+    startBLE: () => throwMissingNative(),
+    stopBLE: () => throwMissingNative(),
+    blePeerCount: () => throwMissingNative(),
+    bleUnpairedRNodeCount: () => throwMissingNative(),
+};
+export const LxmfModule = LxmfModuleNative ?? missingNativeShim;
+/**
+ * The raw native module instance, or null when unavailable.
+ * In Expo SDK 50+, NativeModule extends the C++ EventEmitter — call addListener() on it directly.
+ * Do NOT use NativeEventEmitter from react-native; it does not wire up to Expo module events.
+ */
+export { LxmfModuleNative };

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export { LxmfModule, LxmfModuleNative, NativeModuleType } from './LxmfModule';
+export { useLxmf, LxmfNodeMode, type UseLxmfOptions, type TcpInterface, type LxmfNodeStatus, type Beacon, type LxmfEvent } from './useLxmf';

package/build/index.js

@@ -0,0 +1,2 @@
+export { LxmfModule, LxmfModuleNative } from './LxmfModule';
+export { useLxmf, LxmfNodeMode } from './useLxmf';

package/build/useLxmf.d.ts

@@ -0,0 +1,81 @@
+export interface LxmfNodeStatus {
+    running: boolean;
+    mode: number;
+    identityHex: string;
+    addressHex: string;
+    lifecycle: number;
+    epoch: number;
+    pendingOutbound: number;
+    outboundSent: number;
+    inboundAccepted: number;
+    announcesReceived: number;
+    lxmfMessagesReceived: number;
+    blePeerCount: number;
+}
+export interface Beacon {
+    destHash: string;
+    state: string;
+    lastAnnounce: number;
+    reconnectAttempts: number;
+}
+export interface LxmfEvent {
+    type: 'statusChanged' | 'packetReceived' | 'txReceived' | 'beaconDiscovered' | 'messageReceived' | 'announceReceived' | 'log' | 'error';
+    [key: string]: any;
+}
+/** Node transport mode */
+export declare enum LxmfNodeMode {
+    /** BLE-only mesh (default) */
+    BleOnly = 0,
+    /** Connect via FFI's internal TCP (non-standard framing) */
+    TcpClient = 1,
+    /** Listen via FFI's internal TCP (non-standard framing) */
+    TcpServer = 2,
+    /** Connect to standard Reticulum daemon (rnsd) via HDLC-framed TCP */
+    Reticulum = 3
+}
+export interface TcpInterface {
+    host: string;
+    port: number;
+}
+export interface UseLxmfOptions {
+    autoStart?: boolean;
+    identityHex?: string;
+    lxmfAddressHex?: string;
+    dbPath?: string;
+    logLevel?: number;
+    /** Transport mode — BLE or Reticulum TCP. Default: BleOnly */
+    mode?: LxmfNodeMode;
+    /** One or more TCP interfaces to connect to (required for Reticulum mode). */
+    tcpInterfaces?: TcpInterface[];
+    /** Announce interval in ms. Default: 5000 */
+    announceIntervalMs?: number;
+    /** BLE MTU hint. Default: 255 */
+    bleMtuHint?: number;
+    /** Display name broadcast in LXMF announces. Default: "lxmf-mobile" */
+    displayName?: string;
+}
+export declare function useLxmf(options?: UseLxmfOptions): {
+    status: LxmfNodeStatus | null;
+    beacons: Beacon[];
+    events: LxmfEvent[];
+    error: string | null;
+    isRunning: boolean;
+    isNativeAvailable: boolean;
+    start: (overrides?: {
+        identityHex?: string;
+        lxmfAddressHex?: string;
+        mode?: LxmfNodeMode;
+        tcpInterfaces?: TcpInterface[];
+        displayName?: string;
+    }) => Promise<boolean>;
+    stop: () => Promise<void>;
+    send: (destHex: string, bodyBase64: string) => Promise<number>;
+    broadcast: (destsHex: string[], bodyBase64: string) => Promise<number>;
+    getStatus: () => LxmfNodeStatus | null;
+    getBeacons: () => Beacon[];
+    fetchMessages: (limit?: number) => any[];
+    setLogLevel: (level: number) => boolean;
+    startBLE: () => void;
+    stopBLE: () => void;
+    bleUnpairedRNodeCount: () => number;
+};

package/build/useLxmf.js

@@ -0,0 +1,252 @@
+import { useCallback, useEffect, useState } from 'react';
+import { isLxmfNativeAvailable, LxmfModule, LxmfModuleNative } from './LxmfModule';
+/** Node transport mode */
+export var LxmfNodeMode;
+(function (LxmfNodeMode) {
+    /** BLE-only mesh (default) */
+    LxmfNodeMode[LxmfNodeMode["BleOnly"] = 0] = "BleOnly";
+    /** Connect via FFI's internal TCP (non-standard framing) */
+    LxmfNodeMode[LxmfNodeMode["TcpClient"] = 1] = "TcpClient";
+    /** Listen via FFI's internal TCP (non-standard framing) */
+    LxmfNodeMode[LxmfNodeMode["TcpServer"] = 2] = "TcpServer";
+    /** Connect to standard Reticulum daemon (rnsd) via HDLC-framed TCP */
+    LxmfNodeMode[LxmfNodeMode["Reticulum"] = 3] = "Reticulum";
+})(LxmfNodeMode || (LxmfNodeMode = {}));
+function parseJson(value, fallback) {
+    if (!value)
+        return fallback;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function useLxmf(options = {}) {
+    const [status, setStatus] = useState(null);
+    const [beacons, setBeacons] = useState([]);
+    const [events, setEvents] = useState([]);
+    const [error, setError] = useState(null);
+    const [running, setRunning] = useState(false);
+    const pushEvent = useCallback((type, payload) => {
+        const event = { ...payload, type };
+        setEvents((prev) => [event, ...prev].slice(0, 200));
+        return event;
+    }, []);
+    const syncStatus = useCallback(() => {
+        const parsed = parseJson(LxmfModule.getStatus(), null);
+        setStatus(parsed);
+        if (parsed && typeof parsed.running === 'boolean') {
+            setRunning(parsed.running);
+        }
+        return parsed;
+    }, []);
+    useEffect(() => {
+        if (!isLxmfNativeAvailable) {
+            setError("Cannot find native module 'LxmfModule'. Run this app in an Expo development build (not Expo Go).");
+            return;
+        }
+        try {
+            const initialized = LxmfModule.init(options.dbPath || null);
+            if (!initialized) {
+                setError('Failed to initialize LXMF module');
+                return;
+            }
+            const alreadyRunning = LxmfModule.isRunning();
+            setRunning(alreadyRunning);
+            if (alreadyRunning) {
+                syncStatus();
+            }
+            setError(null);
+        }
+        catch (e) {
+            setError(e?.message ?? 'Initialization failed');
+        }
+    }, [options.dbPath, syncStatus]);
+    useEffect(() => {
+        if (!isLxmfNativeAvailable || !LxmfModuleNative) {
+            return;
+        }
+        const mod = LxmfModuleNative;
+        const subscriptions = [
+            mod.addListener('onStatusChanged', (event) => {
+                pushEvent('statusChanged', event);
+                if (typeof event.running === 'boolean') {
+                    setRunning(event.running);
+                }
+                syncStatus();
+            }),
+            mod.addListener('onPacketReceived', (event) => {
+                pushEvent('packetReceived', event);
+            }),
+            mod.addListener('onTxReceived', (event) => {
+                pushEvent('txReceived', event);
+            }),
+            mod.addListener('onBeaconDiscovered', (event) => {
+                pushEvent('beaconDiscovered', event);
+                const latestBeacons = parseJson(LxmfModule.getBeacons(), []);
+                setBeacons(latestBeacons);
+            }),
+            mod.addListener('onMessageReceived', (event) => {
+                pushEvent('messageReceived', event);
+            }),
+            mod.addListener('onAnnounceReceived', (event) => {
+                pushEvent('announceReceived', event);
+            }),
+            mod.addListener('onLog', (event) => {
+                pushEvent('log', event);
+                if (typeof options.logLevel === 'number' && options.logLevel >= Number(event.level ?? 0)) {
+                    console.log(`[LXMF] ${String(event.message)}`);
+                }
+            }),
+            mod.addListener('onError', (event) => {
+                pushEvent('error', event);
+                setError(`${String(event.code)}: ${String(event.message)}`);
+            }),
+        ];
+        return () => {
+            subscriptions.forEach((sub) => sub.remove());
+        };
+    }, [options.logLevel, pushEvent, syncStatus]);
+    const start = useCallback(async (overrides) => {
+        try {
+            if (!isLxmfNativeAvailable) {
+                setError("Cannot find native module 'LxmfModule'. Run this app in an Expo development build (not Expo Go).");
+                return false;
+            }
+            const resolvedIdentityHex = overrides?.identityHex ?? options.identityHex;
+            const resolvedLxmfAddressHex = overrides?.lxmfAddressHex ?? options.lxmfAddressHex;
+            if (!resolvedIdentityHex || !resolvedLxmfAddressHex) {
+                setError('Missing identity or LXMF address. Pass them to start() or UseLxmfOptions.');
+                return false;
+            }
+            const mode = overrides?.mode ?? options.mode ?? LxmfNodeMode.BleOnly;
+            const tcpInterfaces = overrides?.tcpInterfaces ?? options.tcpInterfaces ?? [];
+            const announceMs = options.announceIntervalMs ?? 5000;
+            const bleMtu = options.bleMtuHint ?? 255;
+            const displayName = overrides?.displayName ?? options.displayName ?? '';
+            if (mode !== LxmfNodeMode.BleOnly && tcpInterfaces.length === 0) {
+                setError(`Mode ${mode} requires at least one TCP interface.`);
+                return false;
+            }
+            await LxmfModule.start(resolvedIdentityHex, resolvedLxmfAddressHex, mode, announceMs, bleMtu, tcpInterfaces, displayName);
+            setRunning(true);
+            syncStatus();
+            setError(null);
+            return true;
+        }
+        catch (e) {
+            setError(e?.message ?? 'Failed to start');
+            return false;
+        }
+    }, [
+        options.identityHex,
+        options.lxmfAddressHex,
+        options.mode,
+        options.tcpInterfaces,
+        options.announceIntervalMs,
+        options.bleMtuHint,
+        options.displayName,
+        syncStatus,
+    ]);
+    useEffect(() => {
+        if (!options.autoStart || running)
+            return;
+        if (!options.identityHex || !options.lxmfAddressHex)
+            return;
+        start().catch(() => {
+            // start() already sets error state on failure
+        });
+    }, [options.autoStart, options.identityHex, options.lxmfAddressHex, running, start]);
+    const stop = useCallback(async () => {
+        try {
+            await LxmfModule.stop();
+            setRunning(false);
+            setStatus(null);
+            setError(null);
+        }
+        catch (e) {
+            setError(e?.message ?? 'Failed to stop');
+        }
+    }, []);
+    const send = useCallback(async (destHex, bodyBase64) => {
+        try {
+            return await LxmfModule.send(destHex, bodyBase64);
+        }
+        catch (e) {
+            setError(e.message);
+            return -1;
+        }
+    }, []);
+    const broadcast = useCallback(async (destsHex, bodyBase64) => {
+        try {
+            return await LxmfModule.broadcast(destsHex, bodyBase64);
+        }
+        catch (e) {
+            setError(e.message);
+            return -1;
+        }
+    }, []);
+    const getStatus = useCallback(() => {
+        try {
+            return syncStatus();
+        }
+        catch (e) {
+            setError(`Failed to parse status payload: ${e?.message ?? 'unknown error'}`);
+            return null;
+        }
+    }, [syncStatus]);
+    const getBeacons = useCallback(() => {
+        try {
+            const parsed = parseJson(LxmfModule.getBeacons(), []);
+            setBeacons(parsed);
+            return parsed;
+        }
+        catch (e) {
+            setError(`Failed to parse beacon payload: ${e?.message ?? 'unknown error'}`);
+            return [];
+        }
+    }, []);
+    const fetchMessages = useCallback((limit = 50) => {
+        try {
+            return parseJson(LxmfModule.fetchMessages(limit), []);
+        }
+        catch (e) {
+            setError(`Failed to parse message payload: ${e?.message ?? 'unknown error'}`);
+            return [];
+        }
+    }, []);
+    const setLogLevel = useCallback((level) => {
+        return LxmfModule.setLogLevel(level);
+    }, []);
+    const startBLE = useCallback(() => {
+        LxmfModule.startBLE();
+    }, []);
+    const stopBLE = useCallback(() => {
+        LxmfModule.stopBLE();
+    }, []);
+    const bleUnpairedRNodeCount = useCallback(() => {
+        return LxmfModule.bleUnpairedRNodeCount();
+    }, []);
+    return {
+        // State
+        status,
+        beacons,
+        events,
+        error,
+        isRunning: running,
+        isNativeAvailable: isLxmfNativeAvailable,
+        // Methods
+        start,
+        stop,
+        send,
+        broadcast,
+        getStatus,
+        getBeacons,
+        fetchMessages,
+        setLogLevel,
+        startBLE,
+        stopBLE,
+        bleUnpairedRNodeCount,
+    };
+}

package/expo-module.config.json

@@ -0,0 +1,10 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["LxmfModule"],
+    "podspecPath": "LxmfReactNative.podspec"
+  },
+  "android": {
+    "modules": ["expo.modules.lxmf.LxmfModule"]
+  }
+}