Create audio-stream.service.ts

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

@@ -0,0 +1,130 @@
+import { Injectable } from '@angular/core';
+import { Subject, Observable } from 'rxjs';
+
+export interface AudioChunk {
+  data: string;  // base64 encoded audio
+  timestamp: number;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AudioStreamService {
+  private mediaStream: MediaStream | null = null;
+  private audioContext: AudioContext | null = null;
+  private processor: ScriptProcessorNode | null = null;
+  private source: MediaStreamAudioSourceNode | null = null;
+  private isRecording = false;
+  
+  private audioChunkSubject = new Subject<AudioChunk>();
+  public audioChunk$ = this.audioChunkSubject.asObservable();
+  
+  private errorSubject = new Subject<string>();
+  public error$ = this.errorSubject.asObservable();
+
+  constructor() {}
+
+  async startRecording(): Promise<void> {
+    try {
+      // Request microphone access
+      this.mediaStream = await navigator.mediaDevices.getUserMedia({ 
+        audio: {
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true,
+          sampleRate: 16000
+        } 
+      });
+      
+      // Create audio context
+      this.audioContext = new (window.AudioContext || (window as any).webkitAudioContext)({
+        sampleRate: 16000
+      });
+      
+      // Create audio source
+      this.source = this.audioContext.createMediaStreamSource(this.mediaStream);
+      
+      // Create script processor for capturing audio
+      this.processor = this.audioContext.createScriptProcessor(4096, 1, 1);
+      
+      this.processor.onaudioprocess = (e) => {
+        if (this.isRecording) {
+          const audioData = e.inputBuffer.getChannelData(0);
+          const audioChunk = this.convertToBase64(audioData);
+          
+          this.audioChunkSubject.next({
+            data: audioChunk,
+            timestamp: Date.now()
+          });
+        }
+      };
+      
+      // Connect nodes
+      this.source.connect(this.processor);
+      this.processor.connect(this.audioContext.destination);
+      
+      this.isRecording = true;
+      console.log('🎤 Recording started');
+      
+    } catch (error) {
+      console.error('Failed to start recording:', error);
+      this.errorSubject.next('Mikrofon erişimi sağlanamadı. Lütfen izinleri kontrol edin.');
+      throw error;
+    }
+  }
+
+  stopRecording(): void {
+    if (this.processor) {
+      this.processor.disconnect();
+      this.processor = null;
+    }
+    
+    if (this.source) {
+      this.source.disconnect();
+      this.source = null;
+    }
+    
+    if (this.audioContext) {
+      this.audioContext.close();
+      this.audioContext = null;
+    }
+    
+    if (this.mediaStream) {
+      this.mediaStream.getTracks().forEach(track => track.stop());
+      this.mediaStream = null;
+    }
+    
+    this.isRecording = false;
+    console.log('🎤 Recording stopped');
+  }
+
+  private convertToBase64(audioData: Float32Array): string {
+    // Convert float32 to int16
+    const length = audioData.length;
+    const buffer = new ArrayBuffer(length * 2);
+    const view = new DataView(buffer);
+    
+    for (let i = 0; i < length; i++) {
+      const sample = Math.max(-1, Math.min(1, audioData[i]));
+      view.setInt16(i * 2, sample * 0x7FFF, true);
+    }
+    
+    // Convert to base64
+    const uint8Array = new Uint8Array(buffer);
+    let binary = '';
+    for (let i = 0; i < uint8Array.byteLength; i++) {
+      binary += String.fromCharCode(uint8Array[i]);
+    }
+    
+    return btoa(binary);
+  }
+
+  isCurrentlyRecording(): boolean {
+    return this.isRecording;
+  }
+
+  // Utility method to check browser support
+  static checkBrowserSupport(): boolean {
+    return !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia);
+  }
+}