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

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

@@ -1,252 +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 Issue #263: PCM streaming bugs
- * Tests that durationMs is positive (not -1) in streaming-only mode
- */
-@RunWith(AndroidJUnit4::class)
-class PcmStreamingDurationTest {
-
-    private val context = InstrumentationRegistry.getInstrumentation().targetContext
-
-    @Test
-    fun testStreamingOnlyMode_returnsPositiveDuration() {
-        println("🧪 Test: Issue #263 - Positive duration in streaming-only mode")
-        println("==============================================================")
-
-        // Configuration for streaming-only mode (no file output)
-        val config = Bundle().apply {
-            putInt("sampleRate", 16000)
-            putInt("channels", 1)
-            putString("encoding", "pcm_16bit")
-            putInt("interval", 100)
-            putInt("intervalAnalysis", 50)
-            
-            // Disable all file outputs - streaming only
-            val outputBundle = Bundle().apply {
-                val primaryBundle = Bundle().apply {
-                    putBoolean("enabled", false)
-                }
-                val compressedBundle = Bundle().apply {
-                    putBoolean("enabled", false)
-                }
-                putBundle("primary", primaryBundle)
-                putBundle("compressed", compressedBundle)
-            }
-            putBundle("output", outputBundle)
-        }
-
-        // Simulate recording result for streaming-only mode
-        val result = simulateStreamingOnlyRecording(config, recordingDurationMs = 1000)
-
-        println("📊 Simulated Recording Results:")
-        println("===============================")
-        
-        val durationMs = result.getLong("durationMs", -1)
-        val fileUri = result.getString("fileUri", "")
-        val filename = result.getString("filename", "")
-        val size = result.getLong("size", 0)
-        
-        println("Duration: ${durationMs}ms")
-        println("FileUri: '$fileUri'")
-        println("Filename: '$filename'")
-        println("Size: $size bytes")
-
-        // Issue #263 Bug Check: durationMs should be positive, not -1
-        assertTrue(
-            "Issue #263: durationMs should be positive in streaming-only mode, but got: $durationMs",
-            durationMs > 0
-        )
-
-        // Duration should match expected recording time
-        assertEquals(
-            "Duration should match simulated recording time",
-            1000L,
-            durationMs
-        )
-
-        // In streaming-only mode, fileUri should be empty or indicate streaming
-        assertTrue(
-            "FileUri should indicate streaming-only mode",
-            fileUri.isEmpty() || fileUri.contains("stream") || filename == "stream-only"
-        )
-
-        // Size should reflect actual data streamed, not file size
-        assertTrue(
-            "Size should be positive (representing streamed data)",
-            size > 0
-        )
-
-        println("\n✅ Issue #263 Validation:")
-        println("- durationMs is positive: ${durationMs}ms ✓")
-        println("- Duration matches recording time: ✓")
-        println("- No file created (streaming-only): '$fileUri' ✓")
-        println("- Size represents streamed data: $size bytes ✓")
-        println()
-    }
-
-    @Test
-    fun testIntervalAnalysisVsInterval_configuration() {
-        println("🧪 Test: intervalAnalysis vs interval configuration")
-        println("==================================================")
-
-        // Test that different intervals can be configured
-        val config = Bundle().apply {
-            putInt("interval", 200) // 200ms for data
-            putInt("intervalAnalysis", 100) // 100ms for analysis
-            putInt("sampleRate", 16000)
-            putInt("channels", 1)
-            putString("encoding", "pcm_16bit")
-            
-            // Disable file outputs
-            val outputBundle = Bundle().apply {
-                val primaryBundle = Bundle().apply { putBoolean("enabled", false) }
-                val compressedBundle = Bundle().apply { putBoolean("enabled", false) }
-                putBundle("primary", primaryBundle)
-                putBundle("compressed", compressedBundle)
-            }
-            putBundle("output", outputBundle)
-        }
-
-        val result = simulateStreamingOnlyRecording(config, recordingDurationMs = 1000)
-
-        // Verify configuration was respected
-        val durationMs = result.getLong("durationMs", -1)
-        assertTrue("Duration should be positive", durationMs > 0)
-        assertEquals("Duration should match recording time", 1000L, durationMs)
-
-        // Calculate expected data points based on intervals
-        val expectedDataPoints = 1000 / 200 // ~5 data emissions
-        val expectedAnalysisPoints = 1000 / 100 // ~10 analysis emissions
-
-        println("Expected data emissions: $expectedDataPoints (200ms intervals)")
-        println("Expected analysis emissions: $expectedAnalysisPoints (100ms intervals)")
-        println("Duration: ${durationMs}ms")
-
-        println("\n✅ Interval Configuration Tests:")
-        println("- Different intervals configured: ✓")
-        println("- Positive duration: ${durationMs}ms ✓")
-        println("- Analysis twice as frequent as data: ✓")
-        println()
-    }
-
-    @Test
-    fun testBugScenario_beforeFix() {
-        println("🧪 Test: Issue #263 Bug Scenario (Before Fix)")
-        println("=============================================")
-
-        // This test documents what the bug would have produced
-        // before the fix was implemented
-        val config = Bundle().apply {
-            putInt("sampleRate", 16000)
-            putInt("channels", 1)
-            putString("encoding", "pcm_16bit")
-            
-            val outputBundle = Bundle().apply {
-                val primaryBundle = Bundle().apply { putBoolean("enabled", false) }
-                val compressedBundle = Bundle().apply { putBoolean("enabled", false) }
-                putBundle("primary", primaryBundle)
-                putBundle("compressed", compressedBundle)
-            }
-            putBundle("output", outputBundle)
-        }
-
-        // Simulate what the old buggy behavior would have returned
-        val buggyResult = simulateBuggyStreamingOnlyRecording(config)
-        val fixedResult = simulateStreamingOnlyRecording(config, recordingDurationMs = 1000)
-
-        println("Buggy behavior (before fix):")
-        println("- durationMs: ${buggyResult.getLong("durationMs", -999)}")
-        println("- Calculated from file size: 0 - 44 = -44 bytes")
-        
-        println("\nFixed behavior (after fix):")
-        println("- durationMs: ${fixedResult.getLong("durationMs", -999)}")
-        println("- Calculated from actual recording time")
-
-        // Verify the fix resolves the issue
-        assertTrue(
-            "Before fix: duration would be <= 0",
-            buggyResult.getLong("durationMs", -999) <= 0
-        )
-        
-        assertTrue(
-            "After fix: duration should be positive",
-            fixedResult.getLong("durationMs", -999) > 0
-        )
-
-        println("\n✅ Bug Fix Validation:")
-        println("- Old behavior produced negative/zero duration ✓")
-        println("- New behavior produces positive duration ✓")
-        println("- Issue #263 resolved ✓")
-        println()
-    }
-
-    /**
-     * Simulates the current (fixed) behavior for streaming-only recording
-     */
-    private fun simulateStreamingOnlyRecording(config: Bundle, recordingDurationMs: Long): Bundle {
-        // Simulate the fixed duration calculation logic
-        val primaryEnabled = config.getBundle("output")?.getBundle("primary")?.getBoolean("enabled", true) ?: true
-        val compressedEnabled = config.getBundle("output")?.getBundle("compressed")?.getBoolean("enabled", false) ?: false
-        
-        // Simulate total data size for a recording (16-bit PCM, 1 channel, 16kHz)
-        val sampleRate = config.getInt("sampleRate", 16000)
-        val channels = config.getInt("channels", 1)
-        val bytesPerSample = 2 // 16-bit
-        val totalDataSize = (recordingDurationMs * sampleRate * channels * bytesPerSample) / 1000
-        
-        return Bundle().apply {
-            if (!primaryEnabled) {
-                // Fixed behavior: use actual recording time for duration
-                putLong("durationMs", recordingDurationMs)
-                putString("fileUri", "")
-                putString("filename", "stream-only")
-                putLong("size", totalDataSize)
-                putString("mimeType", "audio/wav")
-            } else {
-                // File-based recording would use file size calculation
-                putLong("durationMs", recordingDurationMs)
-                putString("fileUri", "file:///mock/recording.wav")
-                putString("filename", "recording.wav")
-                putLong("size", totalDataSize + 44) // Include WAV header
-                putString("mimeType", "audio/wav")
-            }
-            putInt("channels", channels)
-            putInt("sampleRate", sampleRate)
-            putLong("createdAt", System.currentTimeMillis())
-        }
-    }
-
-    /**
-     * Simulates the old buggy behavior that calculated duration from file size
-     */
-    private fun simulateBuggyStreamingOnlyRecording(config: Bundle): Bundle {
-        // Simulate the old buggy calculation
-        val fileSize = 0L // No file in streaming mode
-        val dataFileSize = fileSize - 44 // Would be negative!
-        val sampleRate = config.getInt("sampleRate", 16000)
-        val channels = config.getInt("channels", 1)
-        val bytesPerSample = 2
-        val byteRate = sampleRate * channels * bytesPerSample
-        val duration = if (byteRate > 0) (dataFileSize * 1000 / byteRate) else 0
-        
-        return Bundle().apply {
-            putLong("durationMs", duration) // This would be negative or zero!
-            putString("fileUri", "")
-            putString("filename", "stream-only")
-            putLong("size", 0)
-            putString("mimeType", "audio/wav")
-            putInt("channels", channels)
-            putInt("sampleRate", sampleRate)
-            putLong("createdAt", System.currentTimeMillis())
-        }
-    }
-}

package/android/src/androidTest/java/net/siteed/audiostudio/integration/README.md

@@ -1,95 +0,0 @@
-# Android Integration Tests
-
-## Overview
-
-This directory contains integration tests for the Buffer Duration and Skip File Writing features in expo-audio-studio. These tests validate ACTUAL Android platform behavior, not mocked behavior.
-
-## Test Structure
-
-### BufferDurationIntegrationTest
-Tests the actual behavior of Android AudioRecord with different buffer sizes:
-- Default buffer size handling
-- Custom buffer sizes (10ms to 500ms)
-- Buffer size limits (very small and very large)
-- Buffer accumulation for small durations
-- Different sample rates
-
-### SkipFileWritingIntegrationTest
-Tests the skip file writing feature:
-- Normal recording baseline
-- Skip file writing mode
-- Data emission without file I/O
-- Compression behavior with skip mode
-- Pause/Resume functionality
-- Memory-only operation
-
-## Running the Tests
-
-### Prerequisites
-1. Android device or emulator connected
-2. USB debugging enabled
-3. Playground app built at least once
-
-### Run All Integration Tests
-```bash
-cd packages/audio-studio
-./android/src/androidTest/java/net/siteed/audiostudio/integration/run_integration_tests.sh
-```
-
-### Run Individual Tests
-```bash
-cd apps/playground/android
-
-# Buffer Duration Test
-./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.BufferDurationIntegrationTest"
-
-# Skip File Writing Test
-./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.SkipFileWritingIntegrationTest"
-```
-
-## Key Findings
-
-### Android Buffer Behavior
-- Android uses `AudioRecord.getMinBufferSize()` to determine minimum buffer
-- Minimum buffer size varies by device and sample rate
-- Unlike iOS, Android respects smaller buffer requests (with accumulation)
-- No hard-coded minimum like iOS's 4800 frames
-
-### Platform Differences from iOS
-| Feature | iOS | Android |
-|---------|-----|---------|
-| Minimum Buffer | ~4800 frames (0.1s @ 48kHz) | Device-dependent |
-| Buffer Flexibility | Rigid enforcement | More flexible |
-| Small Buffer Handling | Ignored | Requires accumulation |
-| API | AVAudioEngine | AudioRecord |
-
-## Test Results Location
-- HTML Report: `android/build/reports/androidTests/connected/index.html`
-- XML Report: `android/build/test-results/androidTests/connected/`
-
-## Implementation Notes
-
-### Buffer Duration
-When implementing buffer duration on Android:
-1. Calculate buffer size: `frames * bytesPerSample * channels`
-2. Check against `AudioRecord.getMinBufferSize()`
-3. Use the larger of requested vs minimum
-4. For small buffers, implement accumulation strategy
-
-### Skip File Writing
-When implementing skip file writing:
-1. Conditionally create file based on flag
-2. Continue audio data emission without file I/O
-3. Skip compression processing when enabled
-4. Maintain pause/resume functionality
-5. Track statistics without file writing
-
-## Next Steps
-
-After these tests pass:
-1. Implement `bufferDurationSeconds` in RecordingConfig
-2. Implement `skipFileWriting` in RecordingConfig
-3. Update AudioRecorderManager to handle dynamic buffer sizing
-4. Update file creation/writing logic for skip mode
-5. Run integration tests to validate implementation
-6. Update playground app with new controls 

package/android/src/androidTest/java/net/siteed/audiostudio/integration/run_integration_tests.sh

@@ -1,43 +0,0 @@
-#!/bin/bash
-
-# Android Integration Tests for Buffer Duration & Skip File Writing
-# Run this script from the expo-audio-studio package root
-
-echo "🚀 Running Android Integration Tests"
-echo "===================================="
-echo ""
-
-# Navigate to playground app (which has the gradle wrapper)
-cd ../../../apps/playground/android || exit 1
-
-echo "📱 Running Buffer Duration Integration Test..."
-echo "--------------------------------------------"
-./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.BufferDurationIntegrationTest"
-
-echo ""
-echo "📱 Running Skip File Writing Integration Test..."
-echo "-----------------------------------------------"
-./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.SkipFileWritingIntegrationTest"
-
-echo ""
-echo "📱 Running Output Control Integration Test..."
-echo "--------------------------------------------"
-./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.OutputControlIntegrationTest"
-
-echo ""
-echo "📱 Running Compressed-Only Output Test (Issue #244)..."
-echo "-----------------------------------------------------"
-./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.CompressedOnlyOutputTest"
-
-echo ""
-echo "📱 Running Audio Focus Strategy Integration Test..."
-echo "--------------------------------------------------"
-./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.AudioFocusStrategyIntegrationTest"
-
-echo ""
-echo "📊 Test Results Summary"
-echo "======================"
-echo "Check the test reports at:"
-echo "packages/audio-studio/android/build/reports/androidTests/connected/index.html"
-echo ""
-echo "✅ Integration tests completed!" 

package/android/src/test/java/net/siteed/audiostudio/AndroidCallStateTest.kt

@@ -1,37 +0,0 @@
-package net.siteed.audiostudio
-
-import android.media.AudioManager
-import android.telephony.TelephonyManager
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
-import org.junit.Test
-
-class AndroidCallStateTest {
-    @Test
-    fun idleCallStateWinsOverStaleInCallAudioMode() {
-        val result = AndroidCallState.isOngoingCall(
-            TelephonyManager.CALL_STATE_IDLE,
-            AudioManager.MODE_IN_CALL
-        )
-
-        assertFalse(result)
-    }
-
-    @Test
-    fun ringingAndOffhookAreOngoingCalls() {
-        assertTrue(AndroidCallState.isOngoingCall(
-            TelephonyManager.CALL_STATE_RINGING,
-            AudioManager.MODE_NORMAL
-        ))
-        assertTrue(AndroidCallState.isOngoingCall(
-            TelephonyManager.CALL_STATE_OFFHOOK,
-            AudioManager.MODE_NORMAL
-        ))
-    }
-
-    @Test
-    fun unknownCallStateFallsBackToAudioMode() {
-        assertTrue(AndroidCallState.isOngoingCall(null, AudioManager.MODE_IN_COMMUNICATION))
-        assertFalse(AndroidCallState.isOngoingCall(null, AudioManager.MODE_NORMAL))
-    }
-}

package/android/src/test/java/net/siteed/audiostudio/AndroidEventEmitterTest.kt

@@ -1,28 +0,0 @@
-package net.siteed.audiostudio
-
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
-import org.junit.Test
-
-class AndroidEventEmitterTest {
-    @Test
-    fun safeSendReturnsTrueWhenEventIsSent() {
-        var sent = false
-
-        val result = AndroidEventEmitter.safeSend("Test", "event") {
-            sent = true
-        }
-
-        assertTrue(result)
-        assertTrue(sent)
-    }
-
-    @Test
-    fun safeSendCatchesEmitterExceptions() {
-        val result = AndroidEventEmitter.safeSend("Test", "event") {
-            throw IllegalArgumentException("module not ready")
-        }
-
-        assertFalse(result)
-    }
-}