@siteed/expo-audio-studio 2.18.6 → 3.0.1

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

@@ -1,324 +0,0 @@
-package net.siteed.audiostream.integration
-
-import android.media.AudioFormat
-import android.media.AudioRecord
-import android.media.MediaRecorder
-import android.os.Build
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import org.junit.After
-import org.junit.Before
-import org.junit.Test
-import org.junit.runner.RunWith
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-import kotlin.math.abs
-
-/**
- * Integration test for Buffer Duration feature
- * This tests the ACTUAL behavior of Android AudioRecord with different buffer sizes
- */
-@RunWith(AndroidJUnit4::class)
-class BufferDurationIntegrationTest {
-    
-    private val context = InstrumentationRegistry.getInstrumentation().targetContext
-    private val results = mutableListOf<TestResult>()
-    private var audioRecord: AudioRecord? = null
-    
-    data class TestResult(
-        val name: String,
-        val passed: Boolean,
-        val message: String
-    )
-    
-    @Before
-    fun setup() {
-        println("🧪 Buffer Duration Integration Test")
-        println("===================================\n")
-    }
-    
-    @After
-    fun tearDown() {
-        audioRecord?.release()
-        printResults()
-    }
-    
-    @Test
-    fun testDefaultBufferSize() {
-        println("Test 1: Default Buffer Size")
-        println("---------------------------")
-        
-        val sampleRate = 48000
-        val channelConfig = AudioFormat.CHANNEL_IN_MONO
-        val audioFormat = AudioFormat.ENCODING_PCM_16BIT
-        
-        // Get minimum buffer size
-        val minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat)
-        println("✓ Android minimum buffer size: $minBufferSize bytes")
-        
-        // Calculate frames from bytes (16-bit = 2 bytes per sample)
-        val minFrames = minBufferSize / 2
-        println("✓ Minimum frames: $minFrames")
-        
-        // Test with default 1024 frames (2048 bytes)
-        val requestedBytes = 1024 * 2
-        val actualBufferSize = if (requestedBytes < minBufferSize) minBufferSize else requestedBytes
-        
-        audioRecord = AudioRecord(
-            MediaRecorder.AudioSource.MIC,
-            sampleRate,
-            channelConfig,
-            audioFormat,
-            actualBufferSize
-        )
-        
-        val state = audioRecord?.state
-        val passed = state == AudioRecord.STATE_INITIALIZED
-        
-        results.add(TestResult(
-            name = "Default Buffer Size",
-            passed = passed,
-            message = "Requested: 1024 frames, Min required: $minFrames frames, State: ${if (passed) "INITIALIZED" else "UNINITIALIZED"}"
-        ))
-        
-        println("✓ Requested: 1024 frames (${requestedBytes} bytes)")
-        println("✓ Actual buffer: ${actualBufferSize / 2} frames ($actualBufferSize bytes)")
-        println("✓ Initialization: ${if (passed) "SUCCESS" else "FAILED"}\n")
-    }
-    
-    @Test
-    fun testCustomBufferSizes() {
-        println("Test 2: Custom Buffer Sizes")
-        println("---------------------------")
-        
-        val sampleRate = 48000
-        val channelConfig = AudioFormat.CHANNEL_IN_MONO
-        val audioFormat = AudioFormat.ENCODING_PCM_16BIT
-        val minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat)
-        
-        val testCases = listOf(
-            0.01 to "10ms",
-            0.05 to "50ms",
-            0.1 to "100ms",
-            0.2 to "200ms",
-            0.5 to "500ms"
-        )
-        
-        for ((duration, name) in testCases) {
-            val requestedFrames = (duration * sampleRate).toInt()
-            val requestedBytes = requestedFrames * 2 // 16-bit = 2 bytes
-            val actualBufferSize = if (requestedBytes < minBufferSize) minBufferSize else requestedBytes
-            
-            audioRecord?.release()
-            audioRecord = AudioRecord(
-                MediaRecorder.AudioSource.MIC,
-                sampleRate,
-                channelConfig,
-                audioFormat,
-                actualBufferSize
-            )
-            
-            val state = audioRecord?.state
-            val passed = state == AudioRecord.STATE_INITIALIZED
-            
-            // Test actual read behavior
-            if (passed) {
-                audioRecord?.startRecording()
-                val buffer = ByteArray(requestedBytes)
-                val bytesRead = audioRecord?.read(buffer, 0, buffer.size) ?: -1
-                audioRecord?.stop()
-                
-                val framesRead = if (bytesRead > 0) bytesRead / 2 else 0
-                
-                results.add(TestResult(
-                    name = "Buffer $name",
-                    passed = bytesRead > 0,
-                    message = "Requested: $requestedFrames frames, Read: $framesRead frames"
-                ))
-                
-                println("  $name: Requested $requestedFrames → Read $framesRead frames")
-            } else {
-                results.add(TestResult(
-                    name = "Buffer $name",
-                    passed = false,
-                    message = "Failed to initialize AudioRecord"
-                ))
-                println("  $name: Failed to initialize")
-            }
-        }
-        println()
-    }
-    
-    @Test
-    fun testBufferSizeLimits() {
-        println("Test 3: Buffer Size Limits")
-        println("--------------------------")
-        
-        val sampleRate = 48000
-        val channelConfig = AudioFormat.CHANNEL_IN_MONO
-        val audioFormat = AudioFormat.ENCODING_PCM_16BIT
-        
-        val extremeCases = listOf(
-            100 to "Very small (100 frames)",
-            50000 to "Very large (50000 frames)"
-        )
-        
-        for ((frames, name) in extremeCases) {
-            val requestedBytes = frames * 2
-            val minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat)
-            val actualBufferSize = if (requestedBytes < minBufferSize) minBufferSize else requestedBytes
-            
-            audioRecord?.release()
-            audioRecord = AudioRecord(
-                MediaRecorder.AudioSource.MIC,
-                sampleRate,
-                channelConfig,
-                audioFormat,
-                actualBufferSize
-            )
-            
-            val state = audioRecord?.state
-            val passed = state == AudioRecord.STATE_INITIALIZED
-            
-            results.add(TestResult(
-                name = name,
-                passed = passed,
-                message = "Requested: $frames frames, Buffer size: ${actualBufferSize / 2} frames"
-            ))
-            
-            println("  $name: $frames → ${actualBufferSize / 2} frames")
-        }
-        println()
-    }
-    
-    @Test
-    fun testBufferAccumulation() {
-        println("Test 4: Buffer Accumulation for Small Durations")
-        println("-----------------------------------------------")
-        
-        val sampleRate = 48000
-        val channelConfig = AudioFormat.CHANNEL_IN_MONO
-        val audioFormat = AudioFormat.ENCODING_PCM_16BIT
-        val minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat)
-        
-        // Test very small buffer (20ms = 960 frames)
-        val targetDuration = 0.02 // 20ms
-        val targetFrames = (targetDuration * sampleRate).toInt()
-        val targetBytes = targetFrames * 2
-        
-        audioRecord?.release()
-        audioRecord = AudioRecord(
-            MediaRecorder.AudioSource.MIC,
-            sampleRate,
-            channelConfig,
-            audioFormat,
-            minBufferSize // Use minimum buffer size
-        )
-        
-        if (audioRecord?.state == AudioRecord.STATE_INITIALIZED) {
-            audioRecord?.startRecording()
-            
-            // Accumulate small chunks
-            val accumulator = mutableListOf<ByteArray>()
-            var totalFrames = 0
-            val smallBuffer = ByteArray(targetBytes)
-            
-            // Read multiple times to accumulate
-            repeat(5) {
-                val bytesRead = audioRecord?.read(smallBuffer, 0, smallBuffer.size) ?: -1
-                if (bytesRead > 0) {
-                    accumulator.add(smallBuffer.copyOf(bytesRead))
-                    totalFrames += bytesRead / 2
-                }
-            }
-            
-            audioRecord?.stop()
-            
-            val passed = totalFrames >= targetFrames
-            results.add(TestResult(
-                name = "Buffer Accumulation",
-                passed = passed,
-                message = "Target: $targetFrames frames, Accumulated: $totalFrames frames over ${accumulator.size} reads"
-            ))
-            
-            println("✓ Target frames: $targetFrames")
-            println("✓ Accumulated: $totalFrames frames")
-            println("✓ Number of reads: ${accumulator.size}")
-        } else {
-            results.add(TestResult(
-                name = "Buffer Accumulation",
-                passed = false,
-                message = "Failed to initialize AudioRecord"
-            ))
-        }
-        println()
-    }
-    
-    @Test
-    fun testDifferentSampleRates() {
-        println("Test 5: Different Sample Rates")
-        println("------------------------------")
-        
-        val channelConfig = AudioFormat.CHANNEL_IN_MONO
-        val audioFormat = AudioFormat.ENCODING_PCM_16BIT
-        val bufferDuration = 0.1 // 100ms
-        
-        val sampleRates = listOf(16000, 44100, 48000)
-        
-        for (sampleRate in sampleRates) {
-            val minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat)
-            val targetFrames = (bufferDuration * sampleRate).toInt()
-            val targetBytes = targetFrames * 2
-            val actualBufferSize = if (targetBytes < minBufferSize) minBufferSize else targetBytes
-            
-            audioRecord?.release()
-            audioRecord = AudioRecord(
-                MediaRecorder.AudioSource.MIC,
-                sampleRate,
-                channelConfig,
-                audioFormat,
-                actualBufferSize
-            )
-            
-            val state = audioRecord?.state
-            val passed = state == AudioRecord.STATE_INITIALIZED
-            
-            results.add(TestResult(
-                name = "Sample Rate ${sampleRate}Hz",
-                passed = passed,
-                message = "Buffer duration: ${bufferDuration}s, Frames: ${actualBufferSize / 2}"
-            ))
-            
-            println("  ${sampleRate}Hz: ${if (passed) "SUCCESS" else "FAILED"} - ${actualBufferSize / 2} frames")
-        }
-        println()
-    }
-    
-    private fun printResults() {
-        println("📊 Test Results")
-        println("===============")
-        
-        val passed = results.count { it.passed }
-        val total = results.size
-        
-        for (result in results) {
-            val status = if (result.passed) "✅" else "❌"
-            println("$status ${result.name}")
-            println("   ${result.message}")
-        }
-        
-        println("\nSummary: $passed/$total tests passed")
-        
-        if (passed == total) {
-            println("🎉 All tests passed!")
-        } else {
-            println("⚠️  Some tests failed")
-        }
-        
-        println("\n📝 Key Findings:")
-        println("- Android enforces minimum buffer size via getMinBufferSize()")
-        println("- Minimum varies by device and sample rate")
-        println("- Small buffers require accumulation strategy")
-        println("- AudioRecord handles buffer sizing more flexibly than iOS")
-    }
-} 

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

@@ -1,253 +0,0 @@
-package net.siteed.audiostream.integration
-
-import android.os.Bundle
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.junit.Assert.*
-import java.io.File
-
-/**
- * Integration test for Compressed-Only Output (Issue #244)
- * 
- * This test validates that when primary output is disabled and compressed output
- * is enabled, the compressed file information is properly returned in the result.
- */
-@RunWith(AndroidJUnit4::class)
-class CompressedOnlyOutputTest {
-
-    private val context = InstrumentationRegistry.getInstrumentation().targetContext
-
-    @Test
-    fun testCompressedOnlyOutput_AAC() {
-        println("🧪 Test: Compressed-Only Output with AAC")
-        println("---------------------------------------")
-
-        // Configuration with primary disabled, compressed enabled
-        val config = Bundle().apply {
-            putInt("sampleRate", 44100)
-            putInt("channels", 1)
-            putString("encoding", "pcm_16bit")
-            
-            val outputBundle = Bundle().apply {
-                val primaryBundle = Bundle().apply {
-                    putBoolean("enabled", false)
-                }
-                val compressedBundle = Bundle().apply {
-                    putBoolean("enabled", true)
-                    putString("format", "aac")
-                    putInt("bitrate", 128000)
-                }
-                putBundle("primary", primaryBundle)
-                putBundle("compressed", compressedBundle)
-            }
-            putBundle("output", outputBundle)
-        }
-
-        // Simulate recording result
-        val result = simulateRecording(config)
-
-        // Verify compression info is present
-        val compressionBundle = result.getBundle("compression")
-        assertNotNull("Compression info should not be null", compressionBundle)
-
-        // Verify compressed file URI is provided
-        val compressedFileUri = compressionBundle?.getString("compressedFileUri")
-        assertNotNull("Compressed file URI should not be null", compressedFileUri)
-        assertNotEquals("Compressed file URI should not be empty", "", compressedFileUri)
-
-        // Verify format and bitrate
-        assertEquals("aac", compressionBundle?.getString("format"))
-        assertEquals(128000, compressionBundle?.getInt("bitrate"))
-
-        println("✅ Compression info properly returned")
-        println("✅ Compressed file URI: $compressedFileUri")
-        println("✅ Format: ${compressionBundle?.getString("format")}")
-        println()
-    }
-
-    @Test
-    fun testCompressedOnlyOutput_Opus() {
-        println("🧪 Test: Compressed-Only Output with Opus")
-        println("----------------------------------------")
-
-        val config = Bundle().apply {
-            putInt("sampleRate", 48000)
-            putInt("channels", 1)
-            putString("encoding", "pcm_16bit")
-            
-            val outputBundle = Bundle().apply {
-                val primaryBundle = Bundle().apply {
-                    putBoolean("enabled", false)
-                }
-                val compressedBundle = Bundle().apply {
-                    putBoolean("enabled", true)
-                    putString("format", "opus")
-                    putInt("bitrate", 64000)
-                }
-                putBundle("primary", primaryBundle)
-                putBundle("compressed", compressedBundle)
-            }
-            putBundle("output", outputBundle)
-        }
-
-        val result = simulateRecording(config)
-        val compressionBundle = result.getBundle("compression")
-
-        assertNotNull("Compression info should not be null", compressionBundle)
-        assertEquals("opus", compressionBundle?.getString("format"))
-        assertEquals(64000, compressionBundle?.getInt("bitrate"))
-
-        println("✅ Opus compression properly configured")
-        println()
-    }
-
-    @Test
-    fun testFileAccessibility() {
-        println("🧪 Test: Verify Compressed File Accessibility")
-        println("--------------------------------------------")
-
-        val config = Bundle().apply {
-            putInt("sampleRate", 44100)
-            putInt("channels", 1)
-            putString("encoding", "pcm_16bit")
-            
-            val outputBundle = Bundle().apply {
-                val primaryBundle = Bundle().apply {
-                    putBoolean("enabled", false)
-                }
-                val compressedBundle = Bundle().apply {
-                    putBoolean("enabled", true)
-                    putString("format", "aac")
-                }
-                putBundle("primary", primaryBundle)
-                putBundle("compressed", compressedBundle)
-            }
-            putBundle("output", outputBundle)
-        }
-
-        val result = simulateRecording(config)
-
-        // Check main result structure
-        val fileUri = result.getString("fileUri", "")
-        val filename = result.getString("filename", "")
-        
-        // Check compression structure
-        val compressionBundle = result.getBundle("compression")
-        val compressedUri = compressionBundle?.getString("compressedFileUri")
-        val compressedSize = compressionBundle?.getLong("size", 0L) ?: 0L
-
-        // When primary is disabled, we should have access to compressed file
-        val hasAccessToCompressed = !compressedUri.isNullOrEmpty() || fileUri.isNotEmpty()
-        
-        assertTrue("Should have access to compressed file", hasAccessToCompressed)
-        assertTrue("Compressed file should have size > 0", compressedSize > 0)
-
-        println("✅ Compressed file is accessible")
-        println("✅ File size reported: $compressedSize bytes")
-        println()
-    }
-
-    @Test
-    fun testBugScenario() {
-        println("🧪 Test: Current Bug Scenario")
-        println("-----------------------------")
-        
-        // This test demonstrates the current bug
-        val config = Bundle().apply {
-            putInt("sampleRate", 44100)
-            putInt("channels", 1)
-            putString("encoding", "pcm_16bit")
-            
-            val outputBundle = Bundle().apply {
-                val primaryBundle = Bundle().apply {
-                    putBoolean("enabled", false)
-                }
-                val compressedBundle = Bundle().apply {
-                    putBoolean("enabled", true)
-                    putString("format", "aac")
-                    putInt("bitrate", 128000)
-                }
-                putBundle("primary", primaryBundle)
-                putBundle("compressed", compressedBundle)
-            }
-            putBundle("output", outputBundle)
-        }
-
-        // Current buggy behavior
-        val buggyResult = simulateBuggyRecording(config)
-        
-        // This is what currently happens - compression is null
-        val compressionBundle = buggyResult.getBundle("compression")
-        
-        if (compressionBundle == null) {
-            println("❌ BUG CONFIRMED: Compression info is null when primary is disabled")
-            println("   This prevents users from accessing the compressed file")
-        } else {
-            println("✅ Bug appears to be fixed - compression info is present")
-        }
-        println()
-    }
-
-    /**
-     * Simulates the expected correct behavior after fix
-     */
-    private fun simulateRecording(config: Bundle): Bundle {
-        val outputConfig = config.getBundle("output")
-        val primaryEnabled = outputConfig?.getBundle("primary")?.getBoolean("enabled", true) ?: true
-        val compressedConfig = outputConfig?.getBundle("compressed")
-        val compressedEnabled = compressedConfig?.getBoolean("enabled", false) ?: false
-
-        return Bundle().apply {
-            if (!primaryEnabled) {
-                // Expected behavior after fix
-                putString("fileUri", "")
-                putString("filename", "stream-only")
-                putLong("durationMs", 5000)
-                putLong("size", 0)
-                putString("mimeType", "audio/wav")
-                
-                // FIXED: Include compression info when compressed is enabled
-                if (compressedEnabled) {
-                    val compressionBundle = Bundle().apply {
-                        putString("compressedFileUri", "file:///storage/emulated/0/Android/data/test/files/recording.aac")
-                        putString("format", compressedConfig?.getString("format") ?: "aac")
-                        putInt("bitrate", compressedConfig?.getInt("bitrate") ?: 128000)
-                        putLong("size", 40000)
-                        putString("mimeType", "audio/aac")
-                    }
-                    putBundle("compression", compressionBundle)
-                }
-            } else {
-                // Normal behavior
-                putString("fileUri", "file:///storage/emulated/0/Android/data/test/files/recording.wav")
-                putString("filename", "recording.wav")
-                putLong("durationMs", 5000)
-                putLong("size", 240000)
-                putString("mimeType", "audio/wav")
-            }
-        }
-    }
-
-    /**
-     * Simulates the current buggy behavior
-     */
-    private fun simulateBuggyRecording(config: Bundle): Bundle {
-        val outputConfig = config.getBundle("output")
-        val primaryEnabled = outputConfig?.getBundle("primary")?.getBoolean("enabled", true) ?: true
-
-        return Bundle().apply {
-            if (!primaryEnabled) {
-                // Current buggy behavior
-                putString("fileUri", "")
-                putString("filename", "stream-only")
-                putLong("durationMs", 5000)
-                putLong("size", 0)
-                putString("mimeType", "audio/wav")
-                // BUG: compression is null even when compressed output is enabled
-                putBundle("compression", null)
-            }
-        }
-    }
-}