Revert "RU-T47 PR#209 fixes"

This reverts commit f7b8233.

Author: ucswift

app.config.ts

@@ -81,6 +81,7 @@ export default ({ config }: ConfigContext): ExpoConfig => ({
       'android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE',
       'android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK',
       'android.permission.READ_PHONE_STATE',
+      'android.permission.READ_PHONE_NUMBERS',
       'android.permission.MANAGE_OWN_CALLS',
     ],
   },

package.json

@@ -168,7 +168,7 @@
     "react-native-restart": "0.0.27",
     "react-native-safe-area-context": "5.4.0",
     "react-native-screens": "~4.11.1",
-
+    "react-native-sound": "^0.13.0",
     "react-native-svg": "15.11.2",
     "react-native-web": "^0.20.0",
     "react-native-webview": "~13.13.1",

src/components/livekit/__tests__/livekit-bottom-sheet.test.tsx

@@ -130,8 +130,8 @@ const mockAvailableRooms = [
 ];
 
 const mockSelectedAudioDevices = {
-  microphone: { id: 'mic1', name: 'Default Microphone', type: 'microphone' as const, isAvailable: true },
-  speaker: { id: 'speaker1', name: 'Default Speaker', type: 'speaker' as const, isAvailable: true },
+  microphone: { id: 'mic1', name: 'Default Microphone', type: 'default' as const, isAvailable: true },
+  speaker: { id: 'speaker1', name: 'Default Speaker', type: 'default' as const, isAvailable: true },
 };
 
 describe('LiveKitBottomSheet', () => {

src/components/settings/audio-device-selection.tsx

@@ -70,9 +70,9 @@ export const AudioDeviceSelection: React.FC<AudioDeviceSelectionProps> = ({ show
     );
   };
 
-  const availableMicrophones = availableAudioDevices.filter((device) => device.isAvailable && (device.type === 'microphone' || device.type === 'bluetooth' || device.type === 'wired'));
+  const availableMicrophones = availableAudioDevices.filter((device) => device.isAvailable && (device.type === 'default' || device.type === 'microphone' || device.type === 'bluetooth' || device.type === 'wired'));
 
-  const availableSpeakers = availableAudioDevices.filter((device) => device.isAvailable && (device.type === 'speaker' || device.type === 'bluetooth' || device.type === 'wired'));
+  const availableSpeakers = availableAudioDevices.filter((device) => device.isAvailable && (device.type === 'default' || device.type === 'speaker' || device.type === 'bluetooth' || device.type === 'wired'));
 
   return (
     <ScrollView className="flex-1">

src/components/settings/bluetooth-device-selection-bottom-sheet.tsx

@@ -1,8 +1,8 @@
 import { BluetoothIcon, RefreshCwIcon, WifiIcon } from 'lucide-react-native';
 import React, { useCallback, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { Alert, useWindowDimensions } from 'react-native';
 import { showMessage } from 'react-native-flash-message';
+import { Alert, useWindowDimensions } from 'react-native';
 
 import { Box } from '@/components/ui/box';
 import { Button, ButtonIcon, ButtonText } from '@/components/ui/button';
@@ -108,6 +108,7 @@ export function BluetoothDeviceSelectionBottomSheet({ isOpen, onClose }: Bluetoo
         // Checking previous logs, service seems to play "connectedDevice".
 
         onClose();
+
       } catch (error) {
         logger.warn({
           message: 'Failed to connect to device',
@@ -118,7 +119,7 @@ export function BluetoothDeviceSelectionBottomSheet({ isOpen, onClose }: Bluetoo
         const errorMessage = error instanceof Error ? error.message : String(error);
         showMessage({
           message: t('bluetooth.connection_error_title') || 'Connection Failed',
-          description: errorMessage === 'Device disconnected' ? t('bluetooth.device_disconnected') : errorMessage || t('bluetooth.connection_error_message') || 'Could not connect to device',
+          description: errorMessage === 'Device disconnected' ? t('bluetooth.device_disconnected') : (errorMessage || t('bluetooth.connection_error_message') || 'Could not connect to device'),
           type: 'danger',
           duration: 4000,
         });

src/components/ui/actionsheet/index.tsx

@@ -392,7 +392,11 @@ const ActionsheetVirtualizedList = React.forwardRef<React.ElementRef<typeof UIAc
 const ActionsheetFlatList = React.forwardRef<React.ElementRef<typeof UIActionsheet.FlatList>, IActionsheetFlatListProps>(({ className, style, ...props }, ref) => {
   return (
     <View className={actionsheetFlatListStyle({ class: className })} style={style}>
-      <UIActionsheet.FlatList ref={ref} estimatedItemSize={94} {...props} />
+      <UIActionsheet.FlatList
+        ref={ref}
+        estimatedItemSize={94}
+        {...props}
+      />
     </View>
   );
 });

src/components/ui/select/select-actionsheet.tsx

@@ -392,7 +392,11 @@ const ActionsheetVirtualizedList = React.forwardRef<React.ComponentRef<typeof UI
 const ActionsheetFlatList = React.forwardRef<React.ComponentRef<typeof UIActionsheet.FlatList>, IActionsheetFlatListProps>(function ActionsheetFlatList({ className, style, ...props }, ref) {
   return (
     <View className={actionsheetFlatListStyle({ class: className })} style={style}>
-      <UIActionsheet.FlatList ref={ref} estimatedItemSize={94} {...props} />
+      <UIActionsheet.FlatList
+        ref={ref}
+        estimatedItemSize={94}
+        {...props}
+      />
     </View>
   );
 });

src/services/audio.service.ts

@@ -1,18 +1,23 @@
 import { Asset } from 'expo-asset';
-import { Audio, InterruptionModeIOS } from 'expo-av';
+import { Audio, type AVPlaybackSource, InterruptionModeIOS } from 'expo-av';
+import { Platform } from 'react-native';
+import Sound from 'react-native-sound';
 
 import { logger } from '@/lib/logging';
 
+// Enable playback in silence mode
+Sound.setCategory('Ambient', true);
+
 class AudioService {
   private static instance: AudioService;
-
-  // Use expo-av Sound objects
-  private startTransmittingSound: Audio.Sound | null = null;
-  private stopTransmittingSound: Audio.Sound | null = null;
-  private connectedDeviceSound: Audio.Sound | null = null;
-  private connectToAudioRoomSound: Audio.Sound | null = null;
-  private disconnectedFromAudioRoomSound: Audio.Sound | null = null;
-
+  // Use specific type for react-native-sound instances
+  private startTransmittingSound: Sound | null = null;
+  private stopTransmittingSound: Sound | null = null;
+  
+  // Keep others as expo-av for now
+  private connectedDeviceSound: Sound | null = null;
+  private connectToAudioRoomSound: Sound | null = null;
+  private disconnectedFromAudioRoomSound: Sound | null = null;
   private isInitialized = false;
 
   private constructor() {
@@ -37,12 +42,15 @@ class AudioService {
 
     try {
       // Configure audio mode for production builds
+      // Note: react-native-sound handles its own session category (Ambient), 
+      // ensuring expo-av doesn't conflict is still good practice if used elsewhere.
       await Audio.setAudioModeAsync({
         allowsRecordingIOS: true,
         staysActiveInBackground: true,
         playsInSilentModeIOS: true,
         shouldDuckAndroid: true,
-        playThroughEarpieceAndroid: false,
+        // For speaker, we want false (speaker). For others, simple routing.
+        playThroughEarpieceAndroid: false, 
         interruptionModeIOS: InterruptionModeIOS.DoNotMix,
       });
 
@@ -88,25 +96,60 @@ class AudioService {
 
   private async loadAudioFiles(): Promise<void> {
     try {
-      // Load start transmitting sound
-      const { sound: startSound } = await Audio.Sound.createAsync(require('@assets/audio/ui/space_notification1.mp3'));
-      this.startTransmittingSound = startSound;
+      // Load start transmitting sound (react-native-sound)
+      const startTransmittingSoundAsset = Asset.fromModule(require('@assets/audio/ui/space_notification1.mp3'));
+      await startTransmittingSoundAsset.downloadAsync();
+      const startUri = startTransmittingSoundAsset.localUri || startTransmittingSoundAsset.uri;
+      
+      this.startTransmittingSound = new Sound(startUri, '', (error) => {
+        if (error) {
+          logger.error({ message: 'Failed to load start transmitting sound', context: { error } });
+        }
+      });
 
-      // Load stop transmitting sound
-      const { sound: stopSound } = await Audio.Sound.createAsync(require('@assets/audio/ui/space_notification2.mp3'));
-      this.stopTransmittingSound = stopSound;
+      // Load stop transmitting sound (react-native-sound)
+      const stopTransmittingSoundAsset = Asset.fromModule(require('@assets/audio/ui/space_notification2.mp3'));
+      await stopTransmittingSoundAsset.downloadAsync();
+      const stopUri = stopTransmittingSoundAsset.localUri || stopTransmittingSoundAsset.uri;
 
-      // Load connected device sound
-      const { sound: connectedSound } = await Audio.Sound.createAsync(require('@assets/audio/ui/positive_interface_beep.mp3'));
-      this.connectedDeviceSound = connectedSound;
+      this.stopTransmittingSound = new Sound(stopUri, '', (error) => {
+        if (error) {
+          logger.error({ message: 'Failed to load stop transmitting sound', context: { error } });
+        }
+      });
 
-      // Load connect to audio room sound
-      const { sound: connectRoomSound } = await Audio.Sound.createAsync(require('@assets/audio/ui/software_interface_start.mp3'));
-      this.connectToAudioRoomSound = connectRoomSound;
+      // Load connected device sound (react-native-sound)
+      const connectedDeviceSoundAsset = Asset.fromModule(require('@assets/audio/ui/positive_interface_beep.mp3'));
+      await connectedDeviceSoundAsset.downloadAsync();
+      const connectedUri = connectedDeviceSoundAsset.localUri || connectedDeviceSoundAsset.uri;
 
-      // Load disconnect from audio room sound
-      const { sound: disconnectRoomSound } = await Audio.Sound.createAsync(require('@assets/audio/ui/software_interface_back.mp3'));
-      this.disconnectedFromAudioRoomSound = disconnectRoomSound;
+      this.connectedDeviceSound = new Sound(connectedUri, '', (error) => {
+        if (error) {
+            logger.error({ message: 'Failed to load connected device sound', context: { error } });
+        }
+      });
+
+      // Load connect to audio room sound (react-native-sound)
+      const connectToAudioRoomSoundAsset = Asset.fromModule(require('@assets/audio/ui/software_interface_start.mp3'));
+      await connectToAudioRoomSoundAsset.downloadAsync();
+      const connectRoomUri = connectToAudioRoomSoundAsset.localUri || connectToAudioRoomSoundAsset.uri;
+
+      this.connectToAudioRoomSound = new Sound(connectRoomUri, '', (error) => {
+        if (error) {
+            logger.error({ message: 'Failed to load connect to audio room sound', context: { error } });
+        }
+      });
+
+      // Load disconnect from audio room sound (react-native-sound)
+      const disconnectedFromAudioRoomSoundAsset = Asset.fromModule(require('@assets/audio/ui/software_interface_back.mp3'));
+      await disconnectedFromAudioRoomSoundAsset.downloadAsync();
+      const disconnectRoomUri = disconnectedFromAudioRoomSoundAsset.localUri || disconnectedFromAudioRoomSoundAsset.uri;
+
+      this.disconnectedFromAudioRoomSound = new Sound(disconnectRoomUri, '', (error) => {
+        if (error) {
+            logger.error({ message: 'Failed to load disconnect from audio room sound', context: { error } });
+        }
+      });
 
       logger.debug({
         message: 'Audio files loaded successfully',
@@ -119,10 +162,21 @@ class AudioService {
     }
   }
 
+  // Remove old playSound helper as we are using Sound directly now
+  // private async playSound... 
+
+  // Updated to use react-native-sound
   async playStartTransmittingSound(): Promise<void> {
     try {
       if (this.startTransmittingSound) {
-        await this.startTransmittingSound.replayAsync();
+        // Stop if playing
+        this.startTransmittingSound.stop();
+        // Play
+        this.startTransmittingSound.play((success) => {
+            if (!success) {
+                logger.warn({ message: 'Failed to play start transmitting sound (playback error)' });
+            }
+        });
       }
     } catch (error) {
       logger.error({
@@ -132,11 +186,19 @@ class AudioService {
     }
   }
 
+  // Updated to use react-native-sound
   async playStopTransmittingSound(): Promise<void> {
     try {
-      if (this.stopTransmittingSound) {
-        await this.stopTransmittingSound.replayAsync();
-      }
+        if (this.stopTransmittingSound) {
+            // Stop if playing
+            this.stopTransmittingSound.stop();
+            // Play
+            this.stopTransmittingSound.play((success) => {
+                if (!success) {
+                    logger.warn({ message: 'Failed to play stop transmitting sound (playback error)' });
+                }
+            });
+          }
     } catch (error) {
       logger.error({
         message: 'Failed to play stop transmitting sound',
@@ -148,8 +210,14 @@ class AudioService {
   async playConnectedDeviceSound(): Promise<void> {
     try {
       if (this.connectedDeviceSound) {
-        await this.connectedDeviceSound.replayAsync();
-        logger.debug({ message: 'Sound played successfully', context: { soundName: 'connectedDevice' } });
+        this.connectedDeviceSound.stop();
+        this.connectedDeviceSound.play((success) => {
+            if (success) {
+                logger.debug({ message: 'Sound played successfully', context: { soundName: 'connectedDevice' } });
+            } else {
+                logger.warn({ message: 'Failed to play connected device sound (playback error)' });
+            }
+        });
       }
     } catch (error) {
       logger.error({
@@ -161,9 +229,14 @@ class AudioService {
 
   async playConnectToAudioRoomSound(): Promise<void> {
     try {
-      if (this.connectToAudioRoomSound) {
-        await this.connectToAudioRoomSound.replayAsync();
-      }
+        if (this.connectToAudioRoomSound) {
+            this.connectToAudioRoomSound.stop();
+            this.connectToAudioRoomSound.play((success) => {
+                if (!success) {
+                    logger.warn({ message: 'Failed to play connect to audio room sound' });
+                }
+            });
+        }
     } catch (error) {
       logger.error({
         message: 'Failed to play connected to audio room sound',
@@ -174,9 +247,14 @@ class AudioService {
 
   async playDisconnectedFromAudioRoomSound(): Promise<void> {
     try {
-      if (this.disconnectedFromAudioRoomSound) {
-        await this.disconnectedFromAudioRoomSound.replayAsync();
-      }
+        if (this.disconnectedFromAudioRoomSound) {
+            this.disconnectedFromAudioRoomSound.stop();
+            this.disconnectedFromAudioRoomSound.play((success) => {
+                if (!success) {
+                    logger.warn({ message: 'Failed to play disconnected from audio room sound' });
+                }
+            });
+        }
     } catch (error) {
       logger.error({
         message: 'Failed to play disconnected from audio room sound',
@@ -187,21 +265,35 @@ class AudioService {
 
   async cleanup(): Promise<void> {
     try {
-      const sounds = [this.startTransmittingSound, this.stopTransmittingSound, this.connectedDeviceSound, this.connectToAudioRoomSound, this.disconnectedFromAudioRoomSound];
+      // Unload start transmitting sound
+      if (this.startTransmittingSound) {
+        this.startTransmittingSound.release();
+        this.startTransmittingSound = null;
+      }
 
-      await Promise.all(
-        sounds.map(async (sound) => {
-          if (sound) {
-            await sound.unloadAsync();
-          }
-        })
-      );
-
-      this.startTransmittingSound = null;
-      this.stopTransmittingSound = null;
-      this.connectedDeviceSound = null;
-      this.connectToAudioRoomSound = null;
-      this.disconnectedFromAudioRoomSound = null;
+      // Unload stop transmitting sound
+      if (this.stopTransmittingSound) {
+        this.stopTransmittingSound.release();
+        this.stopTransmittingSound = null;
+      }
+
+      // Unload connected device sound
+      if (this.connectedDeviceSound) {
+        this.connectedDeviceSound.release();
+        this.connectedDeviceSound = null;
+      }
+
+      // Unload connect to audio room sound
+      if (this.connectToAudioRoomSound) {
+        this.connectToAudioRoomSound.release();
+        this.connectToAudioRoomSound = null;
+      }
+
+      // Unload disconnect from audio room sound
+      if (this.disconnectedFromAudioRoomSound) {
+        this.disconnectedFromAudioRoomSound.release();
+        this.disconnectedFromAudioRoomSound = null;
+      }
 
       this.isInitialized = false;