feat: replace expo-av with expo-audio for audio handling and update related functions

Author: Gabry848

app.json

@@ -44,7 +44,6 @@
     },
     "plugins": [
       "expo-asset",
-      "expo-av",
       [
         "expo-splash-screen",
         {

package-lock.json

@@ -38,7 +38,6 @@
     "eventsource": "^4.0.0",
     "expo": "~53.0.23",
     "expo-audio": "~0.4.9",
-    "expo-av": "^15.1.7",
     "expo-blur": "~14.1.5",
     "expo-constants": "~17.1.7",
     "expo-crypto": "^14.1.5",

package.json

@@ -1,9 +1,20 @@
 import { TaskCacheService, OfflineChange } from './TaskCacheService';
 import StorageManager from './StorageManager';
 import NetworkService, { NetworkState } from './NetworkService';
-import { getAllTasks as getTasksFromAPI, getCategories as getCategoriesFromAPI, addTask as addTaskToAPI, updateTask as updateTaskToAPI, deleteTask as deleteTaskFromAPI } from './taskService';
 import { emitTasksSynced } from '../utils/eventEmitter';
 
+// Lazy import per evitare require cycle con taskService
+async function getTaskServiceFunctions() {
+  const taskService = await import('./taskService');
+  return {
+    getTasksFromAPI: taskService.getAllTasks,
+    getCategoriesFromAPI: taskService.getCategories,
+    addTaskToAPI: taskService.addTask,
+    updateTaskToAPI: taskService.updateTask,
+    deleteTaskFromAPI: taskService.deleteTask,
+  };
+}
+
 export interface SyncStatus {
   isOnline: boolean;
   isSyncing: boolean;
@@ -184,18 +195,21 @@ class SyncManager {
     switch (change.type) {
       case 'CREATE':
         if (change.entityType === 'TASK') {
+          const { addTaskToAPI } = await getTaskServiceFunctions();
           await addTaskToAPI(change.data);
         }
         break;
 
       case 'UPDATE':
         if (change.entityType === 'TASK') {
+          const { updateTaskToAPI } = await getTaskServiceFunctions();
           await updateTaskToAPI(change.data.id || change.data.task_id, change.data);
         }
         break;
 
       case 'DELETE':
         if (change.entityType === 'TASK') {
+          const { deleteTaskFromAPI } = await getTaskServiceFunctions();
           await deleteTaskFromAPI(change.data.id || change.data.task_id);
         }
         break;
@@ -220,6 +234,7 @@ class SyncManager {
       console.log('[SYNC] 🔄 Aggiornamento dati dal server...');
 
       // Carica tasks e categorie dal server
+      const { getTasksFromAPI, getCategoriesFromAPI } = await getTaskServiceFunctions();
       const [tasks, categories] = await Promise.all([
         getTasksFromAPI(),
         getCategoriesFromAPI()
@@ -312,17 +327,23 @@ class SyncManager {
         await this.syncDataFromServer();
         break;
 
-      case 'CREATE_TASK':
+      case 'CREATE_TASK': {
+        const { addTaskToAPI } = await getTaskServiceFunctions();
         await addTaskToAPI(operation.data);
         break;
+      }
 
-      case 'UPDATE_TASK':
+      case 'UPDATE_TASK': {
+        const { updateTaskToAPI } = await getTaskServiceFunctions();
         await updateTaskToAPI(operation.data.id, operation.data.task);
         break;
+      }
 
-      case 'DELETE_TASK':
+      case 'DELETE_TASK': {
+        const { deleteTaskFromAPI } = await getTaskServiceFunctions();
         await deleteTaskFromAPI(operation.data.id);
         break;
+      }
 
       default:
         throw new Error(`Operazione non supportata: ${operation.type}`);

src/services/SyncManager.ts

@@ -6,15 +6,14 @@ export function debugAudioDependencies() {
   console.log('=== DEBUG AUDIO DEPENDENCIES ===');
 
   try {
-    // Test import expo-av
-    const Audio = require('expo-av').Audio;
-    console.log('✅ expo-av importato correttamente');
-    console.log('Audio object:', !!Audio);
-    console.log('Audio.requestPermissionsAsync:', !!Audio?.requestPermissionsAsync);
-    console.log('Audio.Recording:', !!Audio?.Recording);
-    console.log('Audio.Sound:', !!Audio?.Sound);
+    // Test import expo-audio
+    const expoAudio = require('expo-audio');
+    console.log('✅ expo-audio importato correttamente');
+    console.log('createAudioPlayer:', !!expoAudio?.createAudioPlayer);
+    console.log('setAudioModeAsync:', !!expoAudio?.setAudioModeAsync);
+    console.log('requestRecordingPermissionsAsync:', !!expoAudio?.requestRecordingPermissionsAsync);
   } catch (error) {
-    console.error('❌ Errore import expo-av:', error);
+    console.error('❌ Errore import expo-audio:', error);
   }
 
   try {
@@ -48,8 +47,8 @@ export async function debugAudioPermissions() {
   console.log('=== DEBUG AUDIO PERMISSIONS ===');
 
   try {
-    const { Audio } = require('expo-av');
-    const result = await Audio.requestPermissionsAsync();
+    const { requestRecordingPermissionsAsync } = require('expo-audio');
+    const result = await requestRecordingPermissionsAsync();
     console.log('Risultato richiesta permessi:', result);
     console.log('Permessi concessi:', result.granted);
     console.log('Status:', result.status);

src/utils/audioDebug.ts

@@ -1,4 +1,5 @@
-import { Audio } from 'expo-av';
+import { createAudioPlayer, setAudioModeAsync, requestRecordingPermissionsAsync } from 'expo-audio';
+import type { AudioPlayer as ExpoAudioPlayer } from 'expo-audio/build/AudioModule.types';
 import * as FileSystem from 'expo-file-system';
 import { VoiceProcessor } from '@picovoice/react-native-voice-processor';
 
@@ -274,10 +275,10 @@ export class AudioRecorder {
 
 /**
  * Classe per gestire la riproduzione di chunk audio PCM16
- * Usa expo-av per il playback
+ * Usa expo-audio per il playback
  */
 export class AudioPlayer {
-  private currentSound: Audio.Sound | null = null;
+  private currentPlayer: ExpoAudioPlayer | null = null;
   private chunkBuffer: { index?: number; data: string }[] = [];
   private seenChunkIndexes: Set<number> = new Set();
   private highestIndexedChunk: number = -1;
@@ -353,7 +354,7 @@ export class AudioPlayer {
 
       console.log(`AudioPlayer: ${totalChunks} chunk -> ${pcm16Data.length} bytes PCM16`);
 
-      // Wrappa in WAV per la riproduzione con expo-av
+      // Wrappa in WAV per la riproduzione con expo-audio
       const wavData = wrapPcm16InWav(pcm16Data, AUDIO_CONFIG.SAMPLE_RATE);
       const wavBase64 = encodeBase64(wavData);
 
@@ -362,25 +363,23 @@ export class AudioPlayer {
         encoding: FileSystem.EncodingType.Base64,
       });
 
-      await Audio.setAudioModeAsync({
-        allowsRecordingIOS: false,
+      await setAudioModeAsync({
         playsInSilentModeIOS: true,
-        staysActiveInBackground: true,
-        shouldDuckAndroid: true,
-        playThroughEarpieceAndroid: false,
+        shouldPlayInBackground: true,
+        shouldRouteThroughEarpiece: false,
       });
 
-      const { sound } = await Audio.Sound.createAsync({ uri: tempPath });
-      this.currentSound = sound;
+      const player = createAudioPlayer({ uri: tempPath });
+      this.currentPlayer = player;
 
-      this.currentSound.setOnPlaybackStatusUpdate(async (status) => {
-        if (status.isLoaded && status.didJustFinish) {
+      player.addListener('playbackStatusUpdate', async (status) => {
+        if (status.didJustFinish) {
           console.log('AudioPlayer: Riproduzione completata');
           await this.onPlaybackComplete(onComplete, tempPath);
         }
       });
 
-      await this.currentSound.playAsync();
+      player.play();
       this.isPlaying = true;
       this.clearChunks();
 
@@ -404,13 +403,13 @@ export class AudioPlayer {
   }
 
   private async onPlaybackComplete(onComplete?: () => void, audioFilePath?: string): Promise<void> {
-    if (this.currentSound) {
+    if (this.currentPlayer) {
       try {
-        await this.currentSound.unloadAsync();
+        this.currentPlayer.remove();
       } catch (error) {
         console.error('Errore cleanup audio:', error);
       }
-      this.currentSound = null;
+      this.currentPlayer = null;
     }
 
     if (audioFilePath) {
@@ -426,14 +425,14 @@ export class AudioPlayer {
   }
 
   async stopPlayback(): Promise<void> {
-    if (this.currentSound) {
+    if (this.currentPlayer) {
       try {
-        await this.currentSound.stopAsync();
-        await this.currentSound.unloadAsync();
+        this.currentPlayer.pause();
+        this.currentPlayer.remove();
       } catch (error) {
         console.error('Errore stop riproduzione:', error);
       }
-      this.currentSound = null;
+      this.currentPlayer = null;
     }
     this.isPlaying = false;
   }
@@ -473,7 +472,7 @@ export function base64ToArrayBuffer(base64: string): ArrayBuffer {
  */
 export async function checkAudioPermissions(): Promise<boolean> {
   try {
-    const { status } = await Audio.requestPermissionsAsync();
+    const { status } = await requestRecordingPermissionsAsync();
     return status === 'granted';
   } catch (error) {
     console.error('Errore controllo permessi audio:', error);