@siteed/expo-audio-studio 2.18.6 → 3.0.0

package/android/src/test/java/net/siteed/audiostream/AudioFileHandlerTest.kt

@@ -1,279 +0,0 @@
-package net.siteed.audiostream
-
-import org.junit.Test
-import org.junit.Assert.*
-import org.junit.Before
-import org.junit.After
-import java.io.ByteArrayOutputStream
-import java.io.File
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-import kotlin.test.assertNotNull
-
-class AudioFileHandlerTest {
-    private lateinit var tempDir: File
-    private lateinit var audioFileHandler: AudioFileHandler
-
-    @Before
-    fun setUp() {
-        // Create a temporary directory for testing
-        tempDir = File(System.getProperty("java.io.tmpdir"), "audio_test_${System.currentTimeMillis()}")
-        tempDir.mkdirs()
-        audioFileHandler = AudioFileHandler(tempDir)
-    }
-
-    @After
-    fun tearDown() {
-        // Clean up temporary directory
-        tempDir.deleteRecursively()
-    }
-
-    @Test
-    fun testWriteWavHeader_writesCorrectHeaderFormat() {
-        // Given
-        val outputStream = ByteArrayOutputStream()
-        val sampleRate = 44100
-        val channels = 2
-        val bitDepth = 16
-
-        // When
-        audioFileHandler.writeWavHeader(outputStream, sampleRate, channels, bitDepth)
-        val header = outputStream.toByteArray()
-
-        // Then
-        assertEquals("WAV header should be 44 bytes", 44, header.size)
-        
-        // Check RIFF header
-        assertEquals("Should start with RIFF", "RIFF", String(header.sliceArray(0..3)))
-        assertEquals("Should contain WAVE identifier", "WAVE", String(header.sliceArray(8..11)))
-        assertEquals("Should contain fmt chunk", "fmt ", String(header.sliceArray(12..15)))
-        assertEquals("Should contain data chunk", "data", String(header.sliceArray(36..39)))
-        
-        // Check audio format (PCM = 1)
-        val audioFormat = ByteBuffer.wrap(header.sliceArray(20..21)).order(ByteOrder.LITTLE_ENDIAN).short
-        assertEquals("Audio format should be 1 (PCM)", 1, audioFormat.toInt())
-        
-        // Check channels
-        val headerChannels = ByteBuffer.wrap(header.sliceArray(22..23)).order(ByteOrder.LITTLE_ENDIAN).short
-        assertEquals("Channels should match", channels, headerChannels.toInt())
-        
-        // Check sample rate
-        val headerSampleRate = ByteBuffer.wrap(header.sliceArray(24..27)).order(ByteOrder.LITTLE_ENDIAN).int
-        assertEquals("Sample rate should match", sampleRate, headerSampleRate)
-        
-        // Check bit depth
-        val headerBitDepth = ByteBuffer.wrap(header.sliceArray(34..35)).order(ByteOrder.LITTLE_ENDIAN).short
-        assertEquals("Bit depth should match", bitDepth, headerBitDepth.toInt())
-    }
-
-    @Test
-    fun testWriteWavHeader_calculatesCorrectByteRate() {
-        // Given
-        val outputStream = ByteArrayOutputStream()
-        val sampleRate = 48000
-        val channels = 1
-        val bitDepth = 24
-        val expectedByteRate = sampleRate * channels * bitDepth / 8
-
-        // When
-        audioFileHandler.writeWavHeader(outputStream, sampleRate, channels, bitDepth)
-        val header = outputStream.toByteArray()
-
-        // Then
-        val byteRate = ByteBuffer.wrap(header.sliceArray(28..31)).order(ByteOrder.LITTLE_ENDIAN).int
-        assertEquals("Byte rate should be correctly calculated", expectedByteRate, byteRate)
-    }
-
-    @Test
-    fun testCreateAudioFile_createsFileWithCorrectExtension() {
-        // Given
-        val extension = "wav"
-
-        // When
-        val file = audioFileHandler.createAudioFile(extension)
-
-        // Then
-        assertNotNull("File should not be null", file)
-        assertTrue("File should exist", file.exists())
-        assertTrue("File should have correct extension", file.name.endsWith(".$extension"))
-        assertTrue("File should have correct prefix", file.name.startsWith("recording_"))
-        
-        // Clean up
-        file.delete()
-    }
-
-    @Test
-    fun testCreateAudioFile_createsUniqueFiles() {
-        // Given
-        val extension = "wav"
-
-        // When
-        val file1 = audioFileHandler.createAudioFile(extension)
-        Thread.sleep(10) // Small delay to ensure different timestamps
-        val file2 = audioFileHandler.createAudioFile(extension)
-
-        // Then
-        assertNotEquals("Files should have unique names", file1.name, file2.name)
-        assertTrue("First file should exist", file1.exists())
-        assertTrue("Second file should exist", file2.exists())
-        
-        // Clean up
-        file1.delete()
-        file2.delete()
-    }
-
-    @Test
-    fun testDeleteFile_deletesExistingFile() {
-        // Given
-        val file = audioFileHandler.createAudioFile("wav")
-        assertTrue("File should exist before deletion", file.exists())
-
-        // When
-        val result = audioFileHandler.deleteFile(file)
-
-        // Then
-        assertTrue("Delete should return true", result)
-        assertFalse("File should not exist after deletion", file.exists())
-    }
-
-    @Test
-    fun testDeleteFile_handlesNullFile() {
-        // When
-        val result = audioFileHandler.deleteFile(null)
-
-        // Then
-        assertFalse("Delete should return false for null file", result)
-    }
-
-    @Test
-    fun testDeleteFile_handlesNonExistentFile() {
-        // Given
-        val nonExistentFile = File(tempDir, "non_existent.wav")
-        assertFalse("File should not exist", nonExistentFile.exists())
-
-        // When
-        val result = audioFileHandler.deleteFile(nonExistentFile)
-
-        // Then
-        assertFalse("Delete should return false for non-existent file", result)
-    }
-
-    @Test
-    fun testClearAudioStorage_deletesAllFiles() {
-        // Given
-        val file1 = audioFileHandler.createAudioFile("wav")
-        val file2 = audioFileHandler.createAudioFile("mp3")
-        val file3 = audioFileHandler.createAudioFile("aac")
-        
-        assertTrue("File 1 should exist", file1.exists())
-        assertTrue("File 2 should exist", file2.exists())
-        assertTrue("File 3 should exist", file3.exists())
-
-        // When
-        audioFileHandler.clearAudioStorage()
-
-        // Then
-        assertFalse("File 1 should be deleted", file1.exists())
-        assertFalse("File 2 should be deleted", file2.exists())
-        assertFalse("File 3 should be deleted", file3.exists())
-        assertEquals("Directory should be empty", 0, tempDir.listFiles()?.size ?: 0)
-    }
-
-    @Test
-    fun testUpdateWavHeader_updatesFileSizeCorrectly() {
-        // Given
-        val file = audioFileHandler.createAudioFile("wav")
-        val outputStream = file.outputStream()
-        
-        // Write header
-        audioFileHandler.writeWavHeader(outputStream, 44100, 2, 16)
-        
-        // Write some audio data (1 second of silence)
-        val audioDataSize = 44100 * 2 * 2 // sampleRate * channels * bytesPerSample
-        val audioData = ByteArray(audioDataSize)
-        outputStream.write(audioData)
-        outputStream.close()
-
-        // When
-        audioFileHandler.updateWavHeader(file)
-
-        // Then
-        val updatedHeader = file.inputStream().use { it.readNBytes(44) }
-        
-        // Check file size field (bytes 4-7)
-        val fileSize = ByteBuffer.wrap(updatedHeader.sliceArray(4..7)).order(ByteOrder.LITTLE_ENDIAN).int
-        assertEquals("File size should be data size + 36", audioDataSize + 36, fileSize)
-        
-        // Check data size field (bytes 40-43)
-        val dataSize = ByteBuffer.wrap(updatedHeader.sliceArray(40..43)).order(ByteOrder.LITTLE_ENDIAN).int
-        assertEquals("Data size should match audio data size", audioDataSize, dataSize)
-        
-        // Clean up
-        file.delete()
-    }
-
-    @Test
-    fun testLoadRealWavFile_readsHeaderCorrectly() {
-        // Given - Load a real WAV file from test resources
-        val resourceStream = javaClass.classLoader?.getResourceAsStream("jfk.wav")
-        assertNotNull("Test resource jfk.wav should exist", resourceStream)
-        
-        val testFile = File(tempDir, "test_jfk.wav")
-        resourceStream?.use { input ->
-            testFile.outputStream().use { output ->
-                input.copyTo(output)
-            }
-        }
-        
-        // When - Read the WAV header
-        val header = testFile.inputStream().use { it.readNBytes(44) }
-        
-        // Then - Validate header structure
-        assertEquals("Should start with RIFF", "RIFF", String(header.sliceArray(0..3)))
-        assertEquals("Should contain WAVE identifier", "WAVE", String(header.sliceArray(8..11)))
-        assertEquals("Should contain fmt chunk", "fmt ", String(header.sliceArray(12..15)))
-        
-        // Extract audio properties
-        val channels = ByteBuffer.wrap(header.sliceArray(22..23)).order(ByteOrder.LITTLE_ENDIAN).short
-        val sampleRate = ByteBuffer.wrap(header.sliceArray(24..27)).order(ByteOrder.LITTLE_ENDIAN).int
-        val bitDepth = ByteBuffer.wrap(header.sliceArray(34..35)).order(ByteOrder.LITTLE_ENDIAN).short
-        
-        // JFK.wav is known to be mono, 16kHz, 16-bit
-        assertEquals("JFK audio should be mono", 1, channels.toInt())
-        assertEquals("JFK audio should be 16kHz", 16000, sampleRate)
-        assertEquals("JFK audio should be 16-bit", 16, bitDepth.toInt())
-        
-        // Clean up
-        testFile.delete()
-    }
-
-    @Test
-    fun testProcessMultipleRealWavFiles() {
-        // Test with different real WAV files to ensure compatibility
-        val testFiles = listOf("jfk.wav", "recorder_hello_world.wav", "osr_us_000_0010_8k.wav")
-        
-        for (fileName in testFiles) {
-            val resourceStream = javaClass.classLoader?.getResourceAsStream(fileName)
-            if (resourceStream != null) {
-                val testFile = File(tempDir, "test_$fileName")
-                resourceStream.use { input ->
-                    testFile.outputStream().use { output ->
-                        input.copyTo(output)
-                    }
-                }
-                
-                // Verify file was created and has content
-                assertTrue("$fileName should exist", testFile.exists())
-                assertTrue("$fileName should have more than just header", testFile.length() > 44)
-                
-                // Read and validate header
-                val header = testFile.inputStream().use { it.readNBytes(44) }
-                assertEquals("$fileName should have RIFF header", "RIFF", String(header.sliceArray(0..3)))
-                assertEquals("$fileName should have WAVE format", "WAVE", String(header.sliceArray(8..11)))
-                
-                // Clean up
-                testFile.delete()
-            }
-        }
-    }
-} 

package/android/src/test/java/net/siteed/audiostream/AudioFocusStrategyTest.kt

@@ -1,249 +0,0 @@
-package net.siteed.audiostream
-
-import org.junit.Test
-import org.junit.Assert.*
-
-/**
- * Unit tests for audio focus strategy configuration and logic.
- * These tests verify that the RecordingConfig correctly handles audioFocusStrategy
- * parameter and that the smart defaults work as expected.
- */
-class AudioFocusStrategyTest {
-
-    @Test
-    fun testRecordingConfigWithExplicitBackgroundStrategy() {
-        val options = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "android" to mapOf(
-                "audioFocusStrategy" to "background"
-            )
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
-    }
-
-    @Test
-    fun testRecordingConfigWithExplicitInteractiveStrategy() {
-        val options = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "android" to mapOf(
-                "audioFocusStrategy" to "interactive"
-            )
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertEquals("Audio focus strategy should be interactive", "interactive", config.audioFocusStrategy)
-    }
-
-    @Test
-    fun testRecordingConfigWithExplicitCommunicationStrategy() {
-        val options = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "android" to mapOf(
-                "audioFocusStrategy" to "communication"
-            )
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertEquals("Audio focus strategy should be communication", "communication", config.audioFocusStrategy)
-    }
-
-    @Test
-    fun testRecordingConfigWithExplicitNoneStrategy() {
-        val options = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "android" to mapOf(
-                "audioFocusStrategy" to "none"
-            )
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertEquals("Audio focus strategy should be none", "none", config.audioFocusStrategy)
-    }
-
-    @Test
-    fun testRecordingConfigWithoutAudioFocusStrategy() {
-        val options = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit"
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertNull("Audio focus strategy should be null when not specified", config.audioFocusStrategy)
-    }
-
-    @Test
-    fun testRecordingConfigWithInvalidAudioFocusStrategy() {
-        val options = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "android" to mapOf(
-                "audioFocusStrategy" to "invalid_strategy"
-            )
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed even with invalid strategy", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertEquals("Invalid audio focus strategy should be preserved", "invalid_strategy", config.audioFocusStrategy)
-    }
-
-    @Test
-    fun testRecordingConfigWithNullAudioFocusStrategy() {
-        val options = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "android" to mapOf(
-                "audioFocusStrategy" to null
-            )
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertNull("Audio focus strategy should be null", config.audioFocusStrategy)
-    }
-
-    @Test
-    fun testRecordingConfigKeepAwakeAndBackgroundStrategy() {
-        val options = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "keepAwake" to true,
-            "android" to mapOf(
-                "audioFocusStrategy" to "background"
-            )
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertTrue("keepAwake should be true", config.keepAwake)
-        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
-    }
-
-    @Test
-    fun testRecordingConfigKeepAwakeFalseAndInteractiveStrategy() {
-        val options = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "keepAwake" to false,
-            "android" to mapOf(
-                "audioFocusStrategy" to "interactive"
-            )
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertFalse("keepAwake should be false", config.keepAwake)
-        assertEquals("Audio focus strategy should be interactive", "interactive", config.audioFocusStrategy)
-    }
-
-    @Test
-    fun testRecordingConfigWithAutoResumeAndBackgroundStrategy() {
-        val options = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "autoResumeAfterInterruption" to true,
-            "android" to mapOf(
-                "audioFocusStrategy" to "background"
-            )
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
-        assertTrue("autoResumeAfterInterruption should be true", config.autoResumeAfterInterruption)
-    }
-
-    @Test
-    fun testRecordingConfigWithCommunicationStrategyAndSpeechSampleRate() {
-        val options = mapOf(
-            "sampleRate" to 16000, // Common speech sample rate
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "android" to mapOf(
-                "audioFocusStrategy" to "communication"
-            )
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertEquals("Sample rate should be 16000", 16000, config.sampleRate)
-        assertEquals("Audio focus strategy should be communication", "communication", config.audioFocusStrategy)
-    }
-
-    @Test
-    fun testDefaultRecordingConfigValues() {
-        val result = RecordingConfig.fromMap(null)
-        assertTrue("Config creation should succeed with null input", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertNull("Default audio focus strategy should be null", config.audioFocusStrategy)
-        assertTrue("Default keepAwake should be true", config.keepAwake)
-        assertFalse("Default autoResumeAfterInterruption should be false", config.autoResumeAfterInterruption)
-    }
-
-    @Test
-    fun testRecordingConfigCompleteAudioFocusConfiguration() {
-        val options = mapOf(
-            "sampleRate" to 44100,
-            "channels" to 1,
-            "encoding" to "pcm_16bit",
-            "keepAwake" to true,
-            "autoResumeAfterInterruption" to true,
-            "showNotification" to true,
-            "android" to mapOf(
-                "audioFocusStrategy" to "background"
-            )
-        )
-
-        val result = RecordingConfig.fromMap(options)
-        assertTrue("Config creation should succeed", result.isSuccess)
-
-        val (config, _) = result.getOrThrow()
-        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
-        assertTrue("keepAwake should be true", config.keepAwake)
-        assertTrue("autoResumeAfterInterruption should be true", config.autoResumeAfterInterruption)
-        assertTrue("showNotification should be true", config.showNotification)
-    }
-}

package/android/src/test/java/net/siteed/audiostream/AudioFormatTest.kt

@@ -1,151 +0,0 @@
-package net.siteed.audiostream
-
-import org.junit.Test
-import org.junit.Assert.*
-import org.junit.Before
-import java.io.File
-
-class AudioFormatTest {
-    private lateinit var tempDir: File
-
-    @Before
-    fun setUp() {
-        tempDir = File(System.getProperty("java.io.tmpdir"), "audio_format_test_${System.currentTimeMillis()}")
-        tempDir.mkdirs()
-    }
-
-    @Test
-    fun testGetFileExtension_aacDefaultsToM4a() {
-        // Given
-        val config = RecordingConfig(
-            output = OutputConfig(
-                compressed = OutputConfig.CompressedOutput(
-                    enabled = true,
-                    format = "aac",
-                    preferRawStream = false
-                )
-            )
-        )
-
-        // When
-        val file = createTestFile(config, isCompressed = true)
-
-        // Then
-        assertTrue("AAC without preferRawStream should produce .m4a", file.name.endsWith(".m4a"))
-    }
-
-    @Test
-    fun testGetFileExtension_aacWithPreferRawStreamProducesAac() {
-        // Given
-        val config = RecordingConfig(
-            output = OutputConfig(
-                compressed = OutputConfig.CompressedOutput(
-                    enabled = true,
-                    format = "aac",
-                    preferRawStream = true
-                )
-            )
-        )
-
-        // When
-        val file = createTestFile(config, isCompressed = true)
-
-        // Then
-        assertTrue("AAC with preferRawStream should produce .aac", file.name.endsWith(".aac"))
-    }
-
-    @Test
-    fun testGetFileExtension_opusProducesOpus() {
-        // Given
-        val config = RecordingConfig(
-            output = OutputConfig(
-                compressed = OutputConfig.CompressedOutput(
-                    enabled = true,
-                    format = "opus"
-                )
-            )
-        )
-
-        // When
-        val file = createTestFile(config, isCompressed = true)
-
-        // Then
-        assertTrue("Opus should produce .opus", file.name.endsWith(".opus"))
-    }
-
-    @Test
-    fun testGetFileExtension_wavForUncompressed() {
-        // Given
-        val config = RecordingConfig()
-
-        // When
-        val file = createTestFile(config, isCompressed = false)
-
-        // Then
-        assertTrue("Uncompressed should produce .wav", file.name.endsWith(".wav"))
-    }
-
-    @Test
-    fun testCompressedOutput_parseFromMap() {
-        // Given
-        val map = mapOf(
-            "enabled" to true,
-            "format" to "aac",
-            "bitrate" to 192000,
-            "preferRawStream" to true
-        )
-
-        // When
-        val compressed = OutputConfig.CompressedOutput(
-            enabled = map["enabled"] as Boolean,
-            format = map["format"] as String,
-            bitrate = map["bitrate"] as Int,
-            preferRawStream = map["preferRawStream"] as Boolean
-        )
-
-        // Then
-        assertTrue("enabled should be true", compressed.enabled)
-        assertEquals("format should be aac", "aac", compressed.format)
-        assertEquals("bitrate should be 192000", 192000, compressed.bitrate)
-        assertTrue("preferRawStream should be true", compressed.preferRawStream)
-    }
-
-    @Test
-    fun testCompressedOutput_defaultValues() {
-        // When
-        val compressed = OutputConfig.CompressedOutput()
-
-        // Then
-        assertFalse("enabled should default to false", compressed.enabled)
-        assertEquals("format should default to aac", "aac", compressed.format)
-        assertEquals("bitrate should default to 128000", 128000, compressed.bitrate)
-        assertFalse("preferRawStream should default to false", compressed.preferRawStream)
-    }
-
-    /**
-     * Helper function to simulate file creation logic from AudioRecorderManager
-     */
-    private fun createTestFile(config: RecordingConfig, isCompressed: Boolean): File {
-        val baseFilename = config.filename?.let {
-            it.substringBeforeLast('.', it)
-        } ?: "test_recording"
-
-        val extension = if (isCompressed) {
-            when (config.output.compressed.format.lowercase()) {
-                "aac" -> {
-                    if (config.output.compressed.preferRawStream) {
-                        "aac"  // Raw AAC stream
-                    } else {
-                        "m4a"  // M4A container (new default)
-                    }
-                }
-                "opus" -> "opus"  // Opus in OGG container
-                else -> config.output.compressed.format.lowercase()
-            }
-        } else {
-            "wav"
-        }
-
-        return File(tempDir, "$baseFilename.$extension")
-    }
-}