@siteed/audio-studio 3.0.0

package/android/src/androidTest/java/net/siteed/audiostudio/AudioRecorderPerformanceInstrumentedTest.kt

@@ -0,0 +1,234 @@
+package net.siteed.audiostudio
+
+import android.Manifest
+import android.content.Context
+import android.util.Log
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.rule.GrantPermissionRule
+import expo.modules.kotlin.Promise
+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
+import kotlin.system.measureTimeMillis
+
+/**
+ * Performance tests for measuring stop recording times.
+ */
+@RunWith(AndroidJUnit4::class)
+class AudioRecorderPerformanceInstrumentedTest {
+    
+    @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
+    
+    companion object {
+        private const val TAG = "PerformanceTest"
+    }
+    
+    // Test event sender to capture events
+    private class TestEventSender : EventSender {
+        override fun sendExpoEvent(eventName: String, params: android.os.Bundle) {
+            // No-op for performance 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) {
+            val promise = object : Promise {
+                override fun resolve(value: Any?) {}
+                override fun reject(code: String, message: String?, cause: Throwable?) {}
+            }
+            audioRecorderManager.stopRecording(promise)
+        }
+        
+        // Clean up
+        AudioRecorderManager.destroy()
+        cleanupAudioFiles()
+    }
+    
+    private fun cleanupAudioFiles() {
+        filesDir.listFiles()?.forEach { file ->
+            if (file.name.endsWith(".wav") || file.name.endsWith(".aac") || file.name.endsWith(".opus")) {
+                file.delete()
+            }
+        }
+    }
+    
+    @Test
+    fun measureStopTime_5seconds() {
+        runPerformanceTest(5_000L, "5 second recording")
+    }
+    
+    @Test
+    fun measureStopTime_30seconds() {
+        runPerformanceTest(30_000L, "30 second recording")
+    }
+    
+    @Test
+    fun measureStopTime_1minute() {
+        runPerformanceTest(60_000L, "1 minute recording")
+    }
+    
+    @Test
+    fun measureStopTime_2minutes() {
+        runPerformanceTest(120_000L, "2 minute recording")
+    }
+    
+    @Test
+    fun measureStopTime_5minutes() {
+        runPerformanceTest(300_000L, "5 minute recording")
+    }
+    
+    @Test
+    fun measureStopTime_10minutes() {
+        runPerformanceTest(600_000L, "10 minute recording")
+    }
+    
+    @Test
+    fun measureStopTime_15minutes() {
+        runPerformanceTest(900_000L, "15 minute recording")
+    }
+    
+    private fun runPerformanceTest(recordingDurationMs: Long, testName: String) {
+        val recordingOptions = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "interval" to 1000,
+            "enableProcessing" to false,
+            "showNotification" to false,
+            "output" to mapOf(
+                "primary" to mapOf("enabled" to true),
+                "compressed" to mapOf("enabled" to false)
+            )
+        )
+        
+        // Start recording
+        val startLatch = CountDownLatch(1)
+        audioRecorderManager.startRecording(recordingOptions, object : Promise {
+            override fun resolve(value: Any?) {
+                startLatch.countDown()
+            }
+            override fun reject(code: String, message: String?, cause: Throwable?) {
+                fail("Start recording failed: $message")
+            }
+        })
+        
+        assertTrue("Recording should start", startLatch.await(5, TimeUnit.SECONDS))
+        assertTrue("Recording should be active", audioRecorderManager.isRecording)
+        
+        // Record for specified duration
+        Thread.sleep(recordingDurationMs)
+        
+        // Measure stop time
+        val stopLatch = CountDownLatch(1)
+        var fileSize = 0L
+        var stopResult: Map<String, Any>? = null
+        
+        val stopDuration = measureTimeMillis {
+            audioRecorderManager.stopRecording(object : Promise {
+                override fun resolve(value: Any?) {
+                    when (value) {
+                        is android.os.Bundle -> {
+                            fileSize = value.getLong("size", 0)
+                            stopResult = bundleToMap(value)
+                        }
+                        is Map<*, *> -> {
+                            @Suppress("UNCHECKED_CAST")
+                            stopResult = value as? Map<String, Any>
+                            fileSize = (stopResult?.get("size") as? Long) ?: 0
+                        }
+                    }
+                    stopLatch.countDown()
+                }
+                override fun reject(code: String, message: String?, cause: Throwable?) {
+                    fail("Stop recording failed: $message")
+                }
+            })
+            
+            assertTrue("Stop should complete", stopLatch.await(10, TimeUnit.SECONDS))
+        }
+        
+        // Log results
+        val fileSizeMB = fileSize / (1024.0 * 1024.0)
+        Log.i(TAG, """
+            Performance Test: $testName
+            - Recording Duration: ${recordingDurationMs}ms
+            - Stop Duration: ${stopDuration}ms
+            - File Size: ${"%.2f".format(fileSizeMB)}MB
+            - Performance: ${if (stopDuration < getTargetTime(recordingDurationMs)) "PASS" else "FAIL"}
+        """.trimIndent())
+        
+        println("""
+            Performance Test: $testName
+            - Recording Duration: ${recordingDurationMs}ms
+            - Stop Duration: ${stopDuration}ms
+            - File Size: ${"%.2f".format(fileSizeMB)}MB
+            - Performance: ${if (stopDuration < getTargetTime(recordingDurationMs)) "PASS" else "FAIL"}
+        """.trimIndent())
+        
+        assertFalse("Recording should not be active", audioRecorderManager.isRecording)
+    }
+    
+    private fun getTargetTime(recordingDurationMs: Long): Long {
+        return when {
+            recordingDurationMs <= 5_000 -> 100
+            recordingDurationMs <= 30_000 -> 150
+            recordingDurationMs <= 60_000 -> 200
+            recordingDurationMs <= 300_000 -> 500
+            else -> 750
+        }
+    }
+    
+    private fun bundleToMap(bundle: android.os.Bundle): Map<String, Any> {
+        val map = mutableMapOf<String, Any>()
+        for (key in bundle.keySet()) {
+            val value = bundle.get(key)
+            when (value) {
+                is android.os.Bundle -> map[key] = bundleToMap(value)
+                else -> value?.let { map[key] = it }
+            }
+        }
+        return map
+    }
+}

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

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