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

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

@@ -1,273 +0,0 @@
-package net.siteed.audiostudio
-
-import org.junit.Test
-import org.junit.Assert.*
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-import kotlin.math.abs
-
-class AudioFormatUtilsTest {
-
-    @Test
-    fun testConvertBitDepth_8to16() {
-        // Given - 8-bit PCM data (unsigned, centered at 128)
-        val input8bit = byteArrayOf(0, 64, 128.toByte(), 192.toByte(), 255.toByte())
-        
-        // When
-        val output16bit = AudioFormatUtils.convertBitDepth(input8bit, 8, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(output16bit).order(ByteOrder.LITTLE_ENDIAN)
-        val samples = ShortArray(output16bit.size / 2)
-        buffer.asShortBuffer().get(samples)
-        
-        // Verify conversion (8-bit 128 = silence = 16-bit 0)
-        assertEquals("First sample should be -32768", -32768, samples[0].toInt())
-        assertEquals("Middle sample (128) should be 0", 0, samples[2].toInt())
-        assertEquals("Last sample should be 32767", 32767, samples[4].toInt())
-    }
-
-    @Test
-    fun testConvertBitDepth_16to8() {
-        // Given - 16-bit PCM data
-        val buffer16 = ByteBuffer.allocate(10).order(ByteOrder.LITTLE_ENDIAN)
-        buffer16.putShort(-32768) // Min value
-        buffer16.putShort(-16384) // -0.5
-        buffer16.putShort(0)      // Silence
-        buffer16.putShort(16384)  // 0.5
-        buffer16.putShort(32767)  // Max value
-        
-        // When
-        val output8bit = AudioFormatUtils.convertBitDepth(buffer16.array(), 16, 8)
-        
-        // Then
-        assertEquals("Should have 5 samples", 5, output8bit.size)
-        assertEquals("Min should convert to 0", 0, output8bit[0].toInt() and 0xFF)
-        assertEquals("Silence should convert to 128", 128, output8bit[2].toInt() and 0xFF)
-        assertEquals("Max should convert to 255", 255, output8bit[4].toInt() and 0xFF)
-    }
-
-    @Test
-    fun testConvertBitDepth_16to32() {
-        // Given - 16-bit PCM data
-        val buffer16 = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN)
-        buffer16.putShort(-32768) // Min
-        buffer16.putShort(0)      // Silence
-        buffer16.putShort(32767)  // Max
-        
-        // When
-        val output32bit = AudioFormatUtils.convertBitDepth(buffer16.array(), 16, 32)
-        
-        // Then
-        val buffer32 = ByteBuffer.wrap(output32bit).order(ByteOrder.LITTLE_ENDIAN)
-        assertEquals("Should have 3 32-bit samples", 12, output32bit.size)
-        
-        // Check values (scaled appropriately)
-        val sample1 = buffer32.getInt()
-        val sample2 = buffer32.getInt()
-        val sample3 = buffer32.getInt()
-        
-        assertTrue("Min value should be negative", sample1 < 0)
-        assertEquals("Silence should be 0", 0, sample2)
-        assertTrue("Max value should be positive", sample3 > 0)
-    }
-
-    @Test
-    fun testConvertBitDepth_32to16() {
-        // Given - 32-bit PCM data
-        val buffer32 = ByteBuffer.allocate(12).order(ByteOrder.LITTLE_ENDIAN)
-        buffer32.putInt(Int.MIN_VALUE)  // Min
-        buffer32.putInt(0)              // Silence
-        buffer32.putInt(Int.MAX_VALUE)  // Max
-        
-        // When
-        val output16bit = AudioFormatUtils.convertBitDepth(buffer32.array(), 32, 16)
-        
-        // Then
-        val buffer16 = ByteBuffer.wrap(output16bit).order(ByteOrder.LITTLE_ENDIAN)
-        assertEquals("Should have 3 16-bit samples", 6, output16bit.size)
-        
-        assertEquals("Min should convert to -32768", -32768, buffer16.getShort().toInt())
-        assertEquals("Silence should be 0", 0, buffer16.getShort().toInt())
-        assertEquals("Max should convert to 32767", 32767, buffer16.getShort().toInt())
-    }
-
-    @Test
-    fun testConvertBitDepth_sameDepth() {
-        // Given
-        val input = byteArrayOf(1, 2, 3, 4, 5, 6)
-        
-        // When - Convert 16 to 16 (no-op)
-        val output = AudioFormatUtils.convertBitDepth(input, 16, 16)
-        
-        // Then
-        assertArrayEquals("Should return same data", input, output)
-    }
-
-    @Test
-    fun testConvertBitDepth_emptyData() {
-        // Given
-        val emptyData = byteArrayOf()
-        
-        // When
-        val output = AudioFormatUtils.convertBitDepth(emptyData, 16, 32)
-        
-        // Then
-        assertEquals("Should return empty array", 0, output.size)
-    }
-
-    @Test
-    fun testConvertChannels_monoToStereo() {
-        // Given - Mono 16-bit data
-        val monoData = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN).apply {
-            putShort(1000)
-            putShort(2000)
-            putShort(3000)
-        }.array()
-        
-        // When
-        val stereoData = AudioFormatUtils.convertChannels(monoData, 1, 2, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(stereoData).order(ByteOrder.LITTLE_ENDIAN)
-        assertEquals("Should have 6 samples (3 stereo pairs)", 12, stereoData.size)
-        
-        // Each mono sample should be duplicated to both channels
-        assertEquals("L1", 1000, buffer.getShort().toInt())
-        assertEquals("R1", 1000, buffer.getShort().toInt())
-        assertEquals("L2", 2000, buffer.getShort().toInt())
-        assertEquals("R2", 2000, buffer.getShort().toInt())
-        assertEquals("L3", 3000, buffer.getShort().toInt())
-        assertEquals("R3", 3000, buffer.getShort().toInt())
-    }
-
-    @Test
-    fun testConvertChannels_stereoToMono() {
-        // Given - Stereo 16-bit data
-        val stereoData = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).apply {
-            putShort(1000)  // L1
-            putShort(2000)  // R1
-            putShort(3000)  // L2
-            putShort(4000)  // R2
-        }.array()
-        
-        // When
-        val monoData = AudioFormatUtils.convertChannels(stereoData, 2, 1, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(monoData).order(ByteOrder.LITTLE_ENDIAN)
-        assertEquals("Should have 2 mono samples", 4, monoData.size)
-        
-        // Each mono sample should be average of L+R
-        assertEquals("Sample 1", 1500, buffer.getShort().toInt()) // (1000+2000)/2
-        assertEquals("Sample 2", 3500, buffer.getShort().toInt()) // (3000+4000)/2
-    }
-
-    @Test
-    fun testNormalizeAudio_quietSignal() {
-        // Given - Quiet 16-bit signal
-        val quietData = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN).apply {
-            putShort(100)
-            putShort(-100)
-            putShort(50)
-        }.array()
-        
-        // When
-        val normalized = AudioFormatUtils.normalizeAudio(quietData, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(normalized).order(ByteOrder.LITTLE_ENDIAN)
-        val maxSample = abs(buffer.getShort().toInt())
-        buffer.rewind()
-        
-        // The loudest sample should be close to max value
-        assertTrue("Should be normalized to near max", maxSample > 30000)
-    }
-
-    @Test
-    fun testNormalizeAudio_alreadyLoud() {
-        // Given - Already loud signal
-        val loudData = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).apply {
-            putShort(32000)
-            putShort(-32000)
-        }.array()
-        
-        // When
-        val normalized = AudioFormatUtils.normalizeAudio(loudData, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(normalized).order(ByteOrder.LITTLE_ENDIAN)
-        val sample1 = abs(buffer.getShort().toInt())
-        val sample2 = abs(buffer.getShort().toInt())
-        
-        // Should be normalized but not clipped
-        assertTrue("Samples should be near max", sample1 > 32000 && sample2 > 32000)
-        assertTrue("Samples should not exceed max", sample1 <= 32767 && sample2 <= 32767)
-    }
-
-    @Test
-    fun testNormalizeAudio_silentSignal() {
-        // Given - Silent signal
-        val silentData = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN).apply {
-            putShort(0)
-            putShort(0)
-            putShort(0)
-        }.array()
-        
-        // When
-        val normalized = AudioFormatUtils.normalizeAudio(silentData, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(normalized).order(ByteOrder.LITTLE_ENDIAN)
-        assertEquals("Silent should remain silent", 0, buffer.getShort().toInt())
-        assertEquals("Silent should remain silent", 0, buffer.getShort().toInt())
-        assertEquals("Silent should remain silent", 0, buffer.getShort().toInt())
-    }
-
-    @Test
-    fun testResampleAudio_upsample() {
-        // Given - 8kHz mono audio
-        val samples8k = floatArrayOf(0.0f, 0.5f, 1.0f, 0.5f, 0.0f, -0.5f, -1.0f, -0.5f)
-        
-        // When - Upsample to 16kHz
-        val samples16k = AudioFormatUtils.resampleAudio(samples8k, 8000, 16000)
-        
-        // Then
-        assertEquals("Should have approximately double samples", 16, samples16k.size)
-        // First and last samples should match
-        assertEquals("First sample", samples8k[0], samples16k[0], 0.01f)
-        assertEquals("Last sample", samples8k.last(), samples16k.last(), 0.01f)
-    }
-
-    @Test
-    fun testResampleAudio_downsample() {
-        // Given - 16kHz mono audio
-        val samples16k = floatArrayOf(
-            0.0f, 0.25f, 0.5f, 0.75f, 1.0f, 0.75f, 0.5f, 0.25f,
-            0.0f, -0.25f, -0.5f, -0.75f, -1.0f, -0.75f, -0.5f, -0.25f
-        )
-        
-        // When - Downsample to 8kHz
-        val samples8k = AudioFormatUtils.resampleAudio(samples16k, 16000, 8000)
-        
-        // Then
-        assertEquals("Should have approximately half samples", 8, samples8k.size)
-        // Check general shape is preserved
-        val maxValue = samples8k.maxOrNull() ?: 0f
-        val minValue = samples8k.minOrNull() ?: 0f
-        assertTrue("Peak should be preserved", maxValue > 0.9f)
-        assertTrue("Trough should be preserved", minValue < -0.9f)
-    }
-
-    @Test
-    fun testResampleAudio_sameRate() {
-        // Given
-        val samples = floatArrayOf(0.1f, 0.2f, 0.3f, 0.4f, 0.5f)
-        
-        // When - Same sample rate
-        val resampled = AudioFormatUtils.resampleAudio(samples, 44100, 44100)
-        
-        // Then
-        assertArrayEquals("Should return same samples", samples, resampled, 0.001f)
-    }
-} 

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

@@ -1,140 +0,0 @@
-package net.siteed.audiostudio
-
-import org.junit.Assert.*
-import org.junit.Test
-
-/**
- * Unit test for Device Disconnection Fallback Behavior
- * 
- * Tests the configuration and expected behavior for device disconnection scenarios.
- */
-class DeviceDisconnectionFallbackUnitTest {
-
-    @Test
-    fun `test RecordingConfig stores deviceDisconnectionBehavior correctly`() {
-        // Test fallback behavior
-        val fallbackConfig = RecordingConfig(
-            sampleRate = 44100,
-            channels = 1,
-            encoding = "pcm_16bit",
-            deviceDisconnectionBehavior = "fallback"
-        )
-        
-        assertEquals("Should store fallback behavior", "fallback", fallbackConfig.deviceDisconnectionBehavior)
-        
-        // Test pause behavior
-        val pauseConfig = RecordingConfig(
-            sampleRate = 44100,
-            channels = 1,
-            encoding = "pcm_16bit",
-            deviceDisconnectionBehavior = "pause"
-        )
-        
-        assertEquals("Should store pause behavior", "pause", pauseConfig.deviceDisconnectionBehavior)
-        
-        // Test default behavior (should be null)
-        val defaultConfig = RecordingConfig(
-            sampleRate = 44100,
-            channels = 1,
-            encoding = "pcm_16bit"
-        )
-        
-        assertNull("Default behavior should be null", defaultConfig.deviceDisconnectionBehavior)
-    }
-
-    @Test
-    fun `test AudioRecorderManager stores deviceDisconnectionBehavior`() {
-        val config = RecordingConfig(
-            sampleRate = 44100,
-            channels = 1,
-            encoding = "pcm_16bit",
-            deviceDisconnectionBehavior = "fallback"
-        )
-        
-        // Verify the config has the correct behavior
-        assertEquals("fallback", config.deviceDisconnectionBehavior)
-        
-        // AudioRecorderManager should use this configuration
-        // The actual AudioRecorderManager.getDeviceDisconnectionBehavior() 
-        // will return this value when recording is started with this config
-    }
-
-    @Test
-    fun `test device disconnection behavior values`() {
-        val validBehaviors = listOf("fallback", "pause")
-        
-        for (behavior in validBehaviors) {
-            val config = RecordingConfig(
-                sampleRate = 44100,
-                channels = 1,
-                encoding = "pcm_16bit",
-                deviceDisconnectionBehavior = behavior
-            )
-            
-            assertEquals("Should accept $behavior behavior", behavior, config.deviceDisconnectionBehavior)
-        }
-    }
-
-    @Test
-    fun `test interruption event reasons`() {
-        // Test expected event reasons for device disconnection scenarios
-        val expectedReasons = mapOf(
-            "fallback" to listOf("deviceFallback", "deviceSwitchFailed"),
-            "pause" to listOf("deviceDisconnected")
-        )
-        
-        // Verify the expected reasons are valid strings
-        expectedReasons.forEach { (behavior, reasons) ->
-            assertNotNull("Behavior $behavior should have reasons", reasons)
-            assertTrue("Behavior $behavior should have at least one reason", reasons.isNotEmpty())
-            
-            reasons.forEach { reason ->
-                assertNotNull("Reason should not be null", reason)
-                assertTrue("Reason should not be empty", reason.isNotEmpty())
-            }
-        }
-    }
-
-    @Test
-    fun `test fallback behavior logic`() {
-        // Test the logic for fallback behavior
-        val behavior = "fallback"
-        
-        // When behavior is fallback:
-        // 1. Should attempt to get default device
-        // 2. If default device exists, should select it
-        // 3. If selection succeeds, should send "deviceFallback" event
-        // 4. If selection fails, should pause and send "deviceSwitchFailed" event
-        // 5. If no default device, should pause and send "deviceDisconnected" event
-        
-        when (behavior) {
-            "fallback" -> {
-                // This branch should be taken
-                assertTrue("Should handle fallback behavior", true)
-            }
-            else -> {
-                fail("Should not reach default case for fallback behavior")
-            }
-        }
-    }
-
-    @Test
-    fun `test pause behavior logic`() {
-        // Test the logic for pause behavior
-        val behavior = "pause"
-        
-        // When behavior is pause:
-        // 1. Should pause recording immediately
-        // 2. Should send "deviceDisconnected" event
-        
-        when (behavior) {
-            "fallback" -> {
-                fail("Should not handle as fallback")
-            }
-            else -> {
-                // This branch should be taken for pause
-                assertTrue("Should handle pause behavior", true)
-            }
-        }
-    }
-}

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

@@ -1,49 +0,0 @@
-package net.siteed.audiostudio
-
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
-import org.junit.Test
-
-class InterruptionAutoResumePolicyTest {
-    @Test
-    fun autoResumesOnlyWhenSystemInterruptionPausedRecording() {
-        assertTrue(InterruptionAutoResumePolicy.shouldAutoResume(
-            autoResumeAfterInterruption = true,
-            isRecording = true,
-            isPaused = true,
-            pausedBySystemInterruption = true
-        ))
-    }
-
-    @Test
-    fun doesNotAutoResumeUserPausedRecording() {
-        assertFalse(InterruptionAutoResumePolicy.shouldAutoResume(
-            autoResumeAfterInterruption = true,
-            isRecording = true,
-            isPaused = true,
-            pausedBySystemInterruption = false
-        ))
-    }
-
-    @Test
-    fun requiresAutoResumeAndActivePausedRecording() {
-        assertFalse(InterruptionAutoResumePolicy.shouldAutoResume(
-            autoResumeAfterInterruption = false,
-            isRecording = true,
-            isPaused = true,
-            pausedBySystemInterruption = true
-        ))
-        assertFalse(InterruptionAutoResumePolicy.shouldAutoResume(
-            autoResumeAfterInterruption = true,
-            isRecording = false,
-            isPaused = true,
-            pausedBySystemInterruption = true
-        ))
-        assertFalse(InterruptionAutoResumePolicy.shouldAutoResume(
-            autoResumeAfterInterruption = true,
-            isRecording = true,
-            isPaused = false,
-            pausedBySystemInterruption = true
-        ))
-    }
-}

package/android/src/test/resources/generate_test_audio.py

@@ -1,94 +0,0 @@
-#!/usr/bin/env python3
-"""
-Generate test WAV files for Android unit tests
-"""
-
-import wave
-import struct
-import math
-import array
-
-def generate_sine_wave(frequency, duration, sample_rate, amplitude=0.5):
-    """Generate sine wave samples"""
-    num_samples = int(duration * sample_rate)
-    samples = []
-    for i in range(num_samples):
-        t = i / sample_rate
-        value = amplitude * math.sin(2 * math.pi * frequency * t)
-        # Convert to 16-bit PCM
-        pcm_value = int(value * 32767)
-        samples.append(pcm_value)
-    return samples
-
-def create_wav_file(filename, channels, sample_rate, bit_depth, duration, frequency=440):
-    """Create a WAV file with specified parameters"""
-    print(f"Creating {filename}...")
-    
-    # Generate samples for left channel (or mono)
-    samples = generate_sine_wave(frequency, duration, sample_rate)
-    
-    # For stereo, generate right channel with different frequency
-    if channels == 2:
-        right_samples = generate_sine_wave(frequency * 1.5, duration, sample_rate)
-    
-    # Prepare the data
-    if bit_depth == 16:
-        # Create array of signed shorts
-        audio_data = array.array('h')  # signed short
-        
-        for i in range(len(samples)):
-            if channels == 1:
-                audio_data.append(samples[i])
-            else:
-                # Interleave stereo samples
-                audio_data.append(samples[i])
-                audio_data.append(right_samples[i])
-    elif bit_depth == 8:
-        # Create array of unsigned bytes
-        audio_data = array.array('B')  # unsigned char
-        
-        for i in range(len(samples)):
-            # Convert to 8-bit unsigned
-            sample_8bit = ((samples[i] + 32768) >> 8) & 0xFF
-            if channels == 1:
-                audio_data.append(sample_8bit)
-            else:
-                right_8bit = ((right_samples[i] + 32768) >> 8) & 0xFF
-                audio_data.append(sample_8bit)
-                audio_data.append(right_8bit)
-    else:
-        raise ValueError(f"Unsupported bit depth: {bit_depth}")
-    
-    # Write WAV file
-    with wave.open(filename, 'wb') as wav_file:
-        wav_file.setnchannels(channels)
-        wav_file.setsampwidth(bit_depth // 8)
-        wav_file.setframerate(sample_rate)
-        wav_file.writeframes(audio_data.tobytes())
-    
-    print(f"  Created: {filename} ({duration}s, {sample_rate}Hz, {channels}ch, {bit_depth}bit)")
-
-# Generate test files
-if __name__ == "__main__":
-    try:
-        # Basic mono file
-        create_wav_file("test_mono_16bit_44100.wav", 
-                       channels=1, sample_rate=44100, bit_depth=16, duration=1.0)
-        
-        # Stereo file
-        create_wav_file("test_stereo_16bit_48000.wav", 
-                       channels=2, sample_rate=48000, bit_depth=16, duration=1.0)
-        
-        # Short duration file
-        create_wav_file("test_short_100ms.wav", 
-                       channels=1, sample_rate=44100, bit_depth=16, duration=0.1)
-        
-        # Silent file (0 Hz frequency)
-        create_wav_file("test_silence.wav", 
-                       channels=1, sample_rate=44100, bit_depth=16, duration=0.5, frequency=0)
-        
-        print("\nAll test WAV files generated successfully!")
-    except Exception as e:
-        print(f"Error: {e}")
-        import traceback
-        traceback.print_exc()