react-native-srschat 0.1.60 → 0.1.61

package/src/components/voice.js

@@ -49,40 +49,38 @@ export const VoiceButton = ({ setInput }) => {
         
         if (permissionResult) {
           const initialized = await initVoice(
-            // Final result callback - just update input, don't send
+            // Final result callback
             (result, error) => {
               console.log('Voice final result:', result, 'Error:', error);
+              
+              // Always reset states when the recognition ends
+              setIsListening(false);
+              setLoading(false);
+              
               if (error) {
                 // Don't show alert for permission errors since we handle that elsewhere
                 if (!error.includes('permission')) {
                   Alert.alert('Error', error);
                 }
-                setIsListening(false);
-                setLoading(false);
                 return;
               }
+              
               if (result) {
                 if (setInput) {
-                  // Just update the input field, don't send
+                  // For live transcription mode: just update input, don't auto-send
                   setInput(result);
                 } else {
-                  console.warn('VoiceButton: setInput prop is not provided');
+                  // For original mode: send the message automatically
+                  handleVoiceSend(null, result);
                 }
               }
-              // Always reset states when the recognition ends
-              setIsListening(false);
-              setLoading(false);
             },
             // Partial result callback for live transcription
-            (partialResult) => {
+            setInput ? (partialResult) => {
               if (partialResult) {
-                if (setInput) {
-                  setInput(partialResult);
-                } else {
-                  console.warn('VoiceButton: setInput prop is not provided for partial results');
-                }
+                setInput(partialResult);
               }
-            }
+            } : null
           );
 
           if (!initialized) {
@@ -107,7 +105,8 @@ export const VoiceButton = ({ setInput }) => {
     }
 
     return () => {
-      cleanup();
+      // Optional: only if the entire feature is being removed from the app
+      // cleanup();
     };
   }, [permissionStatus, permissionChecked]);
 
@@ -164,7 +163,7 @@ export const VoiceButton = ({ setInput }) => {
       console.error('Error in toggleRecording:', error);
       Alert.alert('Error', 'An error occurred while managing voice recognition');
       setIsListening(false);
-      await cleanup();
+      // Don't call cleanup here - let the natural session cleanup handle it
     } finally {
       setLoading(false);
     }

package/src/utils/audioRecorder.js

@@ -3,16 +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 = '';
-let lastPartialResultTime = 0;
-const SILENCE_DURATION = 1500; // 1.5 seconds of silence before stopping
-const PARTIAL_RESULT_THROTTLE = 100; // Throttle partial results to every 100ms
+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';
@@ -27,13 +28,15 @@ export function setPermissionStatusHandlers(getter, setter) {
   permissionStatusSetter = setter;
 }
 
-// Initialize Voice handlers
+// Initialize Voice handlers - modified to support live transcription
 export async function initVoice(onResult, onPartialResult = null) {
   try {
     resultCallback = onResult;
-    partialResultCallback = onPartialResult;
+    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');
@@ -46,129 +49,110 @@ export async function initVoice(onResult, onPartialResult = null) {
       console.error('Speech recognition is not available on this device');
       return false;
     }
-    
-    // Check if another recognition session is active
-    try {
-      const isRecognizing = await Voice.isRecognizing();
-      if (isRecognizing) {
-        console.log('Another recognition session is active, cleaning up...');
-        await Voice.destroy();
-        await new Promise(resolve => setTimeout(resolve, 300));
-      }
-    } catch (e) {
-      // Ignore errors checking recognition state
-    }
+
+    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;
-      }
-      
-      // Start initial silence detection
-      handleSilenceDetection();
+      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;
+      // 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);
       }
-
-      // On iOS, onSpeechEnd can fire multiple times, so check if we're still recording
-      if (isCurrentlyRecording && finalResult) {
-        // Don't call handleFinalResult here on iOS as it causes the error
-        // Instead, just mark that speech ended and let silence detection handle it
-        if (Platform.OS === 'ios') {
-          console.log('iOS: Speech ended, waiting for silence detection to handle cleanup');
-        } else {
-          await handleFinalResult();
-        }
+      
+      // 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;
       }
     };
 
-    Voice.onSpeechError = async (e) => {
-      console.error('onSpeechError: ', e);
-      
-      if (silenceTimer) {
-        clearTimeout(silenceTimer);
-        silenceTimer = null;
+    Voice.onSpeechResults = (e) => {
+      console.log('[onSpeechResults] Results received, current state:', state, 'results:', e);
+      clearSilenceTimer();
+      if (e.value && e.value.length > 0) {
+        finalResult = e.value[0];
       }
-
-      // Check for specific error types
-      const isNoSpeechError = e.error?.code === "recognition_fail" && 
-                              e.error?.message?.includes("No speech detected");
       
-      // iOS error 1101 is often transient and related to service availability
-      const isTransientIOSError = Platform.OS === 'ios' && 
-                                  (e.error?.code === "1101" || 
-                                   e.error?.message?.includes("kAFAssistantErrorDomain"));
-      
-      await cleanupVoiceSession();
+      // 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);
+      }
       
-      // Only send error to callback for non-transient errors
-      if (!isNoSpeechError && !isTransientIOSError && resultCallback) {
-        resultCallback(null, e.error?.message || 'Speech recognition error');
-      } else if (isTransientIOSError) {
-        console.log('Transient iOS speech recognition error, attempting to recover');
-        // Send the final result if we have one
-        if (finalResult && resultCallback) {
-          resultCallback(finalResult);
-        }
+      // On Android, we must explicitly stop to avoid session corruption
+      if (Platform.OS === 'android') {
+        console.log('[onSpeechResults] Android: Explicitly calling stopRecording()');
+        stopRecording();
       }
-    };
 
-    Voice.onSpeechResults = (e) => {
-      console.log('onSpeechResults: ', e);
-      if (e.value && e.value.length > 0) {
-        finalResult = e.value[0];
-        // Also trigger silence detection for final results
-        handleSilenceDetection();
+      // 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) => {
-      console.log('onSpeechPartialResults: ', e);
-      
-      if (silenceTimer) {
-        clearTimeout(silenceTimer);
-      }
-      
       if (e.value && e.value.length > 0) {
         finalResult = e.value[0];
-        
-        // Throttle partial results to prevent overwhelming the UI and speech service
-        const now = Date.now();
-        if (partialResultCallback && (now - lastPartialResultTime) > PARTIAL_RESULT_THROTTLE) {
-          partialResultCallback(e.value[0]);
-          lastPartialResultTime = now;
-        }
-        
+        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);
@@ -182,194 +166,144 @@ const handleSilenceDetection = () => {
   }
   
   silenceTimer = setTimeout(async () => {
-    console.log('Silence detected, stopping recording...');
-    if (isCurrentlyRecording && finalResult) {
+    if (state === State.LISTENING) {
       await handleFinalResult();
     }
   }, SILENCE_DURATION);
 };
 
 const handleFinalResult = async () => {
-  if (!isCurrentlyRecording) return;
-  
-  // Set flag immediately to prevent race conditions
-  isCurrentlyRecording = false;
-  
-  // Clear silence timer first
-  if (silenceTimer) {
-    clearTimeout(silenceTimer);
-    silenceTimer = null;
+  console.log('[handleFinalResult] Called, current state:', state);
+  if (state !== State.LISTENING) {
+    console.log('[handleFinalResult] State not LISTENING, returning');
+    return;
   }
   
-  // Send result if we have one
-  if (finalResult && resultCallback) {
-    resultCallback(finalResult);
-  }
+  // Set to FINALIZING first to prevent double callbacks
+  console.log('[handleFinalResult] Setting state to FINALIZING');
+  state = State.FINALIZING;
   
-  // Give iOS time to finish processing before cleanup
-  if (Platform.OS === 'ios') {
-    await new Promise(resolve => setTimeout(resolve, 100));
+  // Call the callback with results
+  if (finalResult && resultCallback) {
+    console.log('[handleFinalResult] Calling callback with result:', finalResult);
+    resultCallback(finalResult, null);
   }
   
-  // Stop recording with proper sequence
+  // Now stop recording (this will call Voice.stop())
+  console.log('[handleFinalResult] Calling stopRecording');
   await stopRecording();
 };
 
-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;
     }
-
-    // Reset throttle timer
-    lastPartialResultTime = 0;
     
+    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 (!Voice) return;
-    
-    // Already stopped
-    if (!isCurrentlyRecording) {
-      // Still try to clean up any lingering session
-      try {
-        const isRecognizing = await Voice.isRecognizing();
-        if (isRecognizing) {
-          await Voice.stop();
-        }
-      } catch (e) {
-        // Ignore errors checking recognition state
-      }
+    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;
     }
-
-    // Set this first to prevent race conditions
-    isCurrentlyRecording = false;
-
-    if (silenceTimer) {
-      clearTimeout(silenceTimer);
-      silenceTimer = null;
-    }
-
-    // For iOS, use a more careful approach
-    if (Platform.OS === 'ios') {
-      try {
-        // First cancel any ongoing recognition
-        await Voice.cancel();
-        await new Promise(resolve => setTimeout(resolve, 50));
-      } catch (error) {
-        // Ignore cancel errors
-      }
-      
-      try {
-        // Then stop
-        await Voice.stop();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      } catch (error) {
-        console.log('Error stopping Voice (expected on iOS):', error);
-      }
-      
-      try {
-        // Finally destroy
-        await Voice.destroy();
-        await new Promise(resolve => setTimeout(resolve, 200));
-      } catch (error) {
-        console.log('Error destroying Voice (expected on iOS):', error);
-      }
-    } else {
-      // Android can handle the normal sequence
-      try {
-        await Voice.stop();
-        await new Promise(resolve => setTimeout(resolve, 100));
-      } catch (error) {
-        console.error('Error stopping Voice:', error);
-      }
-
-      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();
   }
 }
 
@@ -377,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();
   }
 }
 
@@ -415,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) {
@@ -424,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);
@@ -469,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();
+}