@siteed/expo-audio-studio 2.4.1 → 2.6.0

package/build/ExpoAudioStream.web.js

@@ -27,15 +27,12 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
     latestPosition = 0;
     totalCompressedSize = 0;
     maxBufferSize;
+    eventCallback;
     constructor({ audioWorkletUrl, featuresExtratorUrl, logger, maxBufferSize = 100, // Default to storing last 100 chunks (1 chunk = 0.5 seconds)
      }) {
         const mockNativeModule = {
-            addListener: () => {
-                // Not used on web
-            },
-            removeListeners: () => {
-                // Not used on web
-            },
+            addListener: () => { },
+            removeListeners: () => { },
         };
         super(mockNativeModule); // Pass the mock native module to the parent class
         this.logger = logger;
@@ -63,21 +60,104 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
     // Utility to handle user media stream
     async getMediaStream() {
         try {
-            return await navigator.mediaDevices.getUserMedia({ audio: true });
+            this.logger?.debug('Requesting user media (microphone)...');
+            // First check if the browser supports the necessary audio APIs
+            if (!navigator?.mediaDevices?.getUserMedia) {
+                this.logger?.error('Browser does not support mediaDevices.getUserMedia');
+                throw new Error('Browser does not support audio recording');
+            }
+            // Get media with detailed audio constraints for better diagnostics
+            const constraints = {
+                audio: {
+                    echoCancellation: true,
+                    noiseSuppression: true,
+                    autoGainControl: true,
+                    // Add deviceId constraint if specified
+                    ...(this.recordingConfig?.deviceId
+                        ? {
+                            deviceId: {
+                                exact: this.recordingConfig.deviceId,
+                            },
+                        }
+                        : {}),
+                },
+            };
+            this.logger?.debug('Media constraints:', constraints);
+            const stream = await navigator.mediaDevices.getUserMedia(constraints);
+            // Get detailed info about the audio track for debugging
+            const audioTracks = stream.getAudioTracks();
+            if (audioTracks.length > 0) {
+                const track = audioTracks[0];
+                const settings = track.getSettings();
+                this.logger?.debug('Audio track obtained:', {
+                    label: track.label,
+                    id: track.id,
+                    enabled: track.enabled,
+                    muted: track.muted,
+                    readyState: track.readyState,
+                    settings,
+                });
+            }
+            else {
+                this.logger?.warn('Stream has no audio tracks!');
+            }
+            return stream;
         }
         catch (error) {
             this.logger?.error('Failed to get media stream:', error);
             throw error;
         }
     }
+    // Prepare recording with options
+    async prepareRecording(recordingConfig = {}) {
+        if (this.isRecording) {
+            this.logger?.warn('Cannot prepare: Recording is already in progress');
+            return false;
+        }
+        try {
+            // Check permissions and initialize basic settings
+            await this.getMediaStream().then((stream) => {
+                // Just verify we can access the microphone by getting a stream, then release it
+                stream.getTracks().forEach((track) => track.stop());
+            });
+            this.bitDepth = encodingToBitDepth({
+                encoding: recordingConfig.encoding ?? 'pcm_32bit',
+            });
+            // Store recording configuration for later use
+            this.recordingConfig = recordingConfig;
+            // Use custom filename if provided, otherwise fallback to timestamp
+            if (recordingConfig.filename) {
+                // Remove any existing extension from the filename
+                this.streamUuid = recordingConfig.filename.replace(/\.[^/.]+$/, '');
+            }
+            else {
+                this.streamUuid = Date.now().toString();
+            }
+            this.logger?.debug('Recording preparation completed successfully');
+            return true;
+        }
+        catch (error) {
+            this.logger?.error('Error preparing recording:', error);
+            return false;
+        }
+    }
     // Start recording with options
     async startRecording(recordingConfig = {}) {
         if (this.isRecording) {
             throw new Error('Recording is already in progress');
         }
-        this.bitDepth = encodingToBitDepth({
-            encoding: recordingConfig.encoding ?? 'pcm_32bit',
-        });
+        // If we haven't prepared or have different settings, prepare now
+        if (!this.recordingConfig ||
+            this.recordingConfig.sampleRate !== recordingConfig.sampleRate ||
+            this.recordingConfig.channels !== recordingConfig.channels ||
+            this.recordingConfig.encoding !== recordingConfig.encoding) {
+            await this.prepareRecording(recordingConfig);
+        }
+        else {
+            this.logger?.debug('Using previously prepared recording configuration');
+        }
+        // Save recording config for reference
+        this.recordingConfig = recordingConfig;
         const audioContext = new (window.AudioContext ||
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore - Allow webkitAudioContext for Safari
@@ -89,33 +169,13 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
             audioContext,
             source,
             recordingConfig,
-            emitAudioEventCallback: ({ data, position, compression, }) => {
-                // Keep only the latest chunks based on maxBufferSize
-                this.audioChunks.push(new Float32Array(data));
-                if (this.audioChunks.length > this.maxBufferSize) {
-                    this.audioChunks.shift(); // Remove oldest chunk
-                }
-                this.currentSize += data.byteLength;
-                this.emitAudioEvent({ data, position, compression });
-                this.lastEmittedTime = Date.now();
-                this.lastEmittedSize = this.currentSize;
-                this.lastEmittedCompressionSize = compression?.size ?? 0;
-            },
-            emitAudioAnalysisCallback: (audioAnalysisData) => {
-                this.logger?.log(`Emitted AudioAnalysis:`, audioAnalysisData);
-                this.emit('AudioAnalysis', audioAnalysisData);
-            },
+            emitAudioEventCallback: this.customRecorderEventCallback.bind(this),
+            emitAudioAnalysisCallback: this.customRecorderAnalysisCallback.bind(this),
+            onInterruption: this.handleRecordingInterruption.bind(this),
         });
         await this.customRecorder.init();
         this.customRecorder.start();
-        // // Set a timer to stop recording after 5 seconds
-        // setTimeout(() => {
-        //   logger.log("AUTO Stopping recording");
-        //   this.customRecorder?.stopAndPlay();
-        //   this.isRecording = false;
-        // }, 3000);
         this.isRecording = true;
-        this.recordingConfig = recordingConfig;
         this.recordingStartTime = Date.now();
         this.pausedTime = 0;
         this.isPaused = false;
@@ -153,14 +213,96 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         };
         return streamConfig;
     }
+    /**
+     * Centralized handler for recording interruptions
+     */
+    handleRecordingInterruption(event) {
+        this.logger?.debug(`Received recording interruption: ${event.reason}`);
+        // Update local state if the interruption should pause recording
+        if (event.isPaused) {
+            this.isPaused = true;
+            // If this is a device disconnection, handle according to behavior setting
+            if (event.reason === 'deviceDisconnected') {
+                this.pausedTime = Date.now();
+                // Check if we should try fallback to another device
+                if (this.recordingConfig?.deviceDisconnectionBehavior ===
+                    'fallback') {
+                    this.logger?.debug('Device disconnected with fallback behavior - attempting to switch to default device');
+                    // Try to restart with default device
+                    this.handleDeviceFallback().catch((error) => {
+                        // If fallback fails, emit warning
+                        this.logger?.error('Device fallback failed:', error);
+                        this.emit('onRecordingInterrupted', {
+                            reason: 'deviceSwitchFailed',
+                            isPaused: true,
+                            timestamp: Date.now(),
+                            message: 'Failed to switch to fallback device. Recording paused.',
+                        });
+                    });
+                }
+                else {
+                    // Just warn about disconnection if fallback not enabled
+                    this.logger?.warn('Device disconnected - recording paused automatically');
+                    this.emit('onRecordingInterrupted', event);
+                }
+            }
+            else {
+                // For other interruption types, just emit the event
+                this.emit('onRecordingInterrupted', event);
+            }
+        }
+        else {
+            // If not causing a pause, just forward the event
+            this.emit('onRecordingInterrupted', event);
+        }
+    }
+    /**
+     * Handler for audio events from the WebRecorder
+     */
+    customRecorderEventCallback({ data, position, compression, }) {
+        // Keep only the latest chunks based on maxBufferSize
+        this.audioChunks.push(new Float32Array(data));
+        if (this.audioChunks.length > this.maxBufferSize) {
+            this.audioChunks.shift(); // Remove oldest chunk
+        }
+        this.currentSize += data.byteLength;
+        this.emitAudioEvent({ data, position, compression });
+        this.lastEmittedTime = Date.now();
+        this.lastEmittedSize = this.currentSize;
+        this.lastEmittedCompressionSize = compression?.size ?? 0;
+    }
+    /**
+     * Handler for audio analysis events from the WebRecorder
+     */
+    customRecorderAnalysisCallback(audioAnalysisData) {
+        this.emit('AudioAnalysis', audioAnalysisData);
+    }
+    // Get recording duration
+    getRecordingDuration() {
+        if (!this.isRecording) {
+            return 0;
+        }
+        return this.currentDurationMs;
+    }
     emitAudioEvent({ data, position, compression }) {
         const fileUri = `${this.streamUuid}.${this.extension}`;
         if (compression?.size) {
             this.lastEmittedCompressionSize = compression.size;
             this.totalCompressedSize = compression.totalSize;
         }
+        // Update latest position for tracking
         this.latestPosition = position;
-        this.currentDurationMs = position * 1000; // Convert position (in seconds) to ms
+        // Calculate duration of this chunk in ms
+        const sampleRate = this.recordingConfig?.sampleRate || 44100;
+        const chunkDurationMs = (data.length / sampleRate) * 1000;
+        // Handle duration calculation
+        if (this.customRecorder?.isFirstChunkAfterSwitch) {
+            this.logger?.debug(`Processing first chunk after device switch, duration preserved at ${this.currentDurationMs}ms`);
+            this.customRecorder.isFirstChunkAfterSwitch = false;
+        }
+        else {
+            this.currentDurationMs += chunkDurationMs;
+        }
         const audioEventPayload = {
             fileUri,
             mimeType: `audio/${this.extension}`,
@@ -186,39 +328,56 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         if (!this.customRecorder) {
             throw new Error('Recorder is not initialized');
         }
-        this.logger?.debug('[Stop] Starting stop process');
-        const startTime = performance.now();
+        this.logger?.debug('Starting stop process');
         try {
-            this.logger?.debug('[Stop] Stopping recorder');
-            const { compressedBlob } = await this.customRecorder.stop();
+            const { compressedBlob, uncompressedBlob } = await this.customRecorder.stop();
             this.isRecording = false;
             this.isPaused = false;
-            this.currentDurationMs = Date.now() - this.recordingStartTime;
             let compression;
             let fileUri = `${this.streamUuid}.${this.extension}`;
             let mimeType = `audio/${this.extension}`;
-            if (compressedBlob && this.recordingConfig?.compression?.enabled) {
+            // Handle both compressed and uncompressed blobs according to configuration
+            const compressionEnabled = this.recordingConfig?.compression?.enabled ?? false;
+            // Process compressed blob if available
+            if (compressedBlob) {
                 const compressedUri = URL.createObjectURL(compressedBlob);
-                compression = {
+                const compressedInfo = {
                     compressedFileUri: compressedUri,
                     size: compressedBlob.size,
                     mimeType: 'audio/webm',
                     format: 'opus',
-                    bitrate: this.recordingConfig.compression.bitrate ?? 128000,
+                    bitrate: this.recordingConfig?.compression?.bitrate ?? 128000,
                 };
-                // Use compressed values when compression is enabled
-                fileUri = compressedUri;
-                mimeType = 'audio/webm';
+                // If compression is enabled, use compressed blob as primary format
+                if (compressionEnabled) {
+                    this.logger?.debug('Using compressed audio as primary output');
+                    fileUri = compressedUri;
+                    mimeType = 'audio/webm';
+                    // Store compression info
+                    compression = compressedInfo;
+                }
+                else {
+                    // Compression was enabled during recording but not set as primary
+                    // Store as alternate format
+                    compression = compressedInfo;
+                }
             }
-            this.logger?.debug(`[Stop] Completed stop process in ${performance.now() - startTime}ms`, {
-                durationMs: this.currentDurationMs,
-                compressedSize: compression?.size,
-            });
-            // Use the stored streamUuid (which contains our custom filename) for the final filename
+            // Process uncompressed WAV if available
+            if (uncompressedBlob) {
+                const wavUri = URL.createObjectURL(uncompressedBlob);
+                // If compression is disabled or no compressed blob is available,
+                // use WAV as primary format
+                if (!compressionEnabled || !compressedBlob) {
+                    this.logger?.debug('Using uncompressed WAV as primary output');
+                    fileUri = wavUri;
+                    mimeType = 'audio/wav';
+                }
+            }
+            // Use the stored streamUuid for the final filename
             const filename = `${this.streamUuid}.${this.extension}`;
             const result = {
                 fileUri,
-                filename, // This will now use our custom filename
+                filename,
                 bitDepth: this.bitDepth,
                 createdAt: this.recordingStartTime,
                 channels: this.recordingConfig?.channels ?? 1,
@@ -230,41 +389,92 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
             };
             // Reset after creating the result
             this.streamUuid = null;
+            // Reset recording state variables to prepare for next recording
+            this.currentDurationMs = 0;
+            this.currentSize = 0;
+            this.lastEmittedSize = 0;
+            this.totalCompressedSize = 0;
+            this.lastEmittedCompressionSize = 0;
+            this.audioChunks = [];
             return result;
         }
         catch (error) {
-            this.logger?.error('[Stop] Error stopping recording:', error);
+            this.logger?.error('Error stopping recording:', error);
             throw error;
         }
     }
     // Pause recording
     async pauseRecording() {
-        if (!this.isRecording || this.isPaused) {
-            throw new Error('Recording is not active or already paused');
+        if (!this.isRecording) {
+            throw new Error('Recording is not active');
+        }
+        if (this.isPaused) {
+            this.logger?.debug('Recording already paused, skipping');
+            return;
+        }
+        try {
+            if (this.customRecorder) {
+                this.customRecorder.pause();
+            }
+            this.isPaused = true;
+            this.pausedTime = Date.now();
         }
-        if (this.customRecorder) {
-            this.customRecorder.pause();
+        catch (error) {
+            this.logger?.error('Error in pauseRecording', error);
+            // Even if the pause operation failed, make sure our state is consistent
+            this.isPaused = true;
+            this.pausedTime = Date.now();
         }
-        this.isPaused = true;
-        this.pausedTime = Date.now();
     }
     // Resume recording
     async resumeRecording() {
         if (!this.isPaused) {
             throw new Error('Recording is not paused');
         }
-        if (this.customRecorder) {
+        this.logger?.debug('Resuming recording', {
+            deviceDisconnectionBehavior: this.recordingConfig?.deviceDisconnectionBehavior,
+            isDeviceDisconnected: this.customRecorder?.isDeviceDisconnected,
+        });
+        try {
+            // If we have no recorder, or if the device is disconnected, always attempt fallback
+            if (!this.customRecorder ||
+                this.customRecorder.isDeviceDisconnected) {
+                this.logger?.debug('No recorder exists or device disconnected - attempting fallback on resume');
+                await this.handleDeviceFallback();
+                // handleDeviceFallback will manage resuming if successful, or emit error if failed.
+                return;
+            }
+            // Normal resume path - device is still connected
             this.customRecorder.resume();
+            this.isPaused = false;
+            // Adjust the recording start time to account for the pause duration
+            const pauseDuration = Date.now() - this.pausedTime;
+            this.recordingStartTime += pauseDuration;
+            this.pausedTime = 0;
+            this.emit('onRecordingInterrupted', {
+                reason: 'userResumed',
+                isPaused: false,
+                timestamp: Date.now(),
+            });
+        }
+        catch (error) {
+            this.logger?.error('Resume failed:', error);
+            // Fallback to emitting a general failure if resume fails unexpectedly
+            this.emit('onRecordingInterrupted', {
+                reason: 'resumeFailed', // Use a more specific reason
+                isPaused: true, // Remain paused if resume fails
+                timestamp: Date.now(),
+                message: 'Failed to resume recording. Please stop and start again.',
+            });
         }
-        this.isPaused = false;
-        this.recordingStartTime += Date.now() - this.pausedTime;
     }
     // Get current status
     status() {
+        const durationMs = this.getRecordingDuration();
         const status = {
             isRecording: this.isRecording,
             isPaused: this.isPaused,
-            durationMs: this.currentDurationMs,
+            durationMs,
             size: this.currentSize,
             interval: this.currentInterval,
             intervalAnalysis: this.currentIntervalAnalysis,
@@ -281,5 +491,211 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         };
         return status;
     }
+    /**
+     * Handles device fallback when the current device is disconnected
+     */
+    async handleDeviceFallback() {
+        this.logger?.debug('Starting device fallback procedure');
+        if (!this.isRecording) {
+            return false;
+        }
+        try {
+            // Save important state before switching
+            const currentPosition = this.latestPosition;
+            const existingAudioChunks = [...this.audioChunks];
+            // Save compressed chunks if available
+            let compressedChunks = [];
+            if (this.customRecorder) {
+                try {
+                    compressedChunks = this.customRecorder.getCompressedChunks();
+                }
+                catch (err) {
+                    this.logger?.warn('Failed to get compressed chunks:', err);
+                }
+            }
+            // Save the current counter value for continuity
+            let currentDataPointCounter = 0;
+            if (this.customRecorder) {
+                currentDataPointCounter =
+                    this.customRecorder.getDataPointCounter();
+            }
+            // Clean up existing recorder
+            if (this.customRecorder) {
+                try {
+                    this.customRecorder.cleanup();
+                }
+                catch (cleanupError) {
+                    this.logger?.warn('Error during cleanup:', cleanupError);
+                }
+            }
+            // Keep recording state true but mark as paused
+            this.isPaused = true;
+            this.pausedTime = Date.now();
+            // Store current size and other stats
+            const previousTotalSize = this.currentSize;
+            const previousLastEmittedSize = this.lastEmittedSize;
+            const previousCompressedSize = this.totalCompressedSize;
+            // Try to get a fallback device
+            const fallbackDeviceInfo = await this.getFallbackDevice();
+            if (!fallbackDeviceInfo) {
+                this.emit('onRecordingInterrupted', {
+                    reason: 'deviceSwitchFailed',
+                    isPaused: true,
+                    timestamp: Date.now(),
+                    message: 'Failed to switch to fallback device. Recording paused.',
+                });
+                return false;
+            }
+            // Start recording with the new device
+            try {
+                const stream = await this.requestPermissionsAndGetUserMedia(fallbackDeviceInfo.deviceId);
+                const audioContext = new (window.AudioContext ||
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore - Allow webkitAudioContext for Safari
+                    window.webkitAudioContext)();
+                const source = audioContext.createMediaStreamSource(stream);
+                // Create a new recorder with the fallback device
+                this.customRecorder = new WebRecorder({
+                    logger: this.logger,
+                    audioContext,
+                    source,
+                    recordingConfig: this.recordingConfig || {},
+                    emitAudioEventCallback: this.customRecorderEventCallback.bind(this),
+                    emitAudioAnalysisCallback: this.customRecorderAnalysisCallback.bind(this),
+                    onInterruption: this.handleRecordingInterruption.bind(this),
+                });
+                await this.customRecorder.init();
+                // Set the initial position to continue from the previous device
+                this.customRecorder.setPosition(currentPosition);
+                // Reset the data point counter to continue from where the previous device left off
+                if (currentDataPointCounter > 0) {
+                    this.customRecorder.resetDataPointCounter(currentDataPointCounter);
+                }
+                // Prepare the recorder to handle the device switch properly
+                this.customRecorder.prepareForDeviceSwitch();
+                // Restore the existing audio chunks
+                if (existingAudioChunks.length > 0) {
+                    this.audioChunks = existingAudioChunks;
+                }
+                // Restore compressed chunks if available
+                if (compressedChunks.length > 0) {
+                    this.customRecorder.setCompressedChunks(compressedChunks);
+                }
+                // Start the new recorder while preserving counters
+                this.customRecorder.start(true);
+                // Update recording state
+                this.isPaused = false;
+                this.recordingStartTime = Date.now();
+                // Restore size counters to maintain continuity
+                this.currentSize = previousTotalSize;
+                this.lastEmittedSize = previousLastEmittedSize;
+                this.totalCompressedSize = previousCompressedSize;
+                // Notify that we switched to a fallback device
+                if (this.eventCallback) {
+                    this.eventCallback({
+                        type: 'deviceFallback',
+                        device: fallbackDeviceInfo.deviceId,
+                        timestamp: new Date(),
+                    });
+                }
+                return true;
+            }
+            catch (error) {
+                this.logger?.error('Failed to start recording with fallback device', error);
+                this.isPaused = true;
+                this.emit('onRecordingInterrupted', {
+                    reason: 'deviceSwitchFailed',
+                    isPaused: true,
+                    timestamp: Date.now(),
+                    message: 'Failed to switch to fallback device. Recording paused.',
+                });
+                return false;
+            }
+        }
+        catch (error) {
+            this.logger?.error('Failed to use fallback device', error);
+            this.isPaused = true;
+            this.emit('onRecordingInterrupted', {
+                reason: 'deviceSwitchFailed',
+                isPaused: true,
+                timestamp: Date.now(),
+                message: 'Failed to switch to fallback device. Recording paused.',
+            });
+            return false;
+        }
+    }
+    /**
+     * Attempts to get a fallback audio device
+     */
+    async getFallbackDevice() {
+        try {
+            // Get list of available audio input devices
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            const audioInputDevices = devices.filter((device) => device.kind === 'audioinput');
+            if (audioInputDevices.length === 0) {
+                return null;
+            }
+            // Try to find a device that's not the current one
+            if (this.customRecorder) {
+                try {
+                    // Use mediaDevices.enumerateDevices to find the current active device
+                    const tracks = navigator.mediaDevices
+                        .getUserMedia({ audio: true })
+                        .then((stream) => {
+                        const track = stream.getAudioTracks()[0];
+                        return track ? track.label : '';
+                    })
+                        .catch(() => '');
+                    const currentTrackLabel = await tracks;
+                    if (currentTrackLabel) {
+                        // Find a device with a different label
+                        const differentDevice = audioInputDevices.find((device) => device.label &&
+                            device.label !== currentTrackLabel);
+                        if (differentDevice) {
+                            return differentDevice;
+                        }
+                    }
+                }
+                catch (err) {
+                    this.logger?.warn('Error determining current device, using default');
+                }
+            }
+            // Return the first available device (default device)
+            return audioInputDevices[0];
+        }
+        catch (error) {
+            this.logger?.error('Error finding fallback device:', error);
+            return null;
+        }
+    }
+    /**
+     * Gets user media with specific device ID
+     */
+    async requestPermissionsAndGetUserMedia(deviceId) {
+        try {
+            // Request the specific device
+            return await navigator.mediaDevices.getUserMedia({
+                audio: {
+                    deviceId: { exact: deviceId },
+                },
+            });
+        }
+        catch (error) {
+            this.logger?.error(`Failed to get media for device ${deviceId}`, error);
+            // Try with default constraints as fallback
+            return await navigator.mediaDevices.getUserMedia({ audio: true });
+        }
+    }
+    init(options) {
+        try {
+            this.logger = options?.logger;
+            this.eventCallback = options?.eventCallback;
+            return Promise.resolve();
+        }
+        catch (error) {
+            this.logger?.error('Error initializing ExpoAudioStream', error);
+            return Promise.reject(error);
+        }
+    }
 }
 //# sourceMappingURL=ExpoAudioStream.web.js.map