Update src/lib/audio-recorder.ts

src/lib/audio-recorder.ts

@@ -4,7 +4,6 @@ import { audioContext } from "./utils";
 import AudioRecordingWorklet from "./worklets/audio-processing";
 import SafariAudioRecordingWorklet from "./worklets/safari-audio-processing";
 import VolMeterWorket from "./worklets/vol-meter";
-
 import { createWorketFromSrc } from "./audioworklet-registry";
 import EventEmitter from "eventemitter3";
 
@@ -18,292 +17,81 @@ function arrayBufferToBase64(buffer: ArrayBuffer) {
   return window.btoa(binary);
 }
 
-// Add Safari-specific audio context creation
 async function createSafariAudioContext(sampleRate: number): Promise<AudioContext> {
-  console.log('Creating Safari audio context with options:', { sampleRate });
-  
-  // Safari requires webkit prefix
   const AudioContextClass = (window as any).webkitAudioContext || window.AudioContext;
-  console.log('Using AudioContext class:', AudioContextClass.name);
-  
-  const ctx = new AudioContextClass({
-    sampleRate,
-    latencyHint: 'interactive'
-  });
-  
-  console.log('Safari AudioContext initial state:', {
-    state: ctx.state,
-    sampleRate: ctx.sampleRate,
-    baseLatency: ctx.baseLatency,
-    destination: ctx.destination,
-  });
-
-  // Safari requires user interaction to start audio context
+  const ctx = new AudioContextClass({ sampleRate, latencyHint: 'interactive' });
   if (ctx.state === 'suspended') {
-    console.log('Attempting to resume suspended Safari audio context...');
-    try {
-      await ctx.resume();
-      console.log('Successfully resumed Safari audio context:', ctx.state);
-    } catch (err) {
-      console.error('Failed to resume Safari audio context:', err);
-      throw err;
-    }
+    await ctx.resume();
   }
-
   return ctx;
 }
 
 export class AudioRecorder extends EventEmitter {
-  stream: MediaStream | undefined;
-  audioContext: AudioContext | undefined;
-  source: MediaStreamAudioSourceNode | undefined;
+  stream?: MediaStream;
+  audioContext?: AudioContext;
+  source?: MediaStreamAudioSourceNode;
   recording: boolean = false;
-  recordingWorklet: AudioWorkletNode | undefined;
-  vuWorklet: AudioWorkletNode | undefined;
-
+  recordingWorklet?: AudioWorkletNode;
+  vuWorklet?: AudioWorkletNode;
   private starting: Promise<void> | null = null;
-
   isSafari: boolean;
-  isIOS: boolean;
 
   constructor(public sampleRate = 16000) {
     super();
     this.isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
-    this.isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent) && !(window as any).MSStream;
-    console.log('AudioRecorder initialized:', { 
-      isSafari: this.isSafari, 
-      isIOS: this.isIOS,
-      sampleRate: this.sampleRate,
-      userAgent: navigator.userAgent,
-      webAudioSupport: !!(window.AudioContext || (window as any).webkitAudioContext),
-      mediaDevicesSupport: !!navigator.mediaDevices
-    });
   }
 
   async start() {
-    if (!navigator.mediaDevices?.getUserMedia) {
-      console.error('MediaDevices API not available:', { 
-        mediaDevices: !!navigator.mediaDevices,
-        getUserMedia: !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia)
-      });
-      throw new Error("Could not request user media");
-    }
-
-    console.log('Starting AudioRecorder with full environment info:', {
-      userAgent: navigator.userAgent,
-      platform: navigator.platform,
-      vendor: navigator.vendor,
-      audioWorkletSupport: !!(window.AudioWorklet),
-      sampleRate: this.sampleRate,
-      existingAudioContext: !!this.audioContext,
-      existingStream: !!this.stream,
-      isSafari: this.isSafari
-    });
-
+    if (this.recording || this.starting) return;
     this.starting = new Promise(async (resolve, reject) => {
       try {
-        if (this.isSafari) {
-          // Safari implementation
-          console.log('Safari detected - using Safari-specific audio initialization');
-          
-          // 1. First get audio permissions
-          console.log('Requesting audio permissions first for Safari...');
-          const constraints = {
-            audio: {
-              echoCancellation: false,
-              noiseSuppression: false,
-              autoGainControl: false,
-              sampleRate: this.sampleRate,
-              channelCount: 1
-            }
-          };
-          console.log('Safari audio constraints:', constraints);
-          
-          try {
-            this.stream = await navigator.mediaDevices.getUserMedia(constraints);
-            const track = this.stream.getAudioTracks()[0];
-            console.log('Safari audio permissions granted:', {
-              track: track.label,
-              settings: track.getSettings(),
-              constraints: track.getConstraints(),
-              enabled: track.enabled,
-              muted: track.muted,
-              readyState: track.readyState
-            });
-          } catch (err) {
-            console.error('Failed to get Safari audio permissions:', err);
-            throw err;
-          }
-
-          // 2. Create and initialize audio context
-          try {
-            this.audioContext = await createSafariAudioContext(this.sampleRate);
-            console.log('Safari audio context ready:', {
-              state: this.audioContext.state,
-              currentTime: this.audioContext.currentTime
-            });
-          } catch (err) {
-            console.error('Failed to initialize Safari audio context:', err);
-            throw err;
-          }
-
-          // 3. Create and connect audio source
-          try {
-            console.log('Creating Safari audio source...');
-            this.source = this.audioContext.createMediaStreamSource(this.stream);
-            console.log('Safari audio source created successfully:', {
-              numberOfInputs: this.source.numberOfInputs,
-              numberOfOutputs: this.source.numberOfOutputs,
-              channelCount: this.source.channelCount
-            });
-          } catch (err) {
-            console.error('Failed to create Safari audio source:', err);
-            throw err;
-          }
-
-          // 4. Load and create worklets
-          try {
-            const recordingWorkletName = "audio-recorder-worklet";
-            const vuWorkletName = "vu-meter";
-
-            console.log('Loading Safari audio worklets...');
-            await Promise.all([
-                this.audioContext.audioWorklet.addModule(createWorketFromSrc(recordingWorkletName, SafariAudioRecordingWorklet)),
-                this.audioContext.audioWorklet.addModule(createWorketFromSrc(vuWorkletName, VolMeterWorket))
-            ]);
-            console.log('Safari audio worklet modules loaded');
-
-            // Create Recording Worklet
-            this.recordingWorklet = new AudioWorkletNode(this.audioContext, recordingWorkletName, { processorOptions: { sampleRate: this.sampleRate } });
-            this.recordingWorklet.onprocessorerror = (event) => console.error('Safari AudioWorklet processor error:', event);
-            this.recordingWorklet.port.onmessageerror = (event) => console.error('Safari AudioWorklet message error:', event);
-            this.recordingWorklet.port.onmessage = (ev: MessageEvent) => {
-              const data = ev.data.data;
-              if (data?.int16arrayBuffer) {
-                // --- رویداد دیتا برای ارسال به سرور ---
-                this.emit("data", arrayBufferToBase64(data.int16arrayBuffer));
-              }
-            };
-            console.log('Safari Recording WorkletNode created successfully');
-
-            // --- 👇 تغییر اصلی اینجاست: اضافه کردن VU Meter برای سافاری 👇 ---
-            this.vuWorklet = new AudioWorkletNode(this.audioContext, vuWorkletName);
-            this.vuWorklet.port.onmessage = (ev: MessageEvent) => {
-                if (ev.data.volume) {
-                    // --- رویداد حجم صدا برای انیمیشن ---
-                    this.emit("data", '', ev.data.volume); 
-                }
-            };
-            console.log('Safari VU Meter WorkletNode created successfully');
-            // --- 👆 پایان تغییرات اصلی 👆 ---
-
-          } catch (err) {
-            console.error('Failed to setup Safari audio worklets:', err);
-            throw err;
-          }
-
-          // 5. Connect nodes
-          try {
-            console.log('Connecting Safari audio nodes...');
-            this.source.connect(this.recordingWorklet);
-            this.source.connect(this.vuWorklet); // <-- اتصال VU meter به سورس
-            console.log('Safari audio nodes connected successfully');
-          } catch (err) {
-            console.error('Failed to connect Safari audio nodes:', err);
-            throw err;
-          }
-
-        } else {
-          // Chrome/other browsers implementation
-          console.log('Non-Safari browser detected - using standard audio initialization');
-          
-          const constraints = { audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true, sampleRate: this.sampleRate } };
-          console.log('Chrome audio constraints:', constraints);
-          
-          try {
-            this.stream = await navigator.mediaDevices.getUserMedia(constraints);
-            const track = this.stream.getAudioTracks()[0];
-            console.log('Chrome audio permissions granted:', { track: track.label, settings: track.getSettings() });
-          } catch (err) {
-            console.error('Failed to get Chrome audio permissions:', err);
-            throw err;
-          }
-          
-          try {
-            this.audioContext = await audioContext({ sampleRate: this.sampleRate });
-            console.log('Chrome audio context created:', { state: this.audioContext.state, sampleRate: this.audioContext.sampleRate });
-          } catch (err) {
-            console.error('Failed to create Chrome audio context:', err);
-            throw err;
-          }
-
-          try {
-            this.source = this.audioContext.createMediaStreamSource(this.stream);
-            console.log('Chrome audio source created');
-          } catch (err) {
-            console.error('Failed to create Chrome audio source:', err);
-            throw err;
+        const constraints = {
+          audio: this.isSafari 
+            ? { sampleRate: this.sampleRate, channelCount: 1 } 
+            : { echoCancellation: true, noiseSuppression: true, autoGainControl: true, sampleRate: this.sampleRate }
+        };
+        this.stream = await navigator.mediaDevices.getUserMedia(constraints);
+        
+        this.audioContext = this.isSafari 
+            ? await createSafariAudioContext(this.sampleRate)
+            : await audioContext({ sampleRate: this.sampleRate });
+
+        this.source = this.audioContext.createMediaStreamSource(this.stream);
+
+        const recordingWorkletSrc = this.isSafari ? SafariAudioRecordingWorklet : AudioRecordingWorklet;
+        await this.audioContext.audioWorklet.addModule(createWorketFromSrc("recorder", recordingWorkletSrc));
+        await this.audioContext.audioWorklet.addModule(createWorketFromSrc("vumeter", VolMeterWorket));
+
+        this.recordingWorklet = new AudioWorkletNode(this.audioContext, "recorder", { processorOptions: { sampleRate: this.sampleRate } });
+        this.vuWorklet = new AudioWorkletNode(this.audioContext, "vumeter");
+
+        let lastVolume = 0;
+        
+        this.recordingWorklet.port.onmessage = (ev: MessageEvent) => {
+          const arrayBuffer = ev.data.data?.int16arrayBuffer;
+          if (arrayBuffer) {
+            const base64 = arrayBufferToBase64(arrayBuffer);
+            // ارسال همزمان دیتا و آخرین حجم صدای دریافتی
+            this.emit("data", base64, lastVolume);
           }
+        };
 
-          try {
-            const recordingWorkletName = "audio-recorder-worklet";
-            const vuWorkletName = "vu-meter";
-
-            await Promise.all([
-                this.audioContext.audioWorklet.addModule(createWorketFromSrc(recordingWorkletName, AudioRecordingWorklet)),
-                this.audioContext.audioWorklet.addModule(createWorketFromSrc(vuWorkletName, VolMeterWorket))
-            ]);
-            console.log('Chrome audio worklets loaded');
-
-            this.recordingWorklet = new AudioWorkletNode(this.audioContext, recordingWorkletName, { processorOptions: { sampleRate: this.sampleRate } });
-            this.recordingWorklet.onprocessorerror = (event) => console.error('Chrome AudioWorklet processor error:', event);
-            this.recordingWorklet.port.onmessageerror = (event) => console.error('Chrome AudioWorklet message error:', event);
-            
-            this.vuWorklet = new AudioWorkletNode(this.audioContext, vuWorkletName);
-            
-            // یک onmessage handler برای هر دو رویداد
-            let lastBase64 = '';
-            let lastVolume = 0;
-
-            const handleMessage = () => {
-                this.emit("data", lastBase64, lastVolume);
-            }
-
-            this.recordingWorklet.port.onmessage = async (ev: MessageEvent) => {
-              const arrayBuffer = ev.data.data?.int16arrayBuffer;
-              if (arrayBuffer) {
-                lastBase64 = arrayBufferToBase64(arrayBuffer);
-                handleMessage();
-              }
-            };
-            
-            this.vuWorklet.port.onmessage = (ev: MessageEvent) => {
-              if (ev.data.volume !== undefined) {
-                lastVolume = ev.data.volume;
-                handleMessage();
-              }
-            };
-            
-            console.log('Chrome AudioWorkletNodes created');
-
-            this.source.connect(this.recordingWorklet);
-            this.source.connect(this.vuWorklet);
-            console.log('Chrome audio nodes connected');
-
-          } catch (err) {
-            console.error('Failed to setup/connect Chrome audio nodes:', err);
-            throw err;
+        this.vuWorklet.port.onmessage = (ev: MessageEvent) => {
+          if (typeof ev.data.volume === 'number') {
+            lastVolume = ev.data.volume;
           }
-        }
+        };
 
+        this.source.connect(this.recordingWorklet);
+        this.source.connect(this.vuWorklet);
+        
         this.recording = true;
-        console.log('Recording started successfully');
         resolve();
-        this.starting = null;
       } catch (error) {
         console.error('Failed to start recording:', error);
         this.stop();
         reject(error);
+      } finally {
         this.starting = null;
       }
     });
@@ -311,41 +99,25 @@ export class AudioRecorder extends EventEmitter {
   }
 
   stop() {
-    console.log('Stopping audio recorder...');
+    if (!this.recording && !this.starting) return;
     const handleStop = () => {
-      try {
         this.recording = false;
-        if (this.source) {
-          console.log('Disconnecting audio source...');
-          this.source.disconnect();
-        }
-        if (this.stream) {
-          console.log('Stopping media stream tracks...');
-          this.stream.getTracks().forEach(track => {
-            track.stop();
-            console.log('Stopped track:', track.label);
-          });
-        }
-        if (this.audioContext && (this.audioContext.state === 'running' || this.isSafari)) {
-          console.log('Closing audio context...');
-          this.audioContext.close();
+        this.source?.disconnect();
+        this.stream?.getTracks().forEach(track => track.stop());
+        if (this.audioContext?.state === 'running') {
+            this.audioContext.close();
         }
         this.stream = undefined;
+        this.audioContext = undefined;
+        this.source = undefined;
         this.recordingWorklet = undefined;
         this.vuWorklet = undefined;
-        this.source = undefined;
-        this.audioContext = undefined;
         this.emit("stop");
-        console.log('Audio recorder stopped successfully');
-      } catch (err) {
-        console.error('Error while stopping audio recorder:', err);
-      }
     };
     if (this.starting) {
-      console.log('Stop called while starting - waiting for start to complete...');
-      this.starting.then(handleStop);
-      return;
+      this.starting.then(handleStop).catch(handleStop);
+    } else {
+      handleStop();
     }
-    handleStop();
   }
 }