react-native-srschat 0.1.59 → 0.1.61

package/src/utils/audioRecorder.js

@@ -3,13 +3,17 @@
 import { Platform } from 'react-native';
 import Voice from '@react-native-voice/voice';
 import { check, PERMISSIONS, request, RESULTS } from 'react-native-permissions';
-import useAsyncStorage from '../hooks/useAsyncStorage';
 
 let resultCallback = null;
+let partialResultCallback = null;
 let silenceTimer = null;
-let isCurrentlyRecording = false;
 let finalResult = '';
-const SILENCE_DURATION = 1500; // 1.5 seconds of silence before stopping
+const SILENCE_DURATION = 1500;
+
+const State = { IDLE: 'IDLE', LISTENING: 'LISTENING', FINALIZING: 'FINALIZING' };
+let state = State.IDLE;
+
+let listenersBound = false;
 
 // Add this constant for AsyncStorage key
 const PERMISSION_STORAGE_KEY = '@voice_permission_status';
@@ -24,12 +28,15 @@ export function setPermissionStatusHandlers(getter, setter) {
   permissionStatusSetter = setter;
 }
 
-// Initialize Voice handlers
-export async function initVoice(onResult) {
+// Initialize Voice handlers - modified to support live transcription
+export async function initVoice(onResult, onPartialResult = null) {
   try {
     resultCallback = onResult;
+    partialResultCallback = onPartialResult; // Store partial callback
     finalResult = '';
-
+    
+    if (listenersBound) return true;
+    
     // Check if Voice module is available
     if (!Voice) {
       console.error('Voice module is not available');
@@ -43,91 +50,109 @@ export async function initVoice(onResult) {
       return false;
     }
 
+    Voice.removeAllListeners();
+
     // Set up all event listeners
-    Voice.onSpeechStart = (e) => {
-      console.log('onSpeechStart: ', e);
-      isCurrentlyRecording = true;
+    Voice.onSpeechStart = () => {
+      console.log('[onSpeechStart] Setting state to LISTENING');
+      state = State.LISTENING;
       finalResult = '';
-      
-      if (silenceTimer) {
-        clearTimeout(silenceTimer);
-        silenceTimer = null;
-      }
+      clearSilenceTimer();
     };
 
-    Voice.onSpeechRecognized = (e) => {
-      console.log('onSpeechRecognized: ', e);
-      if (e.isFinal) {
-        console.log('Speech recognition final');
-        handleFinalResult();
+    // Optional: ignore onSpeechRecognized or just log
+    Voice.onSpeechRecognized = () => {};
+
+    Voice.onSpeechEnd = () => {
+      console.log('[onSpeechEnd] Speech ended, current state:', state);
+      clearSilenceTimer();
+      // Always reset to IDLE when speech ends (sessions should be considered over)
+      console.log('[onSpeechEnd] Scheduling IDLE reset');
+      if (Platform.OS === 'android') {
+        setTimeout(() => {
+          console.log('[onSpeechEnd] Android timeout - setting state to IDLE');
+          state = State.IDLE;
+        }, 800); // Increased delay
+      } else {
+        console.log('[onSpeechEnd] iOS - setting state to IDLE immediately');
+        state = State.IDLE;
       }
     };
 
-    Voice.onSpeechEnd = async (e) => {
-      console.log('onSpeechEnd: ', e);
+    Voice.onSpeechError = (e) => {
+      console.log('[onSpeechError] Error occurred, current state:', state, 'error:', e);
+      clearSilenceTimer();
+      const code = e.error?.code?.toString();
+      const msg = e.error?.message || '';
       
-      if (silenceTimer) {
-        clearTimeout(silenceTimer);
-        silenceTimer = null;
-      }
-
-      // Only handle final result if we're still recording
-      if (isCurrentlyRecording) {
-        await handleFinalResult();
+      // Handle callback first
+      if (Platform.OS === 'android' && (code === '7' || code === '5')) {
+        if (finalResult && resultCallback) resultCallback(finalResult, null);
+        else if (resultCallback) resultCallback(null, null);
+      } else if (!msg.includes('No speech detected') && resultCallback) {
+        resultCallback(null, msg);
+      } else if (resultCallback) {
+        resultCallback(null, null);
       }
-    };
-
-    Voice.onSpeechError = async (e) => {
-      // console.error('onSpeechError: ', e);
       
-      if (silenceTimer) {
-        clearTimeout(silenceTimer);
-        silenceTimer = null;
+      // Errors end the session immediately, reset to IDLE with delay
+      console.log('[onSpeechError] Scheduling IDLE reset');
+      if (Platform.OS === 'android') {
+        setTimeout(() => {
+          console.log('[onSpeechError] Android timeout - setting state to IDLE');
+          state = State.IDLE;
+        }, 800); // Increased delay to match onSpeechEnd
+      } else {
+        console.log('[onSpeechError] iOS - setting state to IDLE immediately');
+        state = State.IDLE;
       }
-
-      // Check for "No speech detected" error
-      const isNoSpeechError = e.error?.code === "recognition_fail" && 
-                              e.error?.message?.includes("No speech detected");
-      
-      await cleanupVoiceSession();
-      
-      // Only send error to callback if it's not a "No speech detected" error
-      // if (!isNoSpeechError) {
-      //   resultCallback(null, e.error?.message || 'Speech recognition error');
-      // } else {
-      //   console.log('No speech detected, ignoring error');
-      //   // Optionally, call the callback with null parameters or a special indicator
-      //   resultCallback(null, null); // This won't trigger an error alert in the component
-      // }
     };
 
     Voice.onSpeechResults = (e) => {
-      console.log('onSpeechResults: ', e);
+      console.log('[onSpeechResults] Results received, current state:', state, 'results:', e);
+      clearSilenceTimer();
       if (e.value && e.value.length > 0) {
         finalResult = e.value[0];
-        handleSilenceDetection();
       }
-    };
-
-    Voice.onSpeechPartialResults = (e) => {
-      console.log('onSpeechPartialResults: ', e);
       
-      if (silenceTimer) {
-        clearTimeout(silenceTimer);
+      // Only call callback if we haven't already (avoid double-calling)
+      if (state === State.LISTENING && resultCallback) {
+        console.log('[onSpeechResults] Calling callback with results');
+        resultCallback(finalResult, null);
+      } else {
+        console.log('[onSpeechResults] Not calling callback - state:', state);
       }
       
+      // On Android, we must explicitly stop to avoid session corruption
+      if (Platform.OS === 'android') {
+        console.log('[onSpeechResults] Android: Explicitly calling stopRecording()');
+        stopRecording();
+      }
+
+      // Results end the session, reset to IDLE with delay
+      console.log('[onSpeechResults] Scheduling IDLE reset');
+      if (Platform.OS === 'android') {
+        setTimeout(() => {
+          console.log('[onSpeechResults] Android timeout - setting state to IDLE');
+          state = State.IDLE;
+        }, 800); // Increased delay
+      } else {
+        console.log('[onSpeechResults] iOS - setting state to IDLE immediately');
+        state = State.IDLE;
+      }
+    };
+
+    Voice.onSpeechPartialResults = (e) => {
       if (e.value && e.value.length > 0) {
         finalResult = e.value[0];
+        if (partialResultCallback) partialResultCallback(finalResult);
         handleSilenceDetection();
       }
     };
 
-    if (Platform.OS === 'android') {
-      Voice.onSpeechVolumeChanged = (e) => {
-        console.log('onSpeechVolumeChanged: ', e);
-      };
-    }
+    if (Platform.OS === 'android') Voice.onSpeechVolumeChanged = () => {};
 
+    listenersBound = true;
     return true;
   } catch (error) {
     console.error('Error initializing Voice:', error);
@@ -141,139 +166,144 @@ const handleSilenceDetection = () => {
   }
   
   silenceTimer = setTimeout(async () => {
-    if (isCurrentlyRecording) {
+    if (state === State.LISTENING) {
       await handleFinalResult();
     }
   }, SILENCE_DURATION);
 };
 
 const handleFinalResult = async () => {
-  if (!isCurrentlyRecording) return;
+  console.log('[handleFinalResult] Called, current state:', state);
+  if (state !== State.LISTENING) {
+    console.log('[handleFinalResult] State not LISTENING, returning');
+    return;
+  }
+  
+  // Set to FINALIZING first to prevent double callbacks
+  console.log('[handleFinalResult] Setting state to FINALIZING');
+  state = State.FINALIZING;
   
-  if (finalResult) {
-    resultCallback(finalResult);
+  // Call the callback with results
+  if (finalResult && resultCallback) {
+    console.log('[handleFinalResult] Calling callback with result:', finalResult);
+    resultCallback(finalResult, null);
   }
   
-  // Stop recording first
+  // Now stop recording (this will call Voice.stop())
+  console.log('[handleFinalResult] Calling stopRecording');
   await stopRecording();
-  
-  // Then clean up the session
-  await cleanupVoiceSession();
 };
 
-const cleanupVoiceSession = async () => {
-  isCurrentlyRecording = false;
+const cleanupVoiceSession = () => {
+  console.log('[cleanupVoiceSession] Called, current state:', state);
+  finalResult = '';
+  clearSilenceTimer();
   
+  // Add delay before allowing next session on Android
+  if (Platform.OS === 'android') {
+    setTimeout(() => {
+      console.log('[cleanupVoiceSession] Android timeout - setting state to IDLE');
+      state = State.IDLE;
+    }, 800);
+  } else {
+    console.log('[cleanupVoiceSession] iOS - setting state to IDLE immediately');
+    state = State.IDLE;
+  }
+};
+
+const clearSilenceTimer = () => {
   if (silenceTimer) {
     clearTimeout(silenceTimer);
     silenceTimer = null;
   }
+};
 
+export async function startRecording() {
   try {
-    // Check if Voice module is available
-    if (!Voice) {
-      console.log('Voice module not available during cleanup');
-      return;
-    }
+    console.log('[startRecording] Called, current state:', state);
 
-    // First try to stop if still recognizing
-    const isRecognizing = await Voice.isRecognizing();
-    if (isRecognizing) {
+    // On Android, destroy any lingering instance before starting
+    if (Platform.OS === 'android') {
       try {
-        await Voice.stop();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      } catch (e) {
-        console.error('Error stopping in cleanup:', e);
-      }
-    }
-
-    // Then force destroy
-    await Voice.destroy();
-    await new Promise(resolve => setTimeout(resolve, 300));
-    
-    // Double check and force destroy again if needed
-    const stillRecognizing = await Voice.isRecognizing();
-    if (stillRecognizing) {
-      await Voice.destroy();
-      await new Promise(resolve => setTimeout(resolve, 300));
-    }
-  } catch (error) {
-    console.error('Error in cleanupVoiceSession:', error);
-    // Final attempt to destroy on error
-    try {
-      if (Voice) {
+        console.log('[startRecording] Android: Proactively destroying Voice instance');
         await Voice.destroy();
+        await new Promise(r => setTimeout(r, 100)); // Short delay for destroy to complete
+      } catch (e) {
+        console.log('[startRecording] Proactive destroy failed, may be okay:', e);
       }
-    } catch (e) {
-      console.error('Final destroy attempt failed:', e);
     }
-  }
 
-  finalResult = '';
-};
-
-export async function startRecording() {
-  try {
-    // Check if Voice module is available
     if (!Voice) {
-      console.error('Voice module is not available');
+      console.log('[startRecording] Voice not available');
+      return false;
+    }
+    if (state !== State.IDLE) {
+      console.log('[startRecording] State not IDLE, returning false');
       return false;
     }
-
-    // Ensure cleanup of any existing session
-    await cleanupVoiceSession();
     
     const hasPermission = await requestAudioPermission();
     if (!hasPermission) {
       console.error('No permission to record audio');
       return false;
     }
+    
+    const recognizing = await Voice.isRecognizing();
+    console.log('[startRecording] Voice.isRecognizing():', recognizing);
+    if (recognizing) {
+      console.log('[startRecording] Already recognizing, canceling first');
+      await Voice.cancel();
+      // Wait longer for cancel to take effect
+      await new Promise(r => setTimeout(r, 500));
+      
+      // Double-check if still recognizing after cancel
+      const stillRecognizing = await Voice.isRecognizing();
+      console.log('[startRecording] After cancel, still recognizing:', stillRecognizing);
+      if (stillRecognizing) {
+        console.log('[startRecording] Still recognizing after cancel, stopping');
+        try {
+          await Voice.stop();
+          await new Promise(r => setTimeout(r, 300));
+        } catch (e) {
+          console.log('[startRecording] Error stopping:', e);
+        }
+      }
+    }
 
+    console.log('[startRecording] Calling Voice.start()');
     await Voice.start('en-US');
-    isCurrentlyRecording = true;
+    console.log('[startRecording] Voice.start() completed, setting state to LISTENING');
+    state = State.LISTENING;
     return true;
   } catch (error) {
     console.error('Error starting voice recognition:', error);
-    await cleanupVoiceSession();
+    cleanupVoiceSession();
     return false;
   }
 }
 
 export async function stopRecording() {
   try {
-    if (!isCurrentlyRecording || !Voice) return;
-
-    // Set this first to prevent race conditions
-    isCurrentlyRecording = false;
-
-    if (silenceTimer) {
-      clearTimeout(silenceTimer);
-      silenceTimer = null;
-    }
-
-    // First try to stop
-    try {
-      await Voice.stop();
-      // Wait a bit for stop to complete
-      await new Promise(resolve => setTimeout(resolve, 100));
-    } catch (error) {
-      console.error('Error stopping Voice:', error);
+    console.log('[stopRecording] Called, current state:', state);
+    // Can be called from LISTENING or FINALIZING state
+    if ((state !== State.LISTENING && state !== State.FINALIZING) || !Voice) {
+      console.log('[stopRecording] Invalid state or no Voice, returning');
+      return;
     }
-
-    // Then force destroy
-    try {
-      await Voice.destroy();
-      await new Promise(resolve => setTimeout(resolve, 300));
-    } catch (error) {
-      console.error('Error destroying Voice:', error);
+    
+    // Only set to FINALIZING if not already there
+    if (state === State.LISTENING) {
+      console.log('[stopRecording] Setting state to FINALIZING');
+      state = State.FINALIZING;
     }
-
-    // Final cleanup
-    await cleanupVoiceSession();
+    
+    clearSilenceTimer();
+    console.log('[stopRecording] Calling Voice.stop()');
+    await Voice.stop();
+    console.log('[stopRecording] Voice.stop() completed');
   } catch (error) {
     console.error('Error in stopRecording:', error);
-    // Force cleanup on error
-    await cleanupVoiceSession();
+    cleanupVoiceSession();
   }
 }
 
@@ -281,10 +311,10 @@ export async function cancelRecording() {
   try {
     if (!Voice) return;
     await Voice.cancel();
-    await cleanupVoiceSession();
+    cleanupVoiceSession();
   } catch (error) {
     console.error('Error canceling voice recognition:', error);
-    await cleanupVoiceSession();
+    cleanupVoiceSession();
   }
 }
 
@@ -319,8 +349,6 @@ export async function requestAudioPermission() {
 
 async function requestAndroidPermission() {
   try {
-
-
     // Request microphone permission
     const micPermission = await request(PERMISSIONS.ANDROID.RECORD_AUDIO);
     if (micPermission !== RESULTS.GRANTED) {
@@ -328,12 +356,18 @@ async function requestAndroidPermission() {
       return false;
     }
 
-        // Skip checking speech recognition services which is causing errors
-    const services = await Voice.getSpeechRecognitionServices();
-    if (!services || services.length === 0) {
-      console.error('No speech recognition services available');
-      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);
@@ -373,20 +407,5 @@ export function resetStoredPermission() {
 }
 
 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));
-    }
-  });
-}
-
+  cleanupVoiceSession();
+}