@siteed/expo-audio-studio 2.18.6 → 3.0.0

package/ios/tests/standalone/audio_recording_test.swift

@@ -1,277 +0,0 @@
-#!/usr/bin/env swift
-
-import Foundation
-import AVFoundation
-
-// Simple test framework
-struct TestResult {
-    let name: String
-    let passed: Bool
-    let message: String
-}
-
-class AudioRecordingTest {
-    var results: [TestResult] = []
-    let testDir: URL
-    var audioRecorder: AVAudioRecorder?
-    
-    init() {
-        // Create a temporary directory for test files
-        let tempDir = FileManager.default.temporaryDirectory
-        testDir = tempDir.appendingPathComponent("audio_recording_test_\(UUID().uuidString)")
-        try? FileManager.default.createDirectory(at: testDir, withIntermediateDirectories: true)
-    }
-    
-    deinit {
-        // Clean up test directory
-        try? FileManager.default.removeItem(at: testDir)
-    }
-    
-    func assert(_ condition: Bool, _ message: String, file: String = #file, line: Int = #line) {
-        let testName = "\(file.split(separator: "/").last ?? ""):\(line)"
-        results.append(TestResult(name: testName, passed: condition, message: message))
-        if !condition {
-            print("❌ FAILED: \(message) at \(testName)")
-        }
-    }
-    
-    func assertEqual<T: Equatable>(_ a: T, _ b: T, _ message: String = "", file: String = #file, line: Int = #line) {
-        let passed = a == b
-        let msg = message.isEmpty ? "\(a) should equal \(b)" : message
-        assert(passed, msg, file: file, line: line)
-    }
-    
-    func run() {
-        print("🧪 Running iOS Audio Recording Tests...\n")
-        
-        // Request permission first (in a real app)
-        setupAudioSession()
-        
-        testBasicWAVRecording()
-        testCompressedRecording()
-        testRecordingSettings()
-        testFileValidation()
-        
-        // Print summary
-        let passed = results.filter { $0.passed }.count
-        let total = results.count
-        
-        print("\n📊 Test Summary:")
-        print("   Total: \(total)")
-        print("   Passed: \(passed)")
-        print("   Failed: \(total - passed)")
-        
-        if passed == total {
-            print("\n✅ All tests passed!")
-        } else {
-            print("\n❌ Some tests failed!")
-            exit(1)
-        }
-    }
-    
-    func setupAudioSession() {
-        #if os(iOS)
-        let session = AVAudioSession.sharedInstance()
-        do {
-            try session.setCategory(.playAndRecord, mode: .default)
-            try session.setActive(true)
-            print("✓ Audio session configured")
-        } catch {
-            print("⚠️  Failed to setup audio session: \(error)")
-        }
-        #else
-        print("✓ Audio session setup skipped (macOS)")
-        #endif
-    }
-    
-    func testBasicWAVRecording() {
-        print("\nTesting basic WAV recording...")
-        
-        let wavURL = testDir.appendingPathComponent("test_recording.wav")
-        
-        // Configure recording settings for WAV
-        let settings: [String: Any] = [
-            AVFormatIDKey: Int(kAudioFormatLinearPCM),
-            AVSampleRateKey: 44100.0,
-            AVNumberOfChannelsKey: 2,
-            AVLinearPCMBitDepthKey: 16,
-            AVLinearPCMIsBigEndianKey: false,
-            AVLinearPCMIsFloatKey: false
-        ]
-        
-        do {
-            // Create recorder
-            audioRecorder = try AVAudioRecorder(url: wavURL, settings: settings)
-            assert(audioRecorder != nil, "Recorder should be created")
-            
-            // Prepare and record
-            let prepared = audioRecorder!.prepareToRecord()
-            assert(prepared, "Recorder should prepare successfully")
-            
-            let started = audioRecorder!.record()
-            assert(started, "Recording should start")
-            
-            // Record for a short time
-            Thread.sleep(forTimeInterval: 0.5)
-            
-            audioRecorder!.stop()
-            
-            // Verify file exists and has content
-            assert(FileManager.default.fileExists(atPath: wavURL.path), "WAV file should exist")
-            
-            let attributes = try FileManager.default.attributesOfItem(atPath: wavURL.path)
-            let fileSize = attributes[.size] as? Int64 ?? 0
-            assert(fileSize > 44, "WAV file should have content beyond header")
-            
-            // Verify WAV header
-            let data = try Data(contentsOf: wavURL)
-            let riffHeader = String(data: data[0..<4], encoding: .ascii)
-            assertEqual(riffHeader, "RIFF", "Should have RIFF header")
-            
-            let waveFormat = String(data: data[8..<12], encoding: .ascii)
-            assertEqual(waveFormat, "WAVE", "Should have WAVE format")
-            
-            print("✓ Basic WAV recording test completed")
-            
-        } catch {
-            assert(false, "Recording failed: \(error)")
-        }
-    }
-    
-    func testCompressedRecording() {
-        print("\nTesting compressed recording (AAC)...")
-        
-        let aacURL = testDir.appendingPathComponent("test_recording.m4a")
-        
-        // Configure recording settings for AAC
-        let settings: [String: Any] = [
-            AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
-            AVSampleRateKey: 44100.0,
-            AVNumberOfChannelsKey: 2,
-            AVEncoderBitRateKey: 128000,
-            AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue
-        ]
-        
-        do {
-            // Create recorder
-            audioRecorder = try AVAudioRecorder(url: aacURL, settings: settings)
-            assert(audioRecorder != nil, "AAC recorder should be created")
-            
-            // Record
-            let started = audioRecorder!.record()
-            assert(started, "AAC recording should start")
-            
-            Thread.sleep(forTimeInterval: 0.5)
-            audioRecorder!.stop()
-            
-            // Verify file
-            assert(FileManager.default.fileExists(atPath: aacURL.path), "AAC file should exist")
-            
-            let attributes = try FileManager.default.attributesOfItem(atPath: aacURL.path)
-            let fileSize = attributes[.size] as? Int64 ?? 0
-            assert(fileSize > 0, "AAC file should have content")
-            
-            // Verify it's a valid audio file by loading it
-            let audioFile = try AVAudioFile(forReading: aacURL)
-            assert(audioFile.length > 0, "AAC file should have audio frames")
-            assertEqual(Int(audioFile.fileFormat.sampleRate), 44100, "Sample rate should match")
-            
-            print("✓ Compressed recording test completed")
-            
-        } catch {
-            assert(false, "AAC recording failed: \(error)")
-        }
-    }
-    
-    func testRecordingSettings() {
-        print("\nTesting various recording settings...")
-        
-        // Test different sample rates
-        let sampleRates = [8000.0, 16000.0, 44100.0, 48000.0]
-        
-        for sampleRate in sampleRates {
-            let url = testDir.appendingPathComponent("test_\(Int(sampleRate))hz.wav")
-            
-            let settings: [String: Any] = [
-                AVFormatIDKey: Int(kAudioFormatLinearPCM),
-                AVSampleRateKey: sampleRate,
-                AVNumberOfChannelsKey: 1,
-                AVLinearPCMBitDepthKey: 16,
-                AVLinearPCMIsBigEndianKey: false,
-                AVLinearPCMIsFloatKey: false
-            ]
-            
-            do {
-                let recorder = try AVAudioRecorder(url: url, settings: settings)
-                assert(recorder.prepareToRecord(), "Should prepare at \(sampleRate)Hz")
-                
-                // Verify settings were applied
-                let appliedSettings = recorder.settings
-                let appliedRate = appliedSettings[AVSampleRateKey] as? Double ?? 0
-                assertEqual(appliedRate, sampleRate, "Sample rate should be \(sampleRate)")
-                
-            } catch {
-                assert(false, "Failed to create recorder at \(sampleRate)Hz: \(error)")
-            }
-        }
-        
-        print("✓ Recording settings test completed")
-    }
-    
-    func testFileValidation() {
-        print("\nTesting file validation and properties...")
-        
-        // Create a test recording
-        let url = testDir.appendingPathComponent("validation_test.wav")
-        let duration = 1.0 // 1 second
-        
-        let settings: [String: Any] = [
-            AVFormatIDKey: Int(kAudioFormatLinearPCM),
-            AVSampleRateKey: 16000.0,
-            AVNumberOfChannelsKey: 1,
-            AVLinearPCMBitDepthKey: 16,
-            AVLinearPCMIsBigEndianKey: false,
-            AVLinearPCMIsFloatKey: false
-        ]
-        
-        do {
-            audioRecorder = try AVAudioRecorder(url: url, settings: settings)
-            audioRecorder!.record()
-            
-            // Record for the specified duration
-            Thread.sleep(forTimeInterval: duration)
-            audioRecorder!.stop()
-            
-            // Load and validate the file
-            let audioFile = try AVAudioFile(forReading: url)
-            
-            // Check duration (should be close to 1 second)
-            let recordedDuration = Double(audioFile.length) / audioFile.fileFormat.sampleRate
-            assert(abs(recordedDuration - duration) < 0.5, "Duration should be close to \(duration)s (got \(recordedDuration)s)")
-            
-            // Check file format
-            assertEqual(Int(audioFile.fileFormat.sampleRate), 16000, "Sample rate should be 16kHz")
-            assertEqual(Int(audioFile.fileFormat.channelCount), 1, "Should be mono")
-            
-            // Calculate expected file size
-            let expectedDataSize = Int(16000 * duration * 2) // 16kHz * 1s * 2 bytes per sample
-            let expectedFileSize = expectedDataSize + 44 // Plus WAV header
-            
-            let attributes = try FileManager.default.attributesOfItem(atPath: url.path)
-            let actualFileSize = attributes[.size] as? Int64 ?? 0
-            
-            // Allow some tolerance (macOS may add extra metadata)
-            assert(abs(Int(actualFileSize) - expectedFileSize) < 5000, 
-                   "File size should be close to expected (\(actualFileSize) vs \(expectedFileSize))")
-            
-            print("✓ File validation test completed")
-            
-        } catch {
-            assert(false, "File validation failed: \(error)")
-        }
-    }
-}
-
-// Run the tests
-let test = AudioRecordingTest()
-test.run() 

package/ios/tests/standalone/audio_streaming_test.swift

@@ -1,249 +0,0 @@
-#!/usr/bin/env swift
-
-import Foundation
-import AVFoundation
-
-// Simple test framework
-struct TestResult {
-    let name: String
-    let passed: Bool
-    let message: String
-}
-
-class AudioStreamingTest {
-    var results: [TestResult] = []
-    let testDir: URL
-    var audioEngine: AVAudioEngine?
-    var inputNode: AVAudioInputNode?
-    
-    init() {
-        // Create a temporary directory for test files
-        let tempDir = FileManager.default.temporaryDirectory
-        testDir = tempDir.appendingPathComponent("audio_streaming_test_\(UUID().uuidString)")
-        try? FileManager.default.createDirectory(at: testDir, withIntermediateDirectories: true)
-    }
-    
-    deinit {
-        // Clean up
-        audioEngine?.stop()
-        try? FileManager.default.removeItem(at: testDir)
-    }
-    
-    func assert(_ condition: Bool, _ message: String, file: String = #file, line: Int = #line) {
-        let testName = "\(file.split(separator: "/").last ?? ""):\(line)"
-        results.append(TestResult(name: testName, passed: condition, message: message))
-        if !condition {
-            print("❌ FAILED: \(message) at \(testName)")
-        }
-    }
-    
-    func assertEqual<T: Equatable>(_ a: T, _ b: T, _ message: String = "", file: String = #file, line: Int = #line) {
-        let passed = a == b
-        let msg = message.isEmpty ? "\(a) should equal \(b)" : message
-        assert(passed, msg, file: file, line: line)
-    }
-    
-    func run() {
-        print("🧪 Running iOS Audio Streaming Tests...\n")
-        
-        testAudioEngineSetup()
-        testRealtimeStreaming()
-        testBufferProcessing()
-        testMultipleFormats()
-        
-        // Print summary
-        let passed = results.filter { $0.passed }.count
-        let total = results.count
-        
-        print("\n📊 Test Summary:")
-        print("   Total: \(total)")
-        print("   Passed: \(passed)")
-        print("   Failed: \(total - passed)")
-        
-        if passed == total {
-            print("\n✅ All tests passed!")
-        } else {
-            print("\n❌ Some tests failed!")
-            exit(1)
-        }
-    }
-    
-    func testAudioEngineSetup() {
-        print("Testing AVAudioEngine setup...")
-        
-        audioEngine = AVAudioEngine()
-        inputNode = audioEngine!.inputNode
-        
-        assert(audioEngine != nil, "Audio engine should be created")
-        assert(inputNode != nil, "Input node should be available")
-        
-        // Check input format
-        let inputFormat = inputNode!.inputFormat(forBus: 0)
-        assert(inputFormat.sampleRate > 0, "Input format should have valid sample rate")
-        assert(inputFormat.channelCount > 0, "Input format should have channels")
-        
-        print("  Sample rate: \(inputFormat.sampleRate) Hz")
-        print("  Channels: \(inputFormat.channelCount)")
-        print("  Format: \(inputFormat.commonFormat.rawValue)")
-        
-        print("✓ Audio engine setup test completed")
-    }
-    
-    func testRealtimeStreaming() {
-        print("\nTesting real-time audio streaming...")
-        
-        guard let engine = audioEngine, let input = inputNode else {
-            assert(false, "Audio engine not initialized")
-            return
-        }
-        
-        var bufferCount = 0
-        var totalFrames: AVAudioFrameCount = 0
-        let expectation = DispatchSemaphore(value: 0)
-        
-        // Install tap on input
-        let format = input.outputFormat(forBus: 0)
-        input.installTap(onBus: 0, bufferSize: 1024, format: format) { buffer, time in
-            bufferCount += 1
-            totalFrames += buffer.frameLength
-            
-            // Stop after collecting some buffers
-            if bufferCount >= 10 {
-                expectation.signal()
-            }
-        }
-        
-        do {
-            try engine.start()
-            assert(engine.isRunning, "Engine should be running")
-            
-            // Wait for buffers
-            let timeout = expectation.wait(timeout: .now() + 2.0)
-            assert(timeout == .success, "Should receive audio buffers within timeout")
-            
-            engine.stop()
-            input.removeTap(onBus: 0)
-            
-            assert(bufferCount >= 10, "Should have received at least 10 buffers")
-            assert(totalFrames > 0, "Should have received audio frames")
-            
-            print("  Received \(bufferCount) buffers")
-            print("  Total frames: \(totalFrames)")
-            
-            print("✓ Real-time streaming test completed")
-            
-        } catch {
-            assert(false, "Failed to start audio engine: \(error)")
-        }
-    }
-    
-    func testBufferProcessing() {
-        print("\nTesting buffer processing...")
-        
-        guard let engine = audioEngine, let input = inputNode else {
-            assert(false, "Audio engine not initialized")
-            return
-        }
-        
-        var processedBuffers = 0
-        var maxAmplitude: Float = 0
-        var totalRMS: Float = 0
-        let expectation = DispatchSemaphore(value: 0)
-        
-        let format = input.outputFormat(forBus: 0)
-        input.installTap(onBus: 0, bufferSize: 2048, format: format) { buffer, time in
-            // Process buffer
-            if let channelData = buffer.floatChannelData {
-                let frameLength = Int(buffer.frameLength)
-                let channelCount = Int(buffer.format.channelCount)
-                
-                for channel in 0..<channelCount {
-                    let samples = channelData[channel]
-                    
-                    // Find max amplitude
-                    for i in 0..<frameLength {
-                        let amplitude = abs(samples[i])
-                        if amplitude > maxAmplitude {
-                            maxAmplitude = amplitude
-                        }
-                    }
-                    
-                    // Calculate RMS
-                    var sum: Float = 0
-                    for i in 0..<frameLength {
-                        sum += samples[i] * samples[i]
-                    }
-                    let rms = sqrt(sum / Float(frameLength))
-                    totalRMS += rms
-                }
-            }
-            
-            processedBuffers += 1
-            if processedBuffers >= 5 {
-                expectation.signal()
-            }
-        }
-        
-        do {
-            try engine.start()
-            
-            let timeout = expectation.wait(timeout: .now() + 2.0)
-            assert(timeout == .success, "Should process buffers within timeout")
-            
-            engine.stop()
-            input.removeTap(onBus: 0)
-            
-            assert(processedBuffers >= 5, "Should have processed at least 5 buffers")
-            // Note: maxAmplitude might be 0 if there's silence
-            print("  Processed buffers: \(processedBuffers)")
-            print("  Max amplitude: \(maxAmplitude)")
-            print("  Average RMS: \(totalRMS / Float(processedBuffers))")
-            
-            print("✓ Buffer processing test completed")
-            
-        } catch {
-            assert(false, "Failed to process buffers: \(error)")
-        }
-    }
-    
-    func testMultipleFormats() {
-        print("\nTesting multiple audio formats...")
-        
-        // Test creating different format converters
-        let sampleRates = [8000.0, 16000.0, 44100.0, 48000.0]
-        
-        for sampleRate in sampleRates {
-            // Create a format
-            guard let format = AVAudioFormat(
-                commonFormat: .pcmFormatFloat32,
-                sampleRate: sampleRate,
-                channels: 1,
-                interleaved: false
-            ) else {
-                assert(false, "Failed to create format at \(sampleRate)Hz")
-                continue
-            }
-            
-            assert(format.sampleRate == sampleRate, "Format should have correct sample rate")
-            assert(format.channelCount == 1, "Format should be mono")
-            assert(format.commonFormat == .pcmFormatFloat32, "Format should be float32")
-            
-            // Test creating a buffer with this format
-            guard let buffer = AVAudioPCMBuffer(
-                pcmFormat: format,
-                frameCapacity: AVAudioFrameCount(sampleRate * 0.1) // 100ms
-            ) else {
-                assert(false, "Failed to create buffer at \(sampleRate)Hz")
-                continue
-            }
-            
-            assert(buffer.format.sampleRate == sampleRate, "Buffer format should match")
-        }
-        
-        print("✓ Multiple formats test completed")
-    }
-}
-
-// Run the tests
-let test = AudioStreamingTest()
-test.run() 

package/ios/tests/standalone/standalone_test.swift

@@ -1,144 +0,0 @@
-#!/usr/bin/env swift
-
-import Foundation
-import AVFoundation
-
-// Simple test framework
-struct TestResult {
-    let name: String
-    let passed: Bool
-    let message: String
-}
-
-class SimpleTest {
-    var results: [TestResult] = []
-    
-    func assert(_ condition: Bool, _ message: String, file: String = #file, line: Int = #line) {
-        let testName = "\(file.split(separator: "/").last ?? ""):\(line)"
-        results.append(TestResult(name: testName, passed: condition, message: message))
-        if !condition {
-            print("❌ FAILED: \(message) at \(testName)")
-        }
-    }
-    
-    func assertEqual<T: Equatable>(_ a: T, _ b: T, _ message: String = "", file: String = #file, line: Int = #line) {
-        let passed = a == b
-        let msg = message.isEmpty ? "\(a) should equal \(b)" : message
-        assert(passed, msg, file: file, line: line)
-    }
-    
-    func run() {
-        print("🧪 Running iOS Audio Tests...\n")
-        
-        testWAVHeader()
-        testAudioBuffer()
-        
-        // Print summary
-        let passed = results.filter { $0.passed }.count
-        let total = results.count
-        
-        print("\n📊 Test Summary:")
-        print("   Total: \(total)")
-        print("   Passed: \(passed)")
-        print("   Failed: \(total - passed)")
-        
-        if passed == total {
-            print("\n✅ All tests passed!")
-        } else {
-            print("\n❌ Some tests failed!")
-            exit(1)
-        }
-    }
-    
-    func testWAVHeader() {
-        print("Testing WAV header creation...")
-        
-        let sampleRate = 44100
-        let channels = 2
-        let bitsPerSample = 16
-        let dataSize = 1024
-        
-        // Create header
-        var header = Data()
-        
-        // RIFF chunk
-        header.append("RIFF".data(using: .ascii)!)
-        var fileSize = UInt32(dataSize + 36).littleEndian
-        header.append(Data(bytes: &fileSize, count: 4))
-        header.append("WAVE".data(using: .ascii)!)
-        
-        // fmt chunk
-        header.append("fmt ".data(using: .ascii)!)
-        var fmtSize = UInt32(16).littleEndian
-        header.append(Data(bytes: &fmtSize, count: 4))
-        var audioFormat = UInt16(1).littleEndian
-        header.append(Data(bytes: &audioFormat, count: 2))
-        var numChannels = UInt16(channels).littleEndian
-        header.append(Data(bytes: &numChannels, count: 2))
-        var sampleRateValue = UInt32(sampleRate).littleEndian
-        header.append(Data(bytes: &sampleRateValue, count: 4))
-        let byteRate = sampleRate * channels * (bitsPerSample / 8)
-        var byteRateValue = UInt32(byteRate).littleEndian
-        header.append(Data(bytes: &byteRateValue, count: 4))
-        let blockAlign = channels * (bitsPerSample / 8)
-        var blockAlignValue = UInt16(blockAlign).littleEndian
-        header.append(Data(bytes: &blockAlignValue, count: 2))
-        var bitsPerSampleValue = UInt16(bitsPerSample).littleEndian
-        header.append(Data(bytes: &bitsPerSampleValue, count: 2))
-        
-        // data chunk
-        header.append("data".data(using: .ascii)!)
-        var dataSizeValue = UInt32(dataSize).littleEndian
-        header.append(Data(bytes: &dataSizeValue, count: 4))
-        
-        // Tests
-        assertEqual(header.count, 44, "WAV header should be 44 bytes")
-        
-        let riffHeader = String(data: header[0..<4], encoding: .ascii)
-        assertEqual(riffHeader, "RIFF", "Should have RIFF header")
-        
-        let waveFormat = String(data: header[8..<12], encoding: .ascii)
-        assertEqual(waveFormat, "WAVE", "Should have WAVE format")
-        
-        print("✓ WAV header test completed")
-    }
-    
-    func testAudioBuffer() {
-        print("\nTesting audio buffer creation...")
-        
-        let sampleRate = 44100.0
-        let duration = 0.1
-        let frequency = 440.0
-        
-        let frameCount = Int(sampleRate * duration)
-        let format = AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1)!
-        
-        guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: AVAudioFrameCount(frameCount)) else {
-            assert(false, "Failed to create audio buffer")
-            return
-        }
-        
-        buffer.frameLength = AVAudioFrameCount(frameCount)
-        
-        // Generate sine wave
-        let channelData = buffer.floatChannelData![0]
-        for frame in 0..<frameCount {
-            let phase = 2.0 * Double.pi * frequency * Double(frame) / sampleRate
-            channelData[frame] = Float(sin(phase) * 0.5)
-        }
-        
-        // Tests
-        assertEqual(Int(buffer.frameLength), frameCount, "Frame length should match")
-        assertEqual(buffer.format.sampleRate, sampleRate, "Sample rate should match")
-        assertEqual(Int(buffer.format.channelCount), 1, "Should have 1 channel")
-        
-        let middleSample = channelData[frameCount / 4]
-        assert(abs(middleSample) > 0.001, "Middle sample should not be zero")
-        
-        print("✓ Audio buffer test completed")
-    }
-}
-
-// Run the tests
-let test = SimpleTest()
-test.run()