@siteed/audio-studio 3.0.0

package/src/constants/platformLimitations.ts

@@ -0,0 +1,118 @@
+/**
+ * Platform-specific audio recording limitations and capabilities
+ */
+
+import { Platform } from 'react-native'
+
+import { EncodingType, BitDepth } from '../AudioStudio.types'
+
+export interface PlatformCapabilities {
+    supportedEncodings: EncodingType[]
+    supportedBitDepths: BitDepth[]
+    notes: string[]
+}
+
+export const PLATFORM_CAPABILITIES: Record<string, PlatformCapabilities> = {
+    ios: {
+        supportedEncodings: ['pcm_16bit', 'pcm_32bit'],
+        supportedBitDepths: [16, 32],
+        notes: [
+            '8-bit PCM is not natively supported by iOS AVAudioFormat',
+            'Recording with 8-bit will fallback to 16-bit',
+        ],
+    },
+    android: {
+        supportedEncodings: ['pcm_8bit', 'pcm_16bit', 'pcm_32bit'],
+        supportedBitDepths: [8, 16, 32],
+        notes: ['All PCM formats are fully supported'],
+    },
+    web: {
+        supportedEncodings: ['pcm_16bit', 'pcm_32bit'],
+        supportedBitDepths: [16, 32],
+        notes: [
+            'Web Audio API typically works with 32-bit float',
+            '8-bit is not commonly supported in browsers',
+        ],
+    },
+}
+
+/**
+ * Get the current platform's audio capabilities
+ */
+export function getPlatformCapabilities(): PlatformCapabilities {
+    return PLATFORM_CAPABILITIES[Platform.OS] || PLATFORM_CAPABILITIES.web
+}
+
+/**
+ * Check if a specific encoding is supported on the current platform
+ */
+export function isEncodingSupported(encoding: EncodingType): boolean {
+    const capabilities = getPlatformCapabilities()
+    return capabilities.supportedEncodings.includes(encoding)
+}
+
+/**
+ * Check if a specific bit depth is supported on the current platform
+ */
+export function isBitDepthSupported(bitDepth: BitDepth): boolean {
+    const capabilities = getPlatformCapabilities()
+    return capabilities.supportedBitDepths.includes(bitDepth)
+}
+
+/**
+ * Get a fallback encoding if the requested one is not supported
+ */
+export function getFallbackEncoding(
+    requestedEncoding: EncodingType
+): EncodingType {
+    if (isEncodingSupported(requestedEncoding)) {
+        return requestedEncoding
+    }
+
+    // Default fallback is 16-bit PCM (supported on all platforms)
+    return 'pcm_16bit'
+}
+
+/**
+ * Get a fallback bit depth if the requested one is not supported
+ */
+export function getFallbackBitDepth(requestedBitDepth: BitDepth): BitDepth {
+    if (isBitDepthSupported(requestedBitDepth)) {
+        return requestedBitDepth
+    }
+
+    // Default fallback is 16-bit (supported on all platforms)
+    return 16
+}
+
+/**
+ * Validate and adjust recording configuration based on platform limitations
+ */
+export function validateRecordingConfig(config: { encoding?: EncodingType }): {
+    encoding: EncodingType
+    warnings: string[]
+} {
+    const warnings: string[] = []
+    const capabilities = getPlatformCapabilities()
+
+    let encoding = config.encoding || 'pcm_16bit'
+
+    // Check if encoding is supported
+    if (!isEncodingSupported(encoding)) {
+        const fallback = getFallbackEncoding(encoding)
+        warnings.push(
+            `${encoding} is not supported on ${Platform.OS}. Using ${fallback} instead.`
+        )
+        encoding = fallback
+    }
+
+    // Add platform-specific notes if there were changes
+    if (warnings.length > 0) {
+        warnings.push(...capabilities.notes)
+    }
+
+    return {
+        encoding,
+        warnings,
+    }
+}

package/src/constants.ts

@@ -0,0 +1,21 @@
+// packages/audio-studio/src/constants.ts
+import { Platform } from 'react-native'
+
+import { BitDepth, SampleRate } from './AudioStudio.types'
+
+export const isWeb = Platform.OS === 'web'
+export const DEBUG_NAMESPACE = 'audio-studio'
+
+// Constants for identifying chunks in a WAV file
+export const RIFF_HEADER = 0x52494646 // "RIFF"
+export const WAVE_HEADER = 0x57415645 // "WAVE"
+export const FMT_CHUNK_ID = 0x666d7420 // "fmt "
+export const DATA_CHUNK_ID = 0x64617461 // "data"
+export const INFO_CHUNK_ID = 0x494e464f // "INFO"
+
+// Default values
+export const DEFAULT_SAMPLE_RATE: SampleRate = 16000
+export const DEFAULT_BIT_DEPTH: BitDepth = 32
+export const DEFAULT_INTERVAL_MS = 1000
+export const DEFAULT_ANALYSIS_INTERVAL_MS = 500
+export const DEFAULT_MAX_BUFFER_SIZE = 100

package/src/events.ts

@@ -0,0 +1,63 @@
+// packages/audio-studio/src/events.ts
+
+import { LegacyEventEmitter, type EventSubscription } from 'expo-modules-core'
+
+import { AudioAnalysis } from './AudioAnalysis/AudioAnalysis.types'
+import { RecordingInterruptionEvent } from './AudioStudio.types'
+import AudioStudioModule from './AudioStudioModule'
+
+const emitter = new LegacyEventEmitter(AudioStudioModule)
+
+// Internal event payload from native module
+export interface AudioEventPayload {
+    encoded?: string
+    /** Float32 samples in [-1, 1] — sent by native when streamFormat='float32'.
+     *  Android new arch delivers Float32Array; iOS delivers number[]. */
+    pcmFloat32?: Float32Array | number[]
+    buffer?: Float32Array
+    fileUri: string
+    lastEmittedSize: number
+    position: number
+    deltaSize: number
+    totalSize: number
+    mimeType: string
+    streamUuid: string
+    compression?: {
+        data?: string | Blob // Base64 (native) or Float32Array (web) encoded compressed data chunk
+        position: number
+        eventDataSize: number
+        totalSize: number
+    }
+}
+
+export function addAudioEventListener(
+    listener: (event: AudioEventPayload) => Promise<void>
+): EventSubscription {
+    return emitter.addListener<AudioEventPayload>('AudioData', listener)
+}
+
+// Only aliasing the AudioAnalysis type for the event payload
+export interface AudioAnalysisEvent extends AudioAnalysis {}
+
+export function addAudioAnalysisListener(
+    listener: (event: AudioAnalysisEvent) => Promise<void>
+): EventSubscription {
+    return emitter.addListener<AudioAnalysisEvent>('AudioAnalysis', listener)
+}
+
+export function addRecordingInterruptionListener(
+    listener: (event: RecordingInterruptionEvent) => void
+): EventSubscription {
+    // Add debug logging
+    console.debug('Adding recording interruption listener')
+
+    const subscription = emitter.addListener<RecordingInterruptionEvent>(
+        'onRecordingInterrupted', // Make sure this matches the native event name
+        (event) => {
+            console.debug('Recording interruption event received:', event)
+            listener(event)
+        }
+    )
+
+    return subscription
+}

package/src/hooks/useAudioDevices.ts

@@ -0,0 +1,213 @@
+import { useCallback, useEffect, useState, useId } from 'react'
+
+import { audioDeviceManager } from '../AudioDeviceManager'
+import { AudioDevice } from '../AudioStudio.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)
+
+    // Generate unique instance ID for debugging
+    const instanceId = useId().replace(/:/g, '').slice(0, 5)
+
+    // 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) {
+                audioDeviceManager
+                    .getLogger()
+                    ?.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[]) => {
+                audioDeviceManager
+                    .getLogger()
+                    ?.debug(
+                        `🎛️ useAudioDevices [${instanceId}] received device change. Count: ${updatedDevices.length}`
+                    )
+
+                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
+                            .getLogger()
+                            ?.debug(
+                                `🎛️ useAudioDevices [${instanceId}] Current device ${currentDevice.id} no longer available, updating`
+                            )
+                        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) {
+                audioDeviceManager
+                    .getLogger()
+                    ?.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) {
+            audioDeviceManager
+                .getLogger()
+                ?.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) {
+            audioDeviceManager
+                .getLogger()
+                ?.error('Failed to refresh audio devices:', err)
+            setError(
+                err instanceof Error
+                    ? err
+                    : new Error('Failed to refresh audio devices')
+            )
+            return []
+        } finally {
+            setLoading(false)
+        }
+    }, [])
+
+    /**
+     * Initialize device detection
+     * Useful for restarting device detection if it failed initially
+     */
+    const initializeDeviceDetection = useCallback(() => {
+        audioDeviceManager.initializeDeviceDetection()
+    }, [])
+
+    return {
+        devices,
+        currentDevice,
+        loading,
+        error,
+        selectDevice,
+        resetToDefaultDevice,
+        refreshDevices,
+        initializeDeviceDetection,
+    }
+}

package/src/index.ts

@@ -0,0 +1,67 @@
+// src/index.ts
+
+import {
+    extractRawWavAnalysis,
+    extractAudioAnalysis,
+} from './AudioAnalysis/extractAudioAnalysis'
+import { extractAudioData } from './AudioAnalysis/extractAudioData'
+import {
+    extractMelSpectrogram,
+    MAX_DURATION_MS,
+} from './AudioAnalysis/extractMelSpectrogram'
+import { extractPreview } from './AudioAnalysis/extractPreview'
+import {
+    initMelStreamingWasm,
+    computeMelFrameWasm,
+} from './AudioAnalysis/melSpectrogramWasm'
+import {
+    AudioRecorderProvider,
+    useSharedAudioRecorder,
+} from './AudioRecorder.provider'
+import AudioStudioModule from './AudioStudioModule'
+import { trimAudio } from './trimAudio'
+import { useAudioRecorder } from './useAudioRecorder'
+
+export * from './utils/convertPCMToFloat32'
+export * from './utils/getWavFileInfo'
+export * from './utils/writeWavHeader'
+
+// Export platform capabilities
+export {
+    getPlatformCapabilities,
+    isEncodingSupported,
+    isBitDepthSupported,
+    getFallbackEncoding,
+    getFallbackBitDepth,
+    validateRecordingConfig,
+    type PlatformCapabilities,
+} from './constants/platformLimitations'
+
+// Export AudioDeviceManager
+export { AudioDeviceManager, audioDeviceManager } from './AudioDeviceManager'
+
+// Export useAudioDevices hook
+export { useAudioDevices } from './hooks/useAudioDevices'
+
+export {
+    AudioRecorderProvider,
+    AudioStudioModule,
+    extractRawWavAnalysis,
+    extractAudioAnalysis,
+    extractPreview,
+    trimAudio,
+    extractAudioData,
+    extractMelSpectrogram,
+    initMelStreamingWasm,
+    computeMelFrameWasm,
+    MAX_DURATION_MS,
+    useAudioRecorder,
+    useSharedAudioRecorder,
+}
+
+// Export all types
+export type * from './AudioAnalysis/AudioAnalysis.types'
+export type * from './AudioStudio.types'
+
+/** @deprecated Use AudioStudioModule instead */
+export const ExpoAudioStreamModule = AudioStudioModule

package/src/trimAudio.ts

@@ -0,0 +1,94 @@
+import { LegacyEventEmitter, type EventSubscription } from 'expo-modules-core'
+
+import {
+    TrimAudioOptions,
+    TrimAudioResult,
+    TrimProgressEvent,
+} from './AudioStudio.types'
+import AudioStudioModule from './AudioStudioModule'
+import { cleanNativeOptions } from './utils/cleanNativeOptions'
+
+// Create a single emitter instance
+const emitter = new LegacyEventEmitter(AudioStudioModule)
+
+/**
+ * Trims an audio file based on the provided options.
+ *
+ * @experimental This API is experimental and not fully optimized for production use.
+ * Performance may vary based on file size and device capabilities.
+ * Future versions may include breaking changes.
+ *
+ * @param options Configuration options for the trimming operation
+ * @param progressCallback Optional callback to receive progress updates
+ * @returns Promise resolving to the trimmed audio file information, including processing time
+ */
+export async function trimAudio(
+    options: TrimAudioOptions,
+    progressCallback?: (event: TrimProgressEvent) => void
+): Promise<TrimAudioResult> {
+    // Validation
+    if (!options.fileUri) {
+        throw new Error('fileUri is required')
+    }
+    const mode = options.mode ?? 'single'
+    if (mode === 'single') {
+        if (
+            options.startTimeMs === undefined &&
+            options.endTimeMs === undefined
+        ) {
+            throw new Error(
+                'At least one of startTimeMs or endTimeMs must be provided in single mode'
+            )
+        }
+    } else if (mode === 'keep' || mode === 'remove') {
+        if (!options.ranges || options.ranges.length === 0) {
+            throw new Error(
+                'ranges must be provided and non-empty for keep or remove modes'
+            )
+        }
+    } else {
+        throw new Error(
+            `Invalid mode: ${mode}. Must be 'single', 'keep', or 'remove'`
+        )
+    }
+
+    // Set up progress event listener if callback is provided
+    let subscription: EventSubscription | undefined
+    if (progressCallback) {
+        subscription = emitter.addListener(
+            'TrimProgress',
+            (event: TrimProgressEvent) => {
+                progressCallback(event)
+            }
+        )
+    }
+
+    try {
+        // Clean non-serializable/undefined values to avoid Android Kotlin bridge crash
+        const result = await AudioStudioModule.trimAudio(
+            cleanNativeOptions(options)
+        )
+        return result
+    } finally {
+        if (subscription) {
+            subscription.remove()
+        }
+    }
+}
+
+/**
+ * Simplified version of trimAudio that returns only the URI of the trimmed file.
+ *
+ * @experimental This API is experimental and not fully optimized for production use.
+ * Performance may vary based on file size and device capabilities.
+ * Future versions may include breaking changes.
+ *
+ * @param options Configuration options for the trimming operation
+ * @returns Promise resolving to the URI of the trimmed audio file
+ */
+export async function trimAudioSimple(
+    options: TrimAudioOptions
+): Promise<string> {
+    const result = await trimAudio(options)
+    return result.uri
+}

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

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