@siteed/expo-audio-stream 1.1.5 → 1.1.6

package/src/AudioAnalysis/extractWaveform.ts

@@ -0,0 +1,25 @@
+import ExpoAudioStreamModule from '../ExpoAudioStreamModule'
+import { getLogger } from '../logger'
+
+const logger = getLogger('extractWaveform')
+export interface ExtractWaveformProps {
+    fileUri: string
+    numberOfSamples: number
+    offset?: number
+    length?: number
+}
+export const extractWaveform = async ({
+    fileUri,
+    numberOfSamples,
+    offset = 0,
+    length,
+}: ExtractWaveformProps): Promise<unknown> => {
+    const res = await ExpoAudioStreamModule.extractAudioAnalysis({
+        fileUri,
+        numberOfSamples,
+        offset,
+        length,
+    })
+    logger.log(`extractWaveform`, res)
+    return res
+}

package/src/AudioRecorder.provider.tsx

@@ -0,0 +1,53 @@
+// packages/expo-audio-stream/src/AudioRecorder.provider.tsx
+import React, { createContext, useContext } from 'react'
+
+import { UseAudioRecorderState } from './ExpoAudioStream.types'
+import { UseAudioRecorderProps, useAudioRecorder } from './useAudioRecorder'
+
+const initContext: UseAudioRecorderState = {
+    isRecording: false,
+    isPaused: false,
+    durationMs: 0,
+    size: 0,
+    startRecording: async () => {
+        throw new Error('AudioRecorderProvider not found')
+    },
+    stopRecording: async () => {
+        throw new Error('AudioRecorderProvider not found')
+    },
+    pauseRecording: () => {
+        throw new Error('AudioRecorderProvider not found')
+    },
+    resumeRecording: () => {
+        throw new Error('AudioRecorderProvider not found')
+    },
+}
+
+const AudioRecorderContext = createContext<UseAudioRecorderState>(initContext)
+
+interface AudioRecorderProviderProps {
+    children: React.ReactNode
+    config?: UseAudioRecorderProps
+}
+
+export const AudioRecorderProvider: React.FC<AudioRecorderProviderProps> = ({
+    children,
+    config = {},
+}) => {
+    const audioRecorder = useAudioRecorder(config)
+    return (
+        <AudioRecorderContext.Provider value={audioRecorder}>
+            {children}
+        </AudioRecorderContext.Provider>
+    )
+}
+
+export const useSharedAudioRecorder = () => {
+    const context = useContext(AudioRecorderContext)
+    if (!context) {
+        throw new Error(
+            'useSharedAudioRecorder must be used within an AudioRecorderProvider'
+        )
+    }
+    return context
+}

package/src/ExpoAudioStream.native.ts

@@ -0,0 +1,6 @@
+// src/ExpoAudioStreamModule.ts
+import { requireNativeModule } from 'expo-modules-core'
+
+// It loads the native module object from the JSI or falls back to
+// the bridge module (from NativeModulesProxy) if the remote debugger is on.
+export default requireNativeModule('ExpoAudioStream')

package/src/ExpoAudioStream.types.ts

@@ -0,0 +1,93 @@
+// packages/expo-audio-stream/src/ExpoAudioStream.types.ts
+import {
+    AmplitudeAlgorithm,
+    AudioAnalysis,
+    AudioFeaturesOptions,
+} from './AudioAnalysis/AudioAnalysis.types'
+import { AudioAnalysisEvent } from './events'
+
+export interface AudioStreamStatus {
+    isRecording: boolean
+    isPaused: boolean
+    durationMs: number
+    size: number
+    interval: number
+    mimeType: string
+}
+
+export interface AudioDataEvent {
+    data: string | Float32Array
+    position: number
+    fileUri: string
+    eventDataSize: number
+    totalSize: number
+}
+
+export type EncodingType = 'pcm_32bit' | 'pcm_16bit' | 'pcm_8bit'
+export type SampleRate = 16000 | 44100 | 48000
+export type BitDepth = 8 | 16 | 32
+
+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
+    transcripts?: TranscriberData[]
+    wavPCMData?: Float32Array // Full PCM data for the recording in WAV format (only on web, for native use the fileUri)
+    analysisData?: AudioAnalysis // Analysis data for the recording depending on enableProcessing flag
+}
+
+export interface StartRecordingResult {
+    fileUri: string
+    mimeType: string
+    channels?: number
+    bitDepth?: BitDepth
+    sampleRate?: SampleRate
+}
+
+export interface RecordingConfig {
+    sampleRate?: SampleRate // Sample rate for recording
+    channels?: 1 | 2 // 1 or 2 (MONO or STEREO)
+    encoding?: EncodingType // Encoding type for the recording
+    interval?: number // Interval in milliseconds at which to emit recording data
+
+    // Optional parameters for audio processing
+    enableProcessing?: boolean // Boolean to enable/disable audio processing (default is false)
+    pointsPerSecond?: number // Number of data points to extract per second of audio (default is 1000)
+    algorithm?: AmplitudeAlgorithm // Algorithm to use for amplitude computation (default is "rms")
+    features?: AudioFeaturesOptions // Feature options to extract (default is empty)
+
+    onAudioStream?: (_: AudioDataEvent) => Promise<void> // Callback function to handle audio stream
+    onAudioAnalysis?: (_: AudioAnalysisEvent) => Promise<void> // Callback function to handle audio features extraction results
+}
+
+
+export interface UseAudioRecorderState {
+    startRecording: (_: RecordingConfig) => Promise<StartRecordingResult>
+    stopRecording: () => Promise<AudioRecording | null>
+    pauseRecording: () => void
+    resumeRecording: () => void
+    isRecording: boolean
+    isPaused: boolean
+    durationMs: number // Duration of the recording
+    size: number // Size in bytes of the recorded audio
+    analysisData?: AudioAnalysis // Analysis data for the recording depending on enableProcessing flag
+}

package/src/ExpoAudioStream.web.ts

@@ -0,0 +1,255 @@
+// src/ExpoAudioStreamModule.web.ts
+import { EventEmitter } from 'expo-modules-core'
+
+import { AudioAnalysis } from './AudioAnalysis/AudioAnalysis.types'
+import {
+    AudioRecording,
+    AudioStreamStatus,
+    BitDepth,
+    RecordingConfig,
+    StartRecordingResult,
+} from './ExpoAudioStream.types'
+import { WebRecorder } from './WebRecorder.web'
+import { AudioEventPayload } from './events'
+import { getLogger } from './logger'
+import { encodingToBitDepth } from './utils/encodingToBitDepth'
+import { writeWavHeader } from './utils/writeWavHeader'
+
+export interface EmitAudioEventProps {
+    data: Float32Array
+    position: number
+}
+export type EmitAudioEventFunction = (_: EmitAudioEventProps) => void
+export type EmitAudioAnalysisFunction = (_: AudioAnalysis) => void
+
+export interface ExpoAudioStreamWebProps {
+    audioWorkletUrl: string
+    featuresExtratorUrl: string
+}
+
+const logger = getLogger('ExpoAudioStreamWeb')
+
+export class ExpoAudioStreamWeb extends EventEmitter {
+    customRecorder: WebRecorder | null
+    audioChunks: ArrayBuffer[]
+    isRecording: boolean
+    isPaused: boolean
+    recordingStartTime: number
+    pausedTime: number
+    currentDurationMs: number
+    currentSize: number
+    currentInterval: number
+    lastEmittedSize: number
+    lastEmittedTime: number
+    streamUuid: string | null
+    extension: 'webm' | 'wav' = 'wav' // Default extension is 'webm'
+    recordingConfig?: RecordingConfig
+    bitDepth: BitDepth // Bit depth of the audio
+    audioWorkletUrl: string
+    featuresExtratorUrl: string
+
+    constructor({
+        audioWorkletUrl,
+        featuresExtratorUrl,
+    }: 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.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.lastEmittedSize = 0
+        this.lastEmittedTime = 0
+        this.streamUuid = null // Initialize UUID on first recording start
+        this.audioWorkletUrl = audioWorkletUrl
+        this.featuresExtratorUrl = featuresExtratorUrl
+    }
+
+    // Utility to handle user media stream
+    async getMediaStream() {
+        try {
+            return await navigator.mediaDevices.getUserMedia({ audio: true })
+        } catch (error) {
+            console.error('Failed to get media stream:', error)
+            throw error
+        }
+    }
+
+    // Start recording with options
+    async startRecording(recordingConfig: RecordingConfig = {}) {
+        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({
+            audioContext,
+            source,
+            recordingConfig,
+            audioWorkletUrl: this.audioWorkletUrl,
+            emitAudioEventCallback: ({
+                data,
+                position,
+            }: EmitAudioEventProps) => {
+                this.audioChunks.push(data)
+                this.currentSize += data.byteLength
+                this.emitAudioEvent({ data, position })
+                this.lastEmittedTime = Date.now()
+                this.lastEmittedSize = this.currentSize
+            },
+            emitAudioAnalysisCallback: (audioAnalysisData: AudioAnalysis) => {
+                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.lastEmittedSize = 0
+        this.lastEmittedTime = 0
+        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,
+        }
+        return streamConfig
+    }
+
+    emitAudioEvent({ data, position }: EmitAudioEventProps) {
+        const fileUri = `${this.streamUuid}.${this.extension}`
+        const audioEventPayload: AudioEventPayload = {
+            fileUri,
+            mimeType: `audio/${this.extension}`,
+            lastEmittedSize: this.lastEmittedSize, // Since this might be continuously streaming, adjust accordingly
+            deltaSize: data.byteLength,
+            position,
+            totalSize: this.currentSize,
+            buffer: data,
+            streamUuid: this.streamUuid ?? '', // Generate or manage UUID for stream identification
+        }
+
+        this.emit('AudioData', audioEventPayload)
+    }
+
+    // Stop recording
+    async stopRecording(): Promise<AudioRecording> {
+        if (!this.customRecorder) {
+            throw new Error('Recorder is not initialized')
+        }
+
+        const fullPcmBufferArray = await this.customRecorder.stop()
+
+        // concat all audio chunks
+        logger.debug(`Stopped recording`, fullPcmBufferArray)
+        this.isRecording = false
+        this.currentDurationMs = Date.now() - this.recordingStartTime
+
+        const wavConfig = {
+            buffer: fullPcmBufferArray.buffer,
+            sampleRate: this.recordingConfig?.sampleRate ?? 44100,
+            numChannels: this.recordingConfig?.channels ?? 1,
+            bitDepth: this.bitDepth,
+        }
+        logger.debug(`Writing wav header`, wavConfig)
+        const wavBuffer = writeWavHeader(wavConfig).slice(0)
+
+        // Create blob fileUri from audio chunks
+        const blob = new Blob([wavBuffer], {
+            type: `audio/${this.extension}`,
+        })
+        const fileUri = URL.createObjectURL(blob)
+
+        const result: AudioRecording = {
+            fileUri,
+            filename: `${this.streamUuid}.${this.extension}`,
+            wavPCMData: fullPcmBufferArray,
+            bitDepth: this.bitDepth,
+            channels: this.recordingConfig?.channels ?? 1,
+            sampleRate: this.recordingConfig?.sampleRate ?? 44100,
+            durationMs: this.currentDurationMs,
+            size: this.currentSize,
+            mimeType: `audio/${this.extension}`,
+        }
+
+        return result
+    }
+
+    // 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: Date.now() - this.recordingStartTime,
+            size: this.currentSize,
+            interval: this.currentInterval,
+            mimeType: `audio/${this.extension}`,
+        }
+        return status
+    }
+}

package/src/ExpoAudioStreamModule.ts

@@ -0,0 +1,31 @@
+import { requireNativeModule } from 'expo-modules-core'
+import { Platform } from 'react-native'
+
+import {
+    ExpoAudioStreamWeb,
+    ExpoAudioStreamWebProps,
+} from './ExpoAudioStream.web'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let ExpoAudioStreamModule: any
+
+if (Platform.OS === 'web') {
+    let instance: ExpoAudioStreamWeb | null = null
+
+    ExpoAudioStreamModule = (webProps: ExpoAudioStreamWebProps) => {
+        if (!instance) {
+            instance = new ExpoAudioStreamWeb(webProps)
+        }
+        return instance
+    }
+    ExpoAudioStreamModule.requestPermissionsAsync = async () => {
+        return { status: 'granted' }
+    }
+    ExpoAudioStreamModule.getPermissionsAsync = async () => {
+        return { status: 'granted' }
+    }
+} else {
+    ExpoAudioStreamModule = requireNativeModule('ExpoAudioStream')
+}
+
+export default ExpoAudioStreamModule