@siteed/expo-audio-studio 2.10.6 → 2.12.0

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

@@ -17,7 +17,8 @@ data class OutputConfig(
     data class CompressedOutput(
         val enabled: Boolean = false,
         val format: String = "aac",
-        val bitrate: Int = 128000
+        val bitrate: Int = 128000,
+        val preferRawStream: Boolean = false
     )
     
     companion object {
@@ -35,7 +36,8 @@ data class OutputConfig(
             val compressed = CompressedOutput(
                 enabled = compressedMap.getBooleanOrDefault("enabled", false),
                 format = compressedMap.getStringOrDefault("format", "aac").lowercase(),
-                bitrate = compressedMap.getNumberOrDefault("bitrate", 128000)
+                bitrate = compressedMap.getNumberOrDefault("bitrate", 128000),
+                preferRawStream = compressedMap.getBooleanOrDefault("preferRawStream", false)
             )
             
             return OutputConfig(primary = primary, compressed = compressed)
@@ -62,6 +64,7 @@ data class RecordingConfig(
     val filename: String? = null,
     val deviceId: String? = null,
     val deviceDisconnectionBehavior: String? = null,
+    val audioFocusStrategy: String? = null,
     val bufferDurationSeconds: Double? = null,
 ) {
     companion object {
@@ -123,6 +126,10 @@ data class RecordingConfig(
             // Get device-related settings
             val deviceId = options["deviceId"] as? String
             val deviceDisconnectionBehavior = options["deviceDisconnectionBehavior"] as? String
+            
+            // Get Android-specific settings
+            val androidConfig = options["android"] as? Map<String, Any>
+            val audioFocusStrategy = androidConfig?.get("audioFocusStrategy") as? String
 
             // Initialize the recording configuration with cleaned directory path
             val tempRecordingConfig = RecordingConfig(
@@ -130,8 +137,9 @@ data class RecordingConfig(
                 channels = options.getNumberOrDefault("channels", 1),
                 encoding = options.getStringOrDefault("encoding", "pcm_16bit"),
                 keepAwake = options.getBooleanOrDefault("keepAwake", true),
-                interval = options.getNumberOrDefault("interval", Constants.DEFAULT_INTERVAL),
-                intervalAnalysis = options.getNumberOrDefault("intervalAnalysis", Constants.DEFAULT_INTERVAL_ANALYSIS),
+                // Enforce minimum intervals to prevent excessive CPU usage
+                interval = maxOf(Constants.MIN_INTERVAL, options.getNumberOrDefault("interval", Constants.DEFAULT_INTERVAL)),
+                intervalAnalysis = maxOf(Constants.MIN_INTERVAL, options.getNumberOrDefault("intervalAnalysis", Constants.DEFAULT_INTERVAL_ANALYSIS)),
                 enableProcessing = options.getBooleanOrDefault("enableProcessing", false),
                 segmentDurationMs = options.getNumberOrDefault("segmentDurationMs", 100),
                 showNotification = options.getBooleanOrDefault("showNotification", false),
@@ -148,6 +156,7 @@ data class RecordingConfig(
                 filename = options["filename"] as? String,
                 deviceId = deviceId,
                 deviceDisconnectionBehavior = deviceDisconnectionBehavior,
+                audioFocusStrategy = audioFocusStrategy,
                 bufferDurationSeconds = (options["bufferDurationSeconds"] as? Number)?.toDouble(),
             )
 

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

@@ -0,0 +1,249 @@
+package net.siteed.audiostream
+
+import org.junit.Test
+import org.junit.Assert.*
+
+/**
+ * Unit tests for audio focus strategy configuration and logic.
+ * These tests verify that the RecordingConfig correctly handles audioFocusStrategy
+ * parameter and that the smart defaults work as expected.
+ */
+class AudioFocusStrategyTest {
+
+    @Test
+    fun testRecordingConfigWithExplicitBackgroundStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "background"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithExplicitInteractiveStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "interactive"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be interactive", "interactive", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithExplicitCommunicationStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "communication"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be communication", "communication", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithExplicitNoneStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "none"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be none", "none", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithoutAudioFocusStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit"
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertNull("Audio focus strategy should be null when not specified", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithInvalidAudioFocusStrategy() {
+        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 audio focus strategy should be preserved", "invalid_strategy", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithNullAudioFocusStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to null
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertNull("Audio focus strategy should be null", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigKeepAwakeAndBackgroundStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to true,
+            "android" to mapOf(
+                "audioFocusStrategy" to "background"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertTrue("keepAwake should be true", config.keepAwake)
+        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigKeepAwakeFalseAndInteractiveStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to false,
+            "android" to mapOf(
+                "audioFocusStrategy" to "interactive"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertFalse("keepAwake should be false", config.keepAwake)
+        assertEquals("Audio focus strategy should be interactive", "interactive", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithAutoResumeAndBackgroundStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "autoResumeAfterInterruption" to true,
+            "android" to mapOf(
+                "audioFocusStrategy" to "background"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
+        assertTrue("autoResumeAfterInterruption should be true", config.autoResumeAfterInterruption)
+    }
+
+    @Test
+    fun testRecordingConfigWithCommunicationStrategyAndSpeechSampleRate() {
+        val options = mapOf(
+            "sampleRate" to 16000, // Common speech sample rate
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "communication"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Sample rate should be 16000", 16000, config.sampleRate)
+        assertEquals("Audio focus strategy should be communication", "communication", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testDefaultRecordingConfigValues() {
+        val result = RecordingConfig.fromMap(null)
+        assertTrue("Config creation should succeed with null input", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertNull("Default audio focus strategy should be null", config.audioFocusStrategy)
+        assertTrue("Default keepAwake should be true", config.keepAwake)
+        assertFalse("Default autoResumeAfterInterruption should be false", config.autoResumeAfterInterruption)
+    }
+
+    @Test
+    fun testRecordingConfigCompleteAudioFocusConfiguration() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to true,
+            "autoResumeAfterInterruption" to true,
+            "showNotification" to true,
+            "android" to mapOf(
+                "audioFocusStrategy" to "background"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
+        assertTrue("keepAwake should be true", config.keepAwake)
+        assertTrue("autoResumeAfterInterruption should be true", config.autoResumeAfterInterruption)
+        assertTrue("showNotification should be true", config.showNotification)
+    }
+}

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

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

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

@@ -0,0 +1,140 @@
+package net.siteed.audiostream
+
+import org.junit.Assert.*
+import org.junit.Test
+
+/**
+ * Unit test for Device Disconnection Fallback Behavior
+ * 
+ * Tests the configuration and expected behavior for device disconnection scenarios.
+ */
+class DeviceDisconnectionFallbackUnitTest {
+
+    @Test
+    fun `test RecordingConfig stores deviceDisconnectionBehavior correctly`() {
+        // Test fallback behavior
+        val fallbackConfig = RecordingConfig(
+            sampleRate = 44100,
+            channels = 1,
+            encoding = "pcm_16bit",
+            deviceDisconnectionBehavior = "fallback"
+        )
+        
+        assertEquals("Should store fallback behavior", "fallback", fallbackConfig.deviceDisconnectionBehavior)
+        
+        // Test pause behavior
+        val pauseConfig = RecordingConfig(
+            sampleRate = 44100,
+            channels = 1,
+            encoding = "pcm_16bit",
+            deviceDisconnectionBehavior = "pause"
+        )
+        
+        assertEquals("Should store pause behavior", "pause", pauseConfig.deviceDisconnectionBehavior)
+        
+        // Test default behavior (should be null)
+        val defaultConfig = RecordingConfig(
+            sampleRate = 44100,
+            channels = 1,
+            encoding = "pcm_16bit"
+        )
+        
+        assertNull("Default behavior should be null", defaultConfig.deviceDisconnectionBehavior)
+    }
+
+    @Test
+    fun `test AudioRecorderManager stores deviceDisconnectionBehavior`() {
+        val config = RecordingConfig(
+            sampleRate = 44100,
+            channels = 1,
+            encoding = "pcm_16bit",
+            deviceDisconnectionBehavior = "fallback"
+        )
+        
+        // Verify the config has the correct behavior
+        assertEquals("fallback", config.deviceDisconnectionBehavior)
+        
+        // AudioRecorderManager should use this configuration
+        // The actual AudioRecorderManager.getDeviceDisconnectionBehavior() 
+        // will return this value when recording is started with this config
+    }
+
+    @Test
+    fun `test device disconnection behavior values`() {
+        val validBehaviors = listOf("fallback", "pause")
+        
+        for (behavior in validBehaviors) {
+            val config = RecordingConfig(
+                sampleRate = 44100,
+                channels = 1,
+                encoding = "pcm_16bit",
+                deviceDisconnectionBehavior = behavior
+            )
+            
+            assertEquals("Should accept $behavior behavior", behavior, config.deviceDisconnectionBehavior)
+        }
+    }
+
+    @Test
+    fun `test interruption event reasons`() {
+        // Test expected event reasons for device disconnection scenarios
+        val expectedReasons = mapOf(
+            "fallback" to listOf("deviceFallback", "deviceSwitchFailed"),
+            "pause" to listOf("deviceDisconnected")
+        )
+        
+        // Verify the expected reasons are valid strings
+        expectedReasons.forEach { (behavior, reasons) ->
+            assertNotNull("Behavior $behavior should have reasons", reasons)
+            assertTrue("Behavior $behavior should have at least one reason", reasons.isNotEmpty())
+            
+            reasons.forEach { reason ->
+                assertNotNull("Reason should not be null", reason)
+                assertTrue("Reason should not be empty", reason.isNotEmpty())
+            }
+        }
+    }
+
+    @Test
+    fun `test fallback behavior logic`() {
+        // Test the logic for fallback behavior
+        val behavior = "fallback"
+        
+        // When behavior is fallback:
+        // 1. Should attempt to get default device
+        // 2. If default device exists, should select it
+        // 3. If selection succeeds, should send "deviceFallback" event
+        // 4. If selection fails, should pause and send "deviceSwitchFailed" event
+        // 5. If no default device, should pause and send "deviceDisconnected" event
+        
+        when (behavior) {
+            "fallback" -> {
+                // This branch should be taken
+                assertTrue("Should handle fallback behavior", true)
+            }
+            else -> {
+                fail("Should not reach default case for fallback behavior")
+            }
+        }
+    }
+
+    @Test
+    fun `test pause behavior logic`() {
+        // Test the logic for pause behavior
+        val behavior = "pause"
+        
+        // When behavior is pause:
+        // 1. Should pause recording immediately
+        // 2. Should send "deviceDisconnected" event
+        
+        when (behavior) {
+            "fallback" -> {
+                fail("Should not handle as fallback")
+            }
+            else -> {
+                // This branch should be taken for pause
+                assertTrue("Should handle pause behavior", true)
+            }
+        }
+    }
+}