react-native-srschat 0.1.26 → 0.1.28

package/src/components/voice.js

@@ -1,8 +1,9 @@
 // VoiceButton.js
 
 import React, { useState, useContext, useEffect } from 'react';
-import { TouchableOpacity, ActivityIndicator, StyleSheet, Alert } from 'react-native';
+import { TouchableOpacity, ActivityIndicator, StyleSheet, Alert, Linking, Platform } from 'react-native';
 import Ionicons from 'react-native-vector-icons/Ionicons';
+import useAsyncStorage from '../hooks/useAsyncStorage';
 
 import { 
   startRecording, 
@@ -10,60 +11,129 @@ import {
   cancelRecording,
   requestAudioPermission, 
   cleanup, 
-  initVoice 
+  initVoice,
+  resetStoredPermission,
+  setPermissionStatusHandlers
 } from '../utils/audioRecorder';
 import { AppContext } from '../contexts/AppContext';
 
+const PERMISSION_STORAGE_KEY = '@voice_permission_status';
+
 export const VoiceButton = () => {
   const { handleVoiceSend } = useContext(AppContext);
   const [isListening, setIsListening] = useState(false);
   const [loading, setLoading] = useState(false);
+  const [permissionChecked, setPermissionChecked] = useState(false);
+  const [hasPermission, setHasPermission] = useState(null);
+  
+  // Use your custom AsyncStorage hook
+  const [permissionStatus, setPermissionStatus] = useAsyncStorage(PERMISSION_STORAGE_KEY, null);
 
   useEffect(() => {
+    // Register our permission handlers
+    setPermissionStatusHandlers(() => permissionStatus, setPermissionStatus);
+    
     const setupVoice = async () => {
-      const initialized = await initVoice((result, error) => {
-        if (error) {
-          Alert.alert('Error', error);
-          setIsListening(false);
-          setLoading(false);
+      try {
+        // Check stored permission first
+        if (permissionStatus === 'denied') {
+          // We already know permission was denied, don't show alert again
+          setHasPermission(false);
+          setPermissionChecked(true);
           return;
         }
-        if (result) {
-          handleVoiceSend(null, result);
-          setIsListening(false);
-          setLoading(false);
-        }
-      });
+        
+        // Only request permission if not already denied
+        const permissionResult = await requestAudioPermission();
+        setHasPermission(permissionResult);
+        
+        if (permissionResult) {
+          const initialized = await initVoice((result, error) => {
+            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) {
+              handleVoiceSend(null, result);
+            }
+            // Always reset states when the recognition ends
+            setIsListening(false);
+            setLoading(false);
+          });
 
-      if (!initialized) {
-        Alert.alert(
-          'Error',
-          'Speech recognition is not available on this device'
-        );
+          if (!initialized) {
+            // Only show this alert once per session
+            if (!permissionChecked) {
+              Alert.alert(
+                'Error',
+                'Speech recognition is not available on this device'
+              );
+            }
+          }
+        }
+      } catch (error) {
+        console.error('Error in setupVoice:', error);
+      } finally {
+        setPermissionChecked(true);
       }
     };
 
-    setupVoice();
+    if (!permissionChecked) {
+      setupVoice();
+    }
 
     return () => {
       cleanup();
     };
-  }, []);
+  }, [permissionStatus, permissionChecked]);
 
   const toggleRecording = async () => {
     try {
       if (!isListening) {
-        const hasPermission = await requestAudioPermission();
-        if (!hasPermission) {
-          Alert.alert('Permission Denied', 'Microphone permission is required for voice recognition');
+        // If we already know we don't have permission, show a better message
+        if (hasPermission === false) {
+          Alert.alert(
+            'Permission Required', 
+            'Voice recognition requires microphone permission. Would you like to update your settings?',
+            [
+              {
+                text: 'Cancel',
+                style: 'cancel'
+              },
+              {
+                text: 'Settings',
+                onPress: () => {
+                  // Reset stored permission so we can check again
+                  setPermissionStatus(null);
+                  // Open device settings
+                  openAppSettings();
+                  // Reset our permission check 
+                  setPermissionChecked(false);
+                }
+              }
+            ]
+          );
           return;
         }
 
         setLoading(true);
+        const checkPermission = await requestAudioPermission();
+        if (!checkPermission) {
+          setHasPermission(false);
+          setLoading(false);
+          return;
+        }
+
         const started = await startRecording();
         if (started) {
           setIsListening(true);
         } else {
+          // Only show error if not permission related
           Alert.alert('Error', 'Failed to start voice recognition');
         }
       } else {
@@ -78,7 +148,21 @@ export const VoiceButton = () => {
       await cleanup();
     } finally {
       setLoading(false);
+    }
+  };
 
+  const openAppSettings = async () => {
+    try {
+      if (Platform.OS === 'ios') {
+        // For iOS
+        await Linking.openURL('app-settings://');
+      } else {
+        // For Android
+        await Linking.openSettings();
+      }
+    } catch (error) {
+      console.error('Cannot open settings', error);
+      Alert.alert('Error', 'Unable to open settings. Please open settings manually.');
     }
   };
 

package/src/hooks/Stream.js

@@ -76,8 +76,9 @@ export function useWebSocketMessage() {
 
             ws.onmessage = (event) => {
                 const response = JSON.parse(event.data);
-                if (response.type != "chunk") {
-                    console.log(response)
+                
+                if (response.type !== "chunk") {
+                    console.log(JSON.stringify(response, null, 2));
                 }
                 switch (response.type) {
                     case 'middle_message':
@@ -179,7 +180,8 @@ export function useWebSocketMessage() {
                                         product_description: prod.product_details.product_description || "",
                                         product_name: prod.product_details.product_name || "",
                                         type: prod.product_details.type || "",
-                                        vertical: prod.product_details.vertical || ""
+                                        vertical: prod.product_details.vertical || "",
+                                        sku: prod.product_details.sku || ""
                                     } : {}
                                 }));
 

package/src/utils/audioRecorder.js

@@ -3,6 +3,7 @@
 import { Platform, PermissionsAndroid } from 'react-native';
 import Voice from '@react-native-community/voice';
 import { check, PERMISSIONS, request, RESULTS } from 'react-native-permissions';
+import useAsyncStorage from '../hooks/useAsyncStorage';
 
 let resultCallback = null;
 let silenceTimer = null;
@@ -10,6 +11,19 @@ let isCurrentlyRecording = false;
 let finalResult = '';
 const SILENCE_DURATION = 1500; // 1.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
 export async function initVoice(onResult) {
   try {
@@ -60,15 +74,25 @@ export async function initVoice(onResult) {
     Voice.onSpeechError = async (e) => {
       console.error('onSpeechError: ', e);
       
-
       if (silenceTimer) {
         clearTimeout(silenceTimer);
         silenceTimer = null;
       }
 
+      // Check for "No speech detected" error
+      const isNoSpeechError = e.error?.code === "recognition_fail" && 
+                              e.error?.message?.includes("No speech detected");
       
       await cleanupVoiceSession();
-      resultCallback(null, e.error?.message || 'Speech recognition error');
+      
+      // 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) => {
@@ -245,13 +269,32 @@ export async function cancelRecording() {
 }
 
 export async function requestAudioPermission() {
-  if (Platform.OS === 'android') {
-    return await requestAndroidPermission();
-  } else if (Platform.OS === 'ios') {
-    return await requestIOSPermission();
+  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;
   }
-
-  return false;
 }
 
 async function requestAndroidPermission() {
@@ -267,23 +310,19 @@ async function requestAndroidPermission() {
       PermissionsAndroid.PERMISSIONS.RECORD_AUDIO,
       {
         title: 'Microphone Permission',
-
         message: 'This app needs access to your microphone for voice recognition.',
-
         buttonPositive: 'OK',
         buttonNegative: 'Cancel',
       }
     );
-
+    
     return granted === PermissionsAndroid.RESULTS.GRANTED;
   } catch (error) {
     console.error('Error requesting Android permission:', error);
-
     return false;
   }
 }
 
-
 async function requestIOSPermission() {
   try {
     // Request microphone permission
@@ -307,6 +346,14 @@ async function requestIOSPermission() {
   }
 }
 
+export function resetStoredPermission() {
+  if (permissionStatusSetter) {
+    permissionStatusSetter(null);
+    return true;
+  }
+  return false;
+}
+
 export function cleanup() {
   Voice.destroy().then(() => {
     Voice.removeAllListeners();