@revrag-ai/embed-react-native 1.0.5

package/lib/module/hooks/initialize.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useInitialize = useInitialize;
+/**
+ * Custom hook for initializing the OnWid SDK
+ *
+ * Required Parameters:
+ * - apiKey: string - Unique identifier for the user
+ * - deviceId: string - Unique identifier for the device
+ * - metadata: object - Additional device/user information
+ *
+ * The initialization process:
+ * 1. Validates required input parameters
+ * 2. Stores API key securely in keychain
+ * 3. Registers the device with provided details
+ */
+const store_key_1 = require("../store.key");
+const api_1 = require("../onwidApi/api");
+const initializelivekit_1 = __importDefault(require("./initializelivekit"));
+const react_native_1 = require("react-native");
+function useInitialize({ apiKey, onwidUrl, metadata, }) {
+    const checkPermissions = async () => {
+        try {
+            // Check for required permissions on Android
+            if (react_native_1.Platform.OS === 'android') {
+                const recordAudioPermission = react_native_1.PermissionsAndroid.PERMISSIONS.RECORD_AUDIO;
+                if (!recordAudioPermission) {
+                    throw new Error('RECORD_AUDIO permission not available');
+                }
+                const permissions = [recordAudioPermission];
+                const results = await Promise.all(permissions.map((permission) => react_native_1.PermissionsAndroid.request(permission)));
+                const allGranted = results.every((result) => result === react_native_1.PermissionsAndroid.RESULTS.GRANTED);
+                if (!allGranted) {
+                    throw new Error('Required permissions not granted');
+                }
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to check permissions';
+            throw new Error(errorMessage);
+        }
+    };
+    /**
+     * Validates required initialization parameters
+     * @throws Error if any required parameter is missing or invalid
+     */
+    const validateInputs = () => {
+        if (!apiKey || typeof apiKey !== 'string') {
+            throw new Error('apiKey is required and must be a string');
+        }
+        if (!onwidUrl || typeof onwidUrl !== 'string') {
+            throw new Error('onwidUrl is required and must be a string');
+        }
+        if (metadata && typeof metadata === 'object' && !metadata.config) {
+            throw new Error('metadata must contain a config object');
+        }
+    };
+    const initialize = async () => {
+        try {
+            await checkPermissions();
+            (0, initializelivekit_1.default)();
+            // Validate required parameters before proceeding
+            validateInputs();
+            // Store API key in keychain
+            await (0, store_key_1.setAgentData)({
+                apiKey,
+                onwidUrl,
+            });
+            // Get the APIService instance and initialize it
+            const apiService = api_1.APIService.getInstance();
+            await apiService.initialize();
+            console.log('registerOnInitialize');
+            // Register new device with provided details
+            const registerResponse = await apiService.registerOnInitialize();
+            if (!registerResponse.success) {
+                throw new Error(registerResponse.error || 'Device registration failed');
+            }
+            if (registerResponse.data) {
+                // todo: store config
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Initialization failed';
+            throw new Error(errorMessage);
+        }
+    };
+    // Initialize immediately when hook is called
+    initialize().catch(console.error);
+}

package/lib/module/hooks/initialize.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/module/hooks/initializelivekit.js

@@ -0,0 +1,14 @@
+"use strict";
+// This module imports the `registerGlobals` function from the LiveKit React Native library.
+// The `registerGlobals` function is used to register global settings and configurations
+// for the LiveKit service, which is essential for managing real-time audio and video
+// communication in the application. The `registerAgent` constant is created as an alias
+// for `registerGlobals`, allowing for easier reference in other parts of the application.
+// Finally, the `registerAgent` is exported as the default export of this module, making
+// it available for use in other modules that require the registration of LiveKit globals.
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("@livekit/react-native");
+// The registerAgent constant is an alias for the registerGlobals function,
+// which is used to set up global configurations for the LiveKit service.
+const registerAgent = react_native_1.registerGlobals;
+exports.default = registerAgent;

package/lib/module/hooks/voiceAgent.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVoiceAgent = void 0;
+const livekit_client_1 = require("livekit-client");
+const react_1 = require("react");
+const onwid_1 = require("../Event/onwid");
+const api_1 = require("../onwidApi/api");
+const store_key_1 = require("../store.key");
+// Create a singleton instance of Room that persists across hook instances
+// This ensures we don't create multiple Room instances that could conflict
+let roomInstance = null;
+let isConnecting = false;
+let isDisconnecting = false;
+let hasListeners = false;
+let connectionAttempts = 0;
+let stableConnectionTimerId = null;
+const MAX_CONNECTION_ATTEMPTS = 3;
+const STABLE_CONNECTION_TIMEOUT = 5000; // 5 seconds
+// Create getters for the room instance
+const getRoomInstance = () => {
+    if (!roomInstance) {
+        console.log('Creating new Room instance');
+        // Configure the room with the right options at creation time
+        roomInstance = new livekit_client_1.Room({
+            adaptiveStream: true,
+            dynacast: true,
+            // Using the most stable configuration for React Native
+            publishDefaults: {
+                simulcast: false, // Disable simulcast to reduce SDP complexity
+            },
+        });
+    }
+    return roomInstance;
+};
+// Reset connection attempt counter
+const resetConnectionAttempts = () => {
+    connectionAttempts = 0;
+    // Clear any pending stable connection timer
+    if (stableConnectionTimerId) {
+        clearTimeout(stableConnectionTimerId);
+        stableConnectionTimerId = null;
+    }
+};
+// Cleanup function to reset the room state
+const resetRoomState = () => {
+    if (roomInstance) {
+        try {
+            console.log('Resetting room state');
+            console.log('isDisconnecting', isDisconnecting);
+            // Only disconnect if currently connected
+            if (roomInstance.state !== livekit_client_1.ConnectionState.Disconnected &&
+                !isDisconnecting) {
+                isDisconnecting = true;
+                roomInstance.disconnect().finally(() => {
+                    isDisconnecting = false;
+                });
+            }
+            // Don't destroy the room instance, just reset its state
+            hasListeners = false;
+            resetConnectionAttempts();
+        }
+        catch (e) {
+            console.error('Error resetting room state:', e);
+        }
+    }
+};
+const useVoiceAgent = () => {
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [tokenDetails, setTokenDetails] = (0, react_1.useState)(null);
+    const [isMicMuted, setIsMicMuted] = (0, react_1.useState)(false);
+    const [connectionState, setConnectionState] = (0, react_1.useState)(() => {
+        // Initialize with the current room state if it exists
+        const room = getRoomInstance();
+        return room ? room.state : livekit_client_1.ConnectionState.Disconnected;
+    });
+    const [stableConnection, setStableConnection] = (0, react_1.useState)(false);
+    console.log('ConnectionState_connected', connectionState
+    // tokenDetails?.token
+    );
+    // Setup event listeners for the room
+    const setupRoomListeners = () => {
+        if (hasListeners || !roomInstance)
+            return;
+        console.log('Setting up room listeners');
+        const handleConnectionChange = (state) => {
+            console.log('Connection state changed:', state);
+            // Use a function to ensure we're setting with the latest state
+            setConnectionState(() => state);
+            // Handle connection state changes
+            if (state === livekit_client_1.ConnectionState.Connected) {
+                // Reset connection attempts when connected successfully
+                resetConnectionAttempts();
+                // Set up a timer to mark the connection as stable after a few seconds
+                // This prevents immediate disconnections from being treated as stable
+                if (stableConnectionTimerId) {
+                    clearTimeout(stableConnectionTimerId);
+                }
+                stableConnectionTimerId = setTimeout(() => {
+                    console.log('Connection marked as stable');
+                    setStableConnection(true);
+                }, STABLE_CONNECTION_TIMEOUT);
+            }
+            else if (state === livekit_client_1.ConnectionState.Disconnected) {
+                // Mark connection as unstable
+                setStableConnection(false);
+                // Clear any pending stable connection timer
+                if (stableConnectionTimerId) {
+                    clearTimeout(stableConnectionTimerId);
+                    stableConnectionTimerId = null;
+                }
+                // If disconnected unexpectedly and we have token details, don't automatically reconnect
+                // This prevents connection loops
+                if (tokenDetails && !isDisconnecting) {
+                    console.log('Room disconnected unexpectedly - not auto-reconnecting');
+                }
+            }
+        };
+        const handleTrackSubscribed = (track) => {
+            if (track.kind === 'audio') {
+                track.setVolume(1.0);
+            }
+        };
+        // Handle participant disconnected - this could be helpful to detect server-side kicks
+        roomInstance.on('participantDisconnected', () => {
+            console.log('Participant disconnected from room');
+        });
+        roomInstance.on('connectionStateChanged', handleConnectionChange);
+        roomInstance.on('trackSubscribed', handleTrackSubscribed);
+        // Listen for SDP negotiation errors to handle them better
+        roomInstance.on('mediaDevicesError', (e) => {
+            console.log('Media devices error:', e.message);
+        });
+        hasListeners = true;
+    };
+    // Initialize room and listeners
+    (0, react_1.useEffect)(() => {
+        const room = getRoomInstance();
+        setupRoomListeners();
+        // Sync local state with room state
+        setConnectionState(room.state);
+        return () => {
+            // Do NOT disconnect or destroy the room on component unmount
+            // This ensures the singleton persists across component lifecycle
+            // But we do want to update local state if the component is unmounted
+            if (!tokenDetails) {
+                setTokenDetails(null);
+            }
+        };
+    }, []);
+    // Connect to LiveKit when token is set
+    (0, react_1.useEffect)(() => {
+        const room = getRoomInstance();
+        if (!tokenDetails || isConnecting)
+            return;
+        // Always sync our state with the room's current state
+        setConnectionState(room.state);
+        const connectToRoom = async () => {
+            // Prevent multiple connection attempts
+            if (isConnecting)
+                return;
+            // Limit connection attempts to prevent infinite loops
+            if (connectionAttempts >= MAX_CONNECTION_ATTEMPTS) {
+                console.log(`Maximum connection attempts (${MAX_CONNECTION_ATTEMPTS}) reached. Not trying again.`);
+                setError(`Failed to connect after ${MAX_CONNECTION_ATTEMPTS} attempts`);
+                return;
+            }
+            connectionAttempts++;
+            try {
+                isConnecting = true;
+                console.log(`Connecting to LiveKit room... (attempt ${connectionAttempts})`);
+                // Only attempt to connect if we're disconnected
+                if (room.state === livekit_client_1.ConnectionState.Disconnected) {
+                    // Update state before connection attempt
+                    setConnectionState(livekit_client_1.ConnectionState.Connecting);
+                    await room.connect(tokenDetails.server_url, tokenDetails.token, {
+                        autoSubscribe: true, // Ensure we subscribe to tracks automatically
+                    });
+                    // Explicitly set to connected if connection was successful
+                    setConnectionState(room.state);
+                    console.log('Connected to LiveKit room');
+                }
+                else if (room.state === livekit_client_1.ConnectionState.Connected) {
+                    console.log('Room is already connected');
+                    // Ensure our state matches
+                    setConnectionState(livekit_client_1.ConnectionState.Connected);
+                }
+                else {
+                    console.log('Room is in transition state:', room.state);
+                    // Sync our state with the room's current state
+                    setConnectionState(room.state);
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : 'Failed to connect to room';
+                setError(message);
+                console.error('Connection error:', message);
+                // Sync state to disconnected if we failed to connect
+                setConnectionState(room.state);
+                // Don't keep retrying if we hit an SDP error
+                if (message.includes('SDP') || message.includes('sdp')) {
+                    console.log('SDP error detected, will not retry automatically');
+                }
+            }
+            finally {
+                isConnecting = false;
+            }
+        };
+        connectToRoom();
+        // No cleanup here - we don't want to disconnect when token changes or component unmounts
+    }, [tokenDetails]);
+    // Log connection status periodically for debugging
+    (0, react_1.useEffect)(() => {
+        const debugInterval = setInterval(() => {
+            if (roomInstance) {
+                const state = roomInstance.state;
+                const participantCount = roomInstance.numParticipants;
+                console.log(`[DEBUG] Room state: ${state}, Participants: ${participantCount}, Stable: ${stableConnection}`);
+            }
+        }, 10000); // Every 10 seconds
+        return () => clearInterval(debugInterval);
+    }, [stableConnection]);
+    // Generate token and connect
+    const generateVoiceToken = async () => {
+        console.log('generateVoiceToken');
+        // Don't generate a new token if we're already connecting/connected
+        if (isConnecting || isLoading) {
+            console.log('Already connecting or loading, skipping token generation');
+            return;
+        }
+        // Reset connection attempts when starting fresh
+        resetConnectionAttempts();
+        setStableConnection(false);
+        const userData = await (0, store_key_1.getAgentData)(onwid_1.EventKeys.USER_DATA);
+        setIsLoading(true);
+        setError(null);
+        console.log('userData', userData);
+        try {
+            const apiService = api_1.APIService.getInstance();
+            const response = await apiService.getTokenDetails({
+                app_user_id: userData === null || userData === void 0 ? void 0 : userData.app_user_id,
+                call_type: 'EMBEDDED',
+            });
+            if (!response.data)
+                throw new Error('No voice token found');
+            // Only set token details if we're not already connected
+            const room = getRoomInstance();
+            if (room.state !== livekit_client_1.ConnectionState.Connected) {
+                setTokenDetails(response.data);
+            }
+            else {
+                console.log('Room already connected, skipping token update');
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to generate voice token';
+            setError(message);
+            throw new Error(message);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    // End call
+    const endCall = async () => {
+        if (isDisconnecting) {
+            console.log('Already disconnecting, skipping');
+            return;
+        }
+        try {
+            console.log('Ending call');
+            isDisconnecting = true;
+            setTokenDetails(null);
+            setIsMicMuted(false);
+            resetConnectionAttempts();
+            setStableConnection(false);
+            const room = getRoomInstance();
+            if (room.state !== livekit_client_1.ConnectionState.Disconnected) {
+                // Update state before disconnection
+                setConnectionState(livekit_client_1.ConnectionState.Connecting);
+                await room.disconnect();
+                // Update state after disconnection
+                setConnectionState(livekit_client_1.ConnectionState.Disconnected);
+            }
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to end call');
+            // Make sure state is correctly reflected even if there's an error
+            const room = getRoomInstance();
+            setConnectionState(room.state);
+        }
+        finally {
+            isDisconnecting = false;
+        }
+    };
+    // Mute microphone
+    const muteMic = () => {
+        const room = getRoomInstance();
+        if (room.localParticipant) {
+            room.localParticipant.setMicrophoneEnabled(false);
+            setIsMicMuted(true);
+            console.log('Microphone muted');
+        }
+    };
+    // Unmute microphone
+    const unmuteMic = () => {
+        const room = getRoomInstance();
+        if (room.localParticipant) {
+            room.localParticipant.setMicrophoneEnabled(true);
+            setIsMicMuted(false);
+            console.log('Microphone unmuted');
+        }
+    };
+    // Clean up everything (use only when the app is shutting down)
+    const cleanup = () => {
+        endCall();
+        resetRoomState();
+    };
+    return {
+        initializeVoiceAgent: generateVoiceToken,
+        endCall,
+        muteMic,
+        unmuteMic,
+        isMicMuted,
+        connectionState,
+        room: getRoomInstance(),
+        tokenDetails,
+        isLoading,
+        error,
+        roomRef: { current: getRoomInstance() },
+        cleanup,
+    };
+};
+exports.useVoiceAgent = useVoiceAgent;

package/lib/module/hooks/voiceAgent.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/module/index.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useInitialize = exports.registerAgent = exports.onwid = exports.EventKeys = void 0;
+exports.OnwidButton = OnwidButton;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * @file index.tsx
+ * @description Main entry point for the Onwid React Native library.
+ * This file exports the core components and utilities for the Onwid SDK.
+ */
+const OnwidButton_1 = require("./component/OnwidButton");
+const onwid_1 = __importStar(require("./Event/onwid"));
+exports.onwid = onwid_1.default;
+Object.defineProperty(exports, "EventKeys", { enumerable: true, get: function () { return onwid_1.EventKeys; } });
+const initialize_1 = require("./hooks/initialize");
+Object.defineProperty(exports, "useInitialize", { enumerable: true, get: function () { return initialize_1.useInitialize; } });
+const initializelivekit_1 = __importDefault(require("./hooks/initializelivekit"));
+exports.registerAgent = initializelivekit_1.default;
+/**
+ * OnwidButton component that provides a customizable button with menu functionality
+ * @returns React component
+ */
+function OnwidButton() {
+    return (0, jsx_runtime_1.jsx)(OnwidButton_1.OnwidButton, {});
+}