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

package/lib/module/api/api.js

@@ -0,0 +1,248 @@
+"use strict";
+
+import { getAgentData, setAgentData } from "../store/store.key.js";
+
+/**
+ * APIService class that ensures proper initialization before API calls
+ */
+export class APIService {
+  static instance = null;
+  apiBaseUrl = null;
+  isInitialized = false;
+  constructor() {}
+
+  /**
+   * 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 getAgentData();
+    console.log('AgentData', AgentData);
+    if (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 getAgentData();
+    if (!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 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);
+
+      // Enhanced error handling for common iOS network issues
+      let errorMessage = 'Unknown error occurred';
+      if (error instanceof Error) {
+        errorMessage = error.message;
+
+        // iOS ATS related errors
+        if (error.message.includes('The resource could not be loaded') || error.message.includes('App Transport Security')) {
+          errorMessage = `Network request blocked by iOS App Transport Security. ` + `Please configure ATS exceptions in Info.plist for HTTP endpoints, ` + `or use HTTPS instead. Error: ${error.message}`;
+        }
+
+        // Network connectivity errors
+        if (error.message.includes('Network request failed') || error.message.includes('Failed to fetch')) {
+          errorMessage = `Network request failed. Please check your internet connection ` + `and ensure the API endpoint (${this.apiBaseUrl}) is accessible. ` + `Error: ${error.message}`;
+        }
+
+        // Timeout errors
+        if (error.message.includes('timeout')) {
+          errorMessage = `Request timeout. The API server may be slow to respond or unreachable. ` + `Error: ${error.message}`;
+        }
+      }
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+
+  /**
+   * 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);
+
+      // Enhanced error handling for common iOS network issues
+      let errorMessage = 'Unknown error occurred';
+      if (error instanceof Error) {
+        errorMessage = error.message;
+
+        // iOS ATS related errors
+        if (error.message.includes('The resource could not be loaded') || error.message.includes('App Transport Security')) {
+          errorMessage = `Network request blocked by iOS App Transport Security. ` + `Please configure ATS exceptions in Info.plist for HTTP endpoints, ` + `or use HTTPS instead. Error: ${error.message}`;
+        }
+
+        // Network connectivity errors
+        if (error.message.includes('Network request failed') || error.message.includes('Failed to fetch')) {
+          errorMessage = `Network request failed. Please check your internet connection ` + `and ensure the API endpoint (${this.apiBaseUrl}) is accessible. ` + `Error: ${error.message}`;
+        }
+
+        // Timeout errors
+        if (error.message.includes('timeout')) {
+          errorMessage = `Request timeout. The API server may be slow to respond or unreachable. ` + `Error: ${error.message}`;
+        }
+      }
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+
+  /**
+   * 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);
+
+      // Enhanced error handling for common iOS network issues
+      let errorMessage = 'Unknown error occurred';
+      if (error instanceof Error) {
+        errorMessage = error.message;
+
+        // iOS ATS related errors
+        if (error.message.includes('The resource could not be loaded') || error.message.includes('App Transport Security')) {
+          errorMessage = `Network request blocked by iOS App Transport Security. ` + `Please configure ATS exceptions in Info.plist for HTTP endpoints, ` + `or use HTTPS instead. Error: ${error.message}`;
+        }
+
+        // Network connectivity errors
+        if (error.message.includes('Network request failed') || error.message.includes('Failed to fetch')) {
+          errorMessage = `Network request failed. Please check your internet connection ` + `and ensure the API endpoint (${this.apiBaseUrl}) is accessible. ` + `Error: ${error.message}`;
+        }
+
+        // Timeout errors
+        if (error.message.includes('timeout')) {
+          errorMessage = `Request timeout. The API server may be slow to respond or unreachable. ` + `Error: ${error.message}`;
+        }
+      }
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+}
+
+// Export convenience functions for backward compatibility
+export const initializeApi = async () => {
+  const apiService = APIService.getInstance();
+  await apiService.initialize();
+};
+export const registerOnInitialize = async () => {
+  const apiService = APIService.getInstance();
+  return await apiService.registerOnInitialize();
+};
+export const updateUserData = async params => {
+  const apiService = APIService.getInstance();
+  return await apiService.updateUserData(params);
+};
+export const getTokenDetails = async params => {
+  const apiService = APIService.getInstance();
+  return await apiService.getTokenDetails(params);
+};
+//# sourceMappingURL=api.js.map

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

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

package/lib/module/components/Embed/EmbedAudioWave.js

@@ -0,0 +1,152 @@
+"use strict";
+
+import { useEffect, useRef, useState } from 'react';
+import { View, Animated } from 'react-native';
+import { jsx as _jsx } from "react/jsx-runtime";
+// React Native compatible waveform simulator
+const useReactNativeAudioWaveform = roomRef => {
+  const [isAudioActive, setIsAudioActive] = useState(false);
+  const intervalRef = useRef(null);
+  const [currentHeights, setCurrentHeights] = useState(Array(10).fill(0));
+
+  // Create animated values for each bar
+  const barCount = 10;
+  const animatedBars = useRef(Array(barCount).fill(0).map(() => new Animated.Value(0))).current;
+  useEffect(() => {
+    // Check if there's an active room connection AND if agent is talking
+    const checkAudioActivity = () => {
+      const room = roomRef.current;
+      if (room?.state !== 'connected') {
+        setIsAudioActive(false);
+        return;
+      }
+
+      // Check if any remote participant is currently speaking
+      let isAgentSpeaking = false;
+
+      // Loop through all remote participants
+      room.remoteParticipants.forEach(participant => {
+        const audioTrackPublications = Array.from(participant.getTrackPublications().values());
+        const remoteAudioTrack = audioTrackPublications.find(pub => pub.track?.kind === 'audio');
+
+        // Check if this participant has audio track, is not muted, and is actively speaking
+        if (remoteAudioTrack?.track && !remoteAudioTrack?.isMuted) {
+          // Check audio level to detect actual speech (optional but more accurate)
+          const audioLevel = participant.audioLevel || 0;
+          if (audioLevel > 0.05) {
+            // Threshold for detecting speech
+            isAgentSpeaking = true;
+          }
+        }
+      });
+      setIsAudioActive(isAgentSpeaking);
+    };
+
+    // Initial check
+    checkAudioActivity();
+
+    // Set up periodic checking for room state changes
+    intervalRef.current = setInterval(checkAudioActivity, 500);
+
+    // Clean up on unmount
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+      setIsAudioActive(false);
+    };
+  }, [roomRef]);
+
+  // Continuous smooth animation
+  useEffect(() => {
+    const animateWaveform = () => {
+      // Generate smooth waveform data - stop animation completely when not active
+      const targetHeights = isAudioActive ? Array(barCount).fill(0).map((_, index) => {
+        const timeOffset = Date.now() / 800 + index * 0.3;
+        const baseHeight = 0.5;
+        const amplitude = 0.5;
+        const height = baseHeight + amplitude * Math.abs(Math.sin(timeOffset));
+        return Math.max(0.1, Math.min(1.0, height));
+      }) : Array(barCount).fill(0); // Completely freeze animation when mic is muted
+
+      // Update current heights for conditional logic
+      setCurrentHeights(targetHeights);
+      const animations = animatedBars.map((animatedValue, index) => {
+        const targetHeight = targetHeights[index] || 0;
+        return Animated.timing(animatedValue, {
+          toValue: targetHeight,
+          duration: isAudioActive ? 400 : 600,
+          // Slower fade out when going inactive
+          useNativeDriver: false
+        });
+      });
+      Animated.parallel(animations).start();
+    };
+
+    // Start animation immediately and repeat
+    animateWaveform();
+    const animationInterval = setInterval(animateWaveform, 300);
+    return () => {
+      clearInterval(animationInterval);
+    };
+  }, [isAudioActive, animatedBars]);
+  return {
+    animatedBars,
+    currentHeights,
+    isActive: isAudioActive
+  };
+};
+export const WaveformVisualizer = ({
+  roomRef
+}) => {
+  const {
+    animatedBars,
+    currentHeights
+  } = useReactNativeAudioWaveform(roomRef);
+  console.log('animatedBars', animatedBars);
+  return /*#__PURE__*/_jsx(View, {
+    style: {
+      flexDirection: 'row',
+      alignItems: 'center',
+      height: '100%',
+      alignSelf: 'center',
+      // width: '100%',
+      // flex: 1,
+      justifyContent: 'center',
+      // position: 'absolute',
+      zIndex: 1000
+    },
+    children: animatedBars.map((animatedHeight, idx) => {
+      // Use the tracked height values instead of trying to access animated value directly
+      const currentHeightValue = currentHeights[idx] || 0.1;
+
+      // Apply conditional logic based on height
+      let conditionalValue;
+      if (currentHeightValue > 0.7) {
+        conditionalValue = 1;
+      } else if (currentHeightValue >= 0.4 && currentHeightValue <= 0.5) {
+        conditionalValue = 5;
+      } else {
+        conditionalValue = 1;
+      }
+
+      // You can use conditionalValue for width, color, or other properties
+      return /*#__PURE__*/_jsx(Animated.View, {
+        style: {
+          width: conditionalValue === 10 ? 4 : 4,
+          borderRadius: 100,
+          // Example: wider bars for value 5
+          height: animatedHeight.interpolate({
+            inputRange: [0, 1],
+            outputRange: [0, 25]
+          }),
+          alignSelf: 'center',
+          backgroundColor: idx <= 1 || idx >= 8 ? 'rgba(255, 255, 255, 0.5)' : 'white',
+          margin: 1.5
+        }
+      }, idx);
+    })
+  });
+};
+//# sourceMappingURL=EmbedAudioWave.js.map