@siteed/expo-audio-studio 2.13.2 → 2.14.0

package/CHANGELOG.md

@@ -8,6 +8,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 
+## [2.14.0] - 2025-06-11
+### Changed
+- feat(expo-audio-studio): comprehensive cross-platform stop recording performance optimization ([b3ed474](https://github.com/deeeed/expo-audio-stream/commit/b3ed474d91994698fe082354621adc98e758557e))
 ## [2.13.2] - 2025-06-10
 ### Changed
 - fix: invalid type exports ([18340ea](https://github.com/deeeed/expo-audio-stream/commit/18340eac9cfef39691637400fc6af811d5b004df))
@@ -316,7 +319,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Feature: Audio features extraction during recording.
 - Feature: Consistent WAV PCM recording format across all platforms.
 
-[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.13.2...HEAD
+[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.14.0...HEAD
+[2.14.0]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.13.2...@siteed/expo-audio-studio@2.14.0
 [2.13.2]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.13.1...@siteed/expo-audio-studio@2.13.2
 [2.13.1]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.13.0...@siteed/expo-audio-studio@2.13.1
 [2.13.0]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.12.3...@siteed/expo-audio-studio@2.13.0

package/android/src/androidTest/java/net/siteed/audiostream/AudioRecorderPerformanceInstrumentedTest.kt

@@ -0,0 +1,234 @@
+package net.siteed.audiostream
+
+import android.Manifest
+import android.content.Context
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.rule.GrantPermissionRule
+import expo.modules.kotlin.Promise
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.File
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import kotlin.system.measureTimeMillis
+
+/**
+ * Performance tests for measuring stop recording times.
+ */
+@RunWith(AndroidJUnit4::class)
+class AudioRecorderPerformanceInstrumentedTest {
+    
+    @get:Rule
+    val grantPermissionRule: GrantPermissionRule = GrantPermissionRule.grant(
+        Manifest.permission.RECORD_AUDIO
+    )
+    
+    private lateinit var context: Context
+    private lateinit var filesDir: File
+    private lateinit var audioRecorderManager: AudioRecorderManager
+    private lateinit var testEventSender: TestEventSender
+    private lateinit var permissionUtils: PermissionUtils
+    private lateinit var audioDataEncoder: AudioDataEncoder
+    
+    companion object {
+        private const val TAG = "PerformanceTest"
+    }
+    
+    // Test event sender to capture events
+    private class TestEventSender : EventSender {
+        override fun sendExpoEvent(eventName: String, params: android.os.Bundle) {
+            // No-op for performance tests
+        }
+    }
+    
+    @Before
+    fun setUp() {
+        context = InstrumentationRegistry.getInstrumentation().targetContext
+        filesDir = context.filesDir
+        testEventSender = TestEventSender()
+        permissionUtils = PermissionUtils(context)
+        audioDataEncoder = AudioDataEncoder()
+        
+        // Initialize AudioRecorderManager
+        audioRecorderManager = AudioRecorderManager.initialize(
+            context = context,
+            filesDir = filesDir,
+            permissionUtils = permissionUtils,
+            audioDataEncoder = audioDataEncoder,
+            eventSender = testEventSender,
+            enablePhoneStateHandling = false,
+            enableBackgroundAudio = false
+        )
+        
+        // Clean up any existing audio files
+        cleanupAudioFiles()
+    }
+    
+    @After
+    fun tearDown() {
+        // Stop any ongoing recording
+        if (audioRecorderManager.isRecording) {
+            val promise = object : Promise {
+                override fun resolve(value: Any?) {}
+                override fun reject(code: String, message: String?, cause: Throwable?) {}
+            }
+            audioRecorderManager.stopRecording(promise)
+        }
+        
+        // Clean up
+        AudioRecorderManager.destroy()
+        cleanupAudioFiles()
+    }
+    
+    private fun cleanupAudioFiles() {
+        filesDir.listFiles()?.forEach { file ->
+            if (file.name.endsWith(".wav") || file.name.endsWith(".aac") || file.name.endsWith(".opus")) {
+                file.delete()
+            }
+        }
+    }
+    
+    @Test
+    fun measureStopTime_5seconds() {
+        runPerformanceTest(5_000L, "5 second recording")
+    }
+    
+    @Test
+    fun measureStopTime_30seconds() {
+        runPerformanceTest(30_000L, "30 second recording")
+    }
+    
+    @Test
+    fun measureStopTime_1minute() {
+        runPerformanceTest(60_000L, "1 minute recording")
+    }
+    
+    @Test
+    fun measureStopTime_2minutes() {
+        runPerformanceTest(120_000L, "2 minute recording")
+    }
+    
+    @Test
+    fun measureStopTime_5minutes() {
+        runPerformanceTest(300_000L, "5 minute recording")
+    }
+    
+    @Test
+    fun measureStopTime_10minutes() {
+        runPerformanceTest(600_000L, "10 minute recording")
+    }
+    
+    @Test
+    fun measureStopTime_15minutes() {
+        runPerformanceTest(900_000L, "15 minute recording")
+    }
+    
+    private fun runPerformanceTest(recordingDurationMs: Long, testName: String) {
+        val recordingOptions = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "interval" to 1000,
+            "enableProcessing" to false,
+            "showNotification" to false,
+            "output" to mapOf(
+                "primary" to mapOf("enabled" to true),
+                "compressed" to mapOf("enabled" to false)
+            )
+        )
+        
+        // Start recording
+        val startLatch = CountDownLatch(1)
+        audioRecorderManager.startRecording(recordingOptions, object : Promise {
+            override fun resolve(value: Any?) {
+                startLatch.countDown()
+            }
+            override fun reject(code: String, message: String?, cause: Throwable?) {
+                fail("Start recording failed: $message")
+            }
+        })
+        
+        assertTrue("Recording should start", startLatch.await(5, TimeUnit.SECONDS))
+        assertTrue("Recording should be active", audioRecorderManager.isRecording)
+        
+        // Record for specified duration
+        Thread.sleep(recordingDurationMs)
+        
+        // Measure stop time
+        val stopLatch = CountDownLatch(1)
+        var fileSize = 0L
+        var stopResult: Map<String, Any>? = null
+        
+        val stopDuration = measureTimeMillis {
+            audioRecorderManager.stopRecording(object : Promise {
+                override fun resolve(value: Any?) {
+                    when (value) {
+                        is android.os.Bundle -> {
+                            fileSize = value.getLong("size", 0)
+                            stopResult = bundleToMap(value)
+                        }
+                        is Map<*, *> -> {
+                            @Suppress("UNCHECKED_CAST")
+                            stopResult = value as? Map<String, Any>
+                            fileSize = (stopResult?.get("size") as? Long) ?: 0
+                        }
+                    }
+                    stopLatch.countDown()
+                }
+                override fun reject(code: String, message: String?, cause: Throwable?) {
+                    fail("Stop recording failed: $message")
+                }
+            })
+            
+            assertTrue("Stop should complete", stopLatch.await(10, TimeUnit.SECONDS))
+        }
+        
+        // Log results
+        val fileSizeMB = fileSize / (1024.0 * 1024.0)
+        Log.i(TAG, """
+            Performance Test: $testName
+            - Recording Duration: ${recordingDurationMs}ms
+            - Stop Duration: ${stopDuration}ms
+            - File Size: ${"%.2f".format(fileSizeMB)}MB
+            - Performance: ${if (stopDuration < getTargetTime(recordingDurationMs)) "PASS" else "FAIL"}
+        """.trimIndent())
+        
+        println("""
+            Performance Test: $testName
+            - Recording Duration: ${recordingDurationMs}ms
+            - Stop Duration: ${stopDuration}ms
+            - File Size: ${"%.2f".format(fileSizeMB)}MB
+            - Performance: ${if (stopDuration < getTargetTime(recordingDurationMs)) "PASS" else "FAIL"}
+        """.trimIndent())
+        
+        assertFalse("Recording should not be active", audioRecorderManager.isRecording)
+    }
+    
+    private fun getTargetTime(recordingDurationMs: Long): Long {
+        return when {
+            recordingDurationMs <= 5_000 -> 100
+            recordingDurationMs <= 30_000 -> 150
+            recordingDurationMs <= 60_000 -> 200
+            recordingDurationMs <= 300_000 -> 500
+            else -> 750
+        }
+    }
+    
+    private fun bundleToMap(bundle: android.os.Bundle): Map<String, Any> {
+        val map = mutableMapOf<String, Any>()
+        for (key in bundle.keySet()) {
+            val value = bundle.get(key)
+            when (value) {
+                is android.os.Bundle -> map[key] = bundleToMap(value)
+                else -> value?.let { map[key] = it }
+            }
+        }
+        return map
+    }
+}

package/android/src/main/java/net/siteed/audiostream/AudioRecorderManager.kt

@@ -137,6 +137,10 @@ class AudioRecorderManager(
     var isPrepared = false
     private var selectedDeviceId: String? = null
     private var deviceDisconnectionBehavior: String? = null
+    
+    // Cache file sizes to avoid file system calls during stop
+    private var cachedPrimaryFileSize: Long = 44L  // Start with WAV header size
+    private var cachedCompressedFileSize: Long = 0L
 
     // Add a method to handle device changes
     fun handleDeviceChange() {
@@ -819,6 +823,10 @@ class AudioRecorderManager(
             streamUuid = java.util.UUID.randomUUID().toString()
             totalDataSize = 0
             
+            // Reset cached file sizes
+            cachedPrimaryFileSize = 44L  // WAV header size
+            cachedCompressedFileSize = 0L
+            
             // Only create file if primary output is enabled
             if (recordingConfig.output.primary.enabled) {
                 audioFile = createRecordingFile(recordingConfig)
@@ -936,7 +944,19 @@ class AudioRecorderManager(
 
                 _isRecording.set(false)
                 isPrepared = false  // Reset preparation state
-                recordingThread?.join(1000)
+                
+                // Calculate adaptive timeout based on estimated file size
+                // Assume ~5MB per minute at 44.1kHz, 16-bit, mono
+                val recordingDurationMs = if (recordingStartTime > 0) {
+                    System.currentTimeMillis() - recordingStartTime - pausedDuration
+                } else {
+                    0L
+                }
+                val estimatedFileSizeMB = (recordingDurationMs / 60000.0) * 5.0
+                val timeoutMs = maxOf(2000L, (estimatedFileSizeMB * 100).toLong()) // 100ms per MB, min 2 seconds
+                
+                LogUtils.d(CLASS_NAME, "Waiting for recording thread to complete with timeout: ${timeoutMs}ms (estimated size: ${estimatedFileSizeMB}MB)")
+                recordingThread?.join(timeoutMs)
 
                 val audioData = ByteArray(bufferSizeInBytes)
                 val bytesRead = audioRecord?.read(audioData, 0, bufferSizeInBytes) ?: -1
@@ -963,8 +983,9 @@ class AudioRecorderManager(
                 AudioProcessor.resetUniqueIdCounter()
                 audioProcessor.resetCumulativeAmplitudeRange()
 
-                val fileSize = audioFile?.length() ?: 0
-                LogUtils.d(CLASS_NAME, "WAV File validation - Size: $fileSize bytes, Path: ${audioFile?.absolutePath}")
+                // Use cached file size to avoid file system call
+                val fileSize = if (recordingConfig.output.primary.enabled) cachedPrimaryFileSize else 0L
+                LogUtils.d(CLASS_NAME, "WAV File validation - Size: $fileSize bytes (cached), Path: ${audioFile?.absolutePath}")
                 
                 // Calculate duration based on context - use actual recording time for streaming-only mode
                 val duration = if (!recordingConfig.output.primary.enabled) {
@@ -997,9 +1018,12 @@ class AudioRecorderManager(
                 }
                 compressedRecorder = null
 
-                // Log compressed file status if enabled
+                // Log compressed file status if enabled - use actual file size for validation
                 if (recordingConfig.output.compressed.enabled) {
+                    // Note: For compressed files, we need to get actual size as MediaRecorder handles the writing
+                    // Use actual file size here for validation purposes only
                     val compressedSize = compressedFile?.length() ?: 0
+                    cachedCompressedFileSize = compressedSize // Update cache with final size
                     LogUtils.d(CLASS_NAME, "Compressed File validation - Size: $compressedSize bytes, Path: ${compressedFile?.absolutePath}")
                 }
 
@@ -1008,7 +1032,7 @@ class AudioRecorderManager(
                     val localCompressedFile = compressedFile // Create local copy to avoid smart cast issues
                     val compressionBundle = if (recordingConfig.output.compressed.enabled && localCompressedFile != null) {
                         bundleOf(
-                            "size" to localCompressedFile.length(),
+                            "size" to cachedCompressedFileSize,  // Use cached size
                             "mimeType" to if (recordingConfig.output.compressed.format == "aac") "audio/aac" else "audio/opus",
                             "bitrate" to recordingConfig.output.compressed.bitrate,
                             "format" to recordingConfig.output.compressed.format,
@@ -1040,7 +1064,7 @@ class AudioRecorderManager(
                         "mimeType" to mimeType,
                         "createdAt" to System.currentTimeMillis(),
                         "compression" to if (compressedFile != null) bundleOf(
-                            "size" to compressedFile?.length(),
+                            "size" to cachedCompressedFileSize,  // Use cached size
                             "mimeType" to if (recordingConfig.output.compressed.format == "aac") "audio/aac" else "audio/opus",
                             "bitrate" to recordingConfig.output.compressed.bitrate,
                             "format" to recordingConfig.output.compressed.format,
@@ -1195,7 +1219,8 @@ class AudioRecorderManager(
                 )
             }
 
-            val fileSize = audioFile?.length() ?: 0
+            // Use cached file size instead of file system call
+            val fileSize = if (recordingConfig.output.primary.enabled) cachedPrimaryFileSize else 0L
             val duration = when (mimeType) {
                 "audio/wav" -> {
                     val dataFileSize = fileSize - Constants.WAV_HEADER_SIZE
@@ -1208,7 +1233,7 @@ class AudioRecorderManager(
 
             val compressionBundle = if (recordingConfig.output.compressed.enabled) {
                 bundleOf(
-                    "size" to (compressedFile?.length() ?: 0),
+                    "size" to cachedCompressedFileSize,  // Use cached size
                     "mimeType" to if (recordingConfig.output.compressed.format == "aac") "audio/aac" else "audio/opus",
                     "bitrate" to recordingConfig.output.compressed.bitrate,
                     "format" to recordingConfig.output.compressed.format
@@ -1380,6 +1405,7 @@ class AudioRecorderManager(
                         // Only write to file if primary output is enabled
                         if (fos != null) {
                             fos.write(audioData, 0, bytesRead)
+                            cachedPrimaryFileSize += bytesRead  // Update cached file size
                         }
                         totalDataSize += bytesRead
                         
@@ -1440,16 +1466,17 @@ class AudioRecorderManager(
                     }
                 }
             } finally {
-                // Close the file output stream if it was opened
+                // Flush and close the file output stream if it was opened
+                try {
+                    fos?.flush()
+                    LogUtils.d(CLASS_NAME, "FileOutputStream flushed successfully")
+                } catch (e: Exception) {
+                    LogUtils.e(CLASS_NAME, "Error flushing FileOutputStream", e)
+                }
                 fos?.close()
             }
             
-            // Update the WAV header to reflect the actual data size (only if file was created)
-            if (recordingConfig.output.primary.enabled) {
-                audioFile?.let { file ->
-                    audioFileHandler.updateWavHeader(file)
-                }
-            }
+            // WAV header update is already handled in cleanup(), no need to duplicate here
 
         } catch (e: Exception) {
             // Ensure wake lock is released if the thread is interrupted
@@ -1463,7 +1490,8 @@ class AudioRecorderManager(
     private fun emitAudioData(audioData: ByteArray, length: Int) {
         val encodedBuffer = audioDataEncoder.encodeToBase64(audioData)
 
-        val fileSize = audioFile?.length() ?: 0
+        // Use cached file size instead of file system call
+        val fileSize = if (recordingConfig.output.primary.enabled) cachedPrimaryFileSize else 0L
         val from = lastEmittedSize
         lastEmittedSize = fileSize
 
@@ -1472,7 +1500,14 @@ class AudioRecorderManager(
             (from * 1000) / (recordingConfig.sampleRate * recordingConfig.channels * (if (recordingConfig.encoding == "pcm_8bit") 8 else 16) / 8)
 
         val compressionBundle = if (recordingConfig.output.compressed.enabled) {
-            val compressedSize = compressedFile?.length() ?: 0
+            // For compressed files, we need to get actual size as MediaRecorder handles the writing
+            // Only update cache periodically to avoid frequent file system calls
+            val currentTime = System.currentTimeMillis()
+            if (cachedCompressedFileSize == 0L || (currentTime - lastEmittedCompressedSize) > 5000) {
+                cachedCompressedFileSize = compressedFile?.length() ?: 0
+            }
+            
+            val compressedSize = cachedCompressedFileSize
             val eventDataSize = compressedSize - lastEmittedCompressedSize
             
             // Read the new compressed data

package/ios/AudioStreamManager.swift

@@ -112,6 +112,10 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
 
     // Add the stopping flag to the class properties
     private var stopping: Bool = false
+    
+    // Performance optimization: Cache file sizes during recording
+    private var cachedWavFileSize: Int64 = 0
+    private var cachedCompressedFileSize: Int64 = 0
 
     /// Initializes the AudioStreamManager
     override init() {
@@ -819,6 +823,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
                     let header = createWavHeader(dataSize: 0)
                     self.fileHandle?.write(header)
                     self.totalDataSize = Int64(WAV_HEADER_SIZE) // Initialize size with header size
+                    self.cachedWavFileSize = Int64(WAV_HEADER_SIZE) // Initialize cached size
                     Logger.debug("AudioStreamManager", "File handle opened and initial header written for \(url.path). Initial size: \(self.totalDataSize)")
                 } catch {
                     Logger.debug("AudioStreamManager", "Error creating/opening file handle: \(error.localizedDescription)")
@@ -1462,6 +1467,8 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
                     try handle.write(contentsOf: dataToWrite)
                     // Update total size state
                     self.totalDataSize += Int64(dataToWrite.count)
+                    // Cache WAV file size for performance
+                    self.cachedWavFileSize = self.totalDataSize
                 } catch {
                      Logger.debug("BG Write Error: Failed to seek/write: \(error.localizedDescription)")
                 }
@@ -1698,35 +1705,52 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             return nil
         }
         
-        if recordingSettings?.showNotification == true {
-            // Stop and clean up timer safely
+        // PERFORMANCE OPTIMIZATION: Capture current state for immediate return
+        let capturedFileURL = recordingFileURL
+        let capturedSettings = recordingSettings
+        let capturedWavFileSize = cachedWavFileSize
+        let capturedCompressedFileSize = cachedCompressedFileSize
+        let capturedTotalDataSize = totalDataSize
+        let capturedCompressedURL = compressedFileURL
+        
+        // PERFORMANCE OPTIMIZATION: Move all slow operations to background
+        let capturedShowNotification = recordingSettings?.showNotification == true
+        
+        // Queue notification and audio session cleanup for background
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            guard let self = self else { return }
+            
+            if capturedShowNotification {
+                // Clean up notifications on main queue but don't wait
+                DispatchQueue.main.async {
+                    self.mediaInfoUpdateTimer?.invalidate()
+                    self.mediaInfoUpdateTimer = nil
+                    
+                    // Clean up notification manager
+                    self.notificationManager?.stopUpdates()
+                    self.notificationManager = nil
+                    
+                    // Clean up media controls
+                    UIApplication.shared.endReceivingRemoteControlEvents()
+                    self.remoteCommandCenter?.pauseCommand.isEnabled = false
+                    self.remoteCommandCenter?.playCommand.isEnabled = false
+                    self.notificationView?.nowPlayingInfo = nil
+                }
+            }
+            
+            // Reset audio session in background
+            do {
+                try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+            } catch {
+                Logger.debug("Background: Error deactivating audio session: \(error)")
+            }
+            
+            // Reset audio engine in background
             DispatchQueue.main.async {
-                self.mediaInfoUpdateTimer?.invalidate()
-                self.mediaInfoUpdateTimer = nil
-                
-                // Clean up notification manager
-                self.notificationManager?.stopUpdates()
-                self.notificationManager = nil
-                
-                // Clean up media controls
-                UIApplication.shared.endReceivingRemoteControlEvents()
-                self.remoteCommandCenter?.pauseCommand.isEnabled = false
-                self.remoteCommandCenter?.playCommand.isEnabled = false
-                self.notificationView?.nowPlayingInfo = nil
+                self.audioEngine.reset()
             }
         }
         
-        // Reset audio session safely
-        do {
-            try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
-        } catch {
-            Logger.debug("Error deactivating audio session: \(error)")
-            // Continue with cleanup despite session errors
-        }
-
-        // Reset audio engine
-        audioEngine.reset()
-        
         guard let settings = recordingSettings else {
             Logger.debug("Recording settings is nil.")
             stopping = false // Reset stopping flag before returning nil
@@ -1737,40 +1761,25 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         if !settings.output.primary.enabled {
             let durationMs = Int64(finalDuration * 1000)
             
-            // Check for compressed output even when primary is disabled
+            // Check for compressed output using cached size
             var compression: CompressedRecordingInfo?
-            if settings.output.compressed.enabled, let compressedURL = compressedFileURL {
-                let compressedPath = compressedURL.path
-                if FileManager.default.fileExists(atPath: compressedPath) {
-                    do {
-                        let compressedAttributes = try FileManager.default.attributesOfItem(atPath: compressedPath)
-                        let compressedSize = compressedAttributes[FileAttributeKey.size] as? Int64 ?? 0
-                        
-                        Logger.debug("""
-                            Compressed File validation (primary disabled):
-                            - Path: \(compressedPath)
-                            - Format: \(compressedFormat)
-                            - Size: \(compressedSize) bytes
-                            - Bitrate: \(compressedBitRate) bps
-                            """)
-                        
-                        if compressedSize > 0 {
-                            compression = CompressedRecordingInfo(
-                                compressedFileUri: compressedURL.absoluteString,
-                                mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
-                                bitrate: compressedBitRate,
-                                format: compressedFormat,
-                                size: compressedSize
-                            )
-                        } else {
-                            Logger.debug("Warning: Compressed file exists but is empty")
-                        }
-                    } catch {
-                        Logger.debug("Failed to validate compressed file: \(error)")
-                    }
-                } else {
-                    Logger.debug("Warning: Compressed file not found at path: \(compressedPath)")
-                }
+            if settings.output.compressed.enabled, 
+               let compressedURL = capturedCompressedURL,
+               capturedCompressedFileSize > 0 {
+                compression = CompressedRecordingInfo(
+                    compressedFileUri: compressedURL.absoluteString,
+                    mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
+                    bitrate: compressedBitRate,
+                    format: compressedFormat,
+                    size: capturedCompressedFileSize
+                )
+                
+                Logger.debug("""
+                    Compressed File (cached - primary disabled):
+                    - Format: \(compressedFormat)
+                    - Size: \(capturedCompressedFileSize) bytes
+                    - Bitrate: \(compressedBitRate) bps
+                    """)
             }
             
             let result = RecordingResult(
@@ -1804,140 +1813,79 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             return result
         }
         
-        guard let fileURL = recordingFileURL else {
+        guard let fileURL = capturedFileURL else {
             Logger.debug("Recording file URL is nil.")
             stopping = false // Reset stopping flag before returning nil
             return nil
         }
         
-        // Reset stopping flag before returning
-        let result = createRecordingResult(fileURL: fileURL, settings: settings, finalDuration: finalDuration)
-        stopping = false
+        // PERFORMANCE OPTIMIZATION: Create result immediately with cached values
+        let durationMs = Int64(finalDuration * 1000)
         
-        // Return after all cleanup tasks are completed
-        return result
-    }
-
-    /// Creates a RecordingResult from the finished recording
-    /// - Parameters:
-    ///   - fileURL: The URL of the recording file
-    ///   - settings: The settings used for recording
-    ///   - finalDuration: The final duration of the recording
-    /// - Returns: A RecordingResult object or nil if validation fails
-    private func createRecordingResult(fileURL: URL, settings: RecordingSettings, finalDuration: TimeInterval) -> RecordingResult? {
-        // Validate WAV file
-        let wavPath = fileURL.path
-        do {
-            // Check if WAV file exists
-            let wavFileAttributes = try FileManager.default.attributesOfItem(atPath: wavPath)
-            let wavFileSize = wavFileAttributes[FileAttributeKey.size] as? Int64 ?? 0
-            
-            Logger.debug("""
-                WAV File validation:
-                - Path: \(wavPath)
-                - Exists: true
-                - Size: \(wavFileSize) bytes
-                - Duration: \(finalDuration) seconds
-                - Expected minimum size: \(WAV_HEADER_SIZE) bytes (WAV header)
-                """)
-            
-            // Use the final totalDataSize tracked by the background queue
-            let finalDataChunkSize = self.totalDataSize - Int64(WAV_HEADER_SIZE)
-            if finalDataChunkSize <= 0 {
-                Logger.debug("Recording file data chunk size is zero or negative (\(finalDataChunkSize) bytes), likely no audio data was recorded successfully after header")
-                // Optionally delete the empty file?
-                // try? FileManager.default.removeItem(at: fileURL)
-                return nil
-            }
-
-            // Update the WAV header with the correct final file size
-            updateWavHeader(fileURL: fileURL, totalDataSize: finalDataChunkSize)
-            Logger.debug("Final WAV header updated. Data chunk size: \(finalDataChunkSize)")
-            
-            // Validate compressed file if enabled
-            var compression: CompressedRecordingInfo?
-            if let compressedURL = compressedFileURL {
-                let compressedPath = compressedURL.path
-                if FileManager.default.fileExists(atPath: compressedPath) {
-                    let compressedAttributes = try FileManager.default.attributesOfItem(atPath: compressedPath)
-                    let compressedSize = compressedAttributes[FileAttributeKey.size] as? Int64 ?? 0
-                    
-                    Logger.debug("""
-                        Compressed File validation:
-                        - Path: \(compressedPath)
-                        - Format: \(compressedFormat)
-                        - Size: \(compressedSize) bytes
-                        - Bitrate: \(compressedBitRate) bps
-                        """)
-                    
-                    if compressedSize > 0 {
-                        compression = CompressedRecordingInfo(
-                            compressedFileUri: compressedURL.absoluteString,
-                            mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
-                            bitrate: compressedBitRate,
-                            format: compressedFormat,
-                            size: compressedSize
-                        )
-                    } else {
-                        Logger.debug("Warning: Compressed file exists but is empty")
-                    }
-                } else {
-                    Logger.debug("Warning: Compressed file not found at path: \(compressedPath)")
-                }
-            }
-            
-            let durationMs = Int64(finalDuration * 1000)
-            
-            let result = RecordingResult(
-                fileUri: fileURL.absoluteString,
-                filename: fileURL.lastPathComponent,
-                mimeType: mimeType,
-                duration: durationMs,
-                size: wavFileSize,
-                channels: settings.numberOfChannels,
-                bitDepth: settings.bitDepth,
-                sampleRate: settings.sampleRate,
-                compression: compression
+        // Check compressed output
+        var compression: CompressedRecordingInfo?
+        if capturedSettings?.output.compressed.enabled == true, 
+           let compressedURL = capturedCompressedURL,
+           capturedCompressedFileSize > 0 {
+            compression = CompressedRecordingInfo(
+                compressedFileUri: compressedURL.absoluteString,
+                mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
+                bitrate: compressedBitRate,
+                format: compressedFormat,
+                size: capturedCompressedFileSize
             )
+        }
+        
+        // Create result with cached values - no file system access
+        let result = RecordingResult(
+            fileUri: fileURL.absoluteString,
+            filename: fileURL.lastPathComponent,
+            mimeType: mimeType,
+            duration: durationMs,
+            size: capturedWavFileSize,
+            channels: capturedSettings?.numberOfChannels ?? 1,
+            bitDepth: capturedSettings?.bitDepth ?? 16,
+            sampleRate: capturedSettings?.sampleRate ?? 44100,
+            compression: compression
+        )
+        
+        // Perform file operations asynchronously after returning result
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            guard let self = self else { return }
             
-            Logger.debug("""
-                Recording completed successfully:
-                - WAV file: \(fileURL.lastPathComponent)
-                - Size: \(wavFileSize) bytes
-                - Duration: \(durationMs)ms
-                - Sample rate: \(settings.sampleRate)Hz
-                - Bit depth: \(settings.bitDepth)-bit
-                - Channels: \(settings.numberOfChannels)
-                - Compressed: \(compression != nil ? "yes" : "no")
-                """)
-            
-            // Additional cleanup
-            recordingFileURL = nil
-            lastBufferTime = nil
-            lastValidDuration = nil
-            compressedRecorder = nil
-            compressedFileURL = nil
-            recordingSettings = nil
-            startTime = nil
-            totalPausedDuration = 0
-            currentPauseStart = nil
-            lastEmissionTime = nil
-            lastEmissionTimeAnalysis = nil
-            lastEmittedSize = 0
-            lastEmittedSizeAnalysis = 0
-            lastEmittedCompressedSize = 0
-            accumulatedData.removeAll()
-            accumulatedAnalysisData.removeAll()
-            recordingUUID = nil
-            
-            return result
+            // Update WAV header in background
+            let finalDataChunkSize = capturedTotalDataSize - Int64(WAV_HEADER_SIZE)
+            if finalDataChunkSize > 0 {
+                self.updateWavHeader(fileURL: fileURL, totalDataSize: finalDataChunkSize)
+                Logger.debug("Background: WAV header updated. Data chunk size: \(finalDataChunkSize)")
+            }
             
-        } catch {
-            Logger.debug("Failed to validate recording files: \(error)")
-            return nil
+            // Cleanup
+            self.recordingSettings = nil
+            self.startTime = nil
+            self.totalPausedDuration = 0
+            self.currentPauseStart = nil
+            self.lastEmissionTime = nil
+            self.lastEmissionTimeAnalysis = nil
+            self.lastEmittedSize = 0
+            self.lastEmittedSizeAnalysis = 0
+            self.lastEmittedCompressedSize = 0
+            self.accumulatedData.removeAll()
+            self.accumulatedAnalysisData.removeAll()
+            self.recordingUUID = nil
+            self.totalDataSize = 0
+            self.cachedWavFileSize = 0
+            self.cachedCompressedFileSize = 0
+            self.recordingFileURL = nil
+            self.compressedFileURL = nil
+            self.fileHandle = nil
         }
+        
+        stopping = false
+        return result
     }
 
+
     // MARK: - AudioDeviceManagerDelegate Implementation
 
     func audioDeviceManager(_ manager: AudioDeviceManager, didDetectDisconnectionOfDevice disconnectedDeviceId: String) {
@@ -2297,6 +2245,19 @@ extension AudioStreamManager: AVAudioRecorderDelegate {
         Logger.debug("Compressed recording finished - success: \(flag)")
         if !flag {
             delegate?.audioStreamManager(self, didFailWithError: "Compressed recording failed to complete")
+        } else {
+            // Update cached compressed file size when recording finishes
+            if let compressedURL = compressedFileURL {
+                do {
+                    let attributes = try FileManager.default.attributesOfItem(atPath: compressedURL.path)
+                    if let size = attributes[.size] as? Int64 {
+                        cachedCompressedFileSize = size
+                        Logger.debug("Cached compressed file size: \(size) bytes")
+                    }
+                } catch {
+                    Logger.debug("Failed to cache compressed file size: \(error)")
+                }
+            }
         }
     }
     

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@siteed/expo-audio-studio",
-    "version": "2.13.2",
+    "version": "2.14.0",
     "description": "Comprehensive audio processing library for React Native and Expo with recording, analysis, visualization, and streaming capabilities across iOS, Android, and web",
     "license": "MIT",
     "type": "commonjs",