@revrag-ai/embed-react-native 1.0.5 → 1.0.7

package/lib/module/hooks/voiceAgent.js

@@ -1,334 +0,0 @@
-"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

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

package/lib/module/onwidApi/api.js

@@ -1,184 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTokenDetails = exports.updateUserData = exports.registerOnInitialize = exports.initializeApi = exports.APIService = void 0;
-const store_key_1 = require("../store.key");
-/**
- * APIService class that ensures proper initialization before API calls
- */
-class APIService {
-    constructor() {
-        this.apiBaseUrl = null;
-        this.isInitialized = false;
-    }
-    /**
-     * Get singleton instance of APIService
-     */
-    static getInstance() {
-        if (!APIService.instance) {
-            APIService.instance = new APIService();
-        }
-        return APIService.instance;
-    }
-    /**
-     * Initialize the API service with the base URL
-     */
-    async initialize() {
-        if (this.isInitialized && this.apiBaseUrl) {
-            return; // Already initialized
-        }
-        const AgentData = await (0, store_key_1.getAgentData)();
-        console.log('AgentData', AgentData);
-        if (AgentData === null || AgentData === void 0 ? void 0 : AgentData.onwidUrl) {
-            this.apiBaseUrl = AgentData.onwidUrl;
-            this.isInitialized = true;
-            console.log('API_BASE_URL initialized:', this.apiBaseUrl);
-        }
-        else {
-            throw new Error('API base URL not found in keychain');
-        }
-    }
-    /**
-     * Ensure the service is initialized before making API calls
-     */
-    async ensureInitialized() {
-        if (!this.isInitialized || !this.apiBaseUrl) {
-            await this.initialize();
-        }
-    }
-    /**
-     * Get headers with stored API key
-     */
-    async getHeaders() {
-        const AgentData = await (0, store_key_1.getAgentData)();
-        if (!(AgentData === null || AgentData === void 0 ? void 0 : AgentData.apiKey)) {
-            throw new Error('API key not found in keychain');
-        }
-        return {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${AgentData.apiKey}`,
-            'X-Revrag-Embedded-Key': AgentData.apiKey,
-        };
-    }
-    /**
-     * Register a new user/device on initialization
-     * @returns Promise with registration response
-     */
-    async registerOnInitialize() {
-        try {
-            await this.ensureInitialized();
-            console.log('registerOnInitialize ApiData', this.apiBaseUrl);
-            const headers = await this.getHeaders();
-            const response = await fetch(`${this.apiBaseUrl}/embedded-agent/initialize`, {
-                method: 'GET',
-                headers: headers,
-            });
-            const data = await response.json();
-            console.log('dat config data after register', data);
-            await (0, store_key_1.setAgentData)(data, '@config_data');
-            if (!response.ok) {
-                console.log('registerOnInitialize error', data.error);
-                throw new Error(data.error || 'Registration failed');
-            }
-            return {
-                success: true,
-                data: data,
-            };
-        }
-        catch (error) {
-            console.log('registerOnInitialize error', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred',
-            };
-        }
-    }
-    /**
-     * Update user data
-     * @param params Update parameters including userId and data to update
-     * @returns Promise with update response
-     */
-    async updateUserData(params) {
-        try {
-            await this.ensureInitialized();
-            console.log('params', params, `${this.apiBaseUrl}/embedded-agent/user-context/update?app_user_id=${params.data.app_user_id}`);
-            console.log('updateUserData');
-            const headers = await this.getHeaders();
-            const response = await fetch(`${this.apiBaseUrl}/embedded-agent/user-context/update?app_user_id=${params.data.app_user_id}`, {
-                method: 'PUT',
-                headers,
-                body: JSON.stringify({ [params.eventKey]: params.data }),
-            });
-            const data = await response.json();
-            console.log('data after update', data);
-            if (!response.ok) {
-                throw new Error(data.error || 'Update failed');
-            }
-            return {
-                success: true,
-            };
-        }
-        catch (error) {
-            console.log('updateUserData error', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred',
-            };
-        }
-    }
-    /**
-     * Get token details for a user
-     * @param params Parameters including app_user_id and call_type
-     * @returns Promise with token details
-     */
-    async getTokenDetails(params) {
-        try {
-            await this.ensureInitialized();
-            const headers = await this.getHeaders();
-            console.log('params', this.apiBaseUrl, params, headers, `${this.apiBaseUrl}/embedded-agent/token`);
-            const response = await fetch(`${this.apiBaseUrl}/embedded-agent/token`, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify(params),
-            });
-            const data = await response.json();
-            console.log('data', data);
-            if (!response.ok) {
-                throw new Error(data.error || 'Failed to get token details');
-            }
-            return {
-                success: true,
-                data: data,
-            };
-        }
-        catch (error) {
-            console.log('getTokenDetails error', error);
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error occurred',
-            };
-        }
-    }
-}
-exports.APIService = APIService;
-APIService.instance = null;
-// Export convenience functions for backward compatibility
-const initializeApi = async () => {
-    const apiService = APIService.getInstance();
-    await apiService.initialize();
-};
-exports.initializeApi = initializeApi;
-const registerOnInitialize = async () => {
-    const apiService = APIService.getInstance();
-    return await apiService.registerOnInitialize();
-};
-exports.registerOnInitialize = registerOnInitialize;
-const updateUserData = async (params) => {
-    const apiService = APIService.getInstance();
-    return await apiService.updateUserData(params);
-};
-exports.updateUserData = updateUserData;
-const getTokenDetails = async (params) => {
-    const apiService = APIService.getInstance();
-    return await apiService.getTokenDetails(params);
-};
-exports.getTokenDetails = getTokenDetails;

package/lib/module/onwidApi/api.types.js

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

package/lib/module/store.key.js

@@ -1,47 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteFromDetail = exports.getAgentData = exports.setAgentData = void 0;
-const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
-const STORAGE_KEY = '@user_data';
-const setAgentData = async (data, key = STORAGE_KEY) => {
-    try {
-        const jsonString = JSON.stringify(data);
-        await async_storage_1.default.setItem(key, jsonString);
-        console.log('Data saved to storage successfully');
-    }
-    catch (error) {
-        console.error('Storage save error:', error);
-        throw error; // Re-throw to allow caller to handle
-    }
-};
-exports.setAgentData = setAgentData;
-const getAgentData = async (key = STORAGE_KEY) => {
-    try {
-        const jsonString = await async_storage_1.default.getItem(key);
-        if (!jsonString) {
-            console.log('No data stored');
-            return null;
-        }
-        const data = JSON.parse(jsonString);
-        return data;
-    }
-    catch (error) {
-        console.error('Storage fetch error:', error);
-        throw error; // Re-throw to allow caller to handle
-    }
-};
-exports.getAgentData = getAgentData;
-const deleteFromDetail = async (key) => {
-    try {
-        await async_storage_1.default.removeItem(key);
-        console.log('Storage data reset successfully');
-    }
-    catch (error) {
-        console.error('Storage reset error:', error);
-        throw error; // Re-throw to allow caller to handle
-    }
-};
-exports.deleteFromDetail = deleteFromDetail;