@siteed/expo-audio-stream 0.1.0 → 0.2.1

package/ios/AudioStreamManager.swift

@@ -9,15 +9,44 @@ import Foundation
 import AVFoundation
 
 struct RecordingSettings {
-    var sampleRate: Double = 48000.0
+    var sampleRate: Double
     var numberOfChannels: Int = 1
     var bitDepth: Int = 16
 }
 
+// Helper to convert to little-endian byte array
+extension UInt32 {
+    var littleEndianBytes: [UInt8] {
+        let value = self.littleEndian
+        return [UInt8(value & 0xff), UInt8((value >> 8) & 0xff), UInt8((value >> 16) & 0xff), UInt8((value >> 24) & 0xff)]
+    }
+}
+
+extension UInt16 {
+    var littleEndianBytes: [UInt8] {
+        let value = self.littleEndian
+        return [UInt8(value & 0xff), UInt8((value >> 8) & 0xff)]
+    }
+}
+
+
+struct RecordingResult {
+    var fileUri: String
+    var mimeType: String
+    var duration: Int64
+    var size: Int64
+}
+
 protocol AudioStreamManagerDelegate: AnyObject {
     func audioStreamManager(_ manager: AudioStreamManager, didReceiveAudioData data: Data, recordingTime: TimeInterval, totalDataSize: Int64)
 }
 
+enum AudioStreamError: Error {
+    case audioSessionSetupFailed(String)
+    case fileCreationFailed(URL)
+    case audioProcessingError(String)
+}
+
 class AudioStreamManager: NSObject {
     private let audioEngine = AVAudioEngine()
     private var inputNode: AVAudioInputNode {
@@ -33,7 +62,9 @@ class AudioStreamManager: NSObject {
     private var isPaused = false
     private var pausedDuration = 0
     private var fileManager = FileManager.default
+    private var recordingSettings: RecordingSettings?
     internal var recordingUUID: UUID?
+    internal var mimeType: String = "audio/wav"
     weak var delegate: AudioStreamManagerDelegate?  // Define the delegate here
     
     override init() {
@@ -52,85 +83,205 @@ class AudioStreamManager: NSObject {
         }
     }
     
+    @objc func handleAudioSessionInterruption(notification: Notification) {
+        guard let info = notification.userInfo,
+              let typeValue = info[AVAudioSessionInterruptionTypeKey] as? UInt,
+              let type = AVAudioSession.InterruptionType(rawValue: typeValue) else {
+            return
+        }
+        
+        if type == .began {
+            // Pause your audio recording
+        } else if type == .ended {
+            if let optionsValue = info[AVAudioSessionInterruptionOptionKey] as? UInt {
+                let options = AVAudioSession.InterruptionOptions(rawValue: optionsValue)
+                if options.contains(.shouldResume) {
+                    // Resume your audio recording
+                    try? AVAudioSession.sharedInstance().setActive(true)
+                }
+            }
+        }
+    }
+    
     private func createRecordingFile() -> URL? {
         let documentsDirectory = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first!
         recordingUUID = UUID()
-        let fileName = "\(recordingUUID!.uuidString).pcm"
+        let fileName = "\(recordingUUID!.uuidString).wav"
         let fileURL = documentsDirectory.appendingPathComponent(fileName)
-        fileManager.createFile(atPath: fileURL.path, contents: nil, attributes: nil)
-        print("Recording file created at:", fileURL.path)
-
+        
+        if fileManager.createFile(atPath: fileURL.path, contents: nil, attributes: nil) {
+            do {
+                let fileHandle = try FileHandle(forWritingTo: fileURL)
+                let wavHeader = createWavHeader(dataSize: 0)  // Initially set data size to 0
+                fileHandle.write(wavHeader)
+                fileHandle.closeFile()
+                print("Recording file with header created at:", fileURL.path)
+            } catch {
+                print("Failed to write WAV header: \(error.localizedDescription)")
+                return nil
+            }
+        }
         return fileURL
     }
     
+    private func createWavHeader(dataSize: Int) -> Data {
+        var header = Data()
+        
+        let sampleRate = UInt32(recordingSettings!.sampleRate)
+        let channels = UInt32(recordingSettings!.numberOfChannels)
+        let bitDepth = UInt32(recordingSettings!.bitDepth)
+        
+        // Calculate byteRate
+        let byteRate = sampleRate * channels * (bitDepth / 8)
+        
+        // "RIFF" chunk descriptor
+        header.append(contentsOf: "RIFF".utf8)
+        header.append(contentsOf: UInt32(36 + dataSize).littleEndianBytes)
+        header.append(contentsOf: "WAVE".utf8)
+        
+        // "fmt " sub-chunk
+        header.append(contentsOf: "fmt ".utf8)
+        header.append(contentsOf: UInt32(16).littleEndianBytes)  // PCM format requires 16 bytes for the fmt sub-chunk
+        header.append(contentsOf: UInt16(1).littleEndianBytes)   // Audio format 1 for PCM
+        header.append(contentsOf: UInt16(channels).littleEndianBytes)
+        header.append(contentsOf: sampleRate.littleEndianBytes)
+        header.append(contentsOf: byteRate.littleEndianBytes)    // byteRate
+        header.append(contentsOf: UInt16(channels * (bitDepth / 8)).littleEndianBytes)  // blockAlign
+        header.append(contentsOf: UInt16(bitDepth).littleEndianBytes)  // bits per sample
+        
+        // "data" sub-chunk
+        header.append(contentsOf: "data".utf8)
+        header.append(contentsOf: UInt32(dataSize).littleEndianBytes)  // Sub-chunk data size
+        
+        return header
+    }
+    
+    
     func getStatus() -> [String: Any] {
         let currentTime = Date()
         let totalRecordedTime = startTime != nil ? Int(currentTime.timeIntervalSince(startTime!)) - pausedDuration : 0
         return [
-            "duration": totalRecordedTime,
+            "duration": totalRecordedTime * 1000,
             "isRecording": isRecording,
             "isPaused": isPaused,
+            "mimeType": mimeType,
             "size": totalDataSize,
             "interval": emissionInterval
         ]
     }
     
-    func startRecording(settings: RecordingSettings, intervalMilliseconds: Int) {
-        guard !isRecording else { return }
-        
-        emissionInterval = max(100.0, Double(intervalMilliseconds)) / 1000.0 // Convert ms to seconds, ensure minimum of 100 ms
-        lastEmissionTime = Date() // Reset last emission time
+    func startRecording(settings: RecordingSettings, intervalMilliseconds: Int) -> String? {
+        guard !isRecording else {
+            print("Debug: Recording is already in progress.")
+            return nil
+        }
+
+        emissionInterval = max(100.0, Double(intervalMilliseconds)) / 1000.0
+        lastEmissionTime = Date()
+        recordingSettings = settings
         
-        // Configure audio session for the desired sample rate and channel count
         let session = AVAudioSession.sharedInstance()
         do {
+            print("Debug: Configuring audio session with sample rate: \(settings.sampleRate) Hz")
             try session.setPreferredSampleRate(settings.sampleRate)
             try session.setPreferredIOBufferDuration(1024 / settings.sampleRate)
             try session.setCategory(.playAndRecord)
             try session.setActive(true)
+            print("Debug: Audio session activated successfully.")
         } catch {
-            print("Failed to set up audio session: \(error)")
-            return
+            print("Error: Failed to set up audio session with preferred settings: \(error.localizedDescription)")
+            return nil
+        }
+
+        NotificationCenter.default.addObserver(self, selector: #selector(handleAudioSessionInterruption), name: AVAudioSession.interruptionNotification, object: nil)
+
+        guard let channelLayout = AVAudioChannelLayout(layoutTag: settings.numberOfChannels == 1 ? kAudioChannelLayoutTag_Mono : kAudioChannelLayoutTag_Stereo) else {
+            print("Error: Failed to create channel layout.")
+            return nil
         }
-        
-        // Create an audio format with specified or default settings
-        let channelLayout = AVAudioChannelLayout(layoutTag: settings.numberOfChannels == 1 ? kAudioChannelLayoutTag_Mono : kAudioChannelLayoutTag_Stereo) ?? AVAudioChannelLayout(layoutTag: kAudioChannelLayoutTag_Stereo)!
         let errorFormat = AVAudioFormat(standardFormatWithSampleRate: settings.sampleRate, channelLayout: channelLayout)
-        
-        // Create an audio format with default settings
-        let format = audioEngine.inputNode.inputFormat(forBus: 0)
-        
-        // Debugging statements
-        print("Desired Sample Rate:", settings.sampleRate)
-        print("Channel Layout:", channelLayout.description)
-        print("Created Audio Format Sample Rate: \(format.sampleRate) channelLayout: \(format.channelLayout) channelCount: \(format.channelCount)")
-        print("Error Audio Format Sample Rate: \(errorFormat.sampleRate) channel Layout: \(errorFormat.channelLayout) channelCount: \(errorFormat.channelCount)")
-        print("Hardware Format Sample Rate:", audioEngine.inputNode.inputFormat(forBus: 0).sampleRate)
-        
-        // Install tap on the input node and handle audio buffer
+
         audioEngine.inputNode.installTap(onBus: 0, bufferSize: 1024, format: errorFormat) { [weak self] (buffer, time) in
-            guard let self = self, let fileURL = self.recordingFileURL else { return }
+            guard let self = self, let fileURL = self.recordingFileURL else {
+                print("Error: File URL or self is nil during buffer processing.")
+                return
+            }
             self.processAudioBuffer(buffer, fileURL: fileURL)
         }
 
         recordingFileURL = createRecordingFile()
+        if recordingFileURL == nil {
+            print("Error: Failed to create recording file.")
+            return nil
+        }
+
         do {
             startTime = Date()
             try audioEngine.start()
             isRecording = true
+            print("Debug: Recording started successfully.")
+            return recordingFileURL?.absoluteString
         } catch {
-            print("Could not start the audio engine: \(error)")
+            print("Error: Could not start the audio engine: \(error.localizedDescription)")
             isRecording = false
+            return nil
         }
     }
+
     
-    func stopRecording() {
+    func stopRecording() -> RecordingResult? {
         audioEngine.stop()
         audioEngine.inputNode.removeTap(onBus: 0)
         isRecording = false
-        recordingFileURL = nil  // Optionally reset or handle the finalization of the file
-        print("Recording stopped.")
-
+        
+        guard let fileURL = recordingFileURL, let startTime = startTime else {
+            print("Recording or file URL is nil.")
+            return nil
+        }
+        
+        let endTime = Date()
+        let duration = Int64(endTime.timeIntervalSince(startTime) * 1000) - Int64(pausedDuration * 1000)
+        
+        // Calculate the total size of audio data written to the file
+        let filePath = fileURL.path
+        do {
+            let fileAttributes = try FileManager.default.attributesOfItem(atPath: filePath)
+            let fileSize = fileAttributes[FileAttributeKey.size] as? Int64 ?? 0
+            
+            // Update the WAV header with the correct file size
+            updateWavHeader(fileURL: fileURL, totalDataSize: fileSize - 44) // Subtract the header size to get audio data size
+            
+            let result = RecordingResult(fileUri: fileURL.absoluteString, mimeType: mimeType, duration: duration, size: fileSize)
+            recordingFileURL = nil // Reset for next recording
+            return result
+        } catch {
+            print("Failed to fetch file attributes: \(error)")
+            return nil
+        }
+    }
+    
+    private func updateWavHeader(fileURL: URL, totalDataSize: Int64) {
+        do {
+            let fileHandle = try FileHandle(forUpdating: fileURL)
+            defer { fileHandle.closeFile() }
+            
+            // Calculate sizes
+            let fileSize = totalDataSize + 44 - 8 // Total file size minus 8 bytes for 'RIFF' and size field itself
+            let dataSize = totalDataSize // Size of the 'data' sub-chunk
+            
+            // Update RIFF chunk size at offset 4
+            fileHandle.seek(toFileOffset: 4)
+            let fileSizeBytes = UInt32(fileSize).littleEndianBytes
+            fileHandle.write(Data(fileSizeBytes))
+            
+            // Update data chunk size at offset 40
+            fileHandle.seek(toFileOffset: 40)
+            let dataSizeBytes = UInt32(dataSize).littleEndianBytes
+            fileHandle.write(Data(dataSizeBytes))
+            
+        } catch let error {
+            print("Error updating WAV header: \(error)")
+        }
     }
     
     private func processAudioBuffer(_ buffer: AVAudioPCMBuffer, fileURL: URL) {
@@ -146,18 +297,19 @@ class AudioStreamManager: NSObject {
         }
         let data = Data(bytes: bufferData, count: Int(audioData.mDataByteSize))
         
+        print("Writing data size: \(data.count) bytes")  // Debug: Check the size of data being written
         fileHandle.seekToEndOfFile()
         fileHandle.write(data)
         fileHandle.closeFile()
         
         totalDataSize += Int64(data.count)
-        
+        print("Total data size written: \(totalDataSize) bytes")  // Debug: Check total data written
+
         let currentTime = Date()
         if let lastEmissionTime = lastEmissionTime, currentTime.timeIntervalSince(lastEmissionTime) >= emissionInterval {
             if let startTime = startTime {
                 let recordingTime = currentTime.timeIntervalSince(startTime)
                 print("Emitting data: Recording time \(recordingTime) seconds, Data size \(totalDataSize) bytes")
-                print("delegate", self.delegate)
                 self.delegate?.audioStreamManager(self, didReceiveAudioData: data, recordingTime: recordingTime, totalDataSize: totalDataSize)
                 self.lastEmissionTime = currentTime // Update last emission time
                 self.lastEmittedSize = totalDataSize

package/ios/ExpoAudioStreamModule.swift

@@ -1,10 +1,11 @@
 import ExpoModulesCore
+import AVFoundation
 
 let audioDataEvent: String = "AudioData"
 
 public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
     private var streamManager = AudioStreamManager()
-
+    
     public func definition() -> ModuleDefinition {
         Name("ExpoAudioStream")
         
@@ -15,7 +16,7 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
             print("Setting streamManager delegate")
             streamManager.delegate = self
         }
-           
+        
         AsyncFunction("startRecording") { (options: [String: Any], promise: Promise) in
             self.checkMicrophonePermission { granted in
                 guard granted else {
@@ -24,15 +25,15 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
                 }
                 
                 // 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 sampleRate = options["sampleRate"] as? Double ?? 16000.0 // it fails if not 48000, why?
+                let numberOfChannels = options["channelConfig"] as? Int ?? 1 // Mono channel configuration
+                let bitDepth = options["audioFormat"] as? Int ?? 16 // 16bits
                 let interval = options["interval"] as? Int ?? 1000
                 
                 let settings = RecordingSettings(sampleRate: sampleRate, numberOfChannels: numberOfChannels, bitDepth: bitDepth)
-                self.streamManager.startRecording(settings: settings, intervalMilliseconds: interval)
+                let url = self.streamManager.startRecording(settings: settings, intervalMilliseconds: interval)
                 
-                promise.resolve(nil)
+                promise.resolve(url)
             }
         }
         
@@ -41,8 +42,17 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         }
         
         AsyncFunction("stopRecording") { (promise: Promise) in
-            self.streamManager.stopRecording()
-            promise.resolve(nil)
+            if let recordingResult = self.streamManager.stopRecording() {
+                // Convert RecordingResult to a dictionary
+                let resultDict: [String: Any] = [
+                    "fileUri": recordingResult.fileUri,
+                    "duration": recordingResult.duration,
+                    "size": recordingResult.size
+                ]
+                promise.resolve(resultDict)
+            } else {
+                promise.reject("ERROR", "Failed to stop recording or no recording in progress.")
+            }
         }
         
         AsyncFunction("listAudioFiles") { (promise: Promise) in
@@ -56,7 +66,6 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
     }
     
     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()
         
@@ -71,13 +80,13 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
             "encoded": encodedData,
             "deltaSize": deltaSize,
             "totalSize": fileSize,
+            "mimeType": manager.mimeType,
             "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)
     }
@@ -122,7 +131,7 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         
         do {
             let files = try FileManager.default.contentsOfDirectory(at: documentDirectory, includingPropertiesForKeys: nil)
-            let audioFiles = files.filter { $0.pathExtension == "pcm" }.map { $0.lastPathComponent }
+            let audioFiles = files.filter { $0.pathExtension == "wav" }.map { $0.lastPathComponent }
             return audioFiles
         } catch {
             print("Error listing audio files:", error.localizedDescription)

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@siteed/expo-audio-stream",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "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",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deeeed/expo-audio-stream.git"
+  },
   "bugs": {
     "url": "https://github.com/deeeed/expo-audio-stream/issues"
   },
@@ -31,11 +34,13 @@
   },
   "dependencies": {
     "base-64": "^1.0.0",
+    "debug": "^4.3.4",
     "expo-file-system": "^16.0.9"
   },
   "devDependencies": {
     "@expo/config-plugins": "^7.9.1",
     "@release-it/conventional-changelog": "^8.0.1",
+    "@types/debug": "^4.1.12",
     "@types/react": "^18.0.25",
     "@typescript-eslint/eslint-plugin": "^7.7.0",
     "@typescript-eslint/parser": "^7.7.0",
@@ -56,6 +61,7 @@
     "react-native": "*"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
   }
 }

package/plugin/build/index.d.ts

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

package/plugin/build/index.js

@@ -1,8 +1,8 @@
 "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 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,
@@ -10,8 +10,8 @@ const withRecordingPermission = (config, { microphonePermission }) => {
         NSMicrophoneUsageDescription: microphonePermission,
     });
     return config_plugins_1.AndroidConfig.Permissions.withPermissions(config, [
-        microphonePermission !== false && 'android.permission.RECORD_AUDIO',
-        'android.permission.MODIFY_AUDIO_SETTINGS',
+        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

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

package/src/ExpoAudioStream.types.ts

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

package/src/ExpoAudioStreamModule.ts

@@ -1,5 +1,5 @@
-import { requireNativeModule } from 'expo-modules-core';
+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');
+export default requireNativeModule("ExpoAudioStream");