@siteed/expo-audio-studio 2.18.5 → 3.0.0

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

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

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