@siteed/expo-audio-studio 2.18.6 → 3.0.1

package/src/ExpoAudioStream.web.ts

@@ -1,905 +0,0 @@
-// src/ExpoAudioStreamModule.web.ts
-import { LegacyEventEmitter } from 'expo-modules-core'
-
-import { AudioAnalysis } from './AudioAnalysis/AudioAnalysis.types'
-import {
-    AudioRecording,
-    AudioStreamStatus,
-    BitDepth,
-    ConsoleLike,
-    RecordingConfig,
-    RecordingInterruptionReason,
-    StartRecordingResult,
-} from './ExpoAudioStream.types'
-import { WebRecorder } from './WebRecorder.web'
-import { AudioEventPayload } from './events'
-import { encodingToBitDepth } from './utils/encodingToBitDepth'
-
-export interface AudioStreamEvent {
-    type: string
-    device?: string
-    timestamp: Date
-}
-
-export interface ExpoAudioStreamOptions {
-    logger?: ConsoleLike
-    eventCallback?: (event: AudioStreamEvent) => void
-}
-
-export interface EmitAudioEventProps {
-    data: Float32Array
-    position: number
-    compression?: {
-        data: Blob
-        size: number
-        totalSize: number
-        mimeType: string
-        format: string
-        bitrate: number
-    }
-}
-export type EmitAudioEventFunction = (_: EmitAudioEventProps) => void
-export type EmitAudioAnalysisFunction = (_: AudioAnalysis) => void
-
-export interface ExpoAudioStreamWebProps {
-    logger?: ConsoleLike
-    audioWorkletUrl: string
-    featuresExtratorUrl: string
-    maxBufferSize?: number // Maximum number of chunks to keep in memory
-}
-
-export class ExpoAudioStreamWeb extends LegacyEventEmitter {
-    customRecorder: WebRecorder | null
-    audioChunks: Float32Array[]
-    isRecording: boolean
-    isPaused: boolean
-    recordingStartTime: number
-    pausedTime: number
-    currentDurationMs: number
-    currentSize: number
-    currentInterval: number
-    currentIntervalAnalysis: number
-    lastEmittedSize: number
-    lastEmittedTime: number
-    lastEmittedCompressionSize: number
-    lastEmittedAnalysisTime: number
-    streamUuid: string | null
-    extension: 'webm' | 'wav' = 'wav' // Default extension is 'wav'
-    recordingConfig?: RecordingConfig
-    bitDepth: BitDepth // Bit depth of the audio
-    audioWorkletUrl: string
-    featuresExtratorUrl: string
-    logger?: ConsoleLike
-    latestPosition: number = 0
-    totalCompressedSize: number = 0
-    private readonly maxBufferSize: number
-    private eventCallback?: (event: AudioStreamEvent) => void
-
-    constructor({
-        audioWorkletUrl,
-        featuresExtratorUrl,
-        logger,
-        maxBufferSize = 100, // Default to storing last 100 chunks (1 chunk = 0.5 seconds)
-    }: ExpoAudioStreamWebProps) {
-        const mockNativeModule = {
-            addListener: () => {},
-            removeListeners: () => {},
-        }
-        super(mockNativeModule) // Pass the mock native module to the parent class
-
-        this.logger = logger
-        this.customRecorder = null
-        this.audioChunks = []
-        this.isRecording = false
-        this.isPaused = false
-        this.recordingStartTime = 0
-        this.pausedTime = 0
-        this.currentDurationMs = 0
-        this.currentSize = 0
-        this.bitDepth = 32 // Default
-        this.currentInterval = 1000 // Default interval in ms
-        this.currentIntervalAnalysis = 500 // Default analysis interval in ms
-        this.lastEmittedSize = 0
-        this.lastEmittedTime = 0
-        this.latestPosition = 0
-        this.lastEmittedCompressionSize = 0
-        this.lastEmittedAnalysisTime = 0
-        this.streamUuid = null // Initialize UUID on first recording start
-        this.audioWorkletUrl = audioWorkletUrl
-        this.featuresExtratorUrl = featuresExtratorUrl
-        this.maxBufferSize = maxBufferSize
-    }
-
-    // Utility to handle user media stream
-    async getMediaStream() {
-        try {
-            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: RecordingConfig = {}
-    ): Promise<boolean> {
-        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: RecordingConfig = {}
-    ): Promise<StartRecordingResult> {
-        if (this.isRecording) {
-            throw new Error('Recording is already in progress')
-        }
-
-        // 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
-            window.webkitAudioContext)()
-        const stream = await this.getMediaStream()
-
-        const source = audioContext.createMediaStreamSource(stream)
-
-        this.customRecorder = new WebRecorder({
-            logger: this.logger,
-            audioContext,
-            source,
-            recordingConfig,
-            emitAudioEventCallback: this.customRecorderEventCallback.bind(this),
-            emitAudioAnalysisCallback:
-                this.customRecorderAnalysisCallback.bind(this),
-            onInterruption: this.handleRecordingInterruption.bind(this),
-        })
-        await this.customRecorder.init()
-        this.customRecorder.start()
-
-        this.isRecording = true
-        this.recordingStartTime = Date.now()
-        this.pausedTime = 0
-        this.isPaused = false
-        this.lastEmittedSize = 0
-        this.lastEmittedTime = 0
-        this.lastEmittedCompressionSize = 0
-        this.currentInterval = recordingConfig.interval ?? 1000
-        this.currentIntervalAnalysis = recordingConfig.intervalAnalysis ?? 500
-        this.lastEmittedAnalysisTime = Date.now()
-
-        // 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()
-        }
-
-        const fileUri = `${this.streamUuid}.${this.extension}`
-        const streamConfig: StartRecordingResult = {
-            fileUri,
-            mimeType: `audio/${this.extension}`,
-            bitDepth: this.bitDepth,
-            channels: recordingConfig.channels ?? 1,
-            sampleRate: recordingConfig.sampleRate ?? 44100,
-            compression: recordingConfig.output?.compressed?.enabled
-                ? {
-                      ...recordingConfig.output.compressed,
-                      bitrate:
-                          recordingConfig.output.compressed.bitrate ?? 128000,
-                      size: 0,
-                      mimeType: 'audio/webm',
-                      format:
-                          recordingConfig.output.compressed.format ?? 'opus',
-                      compressedFileUri: '',
-                  }
-                : undefined,
-        }
-        return streamConfig
-    }
-
-    /**
-     * Centralized handler for recording interruptions
-     */
-    private handleRecordingInterruption(event: {
-        reason: RecordingInterruptionReason | string
-        isPaused: boolean
-        timestamp: number
-        message?: string
-    }): void {
-        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
-     */
-    private customRecorderEventCallback({
-        data,
-        position,
-        compression,
-    }: EmitAudioEventProps): void {
-        // 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
-     */
-    private customRecorderAnalysisCallback(
-        audioAnalysisData: AudioAnalysis
-    ): void {
-        this.emit('AudioAnalysis', audioAnalysisData)
-    }
-
-    // Get recording duration
-    private getRecordingDuration(): number {
-        if (!this.isRecording) {
-            return 0
-        }
-
-        return this.currentDurationMs
-    }
-
-    emitAudioEvent({ data, position, compression }: EmitAudioEventProps) {
-        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
-
-        // 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: AudioEventPayload = {
-            fileUri,
-            mimeType: `audio/${this.extension}`,
-            lastEmittedSize: this.lastEmittedSize,
-            deltaSize: data.byteLength,
-            position,
-            totalSize: this.currentSize,
-            buffer: data,
-            streamUuid: this.streamUuid ?? '',
-            compression: compression
-                ? {
-                      data: compression?.data,
-                      totalSize: this.totalCompressedSize,
-                      eventDataSize: compression?.size ?? 0,
-                      position,
-                  }
-                : undefined,
-        }
-
-        this.emit('AudioData', audioEventPayload)
-    }
-
-    // Stop recording
-    async stopRecording(): Promise<AudioRecording> {
-        if (!this.customRecorder) {
-            throw new Error('Recorder is not initialized')
-        }
-
-        this.logger?.debug('Starting stop process')
-
-        try {
-            const { compressedBlob, uncompressedBlob } =
-                await this.customRecorder.stop()
-
-            this.isRecording = false
-            this.isPaused = false
-
-            let compression: AudioRecording['compression']
-            let fileUri = `${this.streamUuid}.${this.extension}`
-            let mimeType = `audio/${this.extension}`
-
-            // Handle both compressed and uncompressed blobs according to new output configuration
-            const primaryEnabled =
-                this.recordingConfig?.output?.primary?.enabled ?? true
-            const compressedEnabled =
-                this.recordingConfig?.output?.compressed?.enabled ?? false
-
-            // Process compressed blob if available and enabled
-            if (compressedBlob && compressedEnabled) {
-                const compressedUri = URL.createObjectURL(compressedBlob)
-                const compressedInfo = {
-                    compressedFileUri: compressedUri,
-                    size: compressedBlob.size,
-                    mimeType: 'audio/webm',
-                    format:
-                        this.recordingConfig?.output?.compressed?.format ??
-                        'opus',
-                    bitrate:
-                        this.recordingConfig?.output?.compressed?.bitrate ??
-                        128000,
-                }
-
-                // Store compression info
-                compression = compressedInfo
-
-                // If primary is disabled, use compressed as main file
-                if (!primaryEnabled) {
-                    this.logger?.debug(
-                        'Using compressed audio as primary output (primary disabled)'
-                    )
-                    fileUri = compressedUri
-                    mimeType = 'audio/webm'
-                }
-            }
-
-            // Process uncompressed WAV if available and primary is enabled
-            if (uncompressedBlob && primaryEnabled) {
-                const wavUri = URL.createObjectURL(uncompressedBlob)
-                fileUri = wavUri
-                mimeType = 'audio/wav'
-            } else if (!primaryEnabled && !compressedEnabled) {
-                // No outputs enabled - streaming only mode
-                this.logger?.debug('No outputs enabled - streaming only mode')
-                fileUri = ''
-                mimeType = 'audio/wav'
-            }
-
-            // Use the stored streamUuid for the final filename
-            const filename = fileUri
-                ? `${this.streamUuid}.${this.extension}`
-                : 'stream-only'
-            const result: AudioRecording = {
-                fileUri,
-                filename,
-                bitDepth: this.bitDepth,
-                createdAt: this.recordingStartTime,
-                channels: this.recordingConfig?.channels ?? 1,
-                sampleRate: this.recordingConfig?.sampleRate ?? 44100,
-                durationMs: this.currentDurationMs,
-                size: primaryEnabled ? this.currentSize : 0,
-                mimeType,
-                compression,
-            }
-
-            // 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('Error stopping recording:', error)
-            throw error
-        }
-    }
-
-    // Pause recording
-    async pauseRecording() {
-        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()
-        } 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()
-        }
-    }
-
-    // Resume recording
-    async resumeRecording() {
-        if (!this.isPaused) {
-            throw new Error('Recording is not paused')
-        }
-
-        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.',
-            })
-        }
-    }
-
-    // Get current status
-    status() {
-        const durationMs = this.getRecordingDuration()
-
-        const status: AudioStreamStatus = {
-            isRecording: this.isRecording,
-            isPaused: this.isPaused,
-            durationMs,
-            size: this.currentSize,
-            interval: this.currentInterval,
-            intervalAnalysis: this.currentIntervalAnalysis,
-            mimeType: `audio/${this.extension}`,
-            compression: this.recordingConfig?.output?.compressed?.enabled
-                ? {
-                      size: this.totalCompressedSize,
-                      mimeType: 'audio/webm',
-                      format:
-                          this.recordingConfig.output.compressed.format ??
-                          'opus',
-                      bitrate:
-                          this.recordingConfig.output.compressed.bitrate ??
-                          128000,
-                      compressedFileUri: `${this.streamUuid}.webm`,
-                  }
-                : undefined,
-        }
-        return status
-    }
-
-    /**
-     * Handles device fallback when the current device is disconnected
-     */
-    private async handleDeviceFallback(): Promise<boolean> {
-        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: Blob[] = []
-            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
-     */
-    private async getFallbackDevice(): Promise<MediaDeviceInfo | null> {
-        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',
-                        err
-                    )
-                }
-            }
-
-            // 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
-     */
-    private async requestPermissionsAndGetUserMedia(
-        deviceId: string
-    ): Promise<MediaStream> {
-        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?: ExpoAudioStreamOptions): Promise<void> {
-        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)
-        }
-    }
-}