@siteed/expo-audio-stream 1.11.5 → 1.12.0

package/ios/AudioStreamManager.swift

@@ -380,11 +380,51 @@ class AudioStreamManager: NSObject {
     
     /// Creates a new recording file.
     /// - Returns: The URL of the newly created recording file, or nil if creation failed.
-    private func createRecordingFile() -> URL? {
-        let documentsDirectory = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first!
-        recordingUUID = UUID()
-        let fileName = "\(recordingUUID!.uuidString).wav"
-        let fileURL = documentsDirectory.appendingPathComponent(fileName)
+    private func createRecordingFile(isCompressed: Bool = false) -> URL? {
+        // Add debug logging
+        Logger.debug("Creating recording file - settings filename: \(recordingSettings?.filename ?? "nil")")
+        
+        // Get base directory - use default if no custom directory provided
+        let baseDirectory: URL
+        if let customDir = recordingSettings?.outputDirectory {
+            baseDirectory = URL(fileURLWithPath: customDir)
+            Logger.debug("Using custom directory: \(customDir)")
+        } else {
+            // Use existing default behavior
+            baseDirectory = fileManager.urls(for: .documentDirectory, in: .userDomainMask).first!
+            Logger.debug("Using default directory: \(baseDirectory.path)")
+        }
+        
+        // Use custom filename if provided, otherwise generate UUID
+        let baseFilename = recordingSettings?.filename ?? UUID().uuidString
+        Logger.debug("Using base filename: \(baseFilename)")
+        
+        // Remove any existing extension from the filename
+        let filenameWithoutExtension = baseFilename.replacingOccurrences(
+            of: "\\.[^\\.]+$",
+            with: "",
+            options: .regularExpression
+        )
+        
+        // Choose extension based on whether this is a compressed file
+        let fileExtension: String
+        if isCompressed {
+            fileExtension = recordingSettings?.compressedFormat.lowercased() ?? "aac"
+        } else {
+            fileExtension = "wav"
+        }
+        
+        let fullFilename = "\(filenameWithoutExtension).\(fileExtension)"
+        Logger.debug("Full filename: \(fullFilename)")
+        
+        let fileURL = baseDirectory.appendingPathComponent(fullFilename)
+        Logger.debug("Final file URL: \(fileURL.path)")
+        
+        // Check if file already exists
+        if fileManager.fileExists(atPath: fileURL.path) {
+            Logger.debug("File already exists at: \(fileURL.path)")
+            return nil
+        }
         
         if !fileManager.createFile(atPath: fileURL.path, contents: nil, attributes: nil) {
             Logger.debug("Failed to create file at: \(fileURL.path)")
@@ -479,6 +519,20 @@ class AudioStreamManager: NSObject {
     ///   - intervalMilliseconds: The interval in milliseconds for emitting audio data.
     /// - Returns: A StartRecordingResult object if recording starts successfully, or nil otherwise.
     func startRecording(settings: RecordingSettings, intervalMilliseconds: Int) -> StartRecordingResult? {
+        // Check for active call first
+        let callCenter = CXCallObserver()
+        if callCenter.calls.contains(where: { $0.hasEnded == false }) {
+            Logger.debug("Cannot start recording during an active call")
+            delegate?.audioStreamManager(self, didFailWithError: "Cannot start recording during an active call")
+            return nil
+        }
+
+        // Store settings first before doing anything else
+        recordingSettings = settings
+        
+        // Add debug logging to verify settings
+        Logger.debug("Starting recording with settings - filename: \(settings.filename ?? "nil"), directory: \(settings.outputDirectory ?? "nil")")
+        
         // Update auto-resume preference from settings
         autoResumeAfterInterruption = settings.autoResumeAfterInterruption
         
@@ -606,37 +660,26 @@ class AudioStreamManager: NSObject {
                     
                     Logger.debug("Initializing compressed recording with settings: \(compressedSettings)")
                     
-                    let tempDirectory = FileManager.default.temporaryDirectory
-                    try FileManager.default.createDirectory(at: tempDirectory, withIntermediateDirectories: true)
+                    // Use createRecordingFile for consistency in file handling
+                    compressedFileURL = createRecordingFile(isCompressed: true)
                     
-                    // Use the same UUID as the main recording
-                    if let recordingUUID = recordingUUID {
-                        compressedFileURL = tempDirectory.appendingPathComponent(recordingUUID.uuidString)
-                            .appendingPathExtension(settings.compressedFormat)
+                    if let url = compressedFileURL {
+                        Logger.debug("Using compressed file URL: \(url.path)")
                         
-                        if let url = compressedFileURL {
-                            // Create empty file first
-                            if FileManager.default.createFile(atPath: url.path, contents: nil) {
-                                Logger.debug("Created empty file at: \(url.path)")
-                            } else {
-                                Logger.debug("Failed to create empty file at: \(url.path)")
-                            }
+                        // Initialize recorder
+                        compressedRecorder = try AVAudioRecorder(url: url, settings: compressedSettings)
+                        if let recorder = compressedRecorder {
+                            let prepared = recorder.prepareToRecord()
+                            Logger.debug("Recorder prepared: \(prepared)")
                             
-                            // Then initialize recorder
-                            compressedRecorder = try AVAudioRecorder(url: url, settings: compressedSettings)
-                            if let recorder = compressedRecorder {
-                                let prepared = recorder.prepareToRecord()
-                                Logger.debug("Recorder prepared: \(prepared)")
-                                
-                                let started = recorder.record()
-                                Logger.debug("Recorder started: \(started)")
-                                
-                                Logger.debug("Recorder current time: \(recorder.currentTime)")
-                                
-                                compressedFormat = settings.compressedFormat
-                                compressedBitRate = settings.compressedBitRate
-                                Logger.debug("Compressed recording initialized - Format: \(compressedFormat), Bitrate: \(compressedBitRate)")
-                            }
+                            let started = recorder.record()
+                            Logger.debug("Recorder started: \(started)")
+                            
+                            Logger.debug("Recorder current time: \(recorder.currentTime)")
+                            
+                            compressedFormat = settings.compressedFormat
+                            compressedBitRate = settings.compressedBitRate
+                            Logger.debug("Compressed recording initialized - Format: \(compressedFormat), Bitrate: \(compressedBitRate)")
                         }
                     }
                 } catch {
@@ -700,18 +743,27 @@ class AudioStreamManager: NSObject {
             isPaused = false
             Logger.debug("Debug: Recording started successfully.")
             
+            var compression = compressedRecorder != nil ? CompressedRecordingInfo(
+                fileUri: compressedFileURL?.absoluteString ?? "",
+                mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
+                bitrate: compressedBitRate,
+                format: compressedFormat
+            ) : nil
+
+            // Get the size separately since it's not part of the initializer
+            if let compressedPath = compressedFileURL?.path,
+               let attributes = try? FileManager.default.attributesOfItem(atPath: compressedPath),
+               let fileSize = attributes[.size] as? Int64 {
+                compression?.size = fileSize
+            }
+
             return StartRecordingResult(
                 fileUri: recordingFileURL!.path,
                 mimeType: mimeType,
                 channels: settings.numberOfChannels,
                 bitDepth: settings.bitDepth,
                 sampleRate: settings.sampleRate,
-                compression: settings.enableCompressedOutput && compressedFileURL != nil ? CompressedRecordingInfo(
-                    fileUri: compressedFileURL!.absoluteString,
-                    mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
-                    bitrate: compressedBitRate,
-                    format: compressedFormat
-                ) : nil
+                compression: compression
             )
             
         } catch {
@@ -792,6 +844,14 @@ class AudioStreamManager: NSObject {
     
     /// Resumes the current audio recording.
     func resumeRecording() {
+        // Check for active call first
+        let callCenter = CXCallObserver()
+        if callCenter.calls.contains(where: { $0.hasEnded == false }) {
+            Logger.debug("Cannot resume recording during an active call")
+            delegate?.audioStreamManager(self, didFailWithError: "Cannot resume recording during an active call")
+            return
+        }
+
         guard isRecording && isPaused else { return }
         
         lastValidDuration = nil  // Clear the stored duration when resuming
@@ -920,6 +980,20 @@ class AudioStreamManager: NSObject {
             // Update the WAV header with the correct file size
             updateWavHeader(fileURL: fileURL, totalDataSize: fileSize - 44)
             
+            var compression = compressedRecorder != nil ? CompressedRecordingInfo(
+                fileUri: compressedFileURL?.absoluteString ?? "",
+                mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
+                bitrate: compressedBitRate,
+                format: compressedFormat
+            ) : nil
+
+            // Get the size separately since it's not part of the initializer
+            if let compressedPath = compressedFileURL?.path,
+               let attributes = try? FileManager.default.attributesOfItem(atPath: compressedPath),
+               let fileSize = attributes[.size] as? Int64 {
+                compression?.size = fileSize
+            }
+
             let result = RecordingResult(
                 fileUri: fileURL.absoluteString,
                 filename: fileURL.lastPathComponent,
@@ -929,12 +1003,7 @@ class AudioStreamManager: NSObject {
                 channels: settings.numberOfChannels,
                 bitDepth: settings.bitDepth,
                 sampleRate: settings.sampleRate,
-                compression: settings.enableCompressedOutput && compressedFileURL != nil ? CompressedRecordingInfo(
-                    fileUri: compressedFileURL!.absoluteString,
-                    mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
-                    bitrate: compressedBitRate,
-                    format: compressedFormat
-                ) : nil
+                compression: compression
             )
             
             // Cleanup

package/ios/AudioStreamManagerDelegate.swift

@@ -12,4 +12,5 @@ protocol AudioStreamManagerDelegate: AnyObject {
     func audioStreamManager(_ manager: AudioStreamManager, didResumeRecording resumeTime: Date)
     func audioStreamManager(_ manager: AudioStreamManager, didUpdateNotificationState isPaused: Bool)
     func audioStreamManager(_ manager: AudioStreamManager, didReceiveInterruption info: [String: Any])
+    func audioStreamManager(_ manager: AudioStreamManager, didFailWithError error: String)
 }

package/ios/ExpoAudioStreamModule.swift

@@ -213,8 +213,7 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
         ///   - promise: A promise to resolve with the recording result or reject with an error.
         AsyncFunction("stopRecording") { (promise: Promise) in
             if let recordingResult = self.streamManager.stopRecording() {
-                // Convert RecordingResult to a dictionary
-                let resultDict: [String: Any] = [
+                var resultDict: [String: Any] = [
                     "fileUri": recordingResult.fileUri,
                     "filename": recordingResult.filename,
                     "durationMs": recordingResult.duration,
@@ -224,6 +223,18 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
                     "sampleRate": recordingResult.sampleRate,
                     "mimeType": recordingResult.mimeType,
                 ]
+                
+                // Add compression info if available
+                if let compression = recordingResult.compression {
+                    resultDict["compression"] = [
+                        "fileUri": compression.fileUri,
+                        "mimeType": compression.mimeType,
+                        "bitrate": compression.bitrate,
+                        "format": compression.format,
+                        "size": compression.size
+                    ]
+                }
+                
                 promise.resolve(resultDict)
             } else {
                 promise.reject("ERROR", "Failed to stop recording or no recording in progress.")
@@ -459,4 +470,11 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
     func audioStreamManager(_ manager: AudioStreamManager, didReceiveInterruption info: [String: Any]) {
         sendEvent(recordingInterruptedEvent, info)
     }
+    
+    func audioStreamManager(_ manager: AudioStreamManager, didFailWithError error: String) {
+        // Send error event to JavaScript
+        sendEvent("error", [
+            "message": error
+        ])
+    }
 }

package/ios/RecordingSettings.swift

@@ -22,6 +22,7 @@ struct CompressedRecordingInfo {
     var mimeType: String
     var bitrate: Int
     var format: String
+    var size: Int64 = 0  // Add size with default value
     
     static func validate(format: String, bitrate: Int) -> Result<(String, Int), Error> {
         // Validate format
@@ -59,6 +60,7 @@ struct IOSConfig {
 enum RecordingError: Error {
     case unsupportedFormat(String)
     case invalidBitrate(Int)
+    case invalidOutputDirectory(String)
     
     var localizedDescription: String {
         switch self {
@@ -66,6 +68,8 @@ enum RecordingError: Error {
             return "Unsupported compression format: \(format). iOS only supports AAC."
         case .invalidBitrate(let bitrate):
             return "Invalid bitrate: \(bitrate). Must be between 8000 and 960000 bps."
+        case .invalidOutputDirectory(let directory):
+            return "Invalid output directory: \(directory). Directory does not exist, is not a directory, or is not writable."
         }
     }
 }
@@ -100,6 +104,10 @@ struct RecordingSettings {
     
     let autoResumeAfterInterruption: Bool
     
+    // Make these optional with nil default values
+    var outputDirectory: String? = nil
+    var filename: String? = nil
+    
     static func fromDictionary(_ dict: [String: Any]) -> Result<RecordingSettings, Error> {
         // Extract compression settings
         let compression = dict["compression"] as? [String: Any]
@@ -222,6 +230,34 @@ struct RecordingSettings {
             settings.notification = notificationConfig
         }
         
+        // Parse output settings (they remain nil if not provided)
+        if let directory = dict["outputDirectory"] as? String {
+            // Only validate if a custom directory is provided
+            let fileManager = FileManager.default
+            var isDirectory: ObjCBool = false
+            
+            // Clean up the directory path by removing file:// protocol if present
+            let cleanDirectory = directory.replacingOccurrences(of: "file://", with: "")
+                .trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+                .replacingOccurrences(of: "//", with: "/")
+            
+            if !fileManager.fileExists(atPath: cleanDirectory, isDirectory: &isDirectory) {
+                return .failure(RecordingError.invalidOutputDirectory("Directory does not exist: \(cleanDirectory)"))
+            }
+            
+            if !isDirectory.boolValue {
+                return .failure(RecordingError.invalidOutputDirectory("Path is not a directory: \(cleanDirectory)"))
+            }
+            
+            if !fileManager.isWritableFile(atPath: cleanDirectory) {
+                return .failure(RecordingError.invalidOutputDirectory("Directory is not writable: \(cleanDirectory)"))
+            }
+            
+            settings.outputDirectory = cleanDirectory
+        }
+        
+        settings.filename = dict["filename"] as? String
+        
         return .success(settings)
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siteed/expo-audio-stream",
-  "version": "1.11.5",
+  "version": "1.12.0",
   "description": "stream audio crossplatform",
   "license": "MIT",
   "main": "build/index.js",
@@ -67,7 +67,7 @@
   },
   "devDependencies": {
     "@expo/config-plugins": "~9.0.0",
-    "@siteed/publisher": "^0.4.15",
+    "@siteed/publisher": "^0.4.18",
     "@size-limit/preset-big-lib": "^11.1.4",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.12.7",

package/src/ExpoAudioStream.types.ts

@@ -11,6 +11,7 @@ export interface CompressionInfo {
     mimeType: string
     bitrate: number
     format: string
+    compressedFileUri?: string
 }
 
 export interface AudioStreamStatus {
@@ -188,6 +189,10 @@ export interface RecordingConfig {
 
     // Optional callback to handle recording interruptions
     onRecordingInterrupted?: (_: RecordingInterruptionEvent) => void
+
+    // Optional output configuration
+    outputDirectory?: string // If not provided, uses default app directory
+    filename?: string // If not provided, uses UUID
 }
 
 export interface NotificationConfig {

package/src/ExpoAudioStream.web.ts

@@ -50,7 +50,7 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
     lastEmittedTime: number
     lastEmittedCompressionSize: number
     streamUuid: string | null
-    extension: 'webm' | 'wav' = 'wav' // Default extension is 'webm'
+    extension: 'webm' | 'wav' = 'wav' // Default extension is 'wav'
     recordingConfig?: RecordingConfig
     bitDepth: BitDepth // Bit depth of the audio
     audioWorkletUrl: string
@@ -108,7 +108,9 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
     }
 
     // Start recording with options
-    async startRecording(recordingConfig: RecordingConfig = {}) {
+    async startRecording(
+        recordingConfig: RecordingConfig = {}
+    ): Promise<StartRecordingResult> {
         if (this.isRecording) {
             throw new Error('Recording is already in progress')
         }
@@ -170,7 +172,15 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
         this.lastEmittedSize = 0
         this.lastEmittedTime = 0
         this.lastEmittedCompressionSize = 0
-        this.streamUuid = Date.now().toString()
+
+        // Use custom filename if provided, otherwise fallback to timestamp
+        if (recordingConfig.filename) {
+            // Remove any existing extension from the filename
+            this.streamUuid = recordingConfig.filename.replace(/\.[^/.]+$/, '')
+        } else {
+            this.streamUuid = Date.now().toString()
+        }
+
         const fileUri = `${this.streamUuid}.${this.extension}`
         const streamConfig: StartRecordingResult = {
             fileUri,
@@ -266,9 +276,11 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
                 }
             )
 
-            return {
+            // Use the stored streamUuid (which contains our custom filename) for the final filename
+            const filename = `${this.streamUuid}.${this.extension}`
+            const result: AudioRecording = {
                 fileUri,
-                filename: `${this.streamUuid}.${this.extension}`,
+                filename, // This will now use our custom filename
                 bitDepth: this.bitDepth,
                 channels: this.recordingConfig?.channels ?? 1,
                 sampleRate: this.recordingConfig?.sampleRate ?? 44100,
@@ -277,6 +289,11 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
                 mimeType,
                 compression,
             }
+
+            // Reset after creating the result
+            this.streamUuid = null
+
+            return result
         } catch (error) {
             this.logger?.error('[Stop] Error stopping recording:', error)
             throw error
@@ -325,6 +342,7 @@ export class ExpoAudioStreamWeb extends LegacyEventEmitter {
                       format: this.recordingConfig.compression.format ?? 'opus',
                       bitrate:
                           this.recordingConfig.compression.bitrate ?? 128000,
+                      compressedFileUri: `${this.streamUuid}.webm`,
                   }
                 : undefined,
         }

package/src/WebRecorder.web.ts

@@ -351,6 +351,10 @@ export class WebRecorder {
             return { pcmData: new Float32Array() }
         } finally {
             this.cleanup()
+            // Reset the chunks array
+            this.compressedChunks = []
+            this.compressedSize = 0
+            this.pendingCompressedChunk = null
         }
     }