@siteed/expo-audio-studio 2.4.1 → 2.6.0

package/src/hooks/useAudioDevices.ts

@@ -0,0 +1,180 @@
+import { useCallback, useEffect, useState } from 'react'
+
+import { audioDeviceManager } from '../AudioDeviceManager'
+import { AudioDevice } from '../ExpoAudioStream.types'
+
+/**
+ * React hook for managing audio input devices
+ */
+export function useAudioDevices() {
+    const [devices, setDevices] = useState<AudioDevice[]>([])
+    const [currentDevice, setCurrentDevice] = useState<AudioDevice | null>(null)
+    const [loading, setLoading] = useState(true)
+    const [error, setError] = useState<Error | null>(null)
+
+    // Load devices on mount
+    useEffect(() => {
+        let isMounted = true
+
+        const loadDevices = async () => {
+            try {
+                setLoading(true)
+                setError(null)
+
+                // Load available devices
+                const availableDevices =
+                    await audioDeviceManager.getAvailableDevices()
+                if (isMounted) setDevices(availableDevices)
+
+                // Get current device
+                const device = await audioDeviceManager.getCurrentDevice()
+                if (isMounted) setCurrentDevice(device)
+            } catch (err) {
+                console.error('Failed to load audio devices:', err)
+                if (isMounted)
+                    setError(
+                        err instanceof Error
+                            ? err
+                            : new Error('Failed to load audio devices')
+                    )
+            } finally {
+                if (isMounted) setLoading(false)
+            }
+        }
+
+        loadDevices()
+
+        // Set up device change listener
+        const removeListener = audioDeviceManager.addDeviceChangeListener(
+            (updatedDevices: AudioDevice[]) => {
+                if (isMounted) {
+                    setDevices(updatedDevices)
+
+                    // If our current device is no longer available, update it
+                    if (
+                        currentDevice &&
+                        !updatedDevices.some(
+                            (d: AudioDevice) => d.id === currentDevice.id
+                        )
+                    ) {
+                        audioDeviceManager
+                            .getCurrentDevice()
+                            .then((newDevice: AudioDevice | null) => {
+                                if (isMounted) setCurrentDevice(newDevice)
+                            })
+                    }
+                }
+            }
+        )
+
+        return () => {
+            isMounted = false
+            removeListener()
+        }
+    }, [])
+
+    /**
+     * Select a specific audio input device
+     * @param deviceId The ID of the device to select
+     * @returns Promise resolving to a boolean indicating success
+     */
+    const selectDevice = useCallback(
+        async (deviceId: string): Promise<boolean> => {
+            try {
+                setLoading(true)
+                setError(null)
+
+                const success = await audioDeviceManager.selectDevice(deviceId)
+
+                if (success) {
+                    // Get the updated current device after selection
+                    const device = await audioDeviceManager.getCurrentDevice()
+                    setCurrentDevice(device)
+                }
+
+                return success
+            } catch (err) {
+                console.error('Failed to select audio device:', err)
+                setError(
+                    err instanceof Error
+                        ? err
+                        : new Error('Failed to select audio device')
+                )
+                return false
+            } finally {
+                setLoading(false)
+            }
+        },
+        []
+    )
+
+    /**
+     * Reset to the default audio input device
+     * @returns Promise resolving to a boolean indicating success
+     */
+    const resetToDefaultDevice = useCallback(async (): Promise<boolean> => {
+        try {
+            setLoading(true)
+            setError(null)
+
+            const success = await audioDeviceManager.resetToDefaultDevice()
+
+            if (success) {
+                // Get the updated current device after reset
+                const device = await audioDeviceManager.getCurrentDevice()
+                setCurrentDevice(device)
+            }
+
+            return success
+        } catch (err) {
+            console.error('Failed to reset to default audio device:', err)
+            setError(
+                err instanceof Error
+                    ? err
+                    : new Error('Failed to reset to default audio device')
+            )
+            return false
+        } finally {
+            setLoading(false)
+        }
+    }, [])
+
+    /**
+     * Refresh the list of available devices
+     */
+    const refreshDevices = useCallback(async (): Promise<AudioDevice[]> => {
+        try {
+            setLoading(true)
+            setError(null)
+
+            const updatedDevices = await audioDeviceManager.refreshDevices()
+            setDevices(updatedDevices)
+
+            // Also refresh the current device
+            const device = await audioDeviceManager.getCurrentDevice()
+            setCurrentDevice(device)
+
+            return updatedDevices
+        } catch (err) {
+            console.error('Failed to refresh audio devices:', err)
+            setError(
+                err instanceof Error
+                    ? err
+                    : new Error('Failed to refresh audio devices')
+            )
+            return []
+        } finally {
+            setLoading(false)
+        }
+    }, [])
+
+    return {
+        devices,
+        currentDevice,
+        loading,
+        error,
+        selectDevice,
+        resetToDefaultDevice,
+        refreshDevices,
+    }
+}

package/src/index.ts

@@ -19,6 +19,12 @@ export * from './utils/convertPCMToFloat32'
 export * from './utils/getWavFileInfo'
 export * from './utils/writeWavHeader'
 
+// Export AudioDeviceManager
+export { AudioDeviceManager, audioDeviceManager } from './AudioDeviceManager'
+
+// Export useAudioDevices hook
+export { useAudioDevices } from './hooks/useAudioDevices'
+
 export {
     AudioRecorderProvider,
     ExpoAudioStreamModule,

package/src/types/crc-32.d.ts

@@ -1,9 +1,9 @@
 declare module 'crc-32' {
     interface CRC32 {
-        (data: string | Uint8Array): number;
-        buf(data: Uint8Array): number;
+        (data: string | Uint8Array): number
+        buf(data: Uint8Array): number
     }
-    
-    const crc32: CRC32;
-    export default crc32;
-} 
+
+    const crc32: CRC32
+    export default crc32
+}

package/src/useAudioRecorder.tsx

@@ -27,6 +27,7 @@ export interface UseAudioRecorderProps {
 }
 
 export interface UseAudioRecorderState {
+    prepareRecording: (_: RecordingConfig) => Promise<void>
     startRecording: (_: RecordingConfig) => Promise<StartRecordingResult>
     stopRecording: () => Promise<AudioRecording>
     pauseRecording: () => Promise<void>
@@ -280,7 +281,7 @@ export function useAudioRecorder({
 
             logger?.debug(
                 `[handleAudioAnalysis] Updated analysis data: durationMs=${savedAnalysisData.durationMs}`,
-                savedAnalysisData
+                { dataPoints: savedAnalysisData.dataPoints.length }
             )
 
             // Call the onAudioAnalysis callback if it exists in the recording config
@@ -511,6 +512,30 @@ export function useAudioRecorder({
         [handleAudioAnalysis, dispatch]
     )
 
+    const prepareRecording = useCallback(
+        async (recordingOptions: RecordingConfig) => {
+            recordingConfigRef.current = recordingOptions
+            logger?.debug(`preparing recording`, recordingOptions)
+
+            analysisRef.current = { ...defaultAnalysis } // Reset analysis data
+            fullAnalysisRef.current = { ...defaultAnalysis }
+            const { onAudioStream, ...options } = recordingOptions
+
+            // Store onAudioStream for later use when recording starts
+            if (typeof onAudioStream === 'function') {
+                onAudioStreamRef.current = onAudioStream
+            } else {
+                logger?.warn(`onAudioStream is not a function`, onAudioStream)
+                onAudioStreamRef.current = null
+            }
+
+            // Call the native prepareRecording method
+            await ExpoAudioStream.prepareRecording(options)
+            logger?.debug(`recording prepared successfully`)
+        },
+        []
+    )
+
     const stopRecording = useCallback(async () => {
         logger?.debug(`stoping recording`)
 
@@ -606,6 +631,7 @@ export function useAudioRecorder({
     }, []) // Empty dependency array since we want this to run once
 
     return {
+        prepareRecording,
         startRecording,
         stopRecording,
         pauseRecording,

package/src/utils/BlobFix.ts

@@ -249,11 +249,13 @@ const sections: Record<number, Section> = {
 class WebmBase<T> {
     source?: Uint8Array
     data?: T
+    name: string
+    type: string
 
-    constructor(
-        private name = 'Unknown',
-        private type = 'Unknown'
-    ) {}
+    constructor(name = 'Unknown', type = 'Unknown') {
+        this.name = name
+        this.type = type
+    }
 
     updateBySource() {}
 

package/src/utils/writeWavHeader.ts

@@ -12,6 +12,8 @@ export interface WavHeaderOptions {
     numChannels: number
     /** The bit depth of the audio (e.g., 16, 24, or 32). */
     bitDepth: number
+    /** Whether the audio data is in float format (only applies to 32-bit) */
+    isFloat?: boolean
 }
 
 /**
@@ -30,30 +32,17 @@ export interface WavHeaderOptions {
  * @returns An ArrayBuffer containing the WAV header, or the header combined with the provided audio data.
  *
  * @throws {Error} Throws an error if the provided options are invalid or if the buffer is too small.
- *
- * @example
- * // Create a standalone WAV header
- * const header = writeWavHeader({
- *   sampleRate: 44100,
- *   numChannels: 2,
- *   bitDepth: 16
- * });
- *
- * @example
- * // Create a WAV header and combine it with audio data
- * const completeWav = writeWavHeader({
- *   buffer: audioData,
- *   sampleRate: 44100,
- *   numChannels: 2,
- *   bitDepth: 16
- * });
  */
 export const writeWavHeader = ({
     buffer,
     sampleRate,
     numChannels,
     bitDepth,
+    isFloat = bitDepth === 32, // Default to float for 32-bit
 }: WavHeaderOptions): ArrayBuffer => {
+    // For 32-bit float, we use format 3, otherwise format 1 for PCM
+    const audioFormat = isFloat ? 3 : 1 // 3 = IEEE float, 1 = PCM
+
     const bytesPerSample = bitDepth / 8
     const blockAlign = numChannels * bytesPerSample
     const byteRate = sampleRate * blockAlign
@@ -67,22 +56,30 @@ export const writeWavHeader = ({
 
     // Function to write or update the header
     const writeHeader = (view: DataView, dataSize: number = 0xffffffff) => {
+        // RIFF chunk descriptor
         writeString(view, 0, 'RIFF') // ChunkID
-        view.setUint32(4, 36 + dataSize, true) // ChunkSize
+        view.setUint32(4, 36 + dataSize, true) // ChunkSize: 4 + (8 + 16) + (8 + dataSize)
         writeString(view, 8, 'WAVE') // Format
+
+        // "fmt " sub-chunk
         writeString(view, 12, 'fmt ') // Subchunk1ID
-        view.setUint32(16, 16, true) // Subchunk1Size (16 for PCM)
-        view.setUint16(20, bitDepth === 32 ? 3 : 1, true) // AudioFormat (3 for float, 1 for PCM)
+        view.setUint32(16, 16, true) // Subchunk1Size (16 for PCM/Float)
+        view.setUint16(20, audioFormat, true) // AudioFormat (3 for float, 1 for PCM)
         view.setUint16(22, numChannels, true) // NumChannels
         view.setUint32(24, sampleRate, true) // SampleRate
-        view.setUint32(28, byteRate, true) // ByteRate
-        view.setUint16(32, blockAlign, true) // BlockAlign
+        view.setUint32(28, byteRate, true) // ByteRate = SampleRate * NumChannels * BitsPerSample/8
+        view.setUint16(32, blockAlign, true) // BlockAlign = NumChannels * BitsPerSample/8
         view.setUint16(34, bitDepth, true) // BitsPerSample
+
+        // "data" sub-chunk
         writeString(view, 36, 'data') // Subchunk2ID
-        view.setUint32(40, dataSize, true) // Subchunk2Size
+        view.setUint32(40, dataSize, true) // Subchunk2Size = NumSamples * NumChannels * BitsPerSample/8
     }
 
     if (buffer) {
+        // Handle existing buffer
+
+        // Check for minimum size
         if (buffer.byteLength < 44) {
             throw new Error('Buffer is too small to contain a valid WAV header')
         }
@@ -97,15 +94,19 @@ export const writeWavHeader = ({
             writeHeader(view, buffer.byteLength - 44)
             return buffer
         } else {
-            // Combine the new header with the existing buffer
+            // Create a new buffer with header + data
             const newBuffer = new ArrayBuffer(44 + buffer.byteLength)
             const newView = new DataView(newBuffer)
+
+            // Write header to new buffer
             writeHeader(newView, buffer.byteLength)
+
+            // Copy audio data after header
             new Uint8Array(newBuffer).set(new Uint8Array(buffer), 44)
             return newBuffer
         }
     } else {
-        // Create a standalone header
+        // Create standalone header
         const headerBuffer = new ArrayBuffer(44)
         const view = new DataView(headerBuffer)
         writeHeader(view)

package/src/workers/InlineFeaturesExtractor.web.tsx

@@ -440,16 +440,36 @@ function estimatePitch(segment, sampleRate) {
     }
 }
 
-// Unique ID counter
+// Unique ID counter - the only state we need to maintain
 let uniqueIdCounter = 0
-let accumulatedDataPoints = []
 let lastEmitTime = Date.now()
 
 self.onmessage = function (event) {
+    // Extract enableLogging early so we can use it consistently
+    const enableLogging = event.data.enableLogging || false;
+    
+    // Create consistent logger that only logs when enabled
+    const logger = enableLogging ? {
+        debug: (...args) => console.debug('[Worker]', ...args),
+        log: (...args) => console.log('[Worker]', ...args),
+        warn: (...args) => console.warn('[Worker]', ...args),
+        error: (...args) => console.error('[Worker]', ...args)
+    } : {
+        debug: () => {},
+        log: () => {},
+        warn: () => {},
+        error: () => {}
+    };
+    
     // Check if this is a reset command
     if (event.data.command === 'resetCounter') {
-        uniqueIdCounter = event.data.startCounterFrom || 0;
-        console.log('[Worker] Reset counter to', uniqueIdCounter);
+        const newValue = event.data.value;
+        logger.log('Reset counter request received with value:', newValue);
+        
+        // Always respect explicit resets through the resetCounter command
+        uniqueIdCounter = typeof newValue === 'number' ? newValue : 0;
+        logger.log('Counter explicitly set to:', uniqueIdCounter);
+        
         return; // Exit early, don't process audio
     }
 
@@ -464,34 +484,13 @@ self.onmessage = function (event) {
         numberOfChannels,
         features: _features,
         intervalAnalysis = 500,
-        enableLogging,
-        resetCounter,
-        startCounterFrom,
     } = event.data
 
-    // Also handle reset as part of regular message
-    if (resetCounter) {
-        uniqueIdCounter = startCounterFrom || 0;
-    }
-
     // Calculate subChunkStartTime safely, defaulting to 0 if fullAudioDurationMs is not a valid number
     const subChunkStartTime = (typeof fullAudioDurationMs === 'number' && !isNaN(fullAudioDurationMs) && fullAudioDurationMs >= 0)
                             ? fullAudioDurationMs / 1000
                             : 0;
 
-    
-    // Create a simple logger that only logs when enabled
-    const logger = enableLogging ? {
-        debug: (...args) => console.debug('[Worker]', ...args),
-        log: (...args) => console.log('[Worker]', ...args),
-        error: (...args) => console.error('[Worker]', ...args)
-    } : {
-        debug: () => {},
-        log: () => {},
-        error: () => {}
-    }
-    logger.log('[Worker] START Feature Extractor - hasData: ' + (event.data ? true : false) + ', channelData: ' + (event.data.channelData ? event.data.channelData.length : 0) + ', fullAudioDurationMs: ' + (event.data.fullAudioDurationMs || 0) + ', sampleRate: ' + (event.data.sampleRate || 0) + ', segmentDurationMs: ' + (event.data.segmentDurationMs || 0) + ', algorithm: ' + (event.data.algorithm || 'none') + ', bitDepth: ' + (event.data.bitDepth || 0) + ', numberOfChannels: ' + (event.data.numberOfChannels || 0) + ', features: ' + (event.data.features ? Object.keys(event.data.features).length : 0) + ', intervalAnalysis: ' + (event.data.intervalAnalysis || 0) + ', dataKeys: ' + (event.data ? Object.keys(event.data).join(',') : ''));
-    
     const features = _features || {}
     const bytesPerSample = bitDepth / 8; // Calculate bytes per sample
 
@@ -692,6 +691,7 @@ self.onmessage = function (event) {
 
             var spectralFeatures = computeSpectralFeatures(channelData.slice(startIdx, endIdx), sampleRate, features);
 
+            // Simply use the counter, increment after assigning
             const dataPoint = {
                 id: uniqueIdCounter++,
                 amplitude: maxAmp,
@@ -756,6 +756,7 @@ self.onmessage = function (event) {
 
             var spectralFeatures = computeSpectralFeatures(channelData.slice(startIdx, endIdx), sampleRate, features);
 
+            // Simply use the counter, increment after assigning
             const dataPoint = {
                 id: uniqueIdCounter++,
                 amplitude: maxAmp,
@@ -769,7 +770,7 @@ self.onmessage = function (event) {
                 samples: remainingSamples,
             }
 
-            logger.log('[Worker] extractWaveform - dataPoint', dataPoint)
+            logger.debug('extractWaveform - dataPoint', dataPoint);
             // Extract features if any are requested
             const extractedFeatures = createFeaturesObject(
                 features,

package/src/workers/inlineAudioWebWorker.web.tsx

@@ -17,6 +17,7 @@ class RecorderProcessor extends AudioWorkletProcessor {
         this.port.onmessage = this.handleMessage.bind(this)
         this.enableLogging = false
         this.exportIntervalSamples = 0
+        this.currentPosition = 0 // Track current position in seconds
     }
 
     handleMessage(event) {
@@ -36,6 +37,14 @@ class RecorderProcessor extends AudioWorkletProcessor {
                 }
                 this.exportBitDepth =
                     event.data.exportBitDepth || this.recordBitDepth
+                
+                // Handle position parameter for device switching
+                if (typeof event.data.position === 'number' && event.data.position > 0) {
+                    this.currentPosition = event.data.position
+                    if (this.enableLogging) {
+                        console.log('AudioWorklet initialized with position:', this.currentPosition)
+                    }
+                }
                 break
 
             case 'stop':
@@ -44,6 +53,14 @@ class RecorderProcessor extends AudioWorkletProcessor {
                     this.processChunk()
                 }
                 break
+                
+            case 'pause':
+                // Just a placeholder for pause handling
+                break
+                
+            case 'resume':
+                // Just a placeholder for resume handling
+                break
         }
     }
 
@@ -138,14 +155,21 @@ class RecorderProcessor extends AudioWorkletProcessor {
                 ? this.convertBitDepth(resampledChunk, this.exportBitDepth)
                 : resampledChunk
 
-        // Send processed chunk
+        // Calculate the duration in seconds
+        const chunkDuration = finalBuffer.length / this.exportSampleRate
+        
+        // Send processed chunk with the current position
         this.port.postMessage({
             command: 'newData',
             recordedData: finalBuffer,
             sampleRate: this.exportSampleRate,
             bitDepth: this.exportBitDepth,
             numberOfChannels: this.numberOfChannels,
+            position: this.currentPosition,
         })
+        
+        // Update the position
+        this.currentPosition += chunkDuration
 
         // Clear the current chunk
         this.currentChunk = []