@siteed/expo-audio-studio 2.10.5 → 2.11.0

package/android/src/androidTest/java/net/siteed/audiostream/integration/M4aFormatTest.kt

@@ -0,0 +1,345 @@
+package net.siteed.audiostream.integration
+
+import android.Manifest
+import android.content.Context
+import android.media.MediaExtractor
+import android.media.MediaFormat
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.rule.GrantPermissionRule
+import expo.modules.kotlin.Promise
+import net.siteed.audiostream.*
+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
+
+@RunWith(AndroidJUnit4::class)
+class M4aFormatTest {
+    
+    @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
+    
+    // Test event sender to capture events
+    private class TestEventSender : EventSender {
+        override fun sendExpoEvent(eventName: String, params: android.os.Bundle) {
+            // No-op for 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) {
+            stopRecordingSync()
+        }
+        
+        // Clean up
+        AudioRecorderManager.destroy()
+        cleanupAudioFiles()
+    }
+    
+    private fun cleanupAudioFiles() {
+        filesDir.listFiles()?.forEach { file ->
+            if (file.name.endsWith(".wav") || file.name.endsWith(".aac") || 
+                file.name.endsWith(".m4a") || file.name.endsWith(".opus")) {
+                file.delete()
+            }
+        }
+    }
+
+    @Test
+    fun testAacFormat_producesM4aByDefault() {
+        // Skip test if API level is too low for compressed recording
+        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.Q) {
+            println("Skipping M4A test - requires API 29+, current API: ${android.os.Build.VERSION.SDK_INT}")
+            return
+        }
+        
+        // Given
+        val recordingOptions = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "interval" to 100,
+            "showNotification" to false,
+            "output" to mapOf(
+                "primary" to mapOf("enabled" to false),
+                "compressed" to mapOf(
+                    "enabled" to true,
+                    "format" to "aac"
+                    // preferRawStream not specified = defaults to false = M4A
+                )
+            )
+        )
+
+        // When - Record for 1 second
+        startRecordingSync(recordingOptions)
+        Thread.sleep(1000)
+        val result = stopRecordingSync()
+
+        // Then
+        val compression = when (val comp = result["compression"]) {
+            is android.os.Bundle -> bundleToMap(comp)
+            is Map<*, *> -> comp
+            else -> null
+        }
+        
+        val compressedUri = compression?.get("compressedFileUri") as? String
+        assertNotNull("Compressed file URI should not be null", compressedUri)
+        
+        val file = when {
+            compressedUri!!.startsWith("file://") -> File(java.net.URI(compressedUri))
+            compressedUri.startsWith("file:") -> File(java.net.URI(compressedUri))
+            else -> File(compressedUri)
+        }
+        
+        assertTrue("File should exist", file.exists())
+        assertTrue("File should have .m4a extension", file.name.endsWith(".m4a"))
+        
+        // Verify it's actually an M4A file
+        verifyM4aFormat(file)
+    }
+
+    @Test
+    fun testAacFormat_withPreferRawStream_producesAac() {
+        // Skip test if API level is too low for compressed recording
+        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.Q) {
+            println("Skipping raw AAC test - requires API 29+, current API: ${android.os.Build.VERSION.SDK_INT}")
+            return
+        }
+        
+        // Given
+        val recordingOptions = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "interval" to 100,
+            "showNotification" to false,
+            "output" to mapOf(
+                "primary" to mapOf("enabled" to false),
+                "compressed" to mapOf(
+                    "enabled" to true,
+                    "format" to "aac",
+                    "preferRawStream" to true  // NEW: Request raw AAC stream
+                )
+            )
+        )
+
+        // When - Record for 1 second
+        startRecordingSync(recordingOptions)
+        Thread.sleep(1000)
+        val result = stopRecordingSync()
+
+        // Then
+        val compression = when (val comp = result["compression"]) {
+            is android.os.Bundle -> bundleToMap(comp)
+            is Map<*, *> -> comp
+            else -> null
+        }
+        
+        val compressedUri = compression?.get("compressedFileUri") as? String
+        assertNotNull("Compressed file URI should not be null", compressedUri)
+        
+        val file = when {
+            compressedUri!!.startsWith("file://") -> File(java.net.URI(compressedUri))
+            compressedUri.startsWith("file:") -> File(java.net.URI(compressedUri))
+            else -> File(compressedUri)
+        }
+        
+        assertTrue("File should exist", file.exists())
+        assertTrue("File should have .aac extension", file.name.endsWith(".aac"))
+        
+        // Verify it's actually an AAC ADTS file
+        verifyAacAdtsFormat(file)
+    }
+
+    @Test
+    fun testOpusFormat_producesOpus() {
+        // Skip test if API level is too low for Opus recording
+        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.Q) {
+            println("Skipping Opus test - requires API 29+, current API: ${android.os.Build.VERSION.SDK_INT}")
+            return
+        }
+        
+        // Given
+        val recordingOptions = mapOf(
+            "sampleRate" to 48000,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "interval" to 100,
+            "showNotification" to false,
+            "output" to mapOf(
+                "primary" to mapOf("enabled" to false),
+                "compressed" to mapOf(
+                    "enabled" to true,
+                    "format" to "opus"
+                )
+            )
+        )
+
+        // When - Record for 1 second
+        startRecordingSync(recordingOptions)
+        Thread.sleep(1000)
+        val result = stopRecordingSync()
+
+        // Then
+        val compression = when (val comp = result["compression"]) {
+            is android.os.Bundle -> bundleToMap(comp)
+            is Map<*, *> -> comp
+            else -> null
+        }
+        
+        val compressedUri = compression?.get("compressedFileUri") as? String
+        assertNotNull("Compressed file URI should not be null", compressedUri)
+        
+        val file = when {
+            compressedUri!!.startsWith("file://") -> File(java.net.URI(compressedUri))
+            compressedUri.startsWith("file:") -> File(java.net.URI(compressedUri))
+            else -> File(compressedUri)
+        }
+        
+        assertTrue("File should exist", file.exists())
+        assertTrue("File should have .opus extension", file.name.endsWith(".opus"))
+    }
+
+    // Helper methods from existing tests
+    private fun startRecordingSync(recordingOptions: Map<String, Any?>): Map<String, Any?> {
+        val startLatch = CountDownLatch(1)
+        var recordingResult: Map<String, Any?>? = null
+        
+        audioRecorderManager.startRecording(recordingOptions, object : Promise {
+            override fun resolve(value: Any?) {
+                when (value) {
+                    is android.os.Bundle -> recordingResult = bundleToMap(value)
+                    is Map<*, *> -> {
+                        @Suppress("UNCHECKED_CAST")
+                        recordingResult = value as? Map<String, Any>
+                    }
+                    else -> {
+                        fail("Unexpected start result type: ${value?.javaClass?.name}")
+                    }
+                }
+                startLatch.countDown()
+            }
+            
+            override fun reject(code: String, message: String?, cause: Throwable?) {
+                fail("Recording start failed: $code - $message")
+            }
+        })
+        
+        assertTrue("Recording should start within 2 seconds", startLatch.await(2, TimeUnit.SECONDS))
+        return recordingResult ?: throw AssertionError("Recording result should not be null")
+    }
+    
+    private fun stopRecordingSync(): Map<String, Any?> {
+        val stopLatch = CountDownLatch(1)
+        var stopResult: Map<String, Any?>? = null
+        
+        audioRecorderManager.stopRecording(object : Promise {
+            override fun resolve(value: Any?) {
+                when (value) {
+                    is android.os.Bundle -> stopResult = bundleToMap(value)
+                    is Map<*, *> -> {
+                        @Suppress("UNCHECKED_CAST")
+                        stopResult = value as? Map<String, Any>
+                    }
+                    else -> {
+                        fail("Unexpected stop result type: ${value?.javaClass?.name}")
+                    }
+                }
+                stopLatch.countDown()
+            }
+            
+            override fun reject(code: String, message: String?, cause: Throwable?) {
+                fail("Recording stop failed: $code - $message")
+            }
+        })
+        
+        assertTrue("Recording should stop within 2 seconds", stopLatch.await(2, TimeUnit.SECONDS))
+        return stopResult ?: throw AssertionError("Stop result should not be null")
+    }
+    
+    private fun bundleToMap(bundle: android.os.Bundle): Map<String, Any?> {
+        val map = mutableMapOf<String, Any?>()
+        for (key in bundle.keySet()) {
+            map[key] = bundle.get(key)
+        }
+        return map
+    }
+
+    private fun verifyM4aFormat(file: File) {
+        val extractor = MediaExtractor()
+        try {
+            extractor.setDataSource(file.absolutePath)
+            assertTrue("Should have at least one track", extractor.trackCount > 0)
+            
+            val format = extractor.getTrackFormat(0)
+            val mimeType = format.getString(MediaFormat.KEY_MIME)
+            
+            // Debug output
+            println("Detected MIME type: $mimeType")
+            
+            // For M4A files, the MIME type should be audio/mp4 or contain aac
+            val isValidM4aMimeType = mimeType?.let { mime ->
+                mime.contains("mp4", ignoreCase = true) || 
+                mime.contains("aac", ignoreCase = true) ||
+                mime.contains("audio/", ignoreCase = true)
+            } ?: false
+            
+            assertTrue("MIME type should be valid for M4A format, got: $mimeType", isValidM4aMimeType)
+            
+            // Read file header to verify MP4 container
+            val header = file.inputStream().use { it.readNBytes(20) }
+            val headerString = String(header, Charsets.ISO_8859_1)
+            val hasFtyp = headerString.contains("ftyp")
+            assertTrue("File should contain ftyp box (MP4 container)", hasFtyp)
+        } finally {
+            extractor.release()
+        }
+    }
+
+    private fun verifyAacAdtsFormat(file: File) {
+        // ADTS header starts with 0xFFF
+        val header = file.inputStream().use { it.readNBytes(2) }
+        val syncWord = ((header[0].toInt() and 0xFF) shl 4) or ((header[1].toInt() and 0xF0) shr 4)
+        assertEquals("ADTS sync word should be 0xFFF", 0xFFF, syncWord)
+    }
+}

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

@@ -903,43 +903,55 @@ class AudioProcessor(private val filesDir: File) {
     }
 
     private fun decodeAudioToPCM(extractor: MediaExtractor, format: MediaFormat): ByteArray {
-        val decoder = MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME)!!)
-        decoder.configure(format, null, null, 0)
-        decoder.start()
-
-        val info = MediaCodec.BufferInfo()
-        val pcmData = mutableListOf<Byte>()
-
-        var isEOS = false
-        while (!isEOS) {
-            val inputBufferId = decoder.dequeueInputBuffer(10000)
-            if (inputBufferId >= 0) {
-                val inputBuffer = decoder.getInputBuffer(inputBufferId)!!
-                val sampleSize = extractor.readSampleData(inputBuffer, 0)
-
-                if (sampleSize < 0) {
-                    decoder.queueInputBuffer(inputBufferId, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
-                    isEOS = true
-                } else {
-                    decoder.queueInputBuffer(inputBufferId, 0, sampleSize, extractor.sampleTime, 0)
-                    extractor.advance()
+        var decoder: MediaCodec? = null
+        
+        try {
+            decoder = MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME)!!)
+            decoder.configure(format, null, null, 0)
+            decoder.start()
+
+            val info = MediaCodec.BufferInfo()
+            val pcmData = mutableListOf<Byte>()
+
+            var isEOS = false
+            while (!isEOS) {
+                val inputBufferId = decoder.dequeueInputBuffer(10000)
+                if (inputBufferId >= 0) {
+                    val inputBuffer = decoder.getInputBuffer(inputBufferId)!!
+                    val sampleSize = extractor.readSampleData(inputBuffer, 0)
+
+                    if (sampleSize < 0) {
+                        decoder.queueInputBuffer(inputBufferId, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
+                        isEOS = true
+                    } else {
+                        decoder.queueInputBuffer(inputBufferId, 0, sampleSize, extractor.sampleTime, 0)
+                        extractor.advance()
+                    }
+                }
+
+                val outputBufferId = decoder.dequeueOutputBuffer(info, 10000)
+                if (outputBufferId >= 0) {
+                    val outputBuffer = decoder.getOutputBuffer(outputBufferId)!!
+                    val chunk = ByteArray(info.size)
+                    outputBuffer.get(chunk)
+                    pcmData.addAll(chunk.toList())
+                    decoder.releaseOutputBuffer(outputBufferId, false)
                 }
             }
 
-            val outputBufferId = decoder.dequeueOutputBuffer(info, 10000)
-            if (outputBufferId >= 0) {
-                val outputBuffer = decoder.getOutputBuffer(outputBufferId)!!
-                val chunk = ByteArray(info.size)
-                outputBuffer.get(chunk)
-                pcmData.addAll(chunk.toList())
-                decoder.releaseOutputBuffer(outputBufferId, false)
+            return pcmData.toByteArray()
+        } finally {
+            try {
+                decoder?.stop()
+            } catch (e: Exception) {
+                LogUtils.w(CLASS_NAME, "Error stopping decoder: ${e.message}")
+            }
+            try {
+                decoder?.release()
+            } catch (e: Exception) {
+                LogUtils.w(CLASS_NAME, "Error releasing decoder: ${e.message}")
             }
         }
-
-        decoder.stop()
-        decoder.release()
-
-        return pcmData.toByteArray()
     }
 
     private fun resampleAudio(

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

@@ -1654,9 +1654,20 @@ class AudioRecorderManager(
 
             compressedRecorder?.apply {
                 setAudioSource(MediaRecorder.AudioSource.MIC)
-                setOutputFormat(if (recordingConfig.output.compressed.format == "aac") 
-                    MediaRecorder.OutputFormat.AAC_ADTS 
-                    else MediaRecorder.OutputFormat.OGG)
+                
+                // Choose output format based on codec and preferRawStream flag
+                val outputFormat = when (recordingConfig.output.compressed.format) {
+                    "aac" -> {
+                        if (recordingConfig.output.compressed.preferRawStream) {
+                            MediaRecorder.OutputFormat.AAC_ADTS  // Raw AAC stream
+                        } else {
+                            MediaRecorder.OutputFormat.MPEG_4    // M4A container (new default)
+                        }
+                    }
+                    else -> MediaRecorder.OutputFormat.OGG       // Opus uses OGG container
+                }
+                setOutputFormat(outputFormat)
+                
                 setAudioEncoder(if (recordingConfig.output.compressed.format == "aac") 
                     MediaRecorder.AudioEncoder.AAC 
                     else MediaRecorder.AudioEncoder.OPUS)
@@ -1765,7 +1776,17 @@ class AudioRecorderManager(
         
         // Choose extension based on whether this is a compressed file
         val extension = if (isCompressed) {
-            config.output.compressed.format.lowercase()
+            when (config.output.compressed.format.lowercase()) {
+                "aac" -> {
+                    if (config.output.compressed.preferRawStream) {
+                        "aac"  // Raw AAC stream
+                    } else {
+                        "m4a"  // M4A container (new default)
+                    }
+                }
+                "opus" -> "opus"  // Opus in OGG container
+                else -> config.output.compressed.format.lowercase()
+            }
         } else {
             "wav"
         }

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

@@ -17,7 +17,8 @@ data class OutputConfig(
     data class CompressedOutput(
         val enabled: Boolean = false,
         val format: String = "aac",
-        val bitrate: Int = 128000
+        val bitrate: Int = 128000,
+        val preferRawStream: Boolean = false
     )
     
     companion object {
@@ -35,7 +36,8 @@ data class OutputConfig(
             val compressed = CompressedOutput(
                 enabled = compressedMap.getBooleanOrDefault("enabled", false),
                 format = compressedMap.getStringOrDefault("format", "aac").lowercase(),
-                bitrate = compressedMap.getNumberOrDefault("bitrate", 128000)
+                bitrate = compressedMap.getNumberOrDefault("bitrate", 128000),
+                preferRawStream = compressedMap.getBooleanOrDefault("preferRawStream", false)
             )
             
             return OutputConfig(primary = primary, compressed = compressed)
@@ -130,8 +132,9 @@ data class RecordingConfig(
                 channels = options.getNumberOrDefault("channels", 1),
                 encoding = options.getStringOrDefault("encoding", "pcm_16bit"),
                 keepAwake = options.getBooleanOrDefault("keepAwake", true),
-                interval = options.getNumberOrDefault("interval", Constants.DEFAULT_INTERVAL),
-                intervalAnalysis = options.getNumberOrDefault("intervalAnalysis", Constants.DEFAULT_INTERVAL_ANALYSIS),
+                // Enforce minimum intervals to prevent excessive CPU usage
+                interval = maxOf(Constants.MIN_INTERVAL, options.getNumberOrDefault("interval", Constants.DEFAULT_INTERVAL)),
+                intervalAnalysis = maxOf(Constants.MIN_INTERVAL, options.getNumberOrDefault("intervalAnalysis", Constants.DEFAULT_INTERVAL_ANALYSIS)),
                 enableProcessing = options.getBooleanOrDefault("enableProcessing", false),
                 segmentDurationMs = options.getNumberOrDefault("segmentDurationMs", 100),
                 showNotification = options.getBooleanOrDefault("showNotification", false),

package/android/src/test/java/net/siteed/audiostream/AudioFormatTest.kt

@@ -0,0 +1,151 @@
+package net.siteed.audiostream
+
+import org.junit.Test
+import org.junit.Assert.*
+import org.junit.Before
+import java.io.File
+
+class AudioFormatTest {
+    private lateinit var tempDir: File
+
+    @Before
+    fun setUp() {
+        tempDir = File(System.getProperty("java.io.tmpdir"), "audio_format_test_${System.currentTimeMillis()}")
+        tempDir.mkdirs()
+    }
+
+    @Test
+    fun testGetFileExtension_aacDefaultsToM4a() {
+        // Given
+        val config = RecordingConfig(
+            output = OutputConfig(
+                compressed = OutputConfig.CompressedOutput(
+                    enabled = true,
+                    format = "aac",
+                    preferRawStream = false
+                )
+            )
+        )
+
+        // When
+        val file = createTestFile(config, isCompressed = true)
+
+        // Then
+        assertTrue("AAC without preferRawStream should produce .m4a", file.name.endsWith(".m4a"))
+    }
+
+    @Test
+    fun testGetFileExtension_aacWithPreferRawStreamProducesAac() {
+        // Given
+        val config = RecordingConfig(
+            output = OutputConfig(
+                compressed = OutputConfig.CompressedOutput(
+                    enabled = true,
+                    format = "aac",
+                    preferRawStream = true
+                )
+            )
+        )
+
+        // When
+        val file = createTestFile(config, isCompressed = true)
+
+        // Then
+        assertTrue("AAC with preferRawStream should produce .aac", file.name.endsWith(".aac"))
+    }
+
+    @Test
+    fun testGetFileExtension_opusProducesOpus() {
+        // Given
+        val config = RecordingConfig(
+            output = OutputConfig(
+                compressed = OutputConfig.CompressedOutput(
+                    enabled = true,
+                    format = "opus"
+                )
+            )
+        )
+
+        // When
+        val file = createTestFile(config, isCompressed = true)
+
+        // Then
+        assertTrue("Opus should produce .opus", file.name.endsWith(".opus"))
+    }
+
+    @Test
+    fun testGetFileExtension_wavForUncompressed() {
+        // Given
+        val config = RecordingConfig()
+
+        // When
+        val file = createTestFile(config, isCompressed = false)
+
+        // Then
+        assertTrue("Uncompressed should produce .wav", file.name.endsWith(".wav"))
+    }
+
+    @Test
+    fun testCompressedOutput_parseFromMap() {
+        // Given
+        val map = mapOf(
+            "enabled" to true,
+            "format" to "aac",
+            "bitrate" to 192000,
+            "preferRawStream" to true
+        )
+
+        // When
+        val compressed = OutputConfig.CompressedOutput(
+            enabled = map["enabled"] as Boolean,
+            format = map["format"] as String,
+            bitrate = map["bitrate"] as Int,
+            preferRawStream = map["preferRawStream"] as Boolean
+        )
+
+        // Then
+        assertTrue("enabled should be true", compressed.enabled)
+        assertEquals("format should be aac", "aac", compressed.format)
+        assertEquals("bitrate should be 192000", 192000, compressed.bitrate)
+        assertTrue("preferRawStream should be true", compressed.preferRawStream)
+    }
+
+    @Test
+    fun testCompressedOutput_defaultValues() {
+        // When
+        val compressed = OutputConfig.CompressedOutput()
+
+        // Then
+        assertFalse("enabled should default to false", compressed.enabled)
+        assertEquals("format should default to aac", "aac", compressed.format)
+        assertEquals("bitrate should default to 128000", 128000, compressed.bitrate)
+        assertFalse("preferRawStream should default to false", compressed.preferRawStream)
+    }
+
+    /**
+     * Helper function to simulate file creation logic from AudioRecorderManager
+     */
+    private fun createTestFile(config: RecordingConfig, isCompressed: Boolean): File {
+        val baseFilename = config.filename?.let {
+            it.substringBeforeLast('.', it)
+        } ?: "test_recording"
+
+        val extension = if (isCompressed) {
+            when (config.output.compressed.format.lowercase()) {
+                "aac" -> {
+                    if (config.output.compressed.preferRawStream) {
+                        "aac"  // Raw AAC stream
+                    } else {
+                        "m4a"  // M4A container (new default)
+                    }
+                }
+                "opus" -> "opus"  // Opus in OGG container
+                else -> config.output.compressed.format.lowercase()
+            }
+        } else {
+            "wav"
+        }
+
+        return File(tempDir, "$baseFilename.$extension")
+    }
+}