@siteed/expo-audio-studio 2.18.6 → 3.0.1

package/plugin/src/index.ts

@@ -1,285 +0,0 @@
-import {
-    ConfigPlugin,
-    withAndroidManifest,
-    withInfoPlist,
-    AndroidConfig,
-} from '@expo/config-plugins'
-import { ExpoConfig } from '@expo/config-types'
-
-const MICROPHONE_USAGE = 'Allow $(PRODUCT_NAME) to access your microphone'
-const NOTIFICATION_USAGE = 'Show recording notifications and controls'
-const LOG_PREFIX = '[@siteed/expo-audio-studio]'
-
-function debugLog(message: string, ...args: unknown[]): void {
-    if (process.env.EXPO_DEBUG) {
-        console.log(`${LOG_PREFIX} ${message}`, ...args)
-    }
-}
-
-interface AudioStreamPluginOptions {
-    enablePhoneStateHandling?: boolean // Controls READ_PHONE_STATE permission
-    enableNotifications?: boolean
-    enableBackgroundAudio?: boolean
-    enableDeviceDetection?: boolean // Controls Bluetooth and USB permissions for device change detection
-    iosBackgroundModes?: {
-        useVoIP?: boolean
-        useAudio?: boolean
-        useProcessing?: boolean
-        useLocation?: boolean
-        useExternalAccessory?: boolean
-    }
-    iosConfig?: {
-        allowBackgroundAudioControls?: boolean
-        backgroundProcessingTitle?: string
-        microphoneUsageDescription?: string
-        notificationUsageDescription?: string
-    }
-}
-
-const withRecordingPermission: ConfigPlugin<AudioStreamPluginOptions> = (
-    config: ExpoConfig,
-    props: AudioStreamPluginOptions | void
-) => {
-    const options: AudioStreamPluginOptions = {
-        enablePhoneStateHandling: true, // Default to true for backward compatibility
-        enableNotifications: true,
-        enableBackgroundAudio: true,
-        enableDeviceDetection: true, // Default to true for backward compatibility
-        iosBackgroundModes: {
-            useVoIP: false,
-            useAudio: false,
-            useProcessing: false,
-            useLocation: false,
-            useExternalAccessory: false,
-        },
-        iosConfig: {
-            microphoneUsageDescription: MICROPHONE_USAGE,
-            notificationUsageDescription: NOTIFICATION_USAGE,
-        },
-        ...(props || {}),
-    }
-
-    const {
-        enablePhoneStateHandling,
-        enableNotifications,
-        enableBackgroundAudio,
-        enableDeviceDetection,
-    } = options
-
-    debugLog('📱 Configuring Recording Permissions Plugin...', options)
-
-    // iOS Configuration
-    config = withInfoPlist(config as any, (config) => {
-        // Always set the microphone usage description from options first
-        config.modResults['NSMicrophoneUsageDescription'] =
-            options.iosConfig?.microphoneUsageDescription ||
-            config.modResults['NSMicrophoneUsageDescription'] ||
-            MICROPHONE_USAGE
-
-        if (enableNotifications) {
-            config.modResults['NSUserNotificationsUsageDescription'] =
-                options.iosConfig?.notificationUsageDescription ||
-                config.modResults['NSUserNotificationsUsageDescription'] ||
-                NOTIFICATION_USAGE
-            config.modResults['NSUserNotificationAlertStyle'] = 'alert'
-        }
-
-        const existingBackgroundModes =
-            config.modResults.UIBackgroundModes || []
-
-        // If background audio is enabled with useAudio, add the audio background mode
-        if (
-            options.iosBackgroundModes?.useAudio === true &&
-            enableBackgroundAudio === true &&
-            !existingBackgroundModes.includes('audio')
-        ) {
-            // Add 'audio' background mode - REQUIRED for background recording
-            existingBackgroundModes.push('audio')
-            debugLog(
-                '✅ Added audio background mode for iOS background recording'
-            )
-
-            // Also ensure processing mode is recommended
-            if (options.iosBackgroundModes?.useProcessing !== true) {
-                console.warn(
-                    `${LOG_PREFIX} Warning: Background audio recording works best with both 'audio' and 'processing' background modes. Consider enabling 'useProcessing' in iosBackgroundModes.`
-                )
-            }
-        }
-
-        if (
-            options.iosBackgroundModes?.useVoIP === true &&
-            enablePhoneStateHandling === true
-        ) {
-            if (!existingBackgroundModes.includes('voip')) {
-                existingBackgroundModes.push('voip')
-            }
-            const existingCapabilities = (config.modResults
-                .UIRequiredDeviceCapabilities || []) as string[]
-            if (!existingCapabilities.includes('telephony')) {
-                existingCapabilities.push('telephony')
-            }
-            config.modResults.UIRequiredDeviceCapabilities =
-                existingCapabilities
-        }
-
-        // Add additional background modes only if explicitly set to true
-        if (options.iosBackgroundModes?.useProcessing === true) {
-            if (!existingBackgroundModes.includes('processing')) {
-                existingBackgroundModes.push('processing')
-            }
-            // Add processing info if enabled
-            // Note: We keep the 'audiostream' namespace for native modules to maintain compatibility
-            config.modResults.BGTaskSchedulerPermittedIdentifiers = [
-                'com.siteed.audiostream.processing',
-            ]
-        }
-
-        if (options.iosBackgroundModes?.useLocation === true) {
-            if (!existingBackgroundModes.includes('location')) {
-                existingBackgroundModes.push('location')
-            }
-        }
-
-        if (options.iosBackgroundModes?.useExternalAccessory === true) {
-            if (!existingBackgroundModes.includes('external-accessory')) {
-                existingBackgroundModes.push('external-accessory')
-            }
-        }
-
-        // Configure background processing info if enabled
-        if (options.iosConfig?.backgroundProcessingTitle) {
-            config.modResults.BGProcessingTaskTitle =
-                options.iosConfig.backgroundProcessingTitle
-        }
-
-        // Configure audio session behavior
-        if (options.iosConfig?.allowBackgroundAudioControls) {
-            config.modResults.UIBackgroundModes = [
-                ...existingBackgroundModes,
-                'remote-notification',
-            ]
-            config.modResults.MPNowPlayingInfoPropertyPlaybackRate = true
-        }
-
-        config.modResults.UIBackgroundModes = existingBackgroundModes
-        return config
-    })
-
-    // Android Configuration
-    config = withAndroidManifest(config as any, (config) => {
-        const basePermissions = ['android.permission.RECORD_AUDIO']
-
-        const optionalPermissions = [
-            enableNotifications && 'android.permission.POST_NOTIFICATIONS',
-            enablePhoneStateHandling && 'android.permission.READ_PHONE_STATE', // Only add if enabled
-            enableBackgroundAudio && 'android.permission.FOREGROUND_SERVICE',
-            enableBackgroundAudio &&
-                'android.permission.FOREGROUND_SERVICE_MICROPHONE',
-            enableBackgroundAudio && 'android.permission.WAKE_LOCK', // Keep device awake during background recording
-            // Device detection permissions (only if enabled)
-            enableDeviceDetection && 'android.permission.BLUETOOTH',
-            enableDeviceDetection && 'android.permission.BLUETOOTH_ADMIN',
-            enableDeviceDetection && 'android.permission.BLUETOOTH_CONNECT',
-            enableDeviceDetection && 'android.permission.USB_PERMISSION',
-        ].filter(Boolean) as string[]
-
-        const permissionsToAdd = [...basePermissions, ...optionalPermissions]
-
-        debugLog(
-            '📋 Existing Android permissions:',
-            config.modResults.manifest['uses-permission']?.map(
-                (p) => p.$?.['android:name']
-            ) || []
-        )
-
-        debugLog('➕ Adding Android permissions:', permissionsToAdd)
-
-        // Add each permission only if it doesn't exist
-        permissionsToAdd.forEach((permission) => {
-            AndroidConfig.Permissions.addPermission(
-                config.modResults,
-                permission
-            )
-        })
-
-        // Get the main application node
-        const mainApplication = config.modResults.manifest.application?.[0]
-        if (mainApplication) {
-            debugLog('📱 Configuring Android application components...')
-
-            // Add RecordingActionReceiver
-            if (!mainApplication.receiver) {
-                mainApplication.receiver = []
-            }
-
-            const receiverConfig = {
-                $: {
-                    'android:name': '.RecordingActionReceiver',
-                    'android:exported': 'false' as const,
-                },
-                'intent-filter': [
-                    {
-                        action: [
-                            { $: { 'android:name': 'PAUSE_RECORDING' } },
-                            { $: { 'android:name': 'RESUME_RECORDING' } },
-                            { $: { 'android:name': 'STOP_RECORDING' } },
-                        ],
-                    },
-                ],
-            }
-
-            const receiverIndex = mainApplication.receiver.findIndex(
-                (receiver: any) =>
-                    receiver.$?.['android:name'] === '.RecordingActionReceiver'
-            )
-
-            if (receiverIndex >= 0) {
-                mainApplication.receiver[receiverIndex] = receiverConfig
-            } else {
-                mainApplication.receiver.push(receiverConfig)
-            }
-
-            debugLog('✅ RecordingActionReceiver configured')
-
-            // Add AudioRecordingService
-            if (!mainApplication.service) {
-                mainApplication.service = []
-            }
-
-            const serviceConfig = {
-                $: {
-                    'android:name': '.AudioRecordingService',
-                    'android:enabled': 'true' as const,
-                    'android:exported': 'false' as const,
-                    'android:foregroundServiceType': 'microphone',
-                },
-            }
-
-            const serviceIndex = mainApplication.service.findIndex(
-                (service: any) =>
-                    service.$?.['android:name'] === '.AudioRecordingService'
-            )
-
-            if (serviceIndex >= 0) {
-                mainApplication.service[serviceIndex] = serviceConfig
-            } else {
-                mainApplication.service.push(serviceConfig)
-            }
-
-            debugLog('✅ AudioRecordingService configured')
-        } else {
-            console.error(
-                `${LOG_PREFIX} ❌ Main application node not found in Android Manifest`
-            )
-        }
-
-        return config
-    })
-
-    debugLog('✨ Recording Permissions Plugin configuration completed')
-    return config as any
-}
-
-// Export as default
-export default withRecordingPermission

package/plugin/tsconfig.json

@@ -1,10 +0,0 @@
-{
-    "extends": "expo-module-scripts/tsconfig.plugin",
-    "compilerOptions": {
-        "outDir": "build",
-        "lib": ["es2023", "dom"],
-        "rootDir": "src"
-    },
-    "include": ["./src"],
-    "exclude": ["**/__mocks__/*", "**/__tests__/*"]
-}

package/plugin/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./src/index.ts"],"version":"5.8.3"}

package/src/AudioAnalysis/AudioAnalysis.types.ts

@@ -1,224 +0,0 @@
-// packages/expo-audio-stream/src/AudioAnalysis/AudioAnalysis.types.ts
-
-import { BitDepth, ConsoleLike } from '../ExpoAudioStream.types'
-
-/**
- * Represents the configuration for decoding audio data.
- */
-export interface DecodingConfig {
-    /** Target sample rate for decoded audio (Android and Web) */
-    targetSampleRate?: number
-    /** Target number of channels (Android and Web) */
-    targetChannels?: number
-    /** Target bit depth (Android and Web) */
-    targetBitDepth?: BitDepth
-    /** Whether to normalize audio levels (Android and Web) */
-    normalizeAudio?: boolean
-}
-
-/**
- * Represents speech-related features extracted from audio.
- */
-export interface SpeechFeatures {
-    isActive: boolean // Whether speech is detected in this segment
-    speakerId?: number // Optional speaker identification
-    // Could add more speech-related features here like:
-    // confidence: number
-    // language?: string
-    // sentiment?: number
-    // etc.
-}
-
-/**
- * Represents various audio features extracted from an audio signal.
- */
-export interface AudioFeatures {
-    energy?: number // The infinite integral of the squared signal, representing the overall energy of the audio.
-    mfcc?: number[] // Mel-frequency cepstral coefficients, describing the short-term power spectrum of a sound.
-    rms?: number // Root mean square value, indicating the amplitude of the audio signal.
-    minAmplitude?: number // Minimum amplitude value in the audio signal.
-    maxAmplitude?: number // Maximum amplitude value in the audio signal.
-    zcr?: number // Zero-crossing rate, indicating the rate at which the signal changes sign.
-    spectralCentroid?: number // The center of mass of the spectrum, indicating the brightness of the sound.
-    spectralFlatness?: number // Measure of the flatness of the spectrum, indicating how noise-like the signal is.
-    spectralRolloff?: number // The frequency below which a specified percentage (usually 85%) of the total spectral energy lies.
-    spectralBandwidth?: number // The width of the spectrum, indicating the range of frequencies present.
-    chromagram?: number[] // Chromagram, representing the 12 different pitch classes of the audio.
-    tempo?: number // Estimated tempo of the audio signal, measured in beats per minute (BPM).
-    hnr?: number // Harmonics-to-noise ratio, indicating the proportion of harmonics to noise in the audio signal.
-    melSpectrogram?: number[] // Mel-scaled spectrogram representation of the audio.
-    spectralContrast?: number[] // Spectral contrast features representing the difference between peaks and valleys.
-    tonnetz?: number[] // Tonal network features representing harmonic relationships.
-    pitch?: number // Pitch of the audio signal, measured in Hertz (Hz).
-    crc32?: number // crc32 checksum of the audio signal, used to verify the integrity of the audio.
-}
-
-/**
- * Options to specify which audio features to extract.
- * Note: Advanced features (spectral features, chromagram, pitch, etc.) are experimental,
- * especially during live recording, due to high processing requirements.
- */
-export interface AudioFeaturesOptions {
-    // Basic features - well optimized
-    energy?: boolean
-    rms?: boolean
-    zcr?: boolean
-
-    // Advanced features - experimental, may impact performance in live recording
-    mfcc?: boolean
-    spectralCentroid?: boolean
-    spectralFlatness?: boolean
-    spectralRolloff?: boolean
-    spectralBandwidth?: boolean
-    chromagram?: boolean
-    tempo?: boolean
-    hnr?: boolean
-    melSpectrogram?: boolean
-    spectralContrast?: boolean
-    tonnetz?: boolean
-    pitch?: boolean
-
-    // Utility
-    crc32?: boolean
-}
-
-/**
- * Represents a single data point in the audio analysis.
- */
-export interface DataPoint {
-    id: number
-    amplitude: number // Peak amplitude for the segment
-    rms: number // Root mean square value
-    dB: number // dBFS (decibels relative to full scale) computed from RMS value
-    silent: boolean // Always computed
-    features?: AudioFeatures
-    speech?: SpeechFeatures
-    startTime?: number
-    endTime?: number
-    // start / end position in bytes
-    startPosition?: number
-    endPosition?: number
-    // number of audio samples for this point (samples size depends on bit depth)
-    samples?: number
-}
-
-/**
- * Represents the complete data from the audio analysis.
- */
-export interface AudioAnalysis {
-    segmentDurationMs: number // Duration of each segment in milliseconds
-    durationMs: number // Duration of the audio in milliseconds
-    /**
-     * Bit depth used for audio analysis processing.
-     *
-     * **Important**: This represents the internal processing bit depth, which may differ
-     * from the recording bit depth. Audio is typically converted to 32-bit float for
-     * analysis to ensure precision in calculations, regardless of the original recording format.
-     *
-     * Platform behavior:
-     * - iOS: Always 32 (float processing)
-     * - Android: Always 32 (float processing)
-     * - Web: Always 32 (Web Audio API standard)
-     *
-     * The actual recorded file will maintain the requested bit depth (8, 16, or 32).
-     */
-    bitDepth: number
-    samples: number // Size of the audio in bytes
-    numberOfChannels: number // Number of audio channels
-    sampleRate: number // Sample rate of the audio
-    dataPoints: DataPoint[] // Array of data points from the analysis.
-    amplitudeRange: {
-        min: number
-        max: number
-    }
-    rmsRange: {
-        min: number
-        max: number
-    }
-    extractionTimeMs: number // Time taken to extract/process the analysis in milliseconds
-    // TODO: speaker changes into a broader speech analysis section
-    speechAnalysis?: {
-        speakerChanges: {
-            timestamp: number
-            speakerId: number
-        }[]
-        // Could add more speech analysis data here like:
-        // dominantSpeaker?: number
-        // totalSpeechDuration?: number
-        // speakerStats?: { [speakerId: number]: { duration: number, segments: number } }
-    }
-}
-
-/**
- * Options for specifying a time range within an audio file.
- */
-export interface AudioRangeOptions {
-    /** Start time in milliseconds */
-    startTimeMs?: number
-    /** End time in milliseconds */
-    endTimeMs?: number
-}
-
-/**
- * Options for generating a quick preview of audio waveform.
- * This is optimized for UI rendering with a specified number of points.
- */
-export interface PreviewOptions extends AudioRangeOptions {
-    /** URI of the audio file to analyze */
-    fileUri: string
-    /**
-     * Total number of points to generate for the preview.
-     * @default 100
-     */
-    numberOfPoints?: number
-    /**
-     * Optional logger for debugging.
-     */
-    logger?: ConsoleLike
-    /**
-     * Optional configuration for decoding the audio file.
-     * Defaults to:
-     * - targetSampleRate: undefined (keep original)
-     * - targetChannels: undefined (keep original)
-     * - targetBitDepth: 16
-     * - normalizeAudio: false
-     */
-    decodingOptions?: DecodingConfig
-}
-
-/**
- * Options for mel-spectrogram extraction
- *
- * @experimental This feature is experimental and currently only available on Android.
- * The API may change in future versions.
- */
-export interface ExtractMelSpectrogramOptions {
-    fileUri?: string // Path to audio file
-    arrayBuffer?: ArrayBuffer // Raw audio buffer
-    windowSizeMs: number // Window size in ms (e.g., 25)
-    hopLengthMs: number // Hop length in ms (e.g., 10)
-    nMels: number // Number of mel filters (e.g., 60)
-    fMin?: number // Min frequency (default: 0)
-    fMax?: number // Max frequency (default: sampleRate / 2)
-    windowType?: 'hann' | 'hamming' // Window function (default: 'hann')
-    normalize?: boolean // Mean normalization (default: false)
-    logScale?: boolean // Log scaling of mel energies (default: true)
-    decodingOptions?: DecodingConfig // Audio decoding settings
-    startTimeMs?: number // Optional start time
-    endTimeMs?: number // Optional end time
-    logger?: ConsoleLike
-}
-
-/**
- * Return type for mel spectrogram extraction
- *
- * @experimental This feature is experimental and currently only available on Android.
- * The API may change in future versions.
- */
-export interface MelSpectrogram {
-    spectrogram: number[][] // 2D array [time][mel]
-    sampleRate: number // Audio sample rate
-    nMels: number // Number of mel filters
-    timeSteps: number // Number of time frames
-    durationMs: number // Audio duration in ms
-}