Update flare-ui/src/app/services/audio-stream.service.ts

flare-ui/src/app/services/audio-stream.service.ts

@@ -1,14 +1,20 @@
-// audio-stream.service.ts (YENİ DOSYA)
+// audio-stream.service.ts
 // Path: /flare-ui/src/app/services/audio-stream.service.ts
 
 import { Injectable, OnDestroy } from '@angular/core';
-import { Subject, Observable } from 'rxjs';
+import { Subject, Observable, throwError } from 'rxjs';
 
 export interface AudioChunk {
   data: string; // Base64 encoded audio
   timestamp: number;
 }
 
+export interface AudioStreamError {
+  type: 'permission' | 'device' | 'browser' | 'unknown';
+  message: string;
+  originalError?: any;
+}
+
 @Injectable({
   providedIn: 'root'
 })
@@ -17,9 +23,18 @@ export class AudioStreamService implements OnDestroy {
   private audioStream: MediaStream | null = null;
   private audioChunkSubject = new Subject<AudioChunk>();
   private recordingStateSubject = new Subject<boolean>();
+  private errorSubject = new Subject<AudioStreamError>();
+  private volumeLevelSubject = new Subject<number>();
   
   public audioChunk$ = this.audioChunkSubject.asObservable();
   public recordingState$ = this.recordingStateSubject.asObservable();
+  public error$ = this.errorSubject.asObservable();
+  public volumeLevel$ = this.volumeLevelSubject.asObservable();
+  
+  // Audio analysis
+  private audioContext: AudioContext | null = null;
+  private analyser: AnalyserNode | null = null;
+  private volumeInterval: any;
   
   // Audio constraints
   private constraints = {
@@ -33,41 +48,57 @@ export class AudioStreamService implements OnDestroy {
   };
   
   ngOnDestroy(): void {
-    this.stopRecording();
+    this.cleanup();
   }
   
   static checkBrowserSupport(): boolean {
-    return !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia);
+    return !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia && window.MediaRecorder);
   }
   
   async startRecording(): Promise<void> {
     try {
+      // Check browser support
+      if (!AudioStreamService.checkBrowserSupport()) {
+        throw this.createError('browser', 'Your browser does not support audio recording');
+      }
+
+      // Check permission first
+      const permission = await this.checkMicrophonePermission();
+      if (permission === 'denied') {
+        throw this.createError('permission', 'Microphone permission denied');
+      }
+
       // Request microphone access
-      this.audioStream = await navigator.mediaDevices.getUserMedia(this.constraints);
+      try {
+        this.audioStream = await navigator.mediaDevices.getUserMedia(this.constraints);
+      } catch (error: any) {
+        if (error.name === 'NotAllowedError' || error.name === 'PermissionDeniedError') {
+          throw this.createError('permission', 'Microphone access denied', error);
+        } else if (error.name === 'NotFoundError' || error.name === 'DevicesNotFoundError') {
+          throw this.createError('device', 'No microphone found', error);
+        } else {
+          throw this.createError('device', `Failed to access microphone: ${error.message}`, error);
+        }
+      }
       
       // Create MediaRecorder with appropriate format
       const options: MediaRecorderOptions = {
         mimeType: this.getPreferredMimeType()
       };
       
-      this.mediaRecorder = new MediaRecorder(this.audioStream, options);
+      try {
+        this.mediaRecorder = new MediaRecorder(this.audioStream, options);
+      } catch (error) {
+        // Fallback to default options if preferred mime type fails
+        console.warn('Failed with preferred mime type, using defaults:', error);
+        this.mediaRecorder = new MediaRecorder(this.audioStream);
+      }
       
-      // Handle data available
-      this.mediaRecorder.ondataavailable = async (event) => {
-        if (event.data.size > 0) {
-          const base64Data = await this.blobToBase64(event.data);
-          this.audioChunkSubject.next({
-            data: base64Data,
-            timestamp: Date.now()
-          });
-        }
-      };
+      // Set up event handlers
+      this.setupMediaRecorderHandlers();
       
-      // Handle errors
-      this.mediaRecorder.onerror = (error) => {
-        console.error('MediaRecorder error:', error);
-        this.stopRecording();
-      };
+      // Start volume monitoring
+      this.startVolumeMonitoring();
       
       // Start recording with timeslice for real-time streaming
       this.mediaRecorder.start(100); // Send chunks every 100ms
@@ -75,25 +106,68 @@ export class AudioStreamService implements OnDestroy {
       
       console.log('✅ Audio recording started');
       
-    } catch (error) {
+    } catch (error: any) {
       console.error('Failed to start recording:', error);
+      this.cleanup();
+      
+      // Emit error
+      if (error.type) {
+        this.errorSubject.next(error);
+      } else {
+        this.errorSubject.next(this.createError('unknown', error.message || 'Failed to start recording', error));
+      }
+      
       throw error;
     }
   }
   
   stopRecording(): void {
-    if (this.mediaRecorder && this.mediaRecorder.state !== 'inactive') {
-      this.mediaRecorder.stop();
-      this.mediaRecorder = null;
+    try {
+      if (this.mediaRecorder && this.mediaRecorder.state !== 'inactive') {
+        this.mediaRecorder.stop();
+      }
+      
+      this.cleanup();
+      this.recordingStateSubject.next(false);
+      console.log('🛑 Audio recording stopped');
+    } catch (error) {
+      console.error('Error stopping recording:', error);
+      this.cleanup();
     }
+  }
+  
+  private setupMediaRecorderHandlers(): void {
+    if (!this.mediaRecorder) return;
+
+    // Handle data available
+    this.mediaRecorder.ondataavailable = async (event) => {
+      try {
+        if (event.data && event.data.size > 0) {
+          const base64Data = await this.blobToBase64(event.data);
+          this.audioChunkSubject.next({
+            data: base64Data,
+            timestamp: Date.now()
+          });
+        }
+      } catch (error) {
+        console.error('Error processing audio chunk:', error);
+        this.errorSubject.next(this.createError('unknown', 'Failed to process audio chunk', error));
+      }
+    };
     
-    if (this.audioStream) {
-      this.audioStream.getTracks().forEach(track => track.stop());
-      this.audioStream = null;
-    }
+    // Handle recording stop
+    this.mediaRecorder.onstop = () => {
+      console.log('MediaRecorder stopped');
+      this.cleanup();
+    };
     
-    this.recordingStateSubject.next(false);
-    console.log('🛑 Audio recording stopped');
+    // Handle errors
+    this.mediaRecorder.onerror = (event: any) => {
+      console.error('MediaRecorder error:', event);
+      const error = this.createError('unknown', `Recording error: ${event.error?.message || 'Unknown error'}`, event.error);
+      this.errorSubject.next(error);
+      this.stopRecording();
+    };
   }
   
   private getPreferredMimeType(): string {
@@ -101,7 +175,8 @@ export class AudioStreamService implements OnDestroy {
       'audio/webm;codecs=opus',
       'audio/webm',
       'audio/ogg;codecs=opus',
-      'audio/ogg'
+      'audio/ogg',
+      'audio/mp4'
     ];
     
     for (const type of types) {
@@ -111,7 +186,8 @@ export class AudioStreamService implements OnDestroy {
       }
     }
     
-    // Fallback to default
+    // Return empty to use browser default
+    console.warn('No supported MIME types found, using browser default');
     return '';
   }
   
@@ -119,52 +195,184 @@ export class AudioStreamService implements OnDestroy {
     return new Promise((resolve, reject) => {
       const reader = new FileReader();
       reader.onloadend = () => {
-        if (reader.result) {
+        if (reader.result && typeof reader.result === 'string') {
           // Remove data URL prefix
-          const base64 = (reader.result as string).split(',')[1];
+          const base64 = reader.result.split(',')[1];
           resolve(base64);
         } else {
           reject(new Error('Failed to convert blob to base64'));
         }
       };
-      reader.onerror = reject;
+      reader.onerror = () => {
+        reject(new Error('FileReader error'));
+      };
       reader.readAsDataURL(blob);
     });
   }
   
   // Volume level monitoring
-  async getVolumeLevel(): Promise<number> {
-    if (!this.audioStream) return 0;
-    
-    const audioContext = new AudioContext();
-    const analyser = audioContext.createAnalyser();
-    const source = audioContext.createMediaStreamSource(this.audioStream);
+  private startVolumeMonitoring(): void {
+    if (!this.audioStream) return;
     
-    source.connect(analyser);
-    analyser.fftSize = 256;
-    
-    const dataArray = new Uint8Array(analyser.frequencyBinCount);
-    analyser.getByteFrequencyData(dataArray);
-    
-    // Calculate average volume
-    const average = dataArray.reduce((sum, value) => sum + value, 0) / dataArray.length;
+    try {
+      this.audioContext = new AudioContext();
+      this.analyser = this.audioContext.createAnalyser();
+      const source = this.audioContext.createMediaStreamSource(this.audioStream);
+      
+      source.connect(this.analyser);
+      this.analyser.fftSize = 256;
+      
+      const dataArray = new Uint8Array(this.analyser.frequencyBinCount);
+      
+      // Monitor volume every 100ms
+      this.volumeInterval = setInterval(() => {
+        if (this.analyser) {
+          this.analyser.getByteFrequencyData(dataArray);
+          
+          // Calculate average volume
+          const sum = dataArray.reduce((acc, val) => acc + val, 0);
+          const average = sum / dataArray.length;
+          const normalizedVolume = average / 255; // Normalize to 0-1
+          
+          this.volumeLevelSubject.next(normalizedVolume);
+        }
+      }, 100);
+    } catch (error) {
+      console.warn('Failed to start volume monitoring:', error);
+    }
+  }
+  
+  private stopVolumeMonitoring(): void {
+    if (this.volumeInterval) {
+      clearInterval(this.volumeInterval);
+      this.volumeInterval = null;
+    }
     
-    // Cleanup
-    source.disconnect();
-    audioContext.close();
+    if (this.audioContext) {
+      try {
+        this.audioContext.close();
+      } catch (error) {
+        console.warn('Error closing audio context:', error);
+      }
+      this.audioContext = null;
+      this.analyser = null;
+    }
+  }
+  
+  async getVolumeLevel(): Promise<number> {
+    if (!this.audioStream || !this.analyser) return 0;
     
-    return average / 255; // Normalize to 0-1
+    try {
+      const dataArray = new Uint8Array(this.analyser.frequencyBinCount);
+      this.analyser.getByteFrequencyData(dataArray);
+      
+      // Calculate average volume
+      const average = dataArray.reduce((sum, value) => sum + value, 0) / dataArray.length;
+      
+      return average / 255; // Normalize to 0-1
+    } catch (error) {
+      console.error('Error getting volume level:', error);
+      return 0;
+    }
   }
   
   // Check microphone permissions
   async checkMicrophonePermission(): Promise<PermissionState> {
     try {
+      // First check if Permissions API is available
+      if (!navigator.permissions || !navigator.permissions.query) {
+        console.warn('Permissions API not supported');
+        // Try to check by attempting getUserMedia with video disabled
+        try {
+          const stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: false });
+          stream.getTracks().forEach(track => track.stop());
+          return 'granted';
+        } catch (error: any) {
+          if (error.name === 'NotAllowedError' || error.name === 'PermissionDeniedError') {
+            return 'denied';
+          }
+          return 'prompt';
+        }
+      }
+      
+      // Use Permissions API
       const result = await navigator.permissions.query({ name: 'microphone' as PermissionName });
       return result.state;
     } catch (error) {
-      console.warn('Permissions API not supported:', error);
-      // Assume granted if API not supported
-      return 'granted';
+      console.warn('Error checking microphone permission:', error);
+      // Assume prompt state if we can't determine
+      return 'prompt';
     }
   }
-}
+  
+  private cleanup(): void {
+    try {
+      // Stop media recorder
+      if (this.mediaRecorder && this.mediaRecorder.state !== 'inactive') {
+        this.mediaRecorder.stop();
+      }
+      this.mediaRecorder = null;
+      
+      // Stop all tracks
+      if (this.audioStream) {
+        this.audioStream.getTracks().forEach(track => {
+          track.stop();
+        });
+        this.audioStream = null;
+      }
+      
+      // Stop volume monitoring
+      this.stopVolumeMonitoring();
+      
+    } catch (error) {
+      console.error('Error during cleanup:', error);
+    }
+  }
+  
+  private createError(type: AudioStreamError['type'], message: string, originalError?: any): AudioStreamError {
+    return {
+      type,
+      message,
+      originalError
+    };
+  }
+  
+  // Get recording state
+  isRecording(): boolean {
+    return this.mediaRecorder !== null && this.mediaRecorder.state === 'recording';
+  }
+  
+  // Get available audio devices
+  async getAudioDevices(): Promise<MediaDeviceInfo[]> {
+    try {
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      return devices.filter(device => device.kind === 'audioinput');
+    } catch (error) {
+      console.error('Error enumerating devices:', error);
+      return [];
+    }
+  }
+  
+  // Switch audio device
+  async switchAudioDevice(deviceId: string): Promise<void> {
+    if (this.isRecording()) {
+      // Stop current recording
+      this.stopRecording();
+      
+      // Update constraints with new device
+      this.constraints.audio = {
+        ...this.constraints.audio,
+        deviceId: { exact: deviceId }
+      } as any;
+      
+      // Restart recording with new device
+      await this.startRecording();
+    } else {
+      // Just update constraints for next recording
+      this.constraints.audio = {
+        ...this.constraints.audio,
+        deviceId: { exact: deviceId }
+      } as any;
+    }
+  }
+}