@siteed/expo-audio-stream 2.0.1 → 2.2.0

package/src/ExpoAudioStream.types.ts

@@ -1,329 +0,0 @@
-// packages/expo-audio-stream/src/ExpoAudioStream.types.ts
-import {
-    AudioAnalysis,
-    AudioFeaturesOptions,
-    DecodingConfig,
-} from './AudioAnalysis/AudioAnalysis.types'
-import { AudioAnalysisEvent } from './events'
-
-export interface CompressionInfo {
-    size: number
-    mimeType: string
-    bitrate: number
-    format: string
-    compressedFileUri?: string
-}
-
-export interface AudioStreamStatus {
-    isRecording: boolean
-    isPaused: boolean
-    durationMs: number
-    size: number
-    interval: number
-    intervalAnalysis: number
-    mimeType: string
-    compression?: CompressionInfo
-}
-
-export interface AudioDataEvent {
-    data: string | Float32Array
-    position: number
-    fileUri: string
-    eventDataSize: number
-    totalSize: number
-    compression?: CompressionInfo & {
-        data?: string | Blob // Base64 (native) or Float32Array (web) encoded compressed data chunk
-    }
-}
-
-export type EncodingType = 'pcm_32bit' | 'pcm_16bit' | 'pcm_8bit'
-export type SampleRate = 16000 | 44100 | 48000
-export type BitDepth = 8 | 16 | 32
-export type PCMFormat = `pcm_${BitDepth}bit`
-
-export type ConsoleLike = {
-    log: (message: string, ...args: unknown[]) => void
-    debug: (message: string, ...args: unknown[]) => void
-    info: (message: string, ...args: unknown[]) => void
-    warn: (message: string, ...args: unknown[]) => void
-    error: (message: string, ...args: unknown[]) => void
-}
-
-export interface Chunk {
-    text: string
-    timestamp: [number, number | null]
-}
-
-export interface TranscriberData {
-    id: string
-    isBusy: boolean
-    text: string
-    startTime: number
-    endTime: number
-    chunks: Chunk[]
-}
-
-export interface AudioRecording {
-    fileUri: string
-    filename: string
-    durationMs: number
-    size: number
-    mimeType: string
-    channels: number
-    bitDepth: BitDepth
-    sampleRate: SampleRate
-    createdAt?: number
-    transcripts?: TranscriberData[]
-    analysisData?: AudioAnalysis // Analysis data for the recording depending on enableProcessing flag
-    compression?: CompressionInfo & {
-        compressedFileUri: string
-    }
-}
-
-export interface StartRecordingResult {
-    fileUri: string
-    mimeType: string
-    channels?: number
-    bitDepth?: BitDepth
-    sampleRate?: SampleRate
-    compression?: CompressionInfo & {
-        compressedFileUri: string
-    }
-}
-
-export interface AudioSessionConfig {
-    category?:
-        | 'Ambient'
-        | 'SoloAmbient'
-        | 'Playback'
-        | 'Record'
-        | 'PlayAndRecord'
-        | 'MultiRoute'
-    mode?:
-        | 'Default'
-        | 'VoiceChat'
-        | 'VideoChat'
-        | 'GameChat'
-        | 'VideoRecording'
-        | 'Measurement'
-        | 'MoviePlayback'
-        | 'SpokenAudio'
-    categoryOptions?: (
-        | 'MixWithOthers'
-        | 'DuckOthers'
-        | 'InterruptSpokenAudioAndMixWithOthers'
-        | 'AllowBluetooth'
-        | 'AllowBluetoothA2DP'
-        | 'AllowAirPlay'
-        | 'DefaultToSpeaker'
-    )[]
-}
-
-export interface IOSConfig {
-    audioSession?: AudioSessionConfig
-}
-
-// Add new type for interruption reasons
-export type RecordingInterruptionReason =
-    | 'audioFocusLoss'
-    | 'audioFocusGain'
-    | 'phoneCall'
-    | 'phoneCallEnded'
-    | 'recordingStopped'
-
-// Add new interface for interruption events
-export interface RecordingInterruptionEvent {
-    reason: RecordingInterruptionReason
-    isPaused: boolean
-}
-
-export interface RecordingConfig {
-    // Sample rate for recording (16000, 44100, or 48000 Hz)
-    sampleRate?: SampleRate
-
-    // Number of audio channels (1 for mono, 2 for stereo)
-    channels?: 1 | 2
-
-    // Encoding type for the recording (pcm_32bit, pcm_16bit, pcm_8bit)
-    encoding?: EncodingType
-
-    // Interval in milliseconds at which to emit recording data
-    interval?: number
-
-    // Interval in milliseconds at which to emit analysis data
-    intervalAnalysis?: number
-
-    // Keep the device awake while recording (default is false)
-    keepAwake?: boolean
-
-    // Show a notification during recording (default is false)
-    showNotification?: boolean
-
-    // Show waveform in the notification (Android only, when showNotification is true)
-    showWaveformInNotification?: boolean
-
-    // Configuration for the notification
-    notification?: NotificationConfig
-
-    // Enable audio processing (default is false)
-    enableProcessing?: boolean
-
-    // iOS-specific configuration
-    ios?: IOSConfig
-
-    // Duration of each segment in milliseconds (default: 100)
-    segmentDurationMs?: number
-
-    // Feature options to extract (default is empty)
-    features?: AudioFeaturesOptions
-
-    // Callback function to handle audio stream
-    onAudioStream?: (_: AudioDataEvent) => Promise<void>
-
-    // Callback function to handle audio features extraction results
-    onAudioAnalysis?: (_: AudioAnalysisEvent) => Promise<void>
-
-    compression?: {
-        enabled: boolean
-        format: 'aac' | 'opus'
-        bitrate?: number
-    }
-
-    // Whether to automatically resume recording after an interruption (default is false)
-    autoResumeAfterInterruption?: boolean
-
-    // Optional callback to handle recording interruptions
-    onRecordingInterrupted?: (_: RecordingInterruptionEvent) => void
-
-    // Optional output configuration
-    outputDirectory?: string // If not provided, uses default app directory
-    filename?: string // If not provided, uses UUID
-}
-
-export interface NotificationConfig {
-    // Title of the notification
-    title?: string
-
-    // Main text content of the notification
-    text?: string
-
-    // Icon to be displayed in the notification (resource name or URI)
-    icon?: string
-
-    // Android-specific notification configuration
-    android?: {
-        // Unique identifier for the notification channel
-        channelId?: string
-
-        // User-visible name of the notification channel
-        channelName?: string
-
-        // User-visible description of the notification channel
-        channelDescription?: string
-
-        // Unique identifier for this notification
-        notificationId?: number
-
-        // List of actions that can be performed from the notification
-        actions?: NotificationAction[]
-
-        // Configuration for the waveform visualization in the notification
-        waveform?: WaveformConfig
-
-        // Color of the notification LED (if device supports it)
-        lightColor?: string
-
-        // Priority of the notification (affects how it's displayed)
-        priority?: 'min' | 'low' | 'default' | 'high' | 'max'
-
-        // Accent color for the notification (used for the app icon and buttons)
-        accentColor?: string
-    }
-
-    // iOS-specific notification configuration
-    ios?: {
-        // Identifier for the notification category (used for grouping similar notifications)
-        categoryIdentifier?: string
-    }
-}
-
-export interface NotificationAction {
-    // Display title for the action
-    title: string
-
-    // Unique identifier for the action
-    identifier: string
-
-    // Icon to be displayed for the action (Android only)
-    icon?: string
-}
-
-export interface WaveformConfig {
-    color?: string // The color of the waveform (e.g., "#FFFFFF" for white)
-    opacity?: number // Opacity of the waveform (0.0 - 1.0)
-    strokeWidth?: number // Width of the waveform line (default: 1.5)
-    style?: 'stroke' | 'fill' // Drawing style: "stroke" for outline, "fill" for solid
-    mirror?: boolean // Whether to mirror the waveform (symmetrical display)
-    height?: number // Height of the waveform view in dp (default: 64)
-}
-
-export interface ExtractAudioDataOptions {
-    fileUri: string
-    // Time-based range (mutually exclusive with byte-based range)
-    startTimeMs?: number
-    endTimeMs?: number
-    // Byte-based range (mutually exclusive with time-based range)
-    position?: number
-    length?: number
-    /** Include normalized audio data in [-1, 1] range */
-    includeNormalizedData?: boolean
-    /** Include base64 encoded string representation of the audio data */
-    includeBase64Data?: boolean
-    /** Include WAV header in the PCM data (makes it a valid WAV file) */
-    includeWavHeader?: boolean
-    /** Logger for debugging - can pass console directly. */
-    logger?: ConsoleLike
-    /** Compute the checksum of the pcm data */
-    computeChecksum?: boolean
-    /** Target config for the normalized audio (Android and Web) */
-    decodingOptions?: DecodingConfig
-}
-
-export interface ExtractedAudioData {
-    /** Raw PCM audio data */
-    pcmData: Uint8Array
-    /** Normalized audio data in [-1, 1] range (when includeNormalizedData is true) */
-    normalizedData?: Float32Array
-    /** Base64 encoded string representation of the audio data (when includeBase64Data is true) */
-    base64Data?: string
-    /** Sample rate in Hz (e.g., 44100, 48000) */
-    sampleRate: number
-    /** Number of audio channels (1 for mono, 2 for stereo) */
-    channels: number
-    /** Bits per sample (8, 16, or 32) */
-    bitDepth: BitDepth
-    /** Duration of the audio in milliseconds */
-    durationMs: number
-    /** PCM format identifier (e.g., "pcm_16bit") */
-    format: PCMFormat
-    /** Total number of audio samples per channel */
-    samples: number
-    /** Whether the pcmData includes a WAV header */
-    hasWavHeader?: boolean
-    /** CRC32 Checksum of pcm data */
-    checksum?: number
-}
-
-export interface UseAudioRecorderState {
-    startRecording: (_: RecordingConfig) => Promise<StartRecordingResult>
-    stopRecording: () => Promise<AudioRecording | null>
-    pauseRecording: () => Promise<void>
-    resumeRecording: () => Promise<void>
-    isRecording: boolean
-    isPaused: boolean
-    durationMs: number // Duration of the recording
-    size: number // Size in bytes of the recorded audio
-    compression?: CompressionInfo
-    analysisData?: AudioAnalysis // Analysis data for the recording depending on enableProcessing flag
-    onRecordingInterrupted?: (_: RecordingInterruptionEvent) => void
-}

package/src/ExpoAudioStream.web.ts

@@ -1,359 +0,0 @@
-// src/ExpoAudioStreamModule.web.ts
-import { LegacyEventEmitter } from 'expo-modules-core'
-
-import { AudioAnalysis } from './AudioAnalysis/AudioAnalysis.types'
-import {
-    AudioRecording,
-    AudioStreamStatus,
-    BitDepth,
-    ConsoleLike,
-    RecordingConfig,
-    StartRecordingResult,
-} from './ExpoAudioStream.types'
-import { WebRecorder } from './WebRecorder.web'
-import { AudioEventPayload } from './events'
-import { encodingToBitDepth } from './utils/encodingToBitDepth'
-
-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
-
-    constructor({
-        audioWorkletUrl,
-        featuresExtratorUrl,
-        logger,
-        maxBufferSize = 100, // Default to storing last 100 chunks (1 chunk = 0.5 seconds)
-    }: ExpoAudioStreamWebProps) {
-        const mockNativeModule = {
-            addListener: () => {
-                // Not used on web
-            },
-            removeListeners: () => {
-                // Not used on web
-            },
-        }
-        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 {
-            return await navigator.mediaDevices.getUserMedia({ audio: true })
-        } catch (error) {
-            this.logger?.error('Failed to get media stream:', error)
-            throw error
-        }
-    }
-
-    // Start recording with options
-    async startRecording(
-        recordingConfig: RecordingConfig = {}
-    ): Promise<StartRecordingResult> {
-        if (this.isRecording) {
-            throw new Error('Recording is already in progress')
-        }
-
-        this.bitDepth = encodingToBitDepth({
-            encoding: recordingConfig.encoding ?? 'pcm_32bit',
-        })
-
-        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: ({
-                data,
-                position,
-                compression,
-            }: EmitAudioEventProps) => {
-                // 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
-            },
-            emitAudioAnalysisCallback: (audioAnalysisData: AudioAnalysis) => {
-                this.logger?.log(`Emitted AudioAnalysis:`, audioAnalysisData)
-                this.emit('AudioAnalysis', audioAnalysisData)
-            },
-        })
-        await this.customRecorder.init()
-        this.customRecorder.start()
-
-        // // Set a timer to stop recording after 5 seconds
-        // setTimeout(() => {
-        //   logger.log("AUTO Stopping recording");
-        //   this.customRecorder?.stopAndPlay();
-        //   this.isRecording = false;
-        // }, 3000);
-
-        this.isRecording = true
-        this.recordingConfig = recordingConfig
-        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.compression
-                ? {
-                      ...recordingConfig.compression,
-                      bitrate: recordingConfig.compression?.bitrate ?? 128000,
-                      size: 0,
-                      mimeType: 'audio/webm',
-                      format: recordingConfig.compression?.format ?? 'opus',
-                      compressedFileUri: '',
-                  }
-                : undefined,
-        }
-        return streamConfig
-    }
-
-    emitAudioEvent({ data, position, compression }: EmitAudioEventProps) {
-        const fileUri = `${this.streamUuid}.${this.extension}`
-        if (compression?.size) {
-            this.lastEmittedCompressionSize = compression.size
-            this.totalCompressedSize = compression.totalSize
-        }
-        this.latestPosition = position
-        this.currentDurationMs = position * 1000 // Convert position (in seconds) to ms
-
-        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('[Stop] Starting stop process')
-        const startTime = performance.now()
-
-        try {
-            this.logger?.debug('[Stop] Stopping recorder')
-            const { compressedBlob } = await this.customRecorder.stop()
-
-            this.isRecording = false
-            this.isPaused = false
-            this.currentDurationMs = Date.now() - this.recordingStartTime
-
-            let compression: AudioRecording['compression']
-            let fileUri = `${this.streamUuid}.${this.extension}`
-            let mimeType = `audio/${this.extension}`
-
-            if (compressedBlob && this.recordingConfig?.compression?.enabled) {
-                const compressedUri = URL.createObjectURL(compressedBlob)
-                compression = {
-                    compressedFileUri: compressedUri,
-                    size: compressedBlob.size,
-                    mimeType: 'audio/webm',
-                    format: 'opus',
-                    bitrate: this.recordingConfig.compression.bitrate ?? 128000,
-                }
-                // Use compressed values when compression is enabled
-                fileUri = compressedUri
-                mimeType = 'audio/webm'
-            }
-
-            this.logger?.debug(
-                `[Stop] Completed stop process in ${performance.now() - startTime}ms`,
-                {
-                    durationMs: this.currentDurationMs,
-                    compressedSize: compression?.size,
-                }
-            )
-
-            // Use the stored streamUuid (which contains our custom filename) for the final filename
-            const filename = `${this.streamUuid}.${this.extension}`
-            const result: AudioRecording = {
-                fileUri,
-                filename, // This will now use our custom filename
-                bitDepth: this.bitDepth,
-                createdAt: this.recordingStartTime,
-                channels: this.recordingConfig?.channels ?? 1,
-                sampleRate: this.recordingConfig?.sampleRate ?? 44100,
-                durationMs: this.currentDurationMs,
-                size: this.currentSize,
-                mimeType,
-                compression,
-            }
-
-            // Reset after creating the result
-            this.streamUuid = null
-
-            return result
-        } catch (error) {
-            this.logger?.error('[Stop] Error stopping recording:', error)
-            throw error
-        }
-    }
-
-    // Pause recording
-    async pauseRecording() {
-        if (!this.isRecording || this.isPaused) {
-            throw new Error('Recording is not active or already paused')
-        }
-
-        if (this.customRecorder) {
-            this.customRecorder.pause()
-        }
-        this.isPaused = true
-        this.pausedTime = Date.now()
-    }
-
-    // Resume recording
-    async resumeRecording() {
-        if (!this.isPaused) {
-            throw new Error('Recording is not paused')
-        }
-
-        if (this.customRecorder) {
-            this.customRecorder.resume()
-        }
-        this.isPaused = false
-        this.recordingStartTime += Date.now() - this.pausedTime
-    }
-
-    // Get current status
-    status() {
-        const status: AudioStreamStatus = {
-            isRecording: this.isRecording,
-            isPaused: this.isPaused,
-            durationMs: this.currentDurationMs,
-            size: this.currentSize,
-            interval: this.currentInterval,
-            intervalAnalysis: this.currentIntervalAnalysis,
-            mimeType: `audio/${this.extension}`,
-            compression: this.recordingConfig?.compression?.enabled
-                ? {
-                      size: this.totalCompressedSize,
-                      mimeType: 'audio/webm',
-                      format: this.recordingConfig.compression.format ?? 'opus',
-                      bitrate:
-                          this.recordingConfig.compression.bitrate ?? 128000,
-                      compressedFileUri: `${this.streamUuid}.webm`,
-                  }
-                : undefined,
-        }
-        return status
-    }
-}