srs-heritage-chatbot 1.0.0

package/src/utils/audioRecorder.js

@@ -0,0 +1,445 @@
+// audioRecorder.js
+
+import { Platform } from 'react-native';
+import Voice from '@react-native-voice/voice';
+import { check, PERMISSIONS, request, RESULTS } from 'react-native-permissions';
+
+let resultCallback = null;
+let partialResultCallback = null;
+let silenceTimer = null;
+let isCurrentlyRecording = false;
+let finalResult = '';
+const SILENCE_DURATION = 5000; // 5 seconds of silence before stopping
+
+// Add this constant for AsyncStorage key
+const PERMISSION_STORAGE_KEY = '@voice_permission_status';
+
+// Create a function that can be called to get permission status
+// This needs to be outside the React component lifecycle
+let permissionStatusGetter = null;
+let permissionStatusSetter = null;
+
+export function setPermissionStatusHandlers(getter, setter) {
+  permissionStatusGetter = getter;
+  permissionStatusSetter = setter;
+}
+
+// Initialize Voice handlers - modified to support live transcription
+export async function initVoice(onResult, onPartialResult = null) {
+  try {
+    resultCallback = onResult;
+    partialResultCallback = onPartialResult; // Store partial callback
+    finalResult = '';
+
+    // Check if Voice module is available
+    if (!Voice) {
+      console.error('Voice module is not available');
+      return false;
+    }
+
+    // First check if speech recognition is available
+    const isAvailable = await Voice.isAvailable();
+    if (!isAvailable) {
+      console.error('Speech recognition is not available on this device');
+      return false;
+    }
+
+    // Remove any existing listeners
+    Voice.removeAllListeners();
+
+    // Set up all event listeners
+    Voice.onSpeechStart = e => {
+      console.log('onSpeechStart: ', e);
+      isCurrentlyRecording = true;
+      finalResult = '';
+
+      // Start silence timer immediately when recording begins
+      handleSilenceDetection();
+    };
+
+    Voice.onSpeechRecognized = e => {
+      console.log('onSpeechRecognized: ', e);
+      if (e.isFinal) {
+        console.log('Speech recognition final');
+        handleFinalResult();
+      }
+    };
+
+    Voice.onSpeechEnd = async e => {
+      console.log('onSpeechEnd: ', e);
+
+      if (silenceTimer) {
+        clearTimeout(silenceTimer);
+        silenceTimer = null;
+      }
+
+      // Only handle final result if we're still recording
+      if (isCurrentlyRecording) {
+        await handleFinalResult();
+      }
+    };
+
+    Voice.onSpeechError = async e => {
+      console.log('onSpeechError: ', e);
+
+      if (silenceTimer) {
+        clearTimeout(silenceTimer);
+        silenceTimer = null;
+      }
+
+      const code = e.error?.code?.toString();
+      const msg = e.error?.message || '';
+
+      // Handle Android-specific errors
+      if (Platform.OS === 'android' && (code === '7' || code === '5')) {
+        if (finalResult && resultCallback) {
+          resultCallback(finalResult, null);
+        }
+      } else if (!msg.includes('No speech detected') && resultCallback) {
+        resultCallback(null, msg);
+      }
+
+      await cleanupVoiceSession();
+    };
+
+    Voice.onSpeechResults = e => {
+      console.log('onSpeechResults: ', e);
+      if (e.value && e.value.length > 0) {
+        finalResult = e.value[0];
+        handleSilenceDetection();
+      }
+    };
+
+    Voice.onSpeechPartialResults = e => {
+      console.log('onSpeechPartialResults: ', e);
+
+      if (silenceTimer) {
+        clearTimeout(silenceTimer);
+      }
+
+      // Only process partial results if we're still actively recording
+      if (e.value && e.value.length > 0 && isCurrentlyRecording) {
+        finalResult = e.value[0];
+
+        // Call partial callback for live transcription
+        if (partialResultCallback) {
+          partialResultCallback(finalResult);
+        }
+
+        handleSilenceDetection();
+      }
+    };
+
+    if (Platform.OS === 'android') {
+      Voice.onSpeechVolumeChanged = e => {
+        console.log('onSpeechVolumeChanged: ', e);
+      };
+    }
+
+    return true;
+  } catch (error) {
+    console.error('Error initializing Voice:', error);
+    return false;
+  }
+}
+
+const handleSilenceDetection = () => {
+  if (silenceTimer) {
+    clearTimeout(silenceTimer);
+  }
+
+  silenceTimer = setTimeout(async () => {
+    if (isCurrentlyRecording) {
+      await handleFinalResult();
+    }
+  }, SILENCE_DURATION);
+};
+
+const handleFinalResult = async () => {
+  if (!isCurrentlyRecording) return;
+
+  console.log('handleFinalResult called with:', finalResult);
+
+  // Set this FIRST to prevent any more partial results from being processed
+  isCurrentlyRecording = false;
+
+  // Call the result callback to update UI (button state)
+  // Always call callback even if result is empty to prevent UI getting stuck
+  if (resultCallback) {
+    resultCallback(finalResult || '', null);
+  }
+
+  // Then stop recording
+  await stopRecording();
+};
+
+const cleanupVoiceSession = async () => {
+  console.log('cleanupVoiceSession called');
+  isCurrentlyRecording = false;
+
+  if (silenceTimer) {
+    clearTimeout(silenceTimer);
+    silenceTimer = null;
+  }
+
+  try {
+    // Check if Voice module is available
+    if (!Voice) {
+      console.log('Voice module not available during cleanup');
+      return;
+    }
+
+    // Check if still recognizing
+    const isRecognizing = await Voice.isRecognizing();
+    console.log('Voice.isRecognizing() in cleanup:', isRecognizing);
+
+    if (isRecognizing) {
+      try {
+        // For iOS, use cancel for immediate termination
+        if (Platform.OS === 'ios') {
+          await Voice.cancel();
+          console.log('Voice.cancel() completed for iOS');
+        } else {
+          await Voice.stop();
+          console.log('Voice.stop() completed for Android');
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+      } catch (e) {
+        console.log('Error stopping/canceling in cleanup:', e);
+      }
+    }
+
+    // Destroy the instance
+    try {
+      await Voice.destroy();
+      console.log('Voice.destroy() completed');
+      await new Promise(resolve => setTimeout(resolve, 200));
+    } catch (e) {
+      console.log('Error destroying in cleanup:', e);
+    }
+  } catch (error) {
+    console.error('Error in cleanupVoiceSession:', error);
+  }
+
+  finalResult = '';
+};
+
+export async function startRecording() {
+  try {
+    console.log('startRecording called');
+
+    // Check if Voice module is available
+    if (!Voice) {
+      console.error('Voice module is not available');
+      return false;
+    }
+
+    // Ensure cleanup of any existing session
+    await cleanupVoiceSession();
+
+    // Small delay to ensure cleanup is complete
+    await new Promise(resolve => setTimeout(resolve, 200));
+
+    const hasPermission = await requestAudioPermission();
+    if (!hasPermission) {
+      console.error('No permission to record audio');
+      return false;
+    }
+
+    // Re-initialize listeners each time for iOS stability
+    await initVoice(resultCallback, partialResultCallback);
+
+    // Start recognition
+    await Voice.start('en-US');
+    console.log('Voice.start() completed');
+    isCurrentlyRecording = true;
+
+    // Start silence detection timer immediately
+    // This ensures recording stops after 3 seconds even if no speech is detected
+    handleSilenceDetection();
+
+    return true;
+  } catch (error) {
+    console.error('Error starting voice recognition:', error);
+    await cleanupVoiceSession();
+    return false;
+  }
+}
+
+export async function stopRecording() {
+  try {
+    console.log('stopRecording called');
+
+    if (!isCurrentlyRecording || !Voice) {
+      console.log('Not recording or Voice not available');
+      return;
+    }
+
+    // Set this first to prevent race conditions
+    isCurrentlyRecording = false;
+
+    if (silenceTimer) {
+      clearTimeout(silenceTimer);
+      silenceTimer = null;
+    }
+
+    // Platform-specific stop
+    try {
+      if (Platform.OS === 'ios') {
+        // iOS: Use cancel for immediate termination - wait 1 second first
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await Voice.cancel();
+        console.log('Voice.cancel() completed for iOS');
+      } else {
+        // Android: Use stop - wait 1 second first
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        await Voice.stop();
+        console.log('Voice.stop() completed for Android');
+      }
+
+      // Small delay
+      await new Promise(resolve => setTimeout(resolve, 100));
+    } catch (error) {
+      console.log('Error stopping/canceling Voice:', error);
+    }
+
+    // Then destroy
+    try {
+      await Voice.destroy();
+      console.log('Voice.destroy() completed');
+      await new Promise(resolve => setTimeout(resolve, 200));
+    } catch (error) {
+      console.log('Error destroying Voice:', error);
+    }
+
+    // Final cleanup
+    finalResult = '';
+  } catch (error) {
+    console.error('Error in stopRecording:', error);
+    await cleanupVoiceSession();
+  }
+}
+
+export async function cancelRecording() {
+  try {
+    if (!Voice) return;
+    await Voice.cancel();
+    await cleanupVoiceSession();
+  } catch (error) {
+    console.error('Error canceling voice recognition:', error);
+    await cleanupVoiceSession();
+  }
+}
+
+export async function requestAudioPermission() {
+  try {
+    // Get stored permission if available
+    const storedPermission = permissionStatusGetter
+      ? permissionStatusGetter()
+      : null;
+
+    if (storedPermission === 'denied') {
+      console.log('Permission previously denied by user');
+      return false;
+    }
+
+    let permissionResult = false;
+    if (Platform.OS === 'android') {
+      permissionResult = await requestAndroidPermission();
+    } else if (Platform.OS === 'ios') {
+      permissionResult = await requestIOSPermission();
+    }
+
+    // Store the result
+    if (permissionStatusSetter) {
+      permissionStatusSetter(permissionResult ? 'granted' : 'denied');
+    }
+
+    return permissionResult;
+  } catch (error) {
+    console.error('Error checking stored permission:', error);
+    return false;
+  }
+}
+
+async function requestAndroidPermission() {
+  try {
+    // Request microphone permission
+    const micPermission = await request(PERMISSIONS.ANDROID.RECORD_AUDIO);
+    if (micPermission !== RESULTS.GRANTED) {
+      console.log('Microphone permission denied');
+      return false;
+    }
+
+    // Check speech recognition services
+    try {
+      const services = await Voice.getSpeechRecognitionServices();
+      if (!services || services.length === 0) {
+        console.error('No speech recognition services available');
+        return false;
+      }
+    } catch (e) {
+      console.log('Error checking speech services:', e);
+      // Continue anyway - some devices report error but work fine
+    }
+
+    return true;
+  } catch (error) {
+    console.error('Error requesting Android permission:', error);
+    return false;
+  }
+}
+
+async function requestIOSPermission() {
+  try {
+    // Request microphone permission
+    const micPermission = await request(PERMISSIONS.IOS.MICROPHONE);
+    if (micPermission !== RESULTS.GRANTED) {
+      console.log('Microphone permission denied');
+      return false;
+    }
+
+    // Request speech recognition permission
+    const speechPermission = await request(PERMISSIONS.IOS.SPEECH_RECOGNITION);
+    if (speechPermission !== RESULTS.GRANTED) {
+      console.log('Speech recognition permission denied');
+      return false;
+    }
+
+    return true;
+  } catch (error) {
+    console.error('Error requesting iOS permissions:', error);
+    return false;
+  }
+}
+
+export function resetStoredPermission() {
+  if (permissionStatusSetter) {
+    permissionStatusSetter(null);
+    return true;
+  }
+  return false;
+}
+
+export function cleanup() {
+  if (!Voice) {
+    console.log('Voice module not available during cleanup');
+    return;
+  }
+
+  Voice.destroy()
+    .then(() => {
+      Voice.removeAllListeners();
+      cleanupVoiceSession();
+    })
+    .catch(error => {
+      console.error('Error in cleanup:', error);
+      // Try one more time
+      if (Voice) {
+        Voice.destroy().catch(e =>
+          console.error('Final cleanup attempt failed:', e),
+        );
+      }
+    });
+}
+

package/src/utils/cloudinary.js

@@ -0,0 +1,61 @@
+import React, { useContext } from 'react';
+import { Cloudinary } from '@cloudinary/url-gen';
+import { Platform, View } from 'react-native';
+import { AdvancedImage } from 'cloudinary-react-native';
+import { scale } from '@cloudinary/url-gen/actions/resize';
+import { AppContext } from '../contexts/AppContext';
+
+const CloudinaryImage = ({ cldImg, imageStyle, accessibilityLabel, testID }) => {
+  const { brandCloudName } = useContext(AppContext);
+  const cld = new Cloudinary({
+    cloud: {
+      cloudName: brandCloudName || 'mktg'
+    }
+  });
+
+  const myImage = Platform.OS === 'ios' ? cld.image(`${cldImg}`) : cld.image(`${cldImg}`).format('png');
+  return (
+    <View>
+      <AdvancedImage
+        cldImg={myImage}
+        accessibilityLabel={accessibilityLabel}
+        testID={testID}
+        style={[{ resizeMode: 'contain' }, imageStyle]}
+      />
+    </View>
+  );
+};
+
+export const CloudinaryBannerImage = ({
+  cldImg,
+  imageStyle,
+  accessibilityLabel,
+  testID,
+  width = 345,
+  height = 100
+}) => {
+  const { brandCloudName } = useContext(AppContext);
+  const cld = new Cloudinary({
+    cloud: {
+      cloudName: brandCloudName || 'mktg'
+    }
+  });
+  const myImage = cld.image(`${cldImg}`);
+  myImage.resize(
+    scale()
+      .width(parseInt(width * 3))
+      .height(parseInt(height * 3))
+  );
+  return (
+    <View>
+      <AdvancedImage
+        cldImg={myImage}
+        accessibilityLabel={accessibilityLabel}
+        testID={testID}
+        style={[{ resizeMode: 'contain', width: width, height: height }, imageStyle]}
+      />
+    </View>
+  );
+};
+
+export default CloudinaryImage;

package/src/utils/storage.ts

@@ -0,0 +1,89 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+export interface ChatMessage {
+  type: string;
+  text: string | string[];
+  form?: boolean;
+}
+
+export interface ChatState {
+  typingIndicator: boolean;
+  ghostMessage: boolean;
+  ghostCard: boolean;
+  stopActivated: boolean;
+  disclaimer: boolean;
+  startStreaming: boolean;
+  messages: ChatMessage[];
+  showIcon: boolean;
+  toggleChat: boolean;
+  showModal?: string;
+}
+
+// Module-level singleton to cache chat states by token
+const chatStore: Record<string, ChatState> = {};
+
+const getStorageKey = (token: string) => `srschat_${token}`;
+
+export const defaultState: ChatState = {
+  typingIndicator: false,
+  ghostMessage: false,
+  ghostCard: false,
+  stopActivated: false,
+  disclaimer: false,
+  startStreaming: false,
+  messages: [{
+    type: "ai", 
+    text: "Hi there 👋 Hi there 👋 I'm your Heritage+ AI Assistant. I'm here to help you with Product and Account information during your online visit. I'm still learning and growing - the more we interact and the more feedback you share, the better I can assist you. How can I help you today?"
+  }],
+  showIcon: true,
+  toggleChat: false,
+  showModal: "Icon"
+};
+
+/**
+ * Loads chat state for a specific customer token
+ * Returns cached state if available, otherwise loads from AsyncStorage
+ */
+export const loadChat = async (token: string): Promise<ChatState> => {
+  // Return from in-memory cache if available
+  const cachedState = chatStore[token];
+  if (cachedState !== undefined) {
+    return cachedState;
+  }
+  
+  // Otherwise load from AsyncStorage
+  try {
+    const key = getStorageKey(token);
+    const storedData = await AsyncStorage.getItem(key);
+    
+    if (storedData) {
+      const parsedData = JSON.parse(storedData) as ChatState;
+      // Cache in memory for future access
+      chatStore[token] = parsedData;
+      return parsedData;
+    }
+  } catch (error) {
+    console.error('Error loading chat state:', error);
+  }
+  
+  // Return default state if nothing found
+  return defaultState;
+};
+
+/**
+ * Updates chat state for a specific customer token
+ * Updates both in-memory cache and persists to AsyncStorage
+ */
+export const updateChat = async (token: string, next: ChatState): Promise<void> => {
+  try {
+    const key = getStorageKey(token);
+    
+    // Update in-memory cache
+    chatStore[token] = next;
+    
+    // Persist to AsyncStorage
+    await AsyncStorage.setItem(key, JSON.stringify(next));
+  } catch (error) {
+    console.error('Error updating chat state:', error);
+  }
+}; 

package/src/utils/textToSpeech.js

@@ -0,0 +1,49 @@
+// textToSpeech.js
+import React,{ useState, useContext} from 'react';
+import Sound from 'react-native-sound';
+import { AppContext } from '../contexts/AppContext';
+
+export const TextToSpeech = async (inputText) => {
+  const { data } = useContext(AppContext)
+  try {
+    const response = await fetch(
+      'https://api.openai.com/v1/audio/speech',
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${data.openai_key}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model: 'tts-1',
+          voice: 'alloy',
+          input: inputText,
+        }),
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const blob = await response.blob();
+    const reader = new FileReader();
+    
+    reader.onloadend = () => {
+      const base64data = reader.result.split(',')[1];
+      const audioFile = `data:audio/mp3;base64,${base64data}`;
+
+      const sound = new Sound(audioFile, null, (error) => {
+        if (error) {
+          console.error('Error playing sound:', error);
+        } else {
+          sound.play();
+        }
+      });
+    };
+    
+    reader.readAsDataURL(blob);
+  } catch (error) {
+    console.error('Error generating TTS:', error);
+  }
+};