@siteed/expo-audio-studio 2.13.1 → 2.14.0

package/CHANGELOG.md

@@ -8,6 +8,13 @@ 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))
+- chore(expo-audio-studio): release @siteed/expo-audio-studio@2.13.1 ([9ccce85](https://github.com/deeeed/expo-audio-stream/commit/9ccce858174254387aac44d30853c908707d8254))
 ## [2.13.1] - 2025-06-09
 ### Changed
 - feat(investigation): resolve Issue #251 - comprehensive sub-100ms audio events analysis (#270) ([4813f1e](https://github.com/deeeed/expo-audio-stream/commit/4813f1ef05f3856b58ec8fde95b7b8909feb513d))
@@ -312,7 +319,9 @@ 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.1...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
 [2.12.3]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.12.2...@siteed/expo-audio-studio@2.12.3

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