@siteed/expo-audio-stream 0.1.0 → 0.2.1

package/src/ExpoAudioStreamModule.web.ts

@@ -1,162 +1,178 @@
+import debug from "debug";
 import { EventEmitter } from "expo-modules-core";
-import { AudioEventPayload, RecordingOptions } from "./ExpoAudioStream.types";
 
-class ExpoAudioStreamWeb extends EventEmitter {
-    mediaRecorder: MediaRecorder | null;
-    audioChunks: Blob[];
-    isRecording: boolean;
-    isPaused: boolean;
-    recordingStartTime: number;
-    pausedTime: number;
-    currentDuration: number;
-    currentSize: number;
-    currentInterval: number;
-    lastEmittedSize: number;
-    streamUuid: string | null;
-
-    constructor() {
-        const mockNativeModule = {
-            addListener: (eventName: string) => {
-                console.log(`Web addListener called for ${eventName}`);
-            },
-            removeListeners: (count: number) => {
-                console.log(`Web removeListeners called, count: ${count}`);
-            }
-        };
-        super(mockNativeModule); // Pass the mock native module to the parent class
-
-
-        this.mediaRecorder = null;
-        this.audioChunks = [];
-        this.isRecording = false;
-        this.isPaused = false;
-        this.recordingStartTime = 0;
-        this.pausedTime = 0;
-        this.currentDuration = 0;
-        this.currentSize = 0;
-        this.currentInterval = 1000; // Default interval in ms
-        this.lastEmittedSize = 0;
-        this.streamUuid = null; // Initialize UUID on first recording start
-    }
-
-    // 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(options: RecordingOptions = {}) {
-        if (this.isRecording) {
-            throw new Error('Recording is already in progress');
-        }
-
-        const stream = await this.getMediaStream();
-        this.mediaRecorder = new MediaRecorder(stream);
-        this.setupRecordingListeners();
-        this.mediaRecorder.start(options.interval || this.currentInterval);
-        this.isRecording = true;
-        this.recordingStartTime = Date.now();
-        this.pausedTime = 0;
-        this.lastEmittedSize = 0;
-        this.streamUuid = this.generateUUID(); // Generate a UUID for the new recording session
-    }
-
-    // Setup listeners for the MediaRecorder
-    setupRecordingListeners() {
-        if (!this.mediaRecorder) {
-            throw new Error('No active media recorder');
-        }
-        this.mediaRecorder.ondataavailable = (event) => {
-            this.audioChunks.push(event.data);
-            this.currentSize += event.data.size; // Update the size of the recording
-            this.emitAudioEvent(event.data);  // Emit the event with the correct payload
-            this.lastEmittedSize = this.currentSize;
-        };
-
-        this.mediaRecorder.onstop = () => {
-            this.isRecording = false;
-            console.log('Recording stopped', this.audioChunks);
-        };
-
-        this.mediaRecorder.onpause = () => {
-            this.isPaused = true;
-        };
-
-        this.mediaRecorder.onresume = () => {
-            this.isPaused = false;
-            this.recordingStartTime += (Date.now() - this.pausedTime); // Adjust start time after resuming
-        };
-    }
-
-    emitAudioEvent(data: Blob) {
-        const fileUri = `${this.streamUuid}.pcm`;
-        const audioEventPayload: AudioEventPayload = {
-            fileUri: fileUri,
-            from: this.lastEmittedSize,  // Since this might be continuously streaming, adjust accordingly
-            deltaSize: data.size,
-            totalSize: this.currentSize,
-            buffer: data,
-            streamUuid: this.streamUuid ?? '',  // Generate or manage UUID for stream identification
-        };
-
-        this.emit('AudioData', audioEventPayload);
-    }
+import {
+  AudioEventPayload,
+  AudioStreamResult,
+  RecordingOptions,
+} from "./ExpoAudioStream.types";
 
-     // Helper method to generate a UUID
-     generateUUID() {
-        // Implementation of UUID generation (use a library or custom method)
-        return 'xxxx-xxxx-xxxx-xxxx'.replace(/[x]/g, (c) => {
-            const r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-        });
-    }
-
-    // Stop recording
-    async stopRecording() {
-        console.debug('Stopping recording', this);
-        this.mediaRecorder?.stop();
-        this.isRecording = false;
-        this.currentDuration = (Date.now() - this.recordingStartTime) / 1000;
-        return this.currentDuration;
+const log = debug("expo-audio-stream:useAudioRecording");
+class ExpoAudioStreamWeb extends EventEmitter {
+  mediaRecorder: MediaRecorder | null;
+  audioChunks: Blob[];
+  isRecording: boolean;
+  isPaused: boolean;
+  recordingStartTime: number;
+  pausedTime: number;
+  currentDuration: number;
+  currentSize: number;
+  currentInterval: number;
+  lastEmittedSize: number;
+  streamUuid: string | null;
+
+  constructor() {
+    const mockNativeModule = {
+      addListener: (eventName: string) => {
+        // Not used on web
+      },
+      removeListeners: (count: number) => {
+        // Not used on web
+      },
+    };
+    super(mockNativeModule); // Pass the mock native module to the parent class
+
+    this.mediaRecorder = null;
+    this.audioChunks = [];
+    this.isRecording = false;
+    this.isPaused = false;
+    this.recordingStartTime = 0;
+    this.pausedTime = 0;
+    this.currentDuration = 0;
+    this.currentSize = 0;
+    this.currentInterval = 1000; // Default interval in ms
+    this.lastEmittedSize = 0;
+    this.streamUuid = null; // Initialize UUID on first recording start
+  }
+
+  // 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;
     }
+  }
 
-    // Pause recording
-    async pauseRecording() {
-        if (!this.mediaRecorder) {
-            throw new Error('No active media recorder');
-        }
-
-        if (this.isRecording && !this.isPaused) {
-            this.mediaRecorder.pause();
-            this.pausedTime = Date.now();
-        } else {
-            throw new Error('Recording is not active or already paused');
-        }
+  // Start recording with options
+  async startRecording(options: RecordingOptions = {}) {
+    if (this.isRecording) {
+      throw new Error("Recording is already in progress");
     }
 
-    // Get current status
-    status() {
-        return {
-            isRecording: this.isRecording,
-            isPaused: this.isPaused,
-            duration: Date.now() - this.recordingStartTime,
-            size: this.currentSize,
-            interval: this.currentInterval,
-        };
+    const stream = await this.getMediaStream();
+    this.mediaRecorder = new MediaRecorder(stream);
+    this.setupRecordingListeners();
+    this.mediaRecorder.start(options.interval || this.currentInterval);
+    this.isRecording = true;
+    this.recordingStartTime = Date.now();
+    this.pausedTime = 0;
+    this.lastEmittedSize = 0;
+    this.streamUuid = this.generateUUID(); // Generate a UUID for the new recording session
+    const fileUri = `${this.streamUuid}.webm`;
+    return fileUri;
+  }
+
+  // Setup listeners for the MediaRecorder
+  setupRecordingListeners() {
+    if (!this.mediaRecorder) {
+      throw new Error("No active media recorder");
     }
-
-    listAudioFiles() {
-        // Not applicable on web
+    this.mediaRecorder.ondataavailable = (event) => {
+      this.audioChunks.push(event.data);
+      this.currentSize += event.data.size; // Update the size of the recording
+      this.emitAudioEvent(event.data); // Emit the event with the correct payload
+      this.lastEmittedSize = this.currentSize;
+    };
+
+    this.mediaRecorder.onstop = () => {
+      this.isRecording = false;
+      log("Recording stopped", this.audioChunks);
+    };
+
+    this.mediaRecorder.onpause = () => {
+      this.isPaused = true;
+    };
+
+    this.mediaRecorder.onresume = () => {
+      this.isPaused = false;
+      this.recordingStartTime += Date.now() - this.pausedTime; // Adjust start time after resuming
+    };
+  }
+
+  emitAudioEvent(data: Blob) {
+    const fileUri = `${this.streamUuid}.webm`;
+    const audioEventPayload: AudioEventPayload = {
+      fileUri,
+      mimeType: "audio/webm",
+      from: this.lastEmittedSize, // Since this might be continuously streaming, adjust accordingly
+      deltaSize: data.size,
+      totalSize: this.currentSize,
+      buffer: data,
+      streamUuid: this.streamUuid ?? "", // Generate or manage UUID for stream identification
+    };
+
+    this.emit("AudioData", audioEventPayload);
+  }
+
+  // Helper method to generate a UUID
+  generateUUID() {
+    // Implementation of UUID generation (use a library or custom method)
+    return "xxxx-xxxx-xxxx-xxxx".replace(/[x]/g, (c) => {
+      const r = (Math.random() * 16) | 0,
+        v = c === "x" ? r : (r & 0x3) | 0x8;
+      return v.toString(16);
+    });
+  }
+
+  // Stop recording
+  async stopRecording(): Promise<AudioStreamResult | null> {
+    this.mediaRecorder?.stop();
+    this.isRecording = false;
+    this.currentDuration = (Date.now() - this.recordingStartTime) / 1000;
+    const result: AudioStreamResult = {
+      fileUri: `${this.streamUuid}.webm`,
+      duration: this.currentDuration,
+      size: this.currentSize,
+      mimeType: "audio/webm",
+    };
+
+    return result;
+  }
+
+  // Pause recording
+  async pauseRecording() {
+    if (!this.mediaRecorder) {
+      throw new Error("No active media recorder");
     }
 
-    clearAudioFiles() {
-        // Not applicable on web
+    if (this.isRecording && !this.isPaused) {
+      this.mediaRecorder.pause();
+      this.pausedTime = Date.now();
+    } else {
+      throw new Error("Recording is not active or already paused");
     }
+  }
+
+  // Get current status
+  status() {
+    return {
+      isRecording: this.isRecording,
+      isPaused: this.isPaused,
+      duration: Date.now() - this.recordingStartTime,
+      size: this.currentSize,
+      interval: this.currentInterval,
+    };
+  }
+
+  listAudioFiles() {
+    // Not applicable on web
+  }
+
+  clearAudioFiles() {
+    // Not applicable on web
+  }
 }
 
-export default new ExpoAudioStreamWeb();
+export default new ExpoAudioStreamWeb();

package/src/index.ts

@@ -1,17 +1,18 @@
-import { NativeModulesProxy, EventEmitter, type Subscription } from 'expo-modules-core';
+import {
+  EventEmitter,
+  NativeModulesProxy,
+  type Subscription,
+} from "expo-modules-core";
 
 // Import the native module. On web, it will be resolved to ExpoAudioStream.web.ts
 // and on native platforms to ExpoAudioStream.ts
-import ExpoAudioStreamModule from './ExpoAudioStreamModule';
-import { AudioEventPayload, RecordingOptions } from './ExpoAudioStream.types';
-import { useAudioRecorder } from './useAudioRecording';
+import { AudioEventPayload } from "./ExpoAudioStream.types";
+import ExpoAudioStreamModule from "./ExpoAudioStreamModule";
+import { useAudioRecorder } from "./useAudioRecording";
 
-const emitter = new EventEmitter(ExpoAudioStreamModule ?? NativeModulesProxy.ExpoAudioStream);
-
-// Function to get the recording duration
-export function getRecordingDuration(): Promise<number> {
-  return ExpoAudioStreamModule.getRecordingDuration();
-}
+const emitter = new EventEmitter(
+  ExpoAudioStreamModule ?? NativeModulesProxy.ExpoAudioStream,
+);
 
 export function listAudioFiles(): Promise<string[]> {
   return ExpoAudioStreamModule.listAudioFiles();
@@ -21,9 +22,10 @@ export function clearAudioFiles(): Promise<void> {
   return ExpoAudioStreamModule.clearAudioFiles();
 }
 
-export function addChangeListener(listener: (event: AudioEventPayload) => void): Subscription {
-  return emitter.addListener<AudioEventPayload>('AudioData', listener);
+export function addAudioEventListener(
+  listener: (event: AudioEventPayload) => void,
+): Subscription {
+  return emitter.addListener<AudioEventPayload>("AudioData", listener);
 }
 
-
 export { AudioEventPayload, useAudioRecorder };

package/src/useAudioRecording.ts

@@ -1,141 +1,160 @@
-import { NativeModulesProxy, EventEmitter, type Subscription, Platform } from 'expo-modules-core';
-
+import { decode as atob } from "base-64";
+import debug from "debug";
+import { Platform } from "expo-modules-core";
 import { useCallback, useEffect, useState } from "react";
-import ExpoAudioStreamModule from './ExpoAudioStreamModule';
-import { AudioEventPayload, AudioStreamStatus, RecordingOptions } from "./ExpoAudioStream.types";
-import { addChangeListener } from '.';
-import * as FileSystem from 'expo-file-system';
-import { decode as atob } from 'base-64';
 
-const emitter = new EventEmitter(ExpoAudioStreamModule ?? NativeModulesProxy.ExpoAudioStream);
+import { addAudioEventListener } from ".";
+import {
+  AudioStreamResult,
+  AudioStreamStatus,
+  RecordingOptions,
+} from "./ExpoAudioStream.types";
+import ExpoAudioStreamModule from "./ExpoAudioStreamModule";
+
+const log = debug("expo-audio-stream:useAudioRecording");
 
 interface UseAudioRecorderState {
-    startRecording: (_: RecordingOptions) => Promise<void>;
-    stopRecording: () => Promise<number>;
-    pauseRecording: () => void;
-    isRecording: boolean;
-    isPaused: boolean;
-    duration: number;  // Duration of the recording
-    size: number;      // Size in bytes of the recorded audio
+  startRecording: (_: RecordingOptions) => Promise<string | null>;
+  stopRecording: () => Promise<AudioStreamResult | null>;
+  pauseRecording: () => void;
+  isRecording: boolean;
+  isPaused: boolean;
+  duration: number; // Duration of the recording
+  size: number; // Size in bytes of the recorded audio
 }
 
-export function useAudioRecorder({onAudioStream}: {onAudioStream?: (buffer: Blob) => void}): UseAudioRecorderState {
-    const [isRecording, setIsRecording] = useState(false);
-    const [isPaused, setIsPaused] = useState(false);
-    const [duration, setDuration] = useState(0);
-    const [size, setSize] = useState(0);
-
-    useEffect( () => {
-        if(isRecording || isPaused) {
-            const interval = setInterval(() => {
-                const status: AudioStreamStatus = ExpoAudioStreamModule.status()
-                setDuration(status.duration);
-                setSize(status.size);
-            }, 1000);
-            return () => clearInterval(interval);
-        }
-
-        return () => null;
-    }, [isRecording, isPaused])
-
+export function useAudioRecorder({
+  onAudioStream,
+}: {
+  onAudioStream?: (buffer: Blob) => void;
+}): UseAudioRecorderState {
+  const [isRecording, setIsRecording] = useState(false);
+  const [isPaused, setIsPaused] = useState(false);
+  const [duration, setDuration] = useState(0);
+  const [size, setSize] = useState(0);
 
   useEffect(() => {
-    const subscribe = addChangeListener(async ({fileUri, deltaSize, totalSize, from, streamUuid, encoded, buffer}) => {
-        console.debug(`Received audio event:`, {fileUri, deltaSize, totalSize, from, streamUuid, encodedLength: encoded?.length})
-        if(deltaSize > 0) {
-            // Fetch the audio data from the fileUri
-            const options = {
-                encoding: FileSystem.EncodingType.Base64,
-                position: from,
-                length: deltaSize,
-              };
-
-              if(Platform.OS !== 'web') {
-                // Read the audio file as a base64 string for comparison
-                try {
-                    const base64Content = await FileSystem.readAsStringAsync(fileUri, options);
-                    const binaryData = atob(base64Content);
-                    const content = new Uint8Array(binaryData.length);
-                    for (let i = 0; i < binaryData.length; i++) {
-                    content[i] = binaryData.charCodeAt(i);
-                    }
-
-                    // TODO: get the filetype based on audio setting and encoding
-                    const audioBlob = new Blob([content], { type: 'application/octet-stream' }); // Create a Blob from the byte array
-                    console.debug(`Read audio file (len: ${content.length}) vs ${deltaSize}`)
-                    onAudioStream?.(audioBlob);
-                } catch (error) {
-                    console.error('Error reading audio file:', error);
-                }
-            } else if(buffer) {
-                onAudioStream?.(buffer);
-            }
-        }
-    });
-    return () => subscribe.remove();
-  }, [isRecording, onAudioStream]);
-
-
-    const startRecording = useCallback(async (recordingOptions: RecordingOptions) => {
-        if (!isRecording) {
-            setIsRecording(true);
-            setIsPaused(false);
-            setSize(0);
-            setDuration(0);
-            const startTime = Date.now();
+    if (isRecording || isPaused) {
+      const interval = setInterval(() => {
+        const status: AudioStreamStatus = ExpoAudioStreamModule.status();
+        setDuration(status.duration);
+        setSize(status.size);
+      }, 1000);
+      return () => clearInterval(interval);
+    }
+
+    return () => null;
+  }, [isRecording, isPaused]);
 
-            console.log(`module shims`, ExpoAudioStreamModule)
-            try {
-                console.log(`start recoding`, recordingOptions)
-                await ExpoAudioStreamModule.startRecording(recordingOptions);
-
-            } catch (error) {
-                console.error('Error starting recording:', error);
-                setIsRecording(false);
-            }
-        }
-    }, [isRecording]);
-
-    const stopRecording = useCallback(async (): Promise<number> => {
-        if (isRecording) {
-            setIsRecording(false);
-            setIsPaused(false);
+  useEffect(() => {
+    const subscribe = addAudioEventListener(
+      async ({
+        fileUri,
+        deltaSize,
+        totalSize,
+        from,
+        streamUuid,
+        encoded,
+        mimeType,
+        buffer,
+      }) => {
+        log(`Received audio event:`, {
+          fileUri,
+          deltaSize,
+          totalSize,
+          mimeType,
+          from,
+          streamUuid,
+          encodedLength: encoded?.length,
+        });
+        if (deltaSize > 0) {
+          // Coming from native ( ios / android ) otherwise buffer is set
+          if (Platform.OS !== "web") {
+            // Read the audio file as a base64 string for comparison
             try {
-                const recordedDuration = await ExpoAudioStreamModule.stopRecording();
-                setDuration(recordedDuration);
-                return recordedDuration;
+              // convert encoded string to binary data
+              const binaryData = atob(encoded);
+              const content = new Uint8Array(binaryData.length);
+              for (let i = 0; i < binaryData.length; i++) {
+                content[i] = binaryData.charCodeAt(i);
+              }
+              const audioBlob = new Blob([content], { type: mimeType });
+
+              // Below code is optional, used to compare encoded data to audio on file system
+              // Fetch the audio data from the fileUri
+              // const options = {
+              //     encoding: FileSystem.EncodingType.Base64,
+              //     position: from,
+              //     length: deltaSize,
+              // };
+              // const base64Content = await FileSystem.readAsStringAsync(fileUri, options);
+              // const binaryData = atob(base64Content);
+              // const content = new Uint8Array(binaryData.length);
+              // for (let i = 0; i < binaryData.length; i++) {
+              // content[i] = binaryData.charCodeAt(i);
+              // }
+              // const audioBlob = new Blob([content], { type: 'application/octet-stream' }); // Create a Blob from the byte array
+              // console.debug(`Read audio file (len: ${content.length}) vs ${deltaSize}`)
+
+              onAudioStream?.(audioBlob);
             } catch (error) {
-                console.error('Error stopping recording:', error);
-                return 0;
+              console.error("Error reading audio file:", error);
             }
+          } else if (buffer) {
+            // Coming from web
+            onAudioStream?.(buffer);
+          }
         }
-        return 0;
-    }, [isRecording]);
-
-    const pauseRecording = useCallback(() => {
-        if (isRecording) {
-            ExpoAudioStreamModule.stopRecording().catch(console.error);
-            setIsPaused(true);
-            setIsRecording(false);
-        }
-    }, [isRecording]);
-
-    // Cleanup listener on unmount to prevent memory leaks
-    useEffect(() => {
-        return () => {
-            if (isRecording) {
-                ExpoAudioStreamModule.stopRecording().catch(console.error);
-            }
-        };
-    }, [isRecording]);
+      },
+    );
+    return () => subscribe.remove();
+  }, [isRecording, onAudioStream]);
 
-    return {
-        startRecording,
-        stopRecording,
-        pauseRecording,
-        isPaused,
-        isRecording,
-        duration,
-        size
-    };
-}
+  const startRecording = useCallback(
+    async (recordingOptions: RecordingOptions) => {
+      setIsRecording(true);
+      setIsPaused(false);
+      setSize(0);
+      setDuration(0);
+      try {
+        log(`start recoding`, recordingOptions);
+        const fileUrl =
+          await ExpoAudioStreamModule.startRecording(recordingOptions);
+
+        return fileUrl;
+      } catch (error) {
+        console.error("Error starting recording:", error);
+        setIsRecording(false);
+      }
+    },
+    [],
+  );
+
+  const stopRecording = useCallback(async () => {
+    setIsRecording(false);
+    setIsPaused(false);
+    const result: AudioStreamResult =
+      await ExpoAudioStreamModule.stopRecording();
+    return result;
+  }, []);
+
+  const pauseRecording = useCallback(async () => {
+    try {
+      await ExpoAudioStreamModule.stopRecording();
+      setIsPaused(true);
+      setIsRecording(false);
+    } catch (error) {
+      console.error("Error pausing recording:", error);
+    }
+  }, []);
+
+  return {
+    startRecording,
+    stopRecording,
+    pauseRecording,
+    isPaused,
+    isRecording,
+    duration,
+    size,
+  };
+}