@siteed/expo-audio-studio 2.18.6 → 3.0.0

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

@@ -1,218 +0,0 @@
-package net.siteed.audiostream.integration
-
-import android.content.Context
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import net.siteed.audiostream.OutputConfig
-import net.siteed.audiostream.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
-        // ExpoAudioStreamModule 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/audiostream/integration/EventEmissionIntervalTest.kt

@@ -1,120 +0,0 @@
-package net.siteed.audiostream.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.audiostream.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.audiostream.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/audiostream/integration/M4aFormatTest.kt

@@ -1,345 +0,0 @@
-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)
-    }
-}