@siteed/audio-studio 3.0.0

package/android/src/androidTest/java/net/siteed/audiostudio/AudioRecorderInstrumentedTest.kt

@@ -0,0 +1,541 @@
+package net.siteed.audiostudio
+
+import android.Manifest
+import android.content.Context
+import android.media.AudioFormat
+import android.media.AudioManager
+import android.media.AudioTrack
+import android.os.Bundle
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.rule.GrantPermissionRule
+import expo.modules.kotlin.Promise
+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
+import kotlin.math.sin
+
+/**
+ * Instrumented tests for AudioRecorderManager that test actual recording functionality.
+ * These tests run on an Android device/emulator and require microphone permissions.
+ */
+@RunWith(AndroidJUnit4::class)
+class AudioRecorderInstrumentedTest {
+    
+    @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 {
+        val events = mutableListOf<Pair<String, Bundle>>()
+        
+        override fun sendExpoEvent(eventName: String, params: Bundle) {
+            events.add(eventName to params)
+        }
+        
+        fun clearEvents() {
+            events.clear()
+        }
+        
+        fun getEventsOfType(eventName: String): List<Bundle> {
+            return events.filter { it.first == eventName }.map { it.second }
+        }
+    }
+    
+    @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, // Disable for tests
+            enableBackgroundAudio = false // Disable for tests
+        )
+        
+        // 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(".opus")) {
+                file.delete()
+            }
+        }
+    }
+    
+    // ========== Basic Recording Tests ==========
+    
+    @Test
+    fun testBasicRecording_createsWavFile() {
+        // Given
+        val recordingOptions = mapOf(
+            "sampleRate" to 16000,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "interval" to 100,
+            "enableProcessing" to false,
+            "showNotification" to false
+        )
+        
+        // When - Start recording
+        val startLatch = CountDownLatch(1)
+        var recordingResult: Map<String, Any>? = null
+        
+        audioRecorderManager.startRecording(recordingOptions, object : Promise {
+            override fun resolve(value: Any?) {
+                when (value) {
+                    is 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))
+        assertNotNull("Recording result should not be null", recordingResult)
+        
+        // Record for 2 seconds
+        Thread.sleep(2000)
+        
+        // Verify we received audio data events
+        val audioEvents = testEventSender.getEventsOfType(Constants.AUDIO_EVENT_NAME)
+        assertTrue("Should have received audio data events", audioEvents.isNotEmpty())
+        
+        // Stop recording
+        val stopResult = stopRecordingSync()
+        assertNotNull("Stop result should not be null", stopResult)
+        
+        // Verify the file was created
+        val fileUri = stopResult["fileUri"] as? String
+        assertNotNull("File URI should not be null", fileUri)
+        
+        // Convert URI string to File - handle both file:// URIs and plain paths
+        val audioFile = when {
+            fileUri!!.startsWith("file://") -> File(java.net.URI(fileUri))
+            fileUri.startsWith("file:") -> File(java.net.URI(fileUri))
+            else -> File(fileUri)
+        }
+        
+        assertTrue("Audio file should exist at ${audioFile.absolutePath}", audioFile.exists())
+        assertTrue("Audio file should have content", audioFile.length() > 44) // WAV header is 44 bytes
+        
+        // Verify file is a valid WAV
+        val wavHeader = audioFile.inputStream().use { it.readNBytes(44) }
+        assertEquals("Should have RIFF header", "RIFF", String(wavHeader.sliceArray(0..3)))
+        assertEquals("Should have WAVE format", "WAVE", String(wavHeader.sliceArray(8..11)))
+    }
+    
+    @Test
+    fun testRecordingWithAnalysis_generatesFeatures() {
+        // Given
+        val recordingOptions = mapOf(
+            "sampleRate" to 16000,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "interval" to 100,
+            "intervalAnalysis" to 500,
+            "enableProcessing" to true,
+            "showNotification" to false,
+            "features" to mapOf(
+                "rms" to true,
+                "zcr" to true,
+                "energy" to true
+            )
+        )
+        
+        // When - Start recording
+        startRecordingSync(recordingOptions)
+        
+        // Record for 2 seconds to ensure we get analysis events
+        Thread.sleep(2000)
+        
+        // Then - Verify analysis events
+        val analysisEvents = testEventSender.getEventsOfType(Constants.AUDIO_ANALYSIS_EVENT_NAME)
+        assertTrue("Should have received analysis events", analysisEvents.isNotEmpty())
+        
+        val firstAnalysis = analysisEvents.first()
+        // Analysis data contains dataPoints array
+        assertTrue("Should have dataPoints", firstAnalysis.containsKey("dataPoints"))
+        val dataPoints = firstAnalysis.get("dataPoints") as? Array<*>
+        assertNotNull("DataPoints should not be null", dataPoints)
+        assertTrue("Should have at least one data point", dataPoints!!.isNotEmpty())
+        
+        // Check the first data point
+        val firstDataPoint = dataPoints[0] as? Bundle
+        assertNotNull("First data point should be a Bundle", firstDataPoint)
+        assertTrue("Data point should have rms", firstDataPoint!!.containsKey("rms"))
+        assertTrue("Data point should have features", firstDataPoint.containsKey("features"))
+        
+        // Check features in the data point
+        val features = firstDataPoint.get("features") as? Bundle
+        assertNotNull("Features should not be null", features)
+        assertTrue("Features should have rms", features!!.containsKey("rms"))
+        assertTrue("Features should have zcr", features.containsKey("zcr"))
+        assertTrue("Features should have energy", features.containsKey("energy"))
+        
+        // Stop recording
+        stopRecordingSync()
+    }
+    
+    @Test
+    fun testPauseResumeRecording() {
+        // Given
+        val recordingOptions = mapOf(
+            "sampleRate" to 16000,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "interval" to 100,
+            "showNotification" to false
+        )
+        
+        // Start recording
+        startRecordingSync(recordingOptions)
+        Thread.sleep(1000)
+        
+        // Clear events before pause
+        testEventSender.clearEvents()
+        
+        // When - Pause recording
+        val pauseLatch = CountDownLatch(1)
+        audioRecorderManager.pauseRecording(object : Promise {
+            override fun resolve(value: Any?) {
+                pauseLatch.countDown()
+            }
+            
+            override fun reject(code: String, message: String?, cause: Throwable?) {
+                fail("Pause failed: $code - $message")
+            }
+        })
+        
+        assertTrue("Pause should complete within 1 second", pauseLatch.await(1, TimeUnit.SECONDS))
+        
+        // Give some time for any pending events to be processed
+        Thread.sleep(200)
+        
+        // Clear events after pause to ensure we only check new events
+        testEventSender.clearEvents()
+        
+        // Wait to verify no new audio events during pause
+        Thread.sleep(500)
+        val eventsDuringPause = testEventSender.getEventsOfType(Constants.AUDIO_EVENT_NAME)
+        assertTrue("Should not receive audio events while paused", eventsDuringPause.isEmpty())
+        
+        // Resume recording
+        val resumeLatch = CountDownLatch(1)
+        audioRecorderManager.resumeRecording(object : Promise {
+            override fun resolve(value: Any?) {
+                resumeLatch.countDown()
+            }
+            
+            override fun reject(code: String, message: String?, cause: Throwable?) {
+                fail("Resume failed: $code - $message")
+            }
+        })
+        
+        assertTrue("Resume should complete within 1 second", resumeLatch.await(1, TimeUnit.SECONDS))
+        
+        // Verify audio events resume
+        Thread.sleep(500)
+        val eventsAfterResume = testEventSender.getEventsOfType(Constants.AUDIO_EVENT_NAME)
+        assertTrue("Should receive audio events after resume", eventsAfterResume.isNotEmpty())
+        
+        // Stop recording
+        stopRecordingSync()
+    }
+    
+    @Test
+    fun testCompressedRecording_createsAacFile() {
+        // 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 compressed recording test - requires API 29+, current API: ${android.os.Build.VERSION.SDK_INT}")
+            return
+        }
+        
+        // Given
+        val recordingOptions = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 2,
+            "encoding" to "pcm_16bit",
+            "interval" to 100,
+            "showNotification" to false,
+            "output" to mapOf(
+                "compressed" to mapOf(
+                    "enabled" to true,
+                    "format" to "aac",
+                    "bitrate" to 128000
+                )
+            )
+        )
+        
+        // When - Record for 2 seconds
+        startRecordingSync(recordingOptions)
+        Thread.sleep(2000)
+        val result = stopRecordingSync()
+        
+        // Debug: Print the result to understand its structure
+        println("Stop recording result keys: ${result.keys}")
+        println("Stop recording result: $result")
+        
+        // Then - Verify both files exist
+        val wavUri = result["fileUri"] as? String
+        assertNotNull("WAV file URI should exist", wavUri)
+        
+        // Check if compression info exists
+        val compression = when (val comp = result["compression"]) {
+            is Bundle -> bundleToMap(comp)
+            is Map<*, *> -> comp
+            else -> null
+        }
+        
+        // The compressed file URI is inside the compression bundle
+        val compressedUri = compression?.get("compressedFileUri") as? String
+        
+        // For debugging - print what we got
+        println("Compression info: $compression")
+        
+        assertNotNull("Compression info should exist", compression)
+        assertNotNull("Compressed file URI should exist in compression info", compressedUri)
+        
+        // Convert URI strings to Files
+        val wavFile = when {
+            wavUri!!.startsWith("file://") -> File(java.net.URI(wavUri))
+            wavUri.startsWith("file:") -> File(java.net.URI(wavUri))
+            else -> File(wavUri)
+        }
+        
+        val aacFile = when {
+            compressedUri!!.startsWith("file://") -> File(java.net.URI(compressedUri))
+            compressedUri.startsWith("file:") -> File(java.net.URI(compressedUri))
+            else -> File(compressedUri)
+        }
+        
+        assertTrue("WAV file should exist at ${wavFile.absolutePath}", wavFile.exists())
+        assertTrue("AAC file should exist at ${aacFile.absolutePath}", aacFile.exists())
+        assertTrue("AAC file should have content", aacFile.length() > 0)
+        assertTrue("AAC file should be smaller than WAV", aacFile.length() < wavFile.length())
+    }
+    
+    @Test
+    fun testRecordingWithToneGeneration_verifiesAudioContent() {
+        // This test generates a tone and plays it while recording to verify
+        // that actual audio is being captured
+        
+        // Given
+        val recordingOptions = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "interval" to 100,
+            "showNotification" to false
+        )
+        
+        // Start recording
+        startRecordingSync(recordingOptions)
+        
+        // Play a 1kHz tone for 1 second
+        playTone(1000.0, 1000)
+        
+        // Stop recording
+        val result = stopRecordingSync()
+        
+        // Load and analyze the recorded file
+        val fileUri = result["fileUri"] as String
+        val audioFile = when {
+            fileUri.startsWith("file://") -> File(java.net.URI(fileUri))
+            fileUri.startsWith("file:") -> File(java.net.URI(fileUri))
+            else -> File(fileUri)
+        }
+        
+        val audioProcessor = AudioProcessor(filesDir)
+        val audioData = audioProcessor.loadAudioFromAnyFormat(audioFile.absolutePath, null)
+        
+        assertNotNull("Should load audio data", audioData)
+        
+        // Analyze the audio to verify it contains the tone
+        val config = RecordingConfig(
+            sampleRate = 44100,
+            channels = 1,
+            encoding = "pcm_16bit",
+            features = mapOf(
+                "rms" to true,
+                "energy" to true,
+                "spectralCentroid" to true
+            )
+        )
+        
+        val analysis = audioProcessor.processAudioData(audioData!!.data, config)
+        
+        // Verify we captured audio with energy (not silence)
+        val dataPoints = analysis.dataPoints
+        assertTrue("Should have data points", dataPoints.isNotEmpty())
+        
+        // Check that we have non-zero RMS values indicating captured audio
+        val avgRms = dataPoints.map { it.rms }.average()
+        assertTrue("Average RMS should indicate captured audio", avgRms > 0.01)
+        
+        // Check that features were extracted
+        val firstPointWithFeatures = dataPoints.firstOrNull { it.features != null }
+        assertNotNull("Should have at least one data point with features", firstPointWithFeatures)
+        
+        // The spectral centroid of a 1kHz tone should be around 1000Hz
+        // Note: spectral centroid can be affected by recording quality and background noise
+        val spectralCentroids = dataPoints.mapNotNull { it.features?.spectralCentroid }.filter { it > 0 }
+        assertTrue("Should have spectral centroid values", spectralCentroids.isNotEmpty())
+        val avgSpectralCentroid = spectralCentroids.average()
+        
+        // Log the actual value for debugging
+        println("Average spectral centroid: $avgSpectralCentroid Hz")
+        
+        // Be more lenient with the range as real device recording can have variations
+        // Just verify it's not silence (very low) or noise (very high)
+        assertTrue("Spectral centroid should indicate tonal content (was $avgSpectralCentroid Hz)", 
+            avgSpectralCentroid > 100 && avgSpectralCentroid < 20000)
+    }
+    
+    // ========== Helper Methods ==========
+    
+    private fun startRecordingSync(options: Map<String, Any>) {
+        val latch = CountDownLatch(1)
+        audioRecorderManager.startRecording(options, object : Promise {
+            override fun resolve(value: Any?) {
+                latch.countDown()
+            }
+            
+            override fun reject(code: String, message: String?, cause: Throwable?) {
+                fail("Recording start failed: $code - $message")
+            }
+        })
+        
+        assertTrue("Recording should start within 2 seconds", latch.await(2, TimeUnit.SECONDS))
+    }
+    
+    private fun stopRecordingSync(): Map<String, Any> {
+        val latch = CountDownLatch(1)
+        var result: Map<String, Any>? = null
+        
+        audioRecorderManager.stopRecording(object : Promise {
+            override fun resolve(value: Any?) {
+                when (value) {
+                    is Bundle -> {
+                        // Convert Bundle to Map
+                        result = bundleToMap(value)
+                    }
+                    is Map<*, *> -> {
+                        @Suppress("UNCHECKED_CAST")
+                        result = value as? Map<String, Any>
+                    }
+                    else -> {
+                        fail("Unexpected result type: ${value?.javaClass?.name}")
+                    }
+                }
+                latch.countDown()
+            }
+            
+            override fun reject(code: String, message: String?, cause: Throwable?) {
+                fail("Recording stop failed: $code - $message")
+            }
+        })
+        
+        assertTrue("Recording should stop within 2 seconds", latch.await(2, TimeUnit.SECONDS))
+        return result ?: throw AssertionError("Stop recording returned null result")
+    }
+    
+    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)
+                null -> { /* skip null values */ }
+                else -> map[key] = value
+            }
+        }
+        return map
+    }
+    
+    private fun playTone(frequency: Double, durationMs: Int) {
+        val sampleRate = 44100
+        val numSamples = (sampleRate * durationMs / 1000.0).toInt()
+        val samples = ShortArray(numSamples)
+        
+        // Generate sine wave
+        for (i in 0 until numSamples) {
+            val angle = 2.0 * Math.PI * i * frequency / sampleRate
+            samples[i] = (sin(angle) * Short.MAX_VALUE * 0.5).toInt().toShort()
+        }
+        
+        // Play the tone
+        val audioTrack = AudioTrack.Builder()
+            .setAudioAttributes(
+                android.media.AudioAttributes.Builder()
+                    .setUsage(android.media.AudioAttributes.USAGE_MEDIA)
+                    .setContentType(android.media.AudioAttributes.CONTENT_TYPE_MUSIC)
+                    .build()
+            )
+            .setAudioFormat(
+                AudioFormat.Builder()
+                    .setSampleRate(sampleRate)
+                    .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
+                    .setChannelMask(AudioFormat.CHANNEL_OUT_MONO)
+                    .build()
+            )
+            .setBufferSizeInBytes(samples.size * 2)
+            .setTransferMode(AudioTrack.MODE_STATIC)
+            .build()
+        
+        audioTrack.write(samples, 0, samples.size)
+        audioTrack.play()
+        
+        // Wait for playback to complete
+        Thread.sleep(durationMs.toLong())
+        
+        audioTrack.stop()
+        audioTrack.release()
+    }
+}