@siteed/expo-audio-stream 0.1.0

package/ios/ExpoAudioStreamModule.swift

@@ -0,0 +1,133 @@
+import ExpoModulesCore
+
+let audioDataEvent: String = "AudioData"
+
+public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
+    private var streamManager = AudioStreamManager()
+
+    public func definition() -> ModuleDefinition {
+        Name("ExpoAudioStream")
+        
+        // Defines event names that the module can send to JavaScript.
+        Events(audioDataEvent)
+        
+        OnCreate {
+            print("Setting streamManager delegate")
+            streamManager.delegate = self
+        }
+           
+        AsyncFunction("startRecording") { (options: [String: Any], promise: Promise) in
+            self.checkMicrophonePermission { granted in
+                guard granted else {
+                    promise.reject("PERMISSION_DENIED", "Recording permission has not been granted")
+                    return
+                }
+                
+                // Extract settings from provided options, using default values if necessary
+                let sampleRate = options["sampleRate"] as? Double ?? 48000.0
+                let numberOfChannels = options["channelConfig"] as? Int ?? 1
+                let bitDepth = options["audioFormat"] as? Int ?? 16
+                let interval = options["interval"] as? Int ?? 1000
+                
+                let settings = RecordingSettings(sampleRate: sampleRate, numberOfChannels: numberOfChannels, bitDepth: bitDepth)
+                self.streamManager.startRecording(settings: settings, intervalMilliseconds: interval)
+                
+                promise.resolve(nil)
+            }
+        }
+        
+        Function("status") {
+            return self.streamManager.getStatus()
+        }
+        
+        AsyncFunction("stopRecording") { (promise: Promise) in
+            self.streamManager.stopRecording()
+            promise.resolve(nil)
+        }
+        
+        AsyncFunction("listAudioFiles") { (promise: Promise) in
+            let files = listAudioFiles()
+            promise.resolve(files)
+        }
+        
+        Function("clearAudioFiles") {
+            clearAudioFiles()
+        }
+    }
+    
+    func audioStreamManager(_ manager: AudioStreamManager, didReceiveAudioData data: Data, recordingTime: TimeInterval, totalDataSize: Int64) {
+        print("audioStreamManager debug sending data")
+        guard let fileURL = manager.recordingFileURL else { return }
+        let encodedData = data.base64EncodedString()
+        
+        // Assuming `lastEmittedSize` and `streamUuid` are tracked within `AudioStreamManager`
+        let deltaSize = data.count  // This needs to be calculated based on what was last sent if using chunks
+        let fileSize = totalDataSize  // Total data size in bytes
+        
+        // Construct the event payload similar to Android
+        let eventBody: [String: Any] = [
+            "fileUri": fileURL.absoluteString,
+            "from": manager.lastEmittedSize,  // Needs to be maintained within AudioStreamManager
+            "encoded": encodedData,
+            "deltaSize": deltaSize,
+            "totalSize": fileSize,
+            "streamUuid": manager.recordingUUID?.uuidString ?? UUID().uuidString
+        ]
+        
+        // Update the last emitted size for the next calculation
+        manager.lastEmittedSize += Int64(deltaSize)
+        
+        print("Sending audio data", eventBody)
+        // Emit the event to JavaScript
+        sendEvent(audioDataEvent, eventBody)
+    }
+    
+    private func checkMicrophonePermission(completion: @escaping (Bool) -> Void) {
+        switch AVAudioSession.sharedInstance().recordPermission {
+        case .granted:
+            completion(true)
+        case .denied:
+            completion(false)
+        case .undetermined:
+            AVAudioSession.sharedInstance().requestRecordPermission { granted in
+                DispatchQueue.main.async {
+                    completion(granted)
+                }
+            }
+        @unknown default:
+            completion(false)
+        }
+    }
+    
+    private func clearAudioFiles() {
+        let filenames = listAudioFiles()
+        let documentDirectory = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+        
+        filenames.forEach { filename in
+            let fileURL = documentDirectory.appendingPathComponent(filename)
+            do {
+                try FileManager.default.removeItem(at: fileURL)
+                print("Removed file at:", fileURL.path)
+            } catch {
+                print("Error removing file at \(fileURL.path):", error.localizedDescription)
+            }
+        }
+    }
+    
+    func listAudioFiles() -> [String] {
+        guard let documentDirectory = try? FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false) else {
+            print("Failed to access document directory.")
+            return []
+        }
+        
+        do {
+            let files = try FileManager.default.contentsOfDirectory(at: documentDirectory, includingPropertiesForKeys: nil)
+            let audioFiles = files.filter { $0.pathExtension == "pcm" }.map { $0.lastPathComponent }
+            return audioFiles
+        } catch {
+            print("Error listing audio files:", error.localizedDescription)
+            return []
+        }
+    }
+    
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@siteed/expo-audio-stream",
+  "version": "0.1.0",
+  "description": "stream audio crossplatform",
+  "license": "MIT",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "author": "Arthur Breton <abreton@siteed.net> (https://github.com/deeeed)",
+  "homepage": "https://github.com/deeeed/expo-audio-stream#readme",
+  "repository": "https://github.com/deeeed/expo-audio-stream",
+  "bugs": {
+    "url": "https://github.com/deeeed/expo-audio-stream/issues"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-audio-stream",
+    "ExpoAudioStream"
+  ],
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "release": "release-it",
+    "expo-module": "expo-module",
+    "open:ios": "open -a \"Xcode\" example/ios",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "dependencies": {
+    "base-64": "^1.0.0",
+    "expo-file-system": "^16.0.9"
+  },
+  "devDependencies": {
+    "@expo/config-plugins": "^7.9.1",
+    "@release-it/conventional-changelog": "^8.0.1",
+    "@types/react": "^18.0.25",
+    "@typescript-eslint/eslint-plugin": "^7.7.0",
+    "@typescript-eslint/parser": "^7.7.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-universe": "^12.0.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-react": "^7.34.1",
+    "expo-module-scripts": "^3.4.2",
+    "expo-modules-core": "^1.11.12",
+    "prettier": "^3.2.5",
+    "release-it": "^17.2.0"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/plugin/build/index.d.ts

@@ -0,0 +1,5 @@
+import { ConfigPlugin } from "@expo/config-plugins";
+declare const _default: ConfigPlugin<{
+    microphonePermission: string | false;
+}>;
+export default _default;

package/plugin/build/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const pkg = require('../../package.json');
+const MICROPHONE_USAGE = 'Allow $(PRODUCT_NAME) to access your microphone';
+const withRecordingPermission = (config, { microphonePermission }) => {
+    config_plugins_1.IOSConfig.Permissions.createPermissionsPlugin({
+        NSMicrophoneUsageDescription: MICROPHONE_USAGE,
+    })(config, {
+        NSMicrophoneUsageDescription: microphonePermission,
+    });
+    return config_plugins_1.AndroidConfig.Permissions.withPermissions(config, [
+        microphonePermission !== false && 'android.permission.RECORD_AUDIO',
+        'android.permission.MODIFY_AUDIO_SETTINGS',
+    ].filter(Boolean));
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withRecordingPermission, pkg.name, pkg.version);

package/plugin/src/index.ts

@@ -0,0 +1,27 @@
+import {
+  AndroidConfig,
+  ConfigPlugin,
+  IOSConfig,
+  createRunOncePlugin
+} from "@expo/config-plugins";
+
+const pkg = require('../../package.json');
+const MICROPHONE_USAGE = 'Allow $(PRODUCT_NAME) to access your microphone';
+
+const withRecordingPermission: ConfigPlugin<{ microphonePermission: string | false }> = (config, { microphonePermission }) => {
+  IOSConfig.Permissions.createPermissionsPlugin({
+    NSMicrophoneUsageDescription: MICROPHONE_USAGE,
+  })(config, {
+    NSMicrophoneUsageDescription: microphonePermission,
+  });
+
+  return AndroidConfig.Permissions.withPermissions(
+    config,
+    [
+      microphonePermission !== false && 'android.permission.RECORD_AUDIO',
+      'android.permission.MODIFY_AUDIO_SETTINGS',
+    ].filter(Boolean) as string[]
+  );
+};
+
+export default createRunOncePlugin(withRecordingPermission, pkg.name, pkg.version);

package/plugin/tsconfig.json

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

package/release-it.js

@@ -0,0 +1,18 @@
+module.exports = {
+  git: {
+    "commitMessage": "chore: release ${version}",
+    "tagName": "v${version}",
+    "requireCleanWorkingDir": false
+  },
+  npm: {
+    "publish": true
+  },
+  github: {
+    "release": true
+  },
+  plugins: {
+    "@release-it/conventional-changelog": {
+      "preset": "angular",
+    }
+  }
+}

package/src/ExpoAudioStream.types.ts

@@ -0,0 +1,25 @@
+export interface AudioEventPayload {
+  encoded?: string, 
+  buffer?: Blob,
+  fileUri: string,
+  from: number,
+  deltaSize: number,
+  totalSize: number,
+  streamUuid: string,
+};
+
+export interface AudioStreamStatus {
+  isRecording: boolean;
+  isPaused: boolean;
+  duration: number;
+  size: number;
+  interval: number;
+}
+
+export interface RecordingOptions {
+  // TODO align Android and IOS options
+  sampleRate?: number;
+  channelConfig?: number; // numberOfChannel
+  audioFormat?: number; // bitDepth (ENCODING_PCM_16BIT --> 2)
+  interval?: number;
+}

package/src/ExpoAudioStreamModule.ts

@@ -0,0 +1,5 @@
+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/ExpoAudioStreamModule.web.ts

@@ -0,0 +1,162 @@
+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);
+    }
+
+     // 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;
+    }
+
+    // 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');
+        }
+    }
+
+    // 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();

package/src/index.ts

@@ -0,0 +1,29 @@
+import { NativeModulesProxy, EventEmitter, 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';
+
+const emitter = new EventEmitter(ExpoAudioStreamModule ?? NativeModulesProxy.ExpoAudioStream);
+
+// Function to get the recording duration
+export function getRecordingDuration(): Promise<number> {
+  return ExpoAudioStreamModule.getRecordingDuration();
+}
+
+export function listAudioFiles(): Promise<string[]> {
+  return ExpoAudioStreamModule.listAudioFiles();
+}
+
+export function clearAudioFiles(): Promise<void> {
+  return ExpoAudioStreamModule.clearAudioFiles();
+}
+
+export function addChangeListener(listener: (event: AudioEventPayload) => void): Subscription {
+  return emitter.addListener<AudioEventPayload>('AudioData', listener);
+}
+
+
+export { AudioEventPayload, useAudioRecorder };

package/src/useAudioRecording.ts

@@ -0,0 +1,141 @@
+import { NativeModulesProxy, EventEmitter, type Subscription, 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);
+
+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
+}
+
+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])
+
+
+  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();
+
+            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);
+            try {
+                const recordedDuration = await ExpoAudioStreamModule.stopRecording();
+                setDuration(recordedDuration);
+                return recordedDuration;
+            } catch (error) {
+                console.error('Error stopping recording:', error);
+                return 0;
+            }
+        }
+        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 {
+        startRecording,
+        stopRecording,
+        pauseRecording,
+        isPaused,
+        isRecording,
+        duration,
+        size
+    };
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+// @generated by expo-module-scripts
+{
+  "extends": "expo-module-scripts/tsconfig.base",
+  "compilerOptions": {
+    "outDir": "./build"
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*"]
+}