@siteed/expo-audio-studio 2.10.6 → 2.11.0

package/CHANGELOG.md

@@ -8,6 +8,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 
+## [2.11.0] - 2025-06-05
+### Changed
+- refactor(expo-audio-studio): remove android/build.gradle and add device disconnection fallback tests ([36fe9a9](https://github.com/deeeed/expo-audio-stream/commit/36fe9a921505e136ea50406d4b664c597293ffd8))
+- fix(expo-audio-studio): enforce 10ms minimum interval on both platforms (#262) ([035fc07](https://github.com/deeeed/expo-audio-stream/commit/035fc076334c169a2371527bad0ca60f222d10ee))
+- fix(expo-audio-studio): add proper MediaCodec resource cleanup in AudioProcessor ([2b069b6](https://github.com/deeeed/expo-audio-stream/commit/2b069b6ae512f97fae80df1b8cb38bb3a14538e5))
+- feat(expo-audio-studio): add audio format enhancement specification and tests ([ace22a2](https://github.com/deeeed/expo-audio-stream/commit/ace22a22cf6c94ec58ddd4f6cb44f77dd383d6bc))
+- feat\!: Add M4A support with preferRawStream option (#261) ([c9faeb0](https://github.com/deeeed/expo-audio-stream/commit/c9faeb01cd5dcd7407f73a0f7e6d5822adb862a4))
 ## [2.10.6] - 2025-06-04
 ### Changed
 - fix(expo-audio-studio): prevent durationMs returning 0 on iOS (#244) (#260) ([595e5d5](https://github.com/deeeed/expo-audio-stream/commit/595e5d56991c9fa88c2fa4e39efb197916cb8b84))
@@ -282,7 +289,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Feature: Audio features extraction during recording.
 - Feature: Consistent WAV PCM recording format across all platforms.
 
-[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.10.6...HEAD
+[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.11.0...HEAD
+[2.11.0]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.10.6...@siteed/expo-audio-studio@2.11.0
 [2.10.6]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.10.5...@siteed/expo-audio-studio@2.10.6
 [2.10.5]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.10.4...@siteed/expo-audio-studio@2.10.5
 [2.10.4]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.10.3...@siteed/expo-audio-studio@2.10.4

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

@@ -0,0 +1,218 @@
+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

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