@siteed/audio-studio 3.0.0

package/android/src/androidTest/java/net/siteed/audiostudio/integration/DeviceDisconnectionFallbackTest.kt

@@ -0,0 +1,218 @@
+package net.siteed.audiostudio.integration
+
+import android.content.Context
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import net.siteed.audiostudio.OutputConfig
+import net.siteed.audiostudio.RecordingConfig
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.File
+
+/**
+ * Integration test for device disconnection fallback behavior.
+ * Tests various scenarios when audio devices are disconnected during recording.
+ */
+@RunWith(AndroidJUnit4::class)
+class DeviceDisconnectionFallbackTest {
+
+    private lateinit var context: Context
+    private lateinit var testDir: File
+
+    @Before
+    fun setup() {
+        context = InstrumentationRegistry.getInstrumentation().targetContext
+        
+        // Create test directory
+        testDir = File(context.getExternalFilesDir(null), "fallback_test")
+        testDir.mkdirs()
+        
+        // Clear any existing test files
+        testDir.listFiles()?.forEach { it.delete() }
+    }
+
+    @After
+    fun tearDown() {
+        // Clean up test files
+        testDir.listFiles()?.forEach { it.delete() }
+        testDir.delete()
+    }
+
+    @Test
+    fun testDeviceDisconnectionBehavior_Fallback() {
+        println("🧪 Test: Device Disconnection with Fallback Behavior")
+        println("--------------------------------------------------")
+        
+        // Create recording config with fallback behavior
+        val config = RecordingConfig(
+            sampleRate = 44100,
+            channels = 1,
+            encoding = "pcm_16bit",
+            deviceDisconnectionBehavior = "fallback",
+            output = OutputConfig(
+                primary = OutputConfig.PrimaryOutput(
+                    enabled = true,
+                    format = "wav"
+                )
+            ),
+            outputDirectory = testDir.absolutePath,
+            filename = "fallback_test.wav"
+        )
+        
+        // Verify device disconnection behavior is set
+        assertEquals("Device disconnection behavior should be fallback", 
+            "fallback", config.deviceDisconnectionBehavior)
+        
+        println("✅ RecordingConfig correctly configured with fallback behavior")
+        
+        // Note: Actual device disconnection simulation would require running the full
+        // AudioStudioModule with device connection/disconnection events
+    }
+
+    @Test
+    fun testDeviceDisconnectionBehavior_Pause() {
+        println("🧪 Test: Device Disconnection with Pause Behavior")
+        println("-----------------------------------------------")
+        
+        val config = RecordingConfig(
+            sampleRate = 44100,
+            channels = 1,
+            encoding = "pcm_16bit",
+            deviceDisconnectionBehavior = "pause",
+            output = OutputConfig(
+                primary = OutputConfig.PrimaryOutput(
+                    enabled = true,
+                    format = "wav"
+                )
+            ),
+            outputDirectory = testDir.absolutePath,
+            filename = "pause_test.wav"
+        )
+        
+        // Verify device disconnection behavior is set to pause
+        assertEquals("Device disconnection behavior should be pause", 
+            "pause", config.deviceDisconnectionBehavior)
+        
+        println("✅ RecordingConfig correctly configured with pause behavior")
+    }
+
+    @Test
+    fun testDefaultDeviceDisconnectionBehavior() {
+        println("🧪 Test: Default Device Disconnection Behavior")
+        println("--------------------------------------------")
+        
+        // Create config without specifying deviceDisconnectionBehavior
+        val config = RecordingConfig(
+            sampleRate = 44100,
+            channels = 1,
+            encoding = "pcm_16bit",
+            output = OutputConfig(
+                primary = OutputConfig.PrimaryOutput(
+                    enabled = true,
+                    format = "wav"
+                )
+            ),
+            outputDirectory = testDir.absolutePath,
+            filename = "default_test.wav"
+        )
+        
+        // Default behavior should be null (handled as pause in implementation)
+        assertNull("Default device disconnection behavior should be null", 
+            config.deviceDisconnectionBehavior)
+        
+        println("✅ Default device disconnection behavior is null (treated as 'pause')")
+    }
+
+    @Test
+    fun testInterruptionEventReasons() {
+        println("🧪 Test: Interruption Event Reasons")
+        println("----------------------------------")
+        
+        // Test that the expected event reasons are valid
+        val fallbackReasons = listOf("deviceFallback", "deviceSwitchFailed")
+        val pauseReasons = listOf("deviceDisconnected")
+        
+        println("📋 Expected reasons for fallback behavior:")
+        fallbackReasons.forEach { reason ->
+            println("   - $reason")
+            assertNotNull("Reason should not be null", reason)
+            assertTrue("Reason should not be empty", reason.isNotEmpty())
+        }
+        
+        println("📋 Expected reasons for pause behavior:")
+        pauseReasons.forEach { reason ->
+            println("   - $reason")
+            assertNotNull("Reason should not be null", reason)
+            assertTrue("Reason should not be empty", reason.isNotEmpty())
+        }
+        
+        println("✅ All interruption event reasons are valid")
+    }
+
+    @Test
+    fun testAllDeviceDisconnectionBehaviors() {
+        println("🧪 Test: All Device Disconnection Behaviors")
+        println("-----------------------------------------")
+        
+        val behaviors = listOf("fallback", "pause")
+        
+        behaviors.forEach { behavior ->
+            val config = RecordingConfig(
+                sampleRate = 44100,
+                channels = 1,
+                encoding = "pcm_16bit",
+                deviceDisconnectionBehavior = behavior,
+                output = OutputConfig(
+                    primary = OutputConfig.PrimaryOutput(
+                        enabled = true,
+                        format = "wav"
+                    )
+                ),
+                outputDirectory = testDir.absolutePath,
+                filename = "${behavior}_test.wav"
+            )
+            
+            // Verify configuration
+            assertEquals("Device disconnection behavior should be $behavior", 
+                behavior, config.deviceDisconnectionBehavior)
+            
+            println("✅ Behavior '$behavior' correctly configured")
+        }
+    }
+
+    @Test
+    fun testDeviceDisconnectionWithCompressedOutput() {
+        println("🧪 Test: Device Disconnection with Compressed Output")
+        println("--------------------------------------------------")
+        
+        // Test fallback behavior with compressed output enabled
+        val config = RecordingConfig(
+            sampleRate = 44100,
+            channels = 1,
+            encoding = "pcm_16bit",
+            deviceDisconnectionBehavior = "fallback",
+            output = OutputConfig(
+                primary = OutputConfig.PrimaryOutput(
+                    enabled = false
+                ),
+                compressed = OutputConfig.CompressedOutput(
+                    enabled = true,
+                    format = "aac",
+                    bitrate = 128000
+                )
+            ),
+            outputDirectory = testDir.absolutePath,
+            filename = "compressed_fallback_test"
+        )
+        
+        assertEquals("Device disconnection behavior should be fallback", 
+            "fallback", config.deviceDisconnectionBehavior)
+        assertTrue("Compressed output should be enabled", config.output.compressed.enabled)
+        assertFalse("Primary output should be disabled", config.output.primary.enabled)
+        
+        println("✅ Fallback behavior configured with compressed-only output")
+    }
+}

package/android/src/androidTest/java/net/siteed/audiostudio/integration/EventEmissionIntervalTest.kt

@@ -0,0 +1,120 @@
+package net.siteed.audiostudio.integration
+
+import android.os.Bundle
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.Assert.*
+import java.io.File
+import kotlin.math.abs
+
+/**
+ * Integration test to validate event emission interval enforcement.
+ * 
+ * This test verifies that the configured intervals respect platform
+ * minimums to prevent excessive CPU usage.
+ */
+@RunWith(AndroidJUnit4::class)
+class EventEmissionIntervalTest {
+
+    private val TAG = "EventEmissionIntervalTest"
+    private val context = InstrumentationRegistry.getInstrumentation().targetContext
+
+    @Test
+    fun testMinimumIntervalEnforcement() {
+        println("🧪 Test: Minimum Interval Enforcement")
+        println("------------------------------------")
+        
+        // Test cases for different requested intervals
+        val testCases = listOf(
+            5 to 10,    // 5ms should be clamped to MIN_INTERVAL (10ms)
+            10 to 10,   // 10ms should remain 10ms
+            50 to 50,   // 50ms should remain 50ms
+            100 to 100  // 100ms should remain 100ms
+        )
+        
+        for ((requested, expected) in testCases) {
+            val config = Bundle().apply {
+                putInt("sampleRate", 48000)
+                putInt("channels", 1)
+                putLong("interval", requested.toLong())
+                putLong("intervalAnalysis", requested.toLong())
+            }
+            
+            // Parse the config to validate interval enforcement
+            val configMap = bundleToMap(config)
+            val result = net.siteed.audiostudio.RecordingConfig.fromMap(configMap)
+            
+            assertTrue("Config parsing should succeed", result.isSuccess)
+            val (recordingConfig, _) = result.getOrNull()!!
+            
+            println("Requested interval: ${requested}ms")
+            println("Actual interval: ${recordingConfig.interval}ms")
+            println("Expected interval: ${expected}ms")
+            
+            assertEquals(
+                "Interval should be clamped to minimum if below MIN_INTERVAL",
+                expected.toLong(),
+                recordingConfig.interval
+            )
+            
+            assertEquals(
+                "Analysis interval should be clamped to minimum if below MIN_INTERVAL",
+                expected.toLong(),
+                recordingConfig.intervalAnalysis
+            )
+            
+            println("✓ Passed\n")
+        }
+    }
+    
+    @Test
+    fun testIntervalConsistencyAcrossPlatforms() {
+        println("🧪 Test: Platform Consistency Check")
+        println("----------------------------------")
+        
+        // Document the expected behavior across platforms
+        println("Expected behavior after fix:")
+        println("- iOS: Minimum interval = 10ms")
+        println("- Android: Minimum interval = 10ms (enforced)")
+        println("")
+        
+        // Verify Android enforces the minimum
+        val intervals = listOf(1, 5, 10, 50, 100)
+        for (interval in intervals) {
+            val config = Bundle().apply {
+                putLong("interval", interval.toLong())
+                putLong("intervalAnalysis", interval.toLong())
+            }
+            
+            val configMap = bundleToMap(config)
+            val result = net.siteed.audiostudio.RecordingConfig.fromMap(configMap)
+            val (recordingConfig, _) = result.getOrNull()!!
+            
+            val expectedInterval = maxOf(10, interval).toLong()
+            assertEquals(
+                "Android should enforce MIN_INTERVAL of 10ms",
+                expectedInterval,
+                recordingConfig.interval
+            )
+            
+            println("✓ Interval ${interval}ms -> ${recordingConfig.interval}ms")
+        }
+    }
+
+    /**
+     * Helper to convert Bundle to Map for RecordingConfig
+     */
+    private fun bundleToMap(bundle: Bundle): Map<String, Any?> {
+        val map = mutableMapOf<String, Any?>()
+        for (key in bundle.keySet()) {
+            when (val value = bundle.get(key)) {
+                is Bundle -> map[key] = bundleToMap(value)
+                else -> map[key] = value
+            }
+        }
+        return map
+    }
+}

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

@@ -0,0 +1,345 @@
+package net.siteed.audiostudio.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.audiostudio.*
+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)
+    }
+}