@siteed/audio-studio 3.2.0-beta.1 → 3.2.0

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

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

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

@@ -1,218 +0,0 @@
-package net.siteed.audiostudio.integration
-
-import android.content.Context
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import net.siteed.audiostudio.OutputConfig
-import net.siteed.audiostudio.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
-        // AudioStudioModule 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")
-    }
-}

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

@@ -1,120 +0,0 @@
-package net.siteed.audiostudio.integration
-
-import android.os.Bundle
-import android.util.Log
-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
-import kotlin.math.abs
-
-/**
- * Integration test to validate event emission interval enforcement.
- * 
- * This test verifies that the configured intervals respect platform
- * minimums to prevent excessive CPU usage.
- */
-@RunWith(AndroidJUnit4::class)
-class EventEmissionIntervalTest {
-
-    private val TAG = "EventEmissionIntervalTest"
-    private val context = InstrumentationRegistry.getInstrumentation().targetContext
-
-    @Test
-    fun testMinimumIntervalEnforcement() {
-        println("🧪 Test: Minimum Interval Enforcement")
-        println("------------------------------------")
-        
-        // Test cases for different requested intervals
-        val testCases = listOf(
-            5 to 10,    // 5ms should be clamped to MIN_INTERVAL (10ms)
-            10 to 10,   // 10ms should remain 10ms
-            50 to 50,   // 50ms should remain 50ms
-            100 to 100  // 100ms should remain 100ms
-        )
-        
-        for ((requested, expected) in testCases) {
-            val config = Bundle().apply {
-                putInt("sampleRate", 48000)
-                putInt("channels", 1)
-                putLong("interval", requested.toLong())
-                putLong("intervalAnalysis", requested.toLong())
-            }
-            
-            // Parse the config to validate interval enforcement
-            val configMap = bundleToMap(config)
-            val result = net.siteed.audiostudio.RecordingConfig.fromMap(configMap)
-            
-            assertTrue("Config parsing should succeed", result.isSuccess)
-            val (recordingConfig, _) = result.getOrNull()!!
-            
-            println("Requested interval: ${requested}ms")
-            println("Actual interval: ${recordingConfig.interval}ms")
-            println("Expected interval: ${expected}ms")
-            
-            assertEquals(
-                "Interval should be clamped to minimum if below MIN_INTERVAL",
-                expected.toLong(),
-                recordingConfig.interval
-            )
-            
-            assertEquals(
-                "Analysis interval should be clamped to minimum if below MIN_INTERVAL",
-                expected.toLong(),
-                recordingConfig.intervalAnalysis
-            )
-            
-            println("✓ Passed\n")
-        }
-    }
-    
-    @Test
-    fun testIntervalConsistencyAcrossPlatforms() {
-        println("🧪 Test: Platform Consistency Check")
-        println("----------------------------------")
-        
-        // Document the expected behavior across platforms
-        println("Expected behavior after fix:")
-        println("- iOS: Minimum interval = 10ms")
-        println("- Android: Minimum interval = 10ms (enforced)")
-        println("")
-        
-        // Verify Android enforces the minimum
-        val intervals = listOf(1, 5, 10, 50, 100)
-        for (interval in intervals) {
-            val config = Bundle().apply {
-                putLong("interval", interval.toLong())
-                putLong("intervalAnalysis", interval.toLong())
-            }
-            
-            val configMap = bundleToMap(config)
-            val result = net.siteed.audiostudio.RecordingConfig.fromMap(configMap)
-            val (recordingConfig, _) = result.getOrNull()!!
-            
-            val expectedInterval = maxOf(10, interval).toLong()
-            assertEquals(
-                "Android should enforce MIN_INTERVAL of 10ms",
-                expectedInterval,
-                recordingConfig.interval
-            )
-            
-            println("✓ Interval ${interval}ms -> ${recordingConfig.interval}ms")
-        }
-    }
-
-    /**
-     * Helper to convert Bundle to Map for RecordingConfig
-     */
-    private fun bundleToMap(bundle: Bundle): Map<String, Any?> {
-        val map = mutableMapOf<String, Any?>()
-        for (key in bundle.keySet()) {
-            when (val value = bundle.get(key)) {
-                is Bundle -> map[key] = bundleToMap(value)
-                else -> map[key] = value
-            }
-        }
-        return map
-    }
-}