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

package/dist/module/component/voice.js

@@ -0,0 +1,127 @@
+"use strict";
+
+import { AudioSession, LiveKitRoom } from '@livekit/react-native';
+import { useEffect, useRef, useState } from 'react';
+
+// export interface VoiceProps {
+//   url: string;
+//   token: string;
+//   onDisconnected: (data: string) => void;
+//   onConnected: (data: string) => void;
+// }
+import { jsx as _jsx } from "react/jsx-runtime";
+// Track audio session state globally to prevent multiple starts/stops
+let audioSessionActive = false;
+let audioSessionStarting = false;
+let audioSessionStopping = false;
+
+// Track connection to prevent unmounting while connected
+let activeConnectionToken = null;
+const Voice = props => {
+  const {
+    url,
+    token,
+    onDisconnected,
+    onConnected,
+    roomRef
+  } = props;
+  const [audioSessionStarted, setAudioSessionStarted] = useState(audioSessionActive);
+  const mountedRef = useRef(true);
+  const connectedRef = useRef(false);
+
+  // Start audio session safely - prevent multiple simultaneous starts
+  const startAudioSession = async () => {
+    if (audioSessionActive || audioSessionStarting) {
+      console.log('Audio session already active or starting, skipping');
+      return;
+    }
+    try {
+      audioSessionStarting = true;
+      console.log('Starting audio session');
+      await AudioSession.startAudioSession();
+      audioSessionActive = true;
+      if (mountedRef.current) {
+        setAudioSessionStarted(true);
+      }
+    } catch (err) {
+      console.error('Failed to start audio session:', err);
+    } finally {
+      audioSessionStarting = false;
+    }
+  };
+
+  // Stop audio session safely - prevent multiple simultaneous stops
+  const stopAudioSession = async () => {
+    if (!audioSessionActive || audioSessionStopping) {
+      console.log('Audio session already inactive or stopping, skipping');
+      return;
+    }
+    try {
+      audioSessionStopping = true;
+      console.log('Stopping audio session');
+      await AudioSession.stopAudioSession();
+      audioSessionActive = false;
+    } catch (err) {
+      console.error('Failed to stop audio session:', err);
+    } finally {
+      audioSessionStopping = false;
+    }
+  };
+
+  // Setup audio session
+  useEffect(() => {
+    mountedRef.current = true;
+    startAudioSession();
+    return () => {
+      mountedRef.current = false;
+
+      // IMPORTANT: Don't stop the audio session on unmount if there might be an active call
+      // This prevents audio session start/stop loops when components remount
+      if (roomRef.current?.state !== 'connected' && !connectedRef.current) {
+        stopAudioSession();
+      } else {
+        console.log('Skipping audio session stop because room is still connected');
+      }
+    };
+  }, []);
+
+  // Track connection state changes to avoid unmounting while connected
+  useEffect(() => {
+    if (token) {
+      activeConnectionToken = token;
+    }
+    return () => {
+      // Only clear token when unmounting with this specific token
+      if (activeConnectionToken === token) {
+        activeConnectionToken = null;
+      }
+    };
+  }, [token]);
+
+  // Only render LiveKitRoom when audio session is ready
+  if (!audioSessionStarted) {
+    return null;
+  }
+
+  // IMPORTANT: Never return empty fragment when connected!
+  // Instead, always render the LiveKitRoom component to maintain the connection
+  return /*#__PURE__*/_jsx(LiveKitRoom, {
+    serverUrl: url,
+    token: token,
+    screen: false,
+    audio: true,
+    onConnected: () => {
+      console.log('LiveKitRoom connected');
+      connectedRef.current = true;
+      onConnected('connected');
+    },
+    room: roomRef.current || undefined,
+    onDisconnected: () => {
+      console.log('LiveKitRoom disconnected');
+      connectedRef.current = false;
+      onDisconnected('disconnected');
+    }
+  });
+};
+export default Voice;
+//# sourceMappingURL=voice.js.map

package/dist/module/hooks/initialize.js

@@ -0,0 +1,96 @@
+"use strict";
+
+/**
+ * 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
+ */
+import { setAgentData } from '../store.key';
+import { APIService } from '../onwidApi/api';
+import registerAgent from './initializelivekit';
+import { PermissionsAndroid, Platform } from 'react-native';
+export function useInitialize({
+  apiKey,
+  onwidUrl,
+  metadata
+}) {
+  const checkPermissions = async () => {
+    try {
+      // Check for required permissions on Android
+      if (Platform.OS === 'android') {
+        const recordAudioPermission = 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 => PermissionsAndroid.request(permission)));
+        const allGranted = results.every(result => result === 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();
+      registerAgent();
+
+      // Validate required parameters before proceeding
+      validateInputs();
+
+      // Store API key in keychain
+      await setAgentData({
+        apiKey,
+        onwidUrl
+      });
+
+      // Get the APIService instance and initialize it
+      const apiService = 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);
+}
+//# sourceMappingURL=initialize.js.map

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

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=initialize.types.js.map

package/dist/module/hooks/initializelivekit.js

@@ -0,0 +1,17 @@
+"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.
+
+import { registerGlobals } from '@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 = registerGlobals;
+export default registerAgent;
+//# sourceMappingURL=initializelivekit.js.map

package/dist/module/hooks/voiceAgent.js

@@ -0,0 +1,353 @@
+"use strict";
+
+import { ConnectionState, Room } from 'livekit-client';
+import { useEffect, useState } from 'react';
+import { EventKeys } from '../Event/onwid';
+import { APIService } from '../onwidApi/api';
+import { getAgentData } from '../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 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 !== 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);
+    }
+  }
+};
+export const useVoiceAgent = () => {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [tokenDetails, setTokenDetails] = useState(null);
+  const [isMicMuted, setIsMicMuted] = useState(false);
+  const [connectionState, setConnectionState] = useState(() => {
+    // Initialize with the current room state if it exists
+    const room = getRoomInstance();
+    return room ? room.state : ConnectionState.Disconnected;
+  });
+  const [stableConnection, setStableConnection] = 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 === 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 === 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
+  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
+  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 === ConnectionState.Disconnected) {
+          // Update state before connection attempt
+          setConnectionState(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 === ConnectionState.Connected) {
+          console.log('Room is already connected');
+          // Ensure our state matches
+          setConnectionState(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
+  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 getAgentData(EventKeys.USER_DATA);
+    setIsLoading(true);
+    setError(null);
+    console.log('userData', userData);
+    try {
+      const apiService = APIService.getInstance();
+      const response = await apiService.getTokenDetails({
+        app_user_id: 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 !== 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 !== ConnectionState.Disconnected) {
+        // Update state before disconnection
+        setConnectionState(ConnectionState.Connecting);
+        await room.disconnect();
+
+        // Update state after disconnection
+        setConnectionState(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
+  };
+};
+//# sourceMappingURL=voiceAgent.js.map

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

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=voiceAgent.types.js.map

package/dist/module/index.d.js

@@ -0,0 +1,22 @@
+"use strict";
+
+/**
+ * @file index.d.ts
+ * @description TypeScript declarations for the Onwid React Native library.
+ */
+
+// Component declarations
+
+// Hook type declarations
+
+// Hook declarations
+
+// API type declarations
+
+// Event system declarations
+export let EventKeys = /*#__PURE__*/function (EventKeys) {
+  EventKeys["USER_DATA"] = "user_data";
+  EventKeys["SCREEN_STATE"] = "state_data";
+  return EventKeys;
+}({});
+//# sourceMappingURL=index.d.js.map

package/dist/module/index.js

@@ -0,0 +1,34 @@
+"use strict";
+
+/**
+ * @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.
+ */
+
+import { OnwidButton as OnwidButtonComponent } from './component/OnwidButton';
+import onwid, { EventKeys } from './Event/onwid';
+import { useInitialize } from './hooks/initialize';
+import registerAgent from './hooks/initializelivekit';
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * OnwidButton component that provides a customizable button with menu functionality
+ * @returns React component
+ */
+export function OnwidButton() {
+  return /*#__PURE__*/_jsx(OnwidButtonComponent, {});
+}
+
+/**
+ * Core exports from the Onwid library
+ * @exports
+ * @property {OnwidButton} OnwidButton - Custom button component with menu functionality
+ * @property {Function} registerAgent - Function to register the Agent (Optional)
+ * @property {OnWid} onwid - Event management system instance
+ * @property {useInitialize} useInitialize - Hook to initialize the Onwid SDK
+ * @property {EventKeys} EventKeys - Available event types
+ */
+export { EventKeys, onwid, registerAgent, useInitialize };
+
+// Export types for TypeScript projects
+//# sourceMappingURL=index.js.map