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

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

@@ -1,345 +0,0 @@
-package net.siteed.audiostudio.integration
-
-import android.Manifest
-import android.content.Context
-import android.media.MediaExtractor
-import android.media.MediaFormat
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.rule.GrantPermissionRule
-import expo.modules.kotlin.Promise
-import net.siteed.audiostudio.*
-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
-
-@RunWith(AndroidJUnit4::class)
-class M4aFormatTest {
-    
-    @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
-    
-    // Test event sender to capture events
-    private class TestEventSender : EventSender {
-        override fun sendExpoEvent(eventName: String, params: android.os.Bundle) {
-            // No-op for 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) {
-            stopRecordingSync()
-        }
-        
-        // Clean up
-        AudioRecorderManager.destroy()
-        cleanupAudioFiles()
-    }
-    
-    private fun cleanupAudioFiles() {
-        filesDir.listFiles()?.forEach { file ->
-            if (file.name.endsWith(".wav") || file.name.endsWith(".aac") || 
-                file.name.endsWith(".m4a") || file.name.endsWith(".opus")) {
-                file.delete()
-            }
-        }
-    }
-
-    @Test
-    fun testAacFormat_producesM4aByDefault() {
-        // Skip test if API level is too low for compressed recording
-        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.Q) {
-            println("Skipping M4A test - requires API 29+, current API: ${android.os.Build.VERSION.SDK_INT}")
-            return
-        }
-        
-        // Given
-        val recordingOptions = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "interval" to 100,
-            "showNotification" to false,
-            "output" to mapOf(
-                "primary" to mapOf("enabled" to false),
-                "compressed" to mapOf(
-                    "enabled" to true,
-                    "format" to "aac"
-                    // preferRawStream not specified = defaults to false = M4A
-                )
-            )
-        )
-
-        // When - Record for 1 second
-        startRecordingSync(recordingOptions)
-        Thread.sleep(1000)
-        val result = stopRecordingSync()
-
-        // Then
-        val compression = when (val comp = result["compression"]) {
-            is android.os.Bundle -> bundleToMap(comp)
-            is Map<*, *> -> comp
-            else -> null
-        }
-        
-        val compressedUri = compression?.get("compressedFileUri") as? String
-        assertNotNull("Compressed file URI should not be null", compressedUri)
-        
-        val file = when {
-            compressedUri!!.startsWith("file://") -> File(java.net.URI(compressedUri))
-            compressedUri.startsWith("file:") -> File(java.net.URI(compressedUri))
-            else -> File(compressedUri)
-        }
-        
-        assertTrue("File should exist", file.exists())
-        assertTrue("File should have .m4a extension", file.name.endsWith(".m4a"))
-        
-        // Verify it's actually an M4A file
-        verifyM4aFormat(file)
-    }
-
-    @Test
-    fun testAacFormat_withPreferRawStream_producesAac() {
-        // Skip test if API level is too low for compressed recording
-        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.Q) {
-            println("Skipping raw AAC test - requires API 29+, current API: ${android.os.Build.VERSION.SDK_INT}")
-            return
-        }
-        
-        // Given
-        val recordingOptions = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "interval" to 100,
-            "showNotification" to false,
-            "output" to mapOf(
-                "primary" to mapOf("enabled" to false),
-                "compressed" to mapOf(
-                    "enabled" to true,
-                    "format" to "aac",
-                    "preferRawStream" to true  // NEW: Request raw AAC stream
-                )
-            )
-        )
-
-        // When - Record for 1 second
-        startRecordingSync(recordingOptions)
-        Thread.sleep(1000)
-        val result = stopRecordingSync()
-
-        // Then
-        val compression = when (val comp = result["compression"]) {
-            is android.os.Bundle -> bundleToMap(comp)
-            is Map<*, *> -> comp
-            else -> null
-        }
-        
-        val compressedUri = compression?.get("compressedFileUri") as? String
-        assertNotNull("Compressed file URI should not be null", compressedUri)
-        
-        val file = when {
-            compressedUri!!.startsWith("file://") -> File(java.net.URI(compressedUri))
-            compressedUri.startsWith("file:") -> File(java.net.URI(compressedUri))
-            else -> File(compressedUri)
-        }
-        
-        assertTrue("File should exist", file.exists())
-        assertTrue("File should have .aac extension", file.name.endsWith(".aac"))
-        
-        // Verify it's actually an AAC ADTS file
-        verifyAacAdtsFormat(file)
-    }
-
-    @Test
-    fun testOpusFormat_producesOpus() {
-        // Skip test if API level is too low for Opus recording
-        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.Q) {
-            println("Skipping Opus test - requires API 29+, current API: ${android.os.Build.VERSION.SDK_INT}")
-            return
-        }
-        
-        // Given
-        val recordingOptions = mapOf(
-            "sampleRate" to 48000,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "interval" to 100,
-            "showNotification" to false,
-            "output" to mapOf(
-                "primary" to mapOf("enabled" to false),
-                "compressed" to mapOf(
-                    "enabled" to true,
-                    "format" to "opus"
-                )
-            )
-        )
-
-        // When - Record for 1 second
-        startRecordingSync(recordingOptions)
-        Thread.sleep(1000)
-        val result = stopRecordingSync()
-
-        // Then
-        val compression = when (val comp = result["compression"]) {
-            is android.os.Bundle -> bundleToMap(comp)
-            is Map<*, *> -> comp
-            else -> null
-        }
-        
-        val compressedUri = compression?.get("compressedFileUri") as? String
-        assertNotNull("Compressed file URI should not be null", compressedUri)
-        
-        val file = when {
-            compressedUri!!.startsWith("file://") -> File(java.net.URI(compressedUri))
-            compressedUri.startsWith("file:") -> File(java.net.URI(compressedUri))
-            else -> File(compressedUri)
-        }
-        
-        assertTrue("File should exist", file.exists())
-        assertTrue("File should have .opus extension", file.name.endsWith(".opus"))
-    }
-
-    // Helper methods from existing tests
-    private fun startRecordingSync(recordingOptions: Map<String, Any?>): Map<String, Any?> {
-        val startLatch = CountDownLatch(1)
-        var recordingResult: Map<String, Any?>? = null
-        
-        audioRecorderManager.startRecording(recordingOptions, object : Promise {
-            override fun resolve(value: Any?) {
-                when (value) {
-                    is android.os.Bundle -> recordingResult = bundleToMap(value)
-                    is Map<*, *> -> {
-                        @Suppress("UNCHECKED_CAST")
-                        recordingResult = value as? Map<String, Any>
-                    }
-                    else -> {
-                        fail("Unexpected start result type: ${value?.javaClass?.name}")
-                    }
-                }
-                startLatch.countDown()
-            }
-            
-            override fun reject(code: String, message: String?, cause: Throwable?) {
-                fail("Recording start failed: $code - $message")
-            }
-        })
-        
-        assertTrue("Recording should start within 2 seconds", startLatch.await(2, TimeUnit.SECONDS))
-        return recordingResult ?: throw AssertionError("Recording result should not be null")
-    }
-    
-    private fun stopRecordingSync(): Map<String, Any?> {
-        val stopLatch = CountDownLatch(1)
-        var stopResult: Map<String, Any?>? = null
-        
-        audioRecorderManager.stopRecording(object : Promise {
-            override fun resolve(value: Any?) {
-                when (value) {
-                    is android.os.Bundle -> stopResult = bundleToMap(value)
-                    is Map<*, *> -> {
-                        @Suppress("UNCHECKED_CAST")
-                        stopResult = value as? Map<String, Any>
-                    }
-                    else -> {
-                        fail("Unexpected stop result type: ${value?.javaClass?.name}")
-                    }
-                }
-                stopLatch.countDown()
-            }
-            
-            override fun reject(code: String, message: String?, cause: Throwable?) {
-                fail("Recording stop failed: $code - $message")
-            }
-        })
-        
-        assertTrue("Recording should stop within 2 seconds", stopLatch.await(2, TimeUnit.SECONDS))
-        return stopResult ?: throw AssertionError("Stop result should not be null")
-    }
-    
-    private fun bundleToMap(bundle: android.os.Bundle): Map<String, Any?> {
-        val map = mutableMapOf<String, Any?>()
-        for (key in bundle.keySet()) {
-            map[key] = bundle.get(key)
-        }
-        return map
-    }
-
-    private fun verifyM4aFormat(file: File) {
-        val extractor = MediaExtractor()
-        try {
-            extractor.setDataSource(file.absolutePath)
-            assertTrue("Should have at least one track", extractor.trackCount > 0)
-            
-            val format = extractor.getTrackFormat(0)
-            val mimeType = format.getString(MediaFormat.KEY_MIME)
-            
-            // Debug output
-            println("Detected MIME type: $mimeType")
-            
-            // For M4A files, the MIME type should be audio/mp4 or contain aac
-            val isValidM4aMimeType = mimeType?.let { mime ->
-                mime.contains("mp4", ignoreCase = true) || 
-                mime.contains("aac", ignoreCase = true) ||
-                mime.contains("audio/", ignoreCase = true)
-            } ?: false
-            
-            assertTrue("MIME type should be valid for M4A format, got: $mimeType", isValidM4aMimeType)
-            
-            // Read file header to verify MP4 container
-            val header = file.inputStream().use { it.readNBytes(20) }
-            val headerString = String(header, Charsets.ISO_8859_1)
-            val hasFtyp = headerString.contains("ftyp")
-            assertTrue("File should contain ftyp box (MP4 container)", hasFtyp)
-        } finally {
-            extractor.release()
-        }
-    }
-
-    private fun verifyAacAdtsFormat(file: File) {
-        // ADTS header starts with 0xFFF
-        val header = file.inputStream().use { it.readNBytes(2) }
-        val syncWord = ((header[0].toInt() and 0xFF) shl 4) or ((header[1].toInt() and 0xF0) shr 4)
-        assertEquals("ADTS sync word should be 0xFFF", 0xFFF, syncWord)
-    }
-}

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

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