@siteed/expo-audio-stream 1.0.2 → 1.0.5

package/src/index.ts

@@ -1,183 +1,22 @@
 // src/index.ts
-import { EventEmitter, type Subscription } from "expo-modules-core";
-import { Platform } from "react-native";
 
-// Import the native module. On web, it will be resolved to ExpoAudioStream.web.ts
-// and on native platforms to ExpoAudioStream.ts
+import { extractAudioAnalysis } from './AudioAnalysis/extractAudioAnalysis'
 import {
-  AudioRecorderProvider,
-  useSharedAudioRecorder,
-} from "./AudioRecorder.provider";
-import { AudioAnalysisData, AudioEventPayload } from "./ExpoAudioStream.types";
-import ExpoAudioStreamModule from "./ExpoAudioStreamModule";
-import { ExtractMetadataProps, useAudioRecorder } from "./useAudioRecording";
-import { convertPCMToFloat32, getWavFileInfo, writeWavHeader } from "./utils";
+    AudioRecorderProvider,
+    useSharedAudioRecorder,
+} from './AudioRecorder.provider'
+import { useAudioRecorder } from './useAudioRecorder'
 
-const emitter = new EventEmitter(ExpoAudioStreamModule);
-
-export function addAudioEventListener(
-  listener: (event: AudioEventPayload) => Promise<void>,
-): Subscription {
-  console.log(`addAudioEventListener`, listener);
-  return emitter.addListener<AudioEventPayload>("AudioData", listener);
-}
-
-export function addAudioAnalysisListener(
-  listener: (event: AudioAnalysisData) => Promise<void>,
-): Subscription {
-  console.log(`addAudioAnalysisListener`, listener);
-  return emitter.addListener<AudioAnalysisData>("AudioAnalysis", listener);
-}
-
-const isWeb = Platform.OS === "web";
-
-export const extractAudioAnalysis = async ({
-  fileUri,
-  pointsPerSecond = 20,
-  arrayBuffer,
-  bitDepth,
-  skipWavHeader,
-  durationMs,
-  sampleRate,
-  numberOfChannels,
-  algorithm = "rms",
-  features,
-  featuresExtratorUrl = "/audio-features-extractor.js",
-}: ExtractMetadataProps): Promise<AudioAnalysisData> => {
-  if (isWeb) {
-    if (!arrayBuffer && !fileUri) {
-      throw new Error("Either arrayBuffer or fileUri must be provided");
-    }
-
-    if (!arrayBuffer) {
-      console.log(`fetching fileUri`, fileUri);
-      const response = await fetch(fileUri!);
-
-      if (!response.ok) {
-        throw new Error(`Failed to fetch fileUri: ${response.statusText}`);
-      }
-
-      arrayBuffer = (await response.arrayBuffer()).slice(0);
-      console.log(`fetched fileUri`, arrayBuffer.byteLength, arrayBuffer);
-    }
-
-    // Create a new copy of the ArrayBuffer to avoid detachment issues
-    const bufferCopy = arrayBuffer.slice(0);
-    console.log(
-      `extractAudioAnalysis skipWavHeader=${skipWavHeader} bitDepth=${bitDepth} len=${bufferCopy.byteLength}`,
-      bufferCopy.slice(0, 100),
-    );
-
-    let actualBitDepth = bitDepth;
-    if (!actualBitDepth) {
-      console.log(
-        `extractAudioAnalysis bitDepth not provided -- getting wav file info`,
-      );
-      const fileInfo = await getWavFileInfo(bufferCopy);
-      actualBitDepth = fileInfo.bitDepth;
-    }
-    console.log(`extractAudioAnalysis actualBitDepth=${actualBitDepth}`);
-    // let copyChannelData: Float32Array;
-    // try {
-    //   const audioContext = new (window.AudioContext ||
-    //     // @ts-ignore
-    //     window.webkitAudioContext)();
-    //   const audioBuffer = await audioContext.decodeAudioData(bufferCopy);
-    //   const channelData = audioBuffer.getChannelData(0); // Use only the first channel
-    //   copyChannelData = new Float32Array(channelData); // Create a new Float32Array
-    // } catch (error) {
-    //   console.warn("Failed to decode audio data:", error);
-    //   // Fall back to creating a new Float32Array from the ArrayBuffer if decoding fails
-    //   copyChannelData = new Float32Array(arrayBuffer);
-    // }
-
-    const {
-      pcmValues: channelData,
-      min,
-      max,
-    } = convertPCMToFloat32({
-      buffer: arrayBuffer,
-      bitDepth: actualBitDepth,
-      skipWavHeader,
-    });
-    console.log(
-      `extractAudioAnalysis skipWaveHeader=${skipWavHeader} convertPCMToFloat32 length=${channelData.length} range: [ ${min} :: ${max} ]`,
-    );
-
-    return new Promise((resolve, reject) => {
-      const worker = new Worker(
-        new URL(featuresExtratorUrl, window.location.href),
-      );
-
-      worker.onmessage = (event) => {
-        resolve(event.data.result);
-      };
-
-      worker.onerror = (error) => {
-        reject(error);
-      };
-
-      worker.postMessage({
-        command: "process",
-        channelData,
-        sampleRate,
-        pointsPerSecond,
-        algorithm,
-        bitDepth,
-        fullAudioDurationMs: durationMs,
-        numberOfChannels,
-      });
-    });
-  } else {
-    if (!fileUri) {
-      throw new Error("fileUri is required");
-    }
-    console.log(`extractAudioAnalysis`, {
-      fileUri,
-      pointsPerSecond,
-      algorithm,
-    });
-    const res = await ExpoAudioStreamModule.extractAudioAnalysis({
-      fileUri,
-      pointsPerSecond,
-      skipWavHeader,
-      algorithm,
-      features,
-    });
-    console.log(`extractAudioAnalysis`, res);
-    return res;
-  }
-};
-
-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,
-  });
-  console.log(`extractWaveform`, res);
-  return res;
-};
+export * from './utils/getWavFileInfo'
+export * from './utils/convertPCMToFloat32'
+export * from './utils/writeWavHeader'
 
 export {
-  AudioRecorderProvider,
-  convertPCMToFloat32,
-  getWavFileInfo,
-  useAudioRecorder,
-  useSharedAudioRecorder,
-  writeWavHeader as writeWaveHeader,
-};
+    AudioRecorderProvider,
+    extractAudioAnalysis,
+    useAudioRecorder,
+    useSharedAudioRecorder,
+}
 
-export * from "./ExpoAudioStream.types";
+export type * from './AudioAnalysis/AudioAnalysis.types'
+export type * from './ExpoAudioStream.types'

package/src/logger.ts

@@ -0,0 +1,23 @@
+// packages/expo-audio-stream/src/logger.ts
+import { getLogger as siteedGetLogger } from '@siteed/react-native-logger'
+
+import { DEBUG_NAMESPACE } from './constants'
+
+type ConsoleLike = {
+    log: (message: string, ...args: unknown[]) => void
+    debug: (message: string, ...args: unknown[]) => void
+    warn: (message: string, ...args: unknown[]) => void
+    error: (message: string, ...args: unknown[]) => void
+}
+
+export const getLogger = (tag: string): ConsoleLike => {
+    const baseLogger = siteedGetLogger(`${DEBUG_NAMESPACE}:${tag}`)
+
+    return {
+        log: (...args: unknown[]) => baseLogger.log(...(args as [unknown])),
+        debug: (...args: unknown[]) => baseLogger.debug(...(args as [unknown])),
+        error: (...args: unknown[]) => baseLogger.error(...(args as [unknown])),
+        warn: (...args: unknown[]) => baseLogger.warn(...(args as [unknown])),
+    }
+}
+

package/src/useAudioRecorder.tsx

@@ -0,0 +1,420 @@
+// src/useAudioRecorder.ts
+import { Platform, Subscription } from 'expo-modules-core'
+import { useCallback, useEffect, useReducer, useRef } from 'react'
+
+import { AudioAnalysis } from './AudioAnalysis/AudioAnalysis.types'
+import {
+    AudioDataEvent,
+    AudioRecording,
+    AudioStreamStatus,
+    RecordingConfig,
+    StartRecordingResult,
+} from './ExpoAudioStream.types'
+import ExpoAudioStreamModule from './ExpoAudioStreamModule'
+import {
+    addAudioAnalysisListener,
+    addAudioEventListener,
+    AudioEventPayload,
+} from './events'
+import { getLogger } from './logger'
+
+const TAG = 'useAudioRecorder'
+const logger = getLogger(TAG)
+export interface UseAudioRecorderProps {
+    debug?: boolean
+    audioWorkletUrl?: string
+    featuresExtratorUrl?: string
+}
+
+export interface UseAudioRecorderState {
+    startRecording: (_: RecordingConfig) => Promise<StartRecordingResult>
+    stopRecording: () => Promise<AudioRecording>
+    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
+}
+
+interface RecorderReducerState {
+    isRecording: boolean
+    isPaused: boolean
+    durationMs: number
+    size: number
+    analysisData?: AudioAnalysis
+}
+
+type RecorderAction =
+    | { type: 'START' | 'STOP' | 'PAUSE' | 'RESUME' }
+    | { type: 'UPDATE_STATUS'; payload: { durationMs: number; size: number } }
+    | { type: 'UPDATE_ANALYSIS'; payload: AudioAnalysis }
+
+const defaultAnalysis: AudioAnalysis = {
+    pointsPerSecond: 10,
+    bitDepth: 32,
+    numberOfChannels: 1,
+    durationMs: 0,
+    sampleRate: 44100,
+    samples: 0,
+    dataPoints: [],
+    amplitudeAlgorithm: 'rms',
+    speakerChanges: [],
+    amplitudeRange: {
+        min: Number.POSITIVE_INFINITY,
+        max: Number.NEGATIVE_INFINITY,
+    },
+}
+
+function audioRecorderReducer(
+    state: RecorderReducerState,
+    action: RecorderAction
+): RecorderReducerState {
+    switch (action.type) {
+        case 'START':
+            return {
+                ...state,
+                isRecording: true,
+                isPaused: false,
+                durationMs: 0,
+                size: 0,
+                analysisData: defaultAnalysis, // Reset analysis data
+            }
+        case 'STOP':
+            return { ...state, isRecording: false, isPaused: false }
+        case 'PAUSE':
+            return { ...state, isPaused: true, isRecording: false }
+        case 'RESUME':
+            return { ...state, isPaused: false, isRecording: true }
+        case 'UPDATE_STATUS':
+            return {
+                ...state,
+                durationMs: action.payload.durationMs,
+                size: action.payload.size,
+            }
+        case 'UPDATE_ANALYSIS':
+            return {
+                ...state,
+                analysisData: action.payload,
+            }
+        default:
+            return state
+    }
+}
+
+interface HandleAudioAnalysisProps {
+    analysis: AudioAnalysis
+    visualizationDuration: number
+}
+
+export function useAudioRecorder({
+    debug = false,
+    audioWorkletUrl,
+    featuresExtratorUrl,
+}: UseAudioRecorderProps = {}): UseAudioRecorderState {
+    const [state, dispatch] = useReducer(audioRecorderReducer, {
+        isRecording: false,
+        isPaused: false,
+        durationMs: 0,
+        size: 0,
+        analysisData: undefined,
+    })
+
+    const analysisListenerRef = useRef<Subscription | null>(null)
+    const analysisRef = useRef<AudioAnalysis>({ ...defaultAnalysis })
+
+    // Instantiate the module for web with URLs
+    const ExpoAudioStream =
+        Platform.OS === 'web'
+            ? ExpoAudioStreamModule({ audioWorkletUrl, featuresExtratorUrl })
+            : ExpoAudioStreamModule
+
+    const onAudioStreamRef = useRef<
+        ((_: AudioDataEvent) => Promise<void>) | null
+    >(null)
+
+    const handleAudioAnalysis = useCallback(
+        async ({
+            analysis,
+            visualizationDuration,
+        }: HandleAudioAnalysisProps) => {
+            const savedAnalysisData = analysisRef.current || {
+                ...defaultAnalysis,
+            }
+
+            const maxDuration = visualizationDuration
+
+            logger.debug(
+                `[handleAudioAnalysis] Received audio analysis: maxDuration=${maxDuration} analysis.dataPoints=${analysis.dataPoints.length} analysisData.dataPoints=${savedAnalysisData.dataPoints.length}`,
+                analysis
+            )
+
+            // Combine data points
+            const combinedDataPoints = [
+                ...savedAnalysisData.dataPoints,
+                ...analysis.dataPoints,
+            ]
+
+            // Calculate the new duration
+            const pointsPerSecond =
+                analysis.pointsPerSecond || savedAnalysisData.pointsPerSecond
+            const maxDataPoints =
+                (pointsPerSecond * visualizationDuration) / 1000
+
+            logger.debug(
+                `[handleAudioAnalysis] Combined data points before trimming: pointsPerSecond=${pointsPerSecond} visualizationDuration=${visualizationDuration} combinedDataPointsLength=${combinedDataPoints.length} vs maxDataPoints=${maxDataPoints}`
+            )
+
+            // Trim data points to keep within the maximum number of data points
+            if (combinedDataPoints.length > maxDataPoints) {
+                combinedDataPoints.splice(
+                    0,
+                    combinedDataPoints.length - maxDataPoints
+                )
+            }
+
+            savedAnalysisData.dataPoints = combinedDataPoints
+            savedAnalysisData.bitDepth =
+                analysis.bitDepth || savedAnalysisData.bitDepth
+            savedAnalysisData.durationMs =
+                combinedDataPoints.length * (1000 / pointsPerSecond)
+
+            // Update amplitude range
+            const newMin = Math.min(
+                savedAnalysisData.amplitudeRange.min,
+                analysis.amplitudeRange.min
+            )
+            const newMax = Math.max(
+                savedAnalysisData.amplitudeRange.max,
+                analysis.amplitudeRange.max
+            )
+
+            savedAnalysisData.amplitudeRange = {
+                min: newMin,
+                max: newMax,
+            }
+
+            logger.debug(
+                `[handleAudioAnalysis] Updated analysis data: durationMs=${savedAnalysisData.durationMs}`,
+                savedAnalysisData
+            )
+
+            // Update the ref
+            analysisRef.current = savedAnalysisData
+
+            // Dispatch the updated analysis data to state to trigger re-render
+            // need to use spread operator otherwise it doesnt trigger update.
+            dispatch({
+                type: 'UPDATE_ANALYSIS',
+                payload: { ...savedAnalysisData },
+            })
+        },
+        [dispatch]
+    )
+
+    const handleAudioEvent = useCallback(
+        async (eventData: AudioEventPayload) => {
+            const {
+                fileUri,
+                deltaSize,
+                totalSize,
+                lastEmittedSize,
+                position,
+                streamUuid,
+                encoded,
+                mimeType,
+                buffer,
+            } = eventData
+            logger.debug(`[handleAudioEvent] Received audio event:`, {
+                fileUri,
+                deltaSize,
+                totalSize,
+                position,
+                mimeType,
+                lastEmittedSize,
+                streamUuid,
+                encodedLength: encoded?.length,
+            })
+            if (deltaSize === 0) {
+                // Ignore packet with no data
+                return
+            }
+            try {
+                // Coming from native ( ios / android ) otherwise buffer is set
+                if (Platform.OS !== 'web') {
+                    // Read the audio file as a base64 string for comparison
+                    if (!encoded) {
+                        console.error(`${TAG} Encoded audio data is missing`)
+                        throw new Error('Encoded audio data is missing')
+                    }
+                    onAudioStreamRef.current?.({
+                        data: encoded,
+                        position,
+                        fileUri,
+                        eventDataSize: deltaSize,
+                        totalSize,
+                    })
+                } else if (buffer) {
+                    // Coming from web
+                    const webEvent: AudioDataEvent = {
+                        data: buffer,
+                        position,
+                        fileUri,
+                        eventDataSize: deltaSize,
+                        totalSize,
+                    }
+                    onAudioStreamRef.current?.(webEvent)
+                    logger.debug(
+                        `[handleAudioEvent] Audio data sent to onAudioStream`,
+                        webEvent
+                    )
+                }
+            } catch (error) {
+                console.error(`${TAG} Error processing audio event:`, error)
+            }
+        },
+        []
+    )
+
+    const checkStatus = useCallback(async () => {
+        try {
+            if (!state.isRecording) {
+                logger.debug(`Not recording, exiting status check.`)
+                return
+            }
+
+            const status: AudioStreamStatus = ExpoAudioStream.status()
+            if (debug) {
+                logger.debug(`Status:`, status)
+            }
+
+            dispatch({
+                type: 'UPDATE_STATUS',
+                payload: { durationMs: status.durationMs, size: status.size },
+            })
+        } catch (error) {
+            console.error(`${TAG} Error getting status:`, error)
+        }
+    }, [state.isRecording])
+
+    const startRecording = useCallback(
+        async (recordingOptions: RecordingConfig) => {
+            logger.debug(`start recoding`, recordingOptions)
+
+            analysisRef.current = { ...defaultAnalysis } // Reset analysis data
+
+            const { onAudioStream, ...options } = recordingOptions
+            const { enableProcessing } = options
+
+            const maxRecentDataDuration = 10000 // TODO compute maxRecentDataDuration based on screen dimensions
+            if (typeof onAudioStream === 'function') {
+                onAudioStreamRef.current = onAudioStream
+            } else {
+                console.warn(
+                    `${TAG} onAudioStream is not a function`,
+                    onAudioStream
+                )
+                onAudioStreamRef.current = null
+            }
+            const startResult: StartRecordingResult =
+                await ExpoAudioStream.startRecording(options)
+            dispatch({ type: 'START' })
+
+            if (enableProcessing) {
+                logger.debug(`Enabling audio analysis listener`)
+                const listener = addAudioAnalysisListener(
+                    async (analysisData) => {
+                        try {
+                            await handleAudioAnalysis({
+                                analysis: analysisData,
+                                visualizationDuration: maxRecentDataDuration,
+                            })
+                        } catch (error) {
+                            console.warn(
+                                `${TAG} Error processing audio analysis:`,
+                                error
+                            )
+                        }
+                    }
+                )
+
+                analysisListenerRef.current = listener
+            }
+
+            return startResult
+        },
+        [handleAudioAnalysis, dispatch]
+    )
+
+    const stopRecording = useCallback(async () => {
+        logger.debug(`stoping recording`)
+
+        const stopResult: AudioRecording = await ExpoAudioStream.stopRecording()
+        stopResult.analysisData = analysisRef.current
+
+        if (analysisListenerRef.current) {
+            analysisListenerRef.current.remove()
+            analysisListenerRef.current = null
+        }
+        onAudioStreamRef.current = null
+        logger.debug(`recording stopped`, stopResult)
+        dispatch({ type: 'STOP' })
+        return stopResult
+    }, [dispatch])
+
+    const pauseRecording = useCallback(async () => {
+        logger.debug(`pause recording`)
+        const pauseResult = await ExpoAudioStream.pauseRecording()
+        dispatch({ type: 'PAUSE' })
+        return pauseResult
+    }, [dispatch])
+
+    const resumeRecording = useCallback(async () => {
+        logger.debug(`resume recording`)
+        const resumeResult = await ExpoAudioStream.resumeRecording()
+        dispatch({ type: 'RESUME' })
+        return resumeResult
+    }, [dispatch])
+
+    useEffect(() => {
+        let interval: ReturnType<typeof setTimeout>
+        if (state.isRecording) {
+            interval = setInterval(checkStatus, 1000)
+        }
+        return () => {
+            if (interval) {
+                clearInterval(interval)
+            }
+        }
+    }, [checkStatus, state.isRecording])
+
+    useEffect(() => {
+        logger.debug(`Registering audio event listener`)
+        const subscribeAudio = addAudioEventListener(handleAudioEvent)
+
+        logger.debug(
+            `Subscribed to audio event listener and analysis listener`,
+            {
+                subscribeAudio,
+            }
+        )
+
+        return () => {
+            logger.debug(`Removing audio event listener`)
+            subscribeAudio.remove()
+        }
+    }, [handleAudioEvent, handleAudioAnalysis])
+
+    return {
+        startRecording,
+        stopRecording,
+        pauseRecording,
+        resumeRecording,
+        isPaused: state.isPaused,
+        isRecording: state.isRecording,
+        durationMs: state.durationMs,
+        size: state.size,
+        analysisData: state.analysisData,
+    }
+}