@siteed/expo-audio-studio 2.10.6 → 2.12.0

package/CHANGELOG.md

@@ -8,6 +8,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 
+## [2.12.0] - 2025-06-07
+### Changed
+- fix(android): resolve PCM streaming duration calculation bug (Issue #263) (#265) ([a0c5500](https://github.com/deeeed/expo-audio-stream/commit/a0c550099fec9d6b0d486440819173d9d9275908))
+- feat(expo-audio-studio): implement Android-only audioFocusStrategy (#264) ([cc77226](https://github.com/deeeed/expo-audio-stream/commit/cc7722605a5502a58b8236b610c9bdccf5f7f561))
+- docs: fix comment formatting in OutputConfig interface for clarity ([07fac61](https://github.com/deeeed/expo-audio-stream/commit/07fac61245843c601709bb7576db6e48b2106cf7))
+## [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 +294,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Feature: Audio features extraction during recording.
 - Feature: Consistent WAV PCM recording format across all platforms.
 
-[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.10.6...HEAD
+[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.12.0...HEAD
+[2.12.0]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-studio@2.11.0...@siteed/expo-audio-studio@2.12.0
+[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/AudioFocusStrategyIntegrationTest.kt

@@ -0,0 +1,332 @@
+package net.siteed.audiostream.integration
+
+import android.media.AudioManager
+import android.content.Context
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Test
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.After
+import org.junit.runner.RunWith
+import net.siteed.audiostream.RecordingConfig
+import java.io.File
+
+/**
+ * Integration tests for audio focus strategy functionality.
+ * These tests run on actual Android devices/emulators to validate that
+ * audio focus strategies work correctly in real scenarios.
+ */
+@RunWith(AndroidJUnit4::class)
+class AudioFocusStrategyIntegrationTest {
+
+    private lateinit var context: Context
+    private lateinit var audioManager: AudioManager
+    private lateinit var filesDir: File
+
+    @Before
+    fun setUp() {
+        context = InstrumentationRegistry.getInstrumentation().targetContext
+        audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+        filesDir = context.filesDir
+    }
+
+    @After
+    fun tearDown() {
+        // Clean up any test files
+        val testFiles = filesDir.listFiles { _, name -> 
+            name.startsWith("test_audio_focus_") 
+        }
+        testFiles?.forEach { it.delete() }
+    }
+
+    @Test
+    fun testRecordingConfigWithBackgroundStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to true,
+            "autoResumeAfterInterruption" to true,
+            "android" to mapOf(
+                "audioFocusStrategy" to "background"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, audioFormat) = result.getOrThrow()
+        
+        // Verify audio focus strategy configuration
+        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
+        assertTrue("keepAwake should be true for background recording", config.keepAwake)
+        assertTrue("autoResumeAfterInterruption should be true", config.autoResumeAfterInterruption)
+        
+        // Verify audio format is properly configured
+        assertNotNull("Audio format should be created", audioFormat)
+        assertEquals("MIME type should be audio/wav", "audio/wav", audioFormat.mimeType)
+    }
+
+    @Test
+    fun testRecordingConfigWithInteractiveStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to false,
+            "autoResumeAfterInterruption" to true,
+            "android" to mapOf(
+                "audioFocusStrategy" to "interactive"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, audioFormat) = result.getOrThrow()
+        
+        // Verify audio focus strategy configuration
+        assertEquals("Audio focus strategy should be interactive", "interactive", config.audioFocusStrategy)
+        assertFalse("keepAwake should be false for interactive recording", config.keepAwake)
+        assertTrue("autoResumeAfterInterruption should be true", config.autoResumeAfterInterruption)
+        
+        // Verify audio format is properly configured
+        assertNotNull("Audio format should be created", audioFormat)
+        assertEquals("MIME type should be audio/wav", "audio/wav", audioFormat.mimeType)
+    }
+
+    @Test
+    fun testRecordingConfigWithCommunicationStrategy() {
+        val options = mapOf(
+            "sampleRate" to 16000, // Common speech sample rate
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to false,
+            "autoResumeAfterInterruption" to true,
+            "android" to mapOf(
+                "audioFocusStrategy" to "communication"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, audioFormat) = result.getOrThrow()
+        
+        // Verify audio focus strategy configuration
+        assertEquals("Audio focus strategy should be communication", "communication", config.audioFocusStrategy)
+        assertEquals("Sample rate should be 16000 for speech", 16000, config.sampleRate)
+        assertFalse("keepAwake should be false", config.keepAwake)
+        assertTrue("autoResumeAfterInterruption should be true", config.autoResumeAfterInterruption)
+        
+        // Verify audio format is properly configured
+        assertNotNull("Audio format should be created", audioFormat)
+        assertEquals("MIME type should be audio/wav", "audio/wav", audioFormat.mimeType)
+    }
+
+    @Test
+    fun testRecordingConfigWithNoneStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to false,
+            "android" to mapOf(
+                "audioFocusStrategy" to "none"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, audioFormat) = result.getOrThrow()
+        
+        // Verify audio focus strategy configuration
+        assertEquals("Audio focus strategy should be none", "none", config.audioFocusStrategy)
+        
+        // Verify audio format is properly configured
+        assertNotNull("Audio format should be created", audioFormat)
+        assertEquals("MIME type should be audio/wav", "audio/wav", audioFormat.mimeType)
+    }
+
+    @Test
+    fun testStrategyOverrideBehavior() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to true, // This would normally default to background
+            "android" to mapOf(
+                "audioFocusStrategy" to "communication" // But we override to communication
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, audioFormat) = result.getOrThrow()
+        
+        // Verify that explicit strategy overrides keepAwake defaults
+        assertEquals("Audio focus strategy should be communication (overriding keepAwake default)", "communication", config.audioFocusStrategy)
+        assertTrue("keepAwake should still be true", config.keepAwake)
+        
+        // Verify audio format is properly configured
+        assertNotNull("Audio format should be created", audioFormat)
+    }
+
+    @Test
+    fun testAudioFocusStrategyWithCompression() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "background"
+            ),
+            "output" to mapOf(
+                "compressed" to mapOf(
+                    "enabled" to true,
+                    "format" to "aac",
+                    "bitrate" to 128000
+                )
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, audioFormat) = result.getOrThrow()
+        
+        // Verify audio focus strategy works with compression
+        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
+        assertTrue("Compressed output should be enabled", config.output.compressed.enabled)
+        assertEquals("Compression format should be aac", "aac", config.output.compressed.format)
+        assertEquals("Bitrate should be 128000", 128000, config.output.compressed.bitrate)
+        
+        // Verify audio format is properly configured
+        assertNotNull("Audio format should be created", audioFormat)
+        assertEquals("MIME type should be audio/wav", "audio/wav", audioFormat.mimeType)
+    }
+
+    @Test
+    fun testAudioFocusStrategyWithNotifications() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "showNotification" to true,
+            "showWaveformInNotification" to true,
+            "android" to mapOf(
+                "audioFocusStrategy" to "background"
+            ),
+            "notification" to mapOf(
+                "title" to "Recording Audio",
+                "text" to "Background recording in progress",
+                "icon" to "ic_mic"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, audioFormat) = result.getOrThrow()
+        
+        // Verify audio focus strategy works with notifications
+        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
+        assertTrue("Notifications should be enabled", config.showNotification)
+        assertTrue("Waveform in notification should be enabled", config.showWaveformInNotification)
+        assertEquals("Notification title should match", "Recording Audio", config.notification.title)
+        assertEquals("Notification text should match", "Background recording in progress", config.notification.text)
+        assertEquals("Notification icon should match", "ic_mic", config.notification.icon)
+        
+        // Verify audio format is properly configured
+        assertNotNull("Audio format should be created", audioFormat)
+        assertEquals("MIME type should be audio/wav", "audio/wav", audioFormat.mimeType)
+    }
+
+    @Test
+    fun testAudioFocusStrategyValidation() {
+        // Test all valid strategies
+        val strategies = listOf("background", "interactive", "communication", "none")
+        
+        for (strategy in strategies) {
+            val options = mapOf(
+                "sampleRate" to 44100,
+                "channels" to 1,
+                "encoding" to "pcm_16bit",
+                "android" to mapOf(
+                    "audioFocusStrategy" to strategy
+                )
+            )
+
+            val result = RecordingConfig.fromMap(options)
+            assertTrue("Config creation should succeed for strategy: $strategy", result.isSuccess)
+            
+            val (config, _) = result.getOrThrow()
+            assertEquals("Audio focus strategy should be $strategy", strategy, config.audioFocusStrategy)
+        }
+    }
+
+    @Test
+    fun testInvalidAudioFocusStrategyHandling() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "invalid_strategy"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed even with invalid strategy", result.isSuccess)
+        
+        val (config, _) = result.getOrThrow()
+        assertEquals("Invalid strategy should be preserved", "invalid_strategy", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testCompleteAudioFocusConfiguration() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to true,
+            "autoResumeAfterInterruption" to true,
+            "showNotification" to true,
+            "showWaveformInNotification" to false,
+            "enableProcessing" to false,
+            "android" to mapOf(
+                "audioFocusStrategy" to "communication"
+            ),
+            "notification" to mapOf(
+                "title" to "Voice Call Recording",
+                "text" to "Call in progress",
+                "icon" to "ic_call"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, audioFormat) = result.getOrThrow()
+        
+        // Verify complete configuration
+        assertEquals("Audio focus strategy should be communication", "communication", config.audioFocusStrategy)
+        assertEquals("Sample rate should be 44100", 44100, config.sampleRate)
+        assertEquals("Channels should be 1", 1, config.channels)
+        assertEquals("Encoding should be pcm_16bit", "pcm_16bit", config.encoding)
+        assertTrue("keepAwake should be true", config.keepAwake)
+        assertFalse("showWaveformInNotification should be false", config.showWaveformInNotification)
+        assertTrue("showNotification should be true", config.showNotification)
+        assertTrue("autoResumeAfterInterruption should be true", config.autoResumeAfterInterruption)
+        assertFalse("enableProcessing should be false", config.enableProcessing)
+        assertEquals("Notification title should match", "Voice Call Recording", config.notification.title)
+        assertEquals("Notification text should match", "Call in progress", config.notification.text)
+        
+        // Verify audio format is properly configured
+        assertNotNull("Audio format should be created", audioFormat)
+        assertEquals("MIME type should be audio/wav", "audio/wav", audioFormat.mimeType)
+    }
+}

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")
+    }
+}