@siteed/expo-audio-studio 2.18.6 → 3.0.0

package/src/constants/platformLimitations.ts

@@ -1,118 +0,0 @@
-/**
- * Platform-specific audio recording limitations and capabilities
- */
-
-import { Platform } from 'react-native'
-
-import { EncodingType, BitDepth } from '../ExpoAudioStream.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

@@ -1,18 +0,0 @@
-// packages/expo-audio-stream/src/constants.ts
-import { Platform } from 'react-native'
-
-import { BitDepth, SampleRate } from './ExpoAudioStream.types'
-
-export const isWeb = Platform.OS === 'web'
-export const DEBUG_NAMESPACE = 'expo-audio-stream'
-
-// 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

package/src/events.ts

@@ -1,60 +0,0 @@
-// packages/expo-audio-stream/src/events.ts
-
-import { LegacyEventEmitter, type EventSubscription } from 'expo-modules-core'
-
-import { AudioAnalysis } from './AudioAnalysis/AudioAnalysis.types'
-import { RecordingInterruptionEvent } from './ExpoAudioStream.types'
-import ExpoAudioStreamModule from './ExpoAudioStreamModule'
-
-const emitter = new LegacyEventEmitter(ExpoAudioStreamModule)
-
-// Internal event payload from native module
-export interface AudioEventPayload {
-    encoded?: string
-    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

@@ -1,213 +0,0 @@
-import { useCallback, useEffect, useState, useId } 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)
-
-    // 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

@@ -1,54 +0,0 @@
-// src/index.ts
-
-import {
-    extractRawWavAnalysis,
-    extractAudioAnalysis,
-} from './AudioAnalysis/extractAudioAnalysis'
-import { extractAudioData } from './AudioAnalysis/extractAudioData'
-import { extractMelSpectrogram } from './AudioAnalysis/extractMelSpectrogram'
-import { extractPreview } from './AudioAnalysis/extractPreview'
-import {
-    AudioRecorderProvider,
-    useSharedAudioRecorder,
-} from './AudioRecorder.provider'
-import ExpoAudioStreamModule from './ExpoAudioStreamModule'
-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,
-    ExpoAudioStreamModule,
-    extractRawWavAnalysis,
-    extractAudioAnalysis,
-    extractPreview,
-    trimAudio,
-    extractAudioData,
-    extractMelSpectrogram,
-    useAudioRecorder,
-    useSharedAudioRecorder,
-}
-
-// Export all types
-export type * from './AudioAnalysis/AudioAnalysis.types'
-export type * from './ExpoAudioStream.types'

package/src/trimAudio.ts

@@ -1,94 +0,0 @@
-import { LegacyEventEmitter, type EventSubscription } from 'expo-modules-core'
-
-import {
-    TrimAudioOptions,
-    TrimAudioResult,
-    TrimProgressEvent,
-} from './ExpoAudioStream.types'
-import ExpoAudioStreamModule from './ExpoAudioStreamModule'
-import { cleanNativeOptions } from './utils/cleanNativeOptions'
-
-// Create a single emitter instance
-const emitter = new LegacyEventEmitter(ExpoAudioStreamModule)
-
-/**
- * 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 ExpoAudioStreamModule.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

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