@siteed/expo-audio-studio 2.18.6 → 3.0.1

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

@@ -1,340 +0,0 @@
-package net.siteed.audiostream.integration
-
-import android.media.AudioFormat
-import android.media.AudioRecord
-import android.media.MediaRecorder
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-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
-import java.io.FileOutputStream
-import java.io.RandomAccessFile
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-import kotlin.concurrent.thread
-import kotlin.random.Random
-
-/**
- * Integration test for Output Control feature
- * This tests the ACTUAL behavior of the output configuration in real scenarios
- */
-@RunWith(AndroidJUnit4::class)
-class OutputControlIntegrationTest {
-    private val context = InstrumentationRegistry.getInstrumentation().targetContext
-    private val testDir = File(context.filesDir, "output_control_test_${System.currentTimeMillis()}")
-    private var audioRecord: AudioRecord? = null
-    private var mediaRecorder: MediaRecorder? = null
-    
-    @Before
-    fun setup() {
-        testDir.mkdirs()
-    }
-    
-    @After
-    fun cleanup() {
-        audioRecord?.release()
-        mediaRecorder?.release()
-        testDir.deleteRecursively()
-    }
-    
-    @Test
-    fun testDefaultOutput() {
-        println("Test 1: Default Output (Primary Only)")
-        println("-------------------------------------")
-        
-        val fileUrl = File(testDir, "default_recording.wav")
-        
-        // Simulate default recording (primary enabled, compressed disabled)
-        val success = createMockRecording(fileUrl, primaryEnabled = true, compressedEnabled = false)
-        
-        assertTrue("Recording should succeed", success)
-        assertTrue("Primary file should exist", fileUrl.exists())
-        assertTrue("Primary file should have content", fileUrl.length() > 44) // More than just header
-        
-        println("✓ Primary file created: ${fileUrl.name}")
-        println("✓ File size: ${fileUrl.length()} bytes")
-    }
-    
-    @Test
-    fun testPrimaryOnlyOutput() {
-        println("\nTest 2: Primary Output Only")
-        println("---------------------------")
-        
-        val primaryFile = File(testDir, "primary_only.wav")
-        val compressedFile = File(testDir, "should_not_exist.aac")
-        
-        // Simulate primary only
-        createMockRecording(primaryFile, primaryEnabled = true, compressedEnabled = false)
-        
-        assertTrue("Primary file should exist", primaryFile.exists())
-        assertFalse("Compressed file should not exist", compressedFile.exists())
-        
-        println("✓ Primary file exists: ${primaryFile.exists()}")
-        println("✓ Compressed file exists: ${compressedFile.exists()}")
-        println("✓ Primary-only output working correctly")
-    }
-    
-    @Test
-    fun testCompressedOnlyOutput() {
-        println("\nTest 3: Compressed Output Only")
-        println("------------------------------")
-        
-        val primaryFile = File(testDir, "should_not_exist.wav")
-        val compressedFile = File(testDir, "compressed_only.aac")
-        
-        // Simulate compressed only
-        createMockRecording(compressedFile, primaryEnabled = false, compressedEnabled = true, compressed = true)
-        
-        assertFalse("Primary file should not exist", primaryFile.exists())
-        assertTrue("Compressed file should exist", compressedFile.exists())
-        
-        println("✓ Primary file exists: ${primaryFile.exists()}")
-        println("✓ Compressed file exists: ${compressedFile.exists()}")
-        println("✓ Compressed-only output working correctly")
-    }
-    
-    @Test
-    fun testBothOutputs() {
-        println("\nTest 4: Both Outputs Enabled")
-        println("----------------------------")
-        
-        val primaryFile = File(testDir, "both_primary.wav")
-        val compressedFile = File(testDir, "both_compressed.aac")
-        
-        // Simulate both outputs
-        createMockRecording(primaryFile, primaryEnabled = true, compressedEnabled = true)
-        createMockRecording(compressedFile, primaryEnabled = true, compressedEnabled = true, compressed = true)
-        
-        assertTrue("Primary file should exist", primaryFile.exists())
-        assertTrue("Compressed file should exist", compressedFile.exists())
-        
-        println("✓ Primary file exists: ${primaryFile.exists()}")
-        println("✓ Compressed file exists: ${compressedFile.exists()}")
-        println("✓ Both outputs working correctly")
-    }
-    
-    @Test
-    fun testNoOutputs() {
-        println("\nTest 5: No Outputs (Streaming Only)")
-        println("-----------------------------------")
-        
-        val primaryFile = File(testDir, "no_primary.wav")
-        val compressedFile = File(testDir, "no_compressed.aac")
-        
-        var dataEmitted = false
-        var totalDataSize = 0L
-        var emissionCount = 0
-        
-        // Simulate no file outputs but data emission continues
-        val sampleRate = 48000
-        val channels = 1
-        val encoding = AudioFormat.ENCODING_PCM_16BIT
-        val channelConfig = AudioFormat.CHANNEL_IN_MONO
-        val bufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, encoding)
-        
-        audioRecord = AudioRecord(
-            MediaRecorder.AudioSource.MIC,
-            sampleRate,
-            channelConfig,
-            encoding,
-            bufferSize
-        )
-        
-        if (audioRecord?.state == AudioRecord.STATE_INITIALIZED) {
-            audioRecord?.startRecording()
-            
-            val buffer = ByteArray(bufferSize)
-            val recordingThread = thread {
-                repeat(5) {
-                    val bytesRead = audioRecord?.read(buffer, 0, bufferSize) ?: 0
-                    if (bytesRead > 0) {
-                        dataEmitted = true
-                        totalDataSize += bytesRead
-                        emissionCount++
-                    }
-                    Thread.sleep(100)
-                }
-            }
-            
-            recordingThread.join(2000)
-            audioRecord?.stop()
-        }
-        
-        assertFalse("Primary file should not exist", primaryFile.exists())
-        assertFalse("Compressed file should not exist", compressedFile.exists())
-        assertTrue("Data should be emitted", dataEmitted)
-        assertEquals("Should have 5 emissions", 5, emissionCount)
-        
-        println("✓ Primary file exists: ${primaryFile.exists()}")
-        println("✓ Compressed file exists: ${compressedFile.exists()}")
-        println("✓ Data emissions: $emissionCount")
-        println("✓ Total data size: $totalDataSize bytes")
-        println("✓ Streaming-only mode working correctly")
-    }
-    
-    @Test
-    fun testPauseResumeWithOutputControl() {
-        println("\nTest 6: Pause/Resume with Output Control")
-        println("----------------------------------------")
-        
-        val fileUrl = File(testDir, "pause_resume_test.wav")
-        var isPaused = false
-        var dataEmittedDuringPause = false
-        
-        // Start recording with primary output enabled
-        val sampleRate = 48000
-        val channels = 1
-        val encoding = AudioFormat.ENCODING_PCM_16BIT
-        val channelConfig = AudioFormat.CHANNEL_IN_MONO
-        val bufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, encoding)
-        
-        audioRecord = AudioRecord(
-            MediaRecorder.AudioSource.MIC,
-            sampleRate,
-            channelConfig,
-            encoding,
-            bufferSize
-        )
-        
-        if (audioRecord?.state == AudioRecord.STATE_INITIALIZED) {
-            // Create WAV file with header
-            createWavFile(fileUrl, sampleRate, channels, 16)
-            
-            audioRecord?.startRecording()
-            
-            val buffer = ByteArray(bufferSize)
-            val fos = FileOutputStream(fileUrl, true)
-            
-            // Record for 500ms
-            val recordingThread = thread {
-                var recordingTime = 0L
-                while (recordingTime < 1500) { // Total 1.5 seconds
-                    if (recordingTime == 500L) {
-                        // Pause after 500ms
-                        isPaused = true
-                        audioRecord?.stop()
-                    } else if (recordingTime == 1000L) {
-                        // Resume after 1000ms
-                        isPaused = false
-                        audioRecord?.startRecording()
-                    }
-                    
-                    if (!isPaused) {
-                        val bytesRead = audioRecord?.read(buffer, 0, bufferSize) ?: 0
-                        if (bytesRead > 0) {
-                            fos.write(buffer, 0, bytesRead)
-                        }
-                    } else {
-                        // During pause, AudioRecord is stopped, so we shouldn't try to read
-                        // The fact that we're not reading data means no data is being emitted
-                    }
-                    
-                    Thread.sleep(100)
-                    recordingTime += 100
-                }
-            }
-            
-            recordingThread.join(2000)
-            audioRecord?.stop()
-            fos.close()
-            
-            // Update WAV header
-            updateWavHeader(fileUrl)
-        }
-        
-        assertTrue("File should exist", fileUrl.exists())
-        assertFalse("No data should be emitted during pause", dataEmittedDuringPause)
-        
-        println("✓ Recording with pause/resume completed")
-        println("✓ File size: ${fileUrl.length()} bytes")
-        println("✓ Data emitted during pause: $dataEmittedDuringPause")
-    }
-    
-    // Helper functions
-    
-    private fun createMockRecording(fileUrl: File, primaryEnabled: Boolean, compressedEnabled: Boolean, compressed: Boolean = false): Boolean {
-        return if (!primaryEnabled && !compressed) {
-            // Don't create file if primary is disabled and this is not a compressed file
-            true
-        } else if (compressed && !compressedEnabled) {
-            // Don't create compressed file if compressed output is disabled
-            true
-        } else {
-            // Create the appropriate file
-            if (compressed) {
-                // Create mock compressed file
-                fileUrl.writeBytes(ByteArray(500) { 0xFF.toByte() })
-            } else {
-                // Create mock WAV file
-                createWavFile(fileUrl, 48000, 1, 16)
-                FileOutputStream(fileUrl, true).use { fos ->
-                    fos.write(ByteArray(1000))
-                }
-                updateWavHeader(fileUrl)
-            }
-            true
-        }
-    }
-    
-    private fun createWavFile(file: File, sampleRate: Int, channels: Int, bitDepth: Int) {
-        val header = ByteArray(44)
-        val buffer = ByteBuffer.wrap(header).order(ByteOrder.LITTLE_ENDIAN)
-        
-        // RIFF header
-        buffer.put("RIFF".toByteArray())
-        buffer.putInt(36) // Will be updated later
-        buffer.put("WAVE".toByteArray())
-        
-        // fmt chunk
-        buffer.put("fmt ".toByteArray())
-        buffer.putInt(16) // Subchunk size
-        buffer.putShort(1) // Audio format (PCM)
-        buffer.putShort(channels.toShort())
-        buffer.putInt(sampleRate)
-        buffer.putInt(sampleRate * channels * bitDepth / 8) // Byte rate
-        buffer.putShort((channels * bitDepth / 8).toShort()) // Block align
-        buffer.putShort(bitDepth.toShort())
-        
-        // data chunk
-        buffer.put("data".toByteArray())
-        buffer.putInt(0) // Will be updated later
-        
-        file.writeBytes(header)
-    }
-    
-    private fun updateWavHeader(file: File) {
-        val raf = RandomAccessFile(file, "rw")
-        val fileSize = file.length()
-        val dataSize = fileSize - 44
-        
-        // Update RIFF chunk size
-        raf.seek(4)
-        raf.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt((fileSize - 8).toInt()).array())
-        
-        // Update data chunk size
-        raf.seek(40)
-        raf.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(dataSize.toInt()).array())
-        
-        raf.close()
-    }
-    
-    @Test
-    fun testSummary() {
-        println("\n📊 Test Results")
-        println("===============")
-        println("✅ All tests validate real Android behavior")
-        println("✅ Output control configuration working correctly")
-        
-        println("\n📝 Key Features Validated:")
-        println("- Default behavior creates primary WAV file only")
-        println("- Can create compressed file only (no WAV)")
-        println("- Can create both primary and compressed files")
-        println("- Streaming-only mode (no files created)")
-        println("- Data emission continues regardless of file outputs")
-        println("- Pause/Resume works correctly with output control")
-    }
-} 

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

@@ -1,252 +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 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/audiostream/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/expo-audio-studio
-./android/src/androidTest/java/net/siteed/audiostream/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