react-native-srschat 0.1.61 → 0.1.63

package/src/utils/audioRecorder.js

@@ -7,13 +7,9 @@ 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 = 1500;
-
-const State = { IDLE: 'IDLE', LISTENING: 'LISTENING', FINALIZING: 'FINALIZING' };
-let state = State.IDLE;
-
-let listenersBound = false;
+const SILENCE_DURATION = 1500; // 1.5 seconds of silence before stopping
 
 // Add this constant for AsyncStorage key
 const PERMISSION_STORAGE_KEY = '@voice_permission_status';
@@ -34,9 +30,7 @@ export async function initVoice(onResult, onPartialResult = null) {
     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');
@@ -50,109 +44,99 @@ export async function initVoice(onResult, onPartialResult = null) {
       return false;
     }
 
+    // Remove any existing listeners
     Voice.removeAllListeners();
 
     // Set up all event listeners
-    Voice.onSpeechStart = () => {
-      console.log('[onSpeechStart] Setting state to LISTENING');
-      state = State.LISTENING;
+    Voice.onSpeechStart = (e) => {
+      console.log('onSpeechStart: ', e);
+      isCurrentlyRecording = true;
       finalResult = '';
-      clearSilenceTimer();
+      
+      if (silenceTimer) {
+        clearTimeout(silenceTimer);
+        silenceTimer = null;
+      }
     };
 
-    // 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.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 = (e) => {
-      console.log('[onSpeechError] Error occurred, current state:', state, 'error:', e);
-      clearSilenceTimer();
+    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 callback first
+      // Handle Android-specific errors
       if (Platform.OS === 'android' && (code === '7' || code === '5')) {
-        if (finalResult && resultCallback) resultCallback(finalResult, null);
-        else if (resultCallback) resultCallback(null, null);
+        if (finalResult && resultCallback) {
+          resultCallback(finalResult, null);
+        }
       } else if (!msg.includes('No speech detected') && resultCallback) {
         resultCallback(null, msg);
-      } else if (resultCallback) {
-        resultCallback(null, 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;
-      }
+      await cleanupVoiceSession();
     };
 
     Voice.onSpeechResults = (e) => {
-      console.log('[onSpeechResults] Results received, current state:', state, 'results:', e);
-      clearSilenceTimer();
+      console.log('onSpeechResults: ', e);
       if (e.value && e.value.length > 0) {
         finalResult = e.value[0];
-      }
-      
-      // 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;
+        handleSilenceDetection();
       }
     };
 
     Voice.onSpeechPartialResults = (e) => {
+      console.log('onSpeechPartialResults: ', e);
+      
+      if (silenceTimer) {
+        clearTimeout(silenceTimer);
+      }
+      
       if (e.value && e.value.length > 0) {
         finalResult = e.value[0];
-        if (partialResultCallback) partialResultCallback(finalResult);
+        
+        // Call partial callback for live transcription
+        if (partialResultCallback) {
+          partialResultCallback(finalResult);
+        }
+        
         handleSilenceDetection();
       }
     };
 
-    if (Platform.OS === 'android') Voice.onSpeechVolumeChanged = () => {};
+    if (Platform.OS === 'android') {
+      Voice.onSpeechVolumeChanged = (e) => {
+        console.log('onSpeechVolumeChanged: ', e);
+      };
+    }
 
-    listenersBound = true;
     return true;
   } catch (error) {
     console.error('Error initializing Voice:', error);
@@ -166,144 +150,163 @@ const handleSilenceDetection = () => {
   }
   
   silenceTimer = setTimeout(async () => {
-    if (state === State.LISTENING) {
+    if (isCurrentlyRecording) {
       await handleFinalResult();
     }
   }, SILENCE_DURATION);
 };
 
 const handleFinalResult = async () => {
-  console.log('[handleFinalResult] Called, current state:', state);
-  if (state !== State.LISTENING) {
-    console.log('[handleFinalResult] State not LISTENING, returning');
-    return;
-  }
+  if (!isCurrentlyRecording) return;
   
-  // Set to FINALIZING first to prevent double callbacks
-  console.log('[handleFinalResult] Setting state to FINALIZING');
-  state = State.FINALIZING;
+  console.log('handleFinalResult called with:', finalResult);
   
-  // Call the callback with results
   if (finalResult && resultCallback) {
-    console.log('[handleFinalResult] Calling callback with result:', finalResult);
     resultCallback(finalResult, null);
   }
   
-  // Now stop recording (this will call Voice.stop())
-  console.log('[handleFinalResult] Calling stopRecording');
+  // Stop recording first
   await stopRecording();
 };
 
-const cleanupVoiceSession = () => {
-  console.log('[cleanupVoiceSession] Called, current state:', state);
-  finalResult = '';
-  clearSilenceTimer();
+const cleanupVoiceSession = async () => {
+  console.log('cleanupVoiceSession called');
+  isCurrentlyRecording = false;
   
-  // 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 {
-    console.log('[startRecording] Called, current state:', state);
+    // Check if Voice module is available
+    if (!Voice) {
+      console.log('Voice module not available during cleanup');
+      return;
+    }
 
-    // On Android, destroy any lingering instance before starting
-    if (Platform.OS === 'android') {
+    // Check if still recognizing
+    const isRecognizing = await Voice.isRecognizing();
+    console.log('Voice.isRecognizing() in cleanup:', isRecognizing);
+    
+    if (isRecognizing) {
       try {
-        console.log('[startRecording] Android: Proactively destroying Voice instance');
-        await Voice.destroy();
-        await new Promise(r => setTimeout(r, 100)); // Short delay for destroy to complete
+        // 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('[startRecording] Proactive destroy failed, may be okay:', e);
+        console.log('Error stopping/canceling in cleanup:', e);
       }
     }
 
-    if (!Voice) {
-      console.log('[startRecording] Voice not available');
-      return false;
+    // 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);
     }
-    if (state !== State.IDLE) {
-      console.log('[startRecording] State not IDLE, returning false');
+    
+  } 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;
     }
-    
-    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()');
+    // Re-initialize listeners each time for iOS stability
+    await initVoice(resultCallback, partialResultCallback);
+    
+    // Start recognition
     await Voice.start('en-US');
-    console.log('[startRecording] Voice.start() completed, setting state to LISTENING');
-    state = State.LISTENING;
+    console.log('Voice.start() completed');
+    isCurrentlyRecording = true;
     return true;
   } catch (error) {
     console.error('Error starting voice recognition:', error);
-    cleanupVoiceSession();
+    await cleanupVoiceSession();
     return false;
   }
 }
 
 export async function stopRecording() {
   try {
-    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');
+    console.log('stopRecording called');
+    
+    if (!isCurrentlyRecording || !Voice) {
+      console.log('Not recording or Voice not available');
       return;
     }
-    
-    // Only set to FINALIZING if not already there
-    if (state === State.LISTENING) {
-      console.log('[stopRecording] Setting state to FINALIZING');
-      state = State.FINALIZING;
+
+    // Set this first to prevent race conditions
+    isCurrentlyRecording = false;
+
+    if (silenceTimer) {
+      clearTimeout(silenceTimer);
+      silenceTimer = null;
     }
-    
-    clearSilenceTimer();
-    console.log('[stopRecording] Calling Voice.stop()');
-    await Voice.stop();
-    console.log('[stopRecording] Voice.stop() completed');
+
+    // Platform-specific stop
+    try {
+      if (Platform.OS === 'ios') {
+        // iOS: Use cancel for immediate termination
+        await Voice.cancel();
+        console.log('Voice.cancel() completed for iOS');
+      } else {
+        // Android: Use stop
+        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);
-    cleanupVoiceSession();
+    await cleanupVoiceSession();
   }
 }
 
@@ -311,10 +314,10 @@ export async function cancelRecording() {
   try {
     if (!Voice) return;
     await Voice.cancel();
-    cleanupVoiceSession();
+    await cleanupVoiceSession();
   } catch (error) {
     console.error('Error canceling voice recognition:', error);
-    cleanupVoiceSession();
+    await cleanupVoiceSession();
   }
 }
 
@@ -407,5 +410,19 @@ export function resetStoredPermission() {
 }
 
 export function cleanup() {
-  cleanupVoiceSession();
+  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));
+    }
+  });
 }