@siteed/expo-audio-studio 2.10.5 → 2.11.0

package/ios/ExpoAudioStudioTests/EventEmissionIntervalTests.swift

@@ -0,0 +1,105 @@
+import XCTest
+@testable import ExpoAudioStudio
+
+class EventEmissionIntervalTests: XCTestCase {
+    
+    var audioStreamManager: AudioStreamManager!
+    
+    override func setUp() {
+        super.setUp()
+        audioStreamManager = AudioStreamManager()
+    }
+    
+    override func tearDown() {
+        audioStreamManager = nil
+        super.tearDown()
+    }
+    
+    func testIntervalClamping() {
+        // Test case 1: Interval below minimum (10ms)
+        let config1 = RecordingConfig()
+        config1.interval = 10
+        config1.intervalAnalysis = 10
+        
+        audioStreamManager.prepareRecording(with: config1) { error in
+            XCTAssertNil(error, "Should prepare successfully")
+        }
+        
+        // After our fix, this should be 10ms (0.01s), not 100ms (0.1s)
+        XCTAssertEqual(audioStreamManager.emissionInterval, 0.01, accuracy: 0.001)
+        XCTAssertEqual(audioStreamManager.emissionIntervalAnalysis, 0.01, accuracy: 0.001)
+        
+        // Test case 2: Interval at old minimum (100ms)
+        let config2 = RecordingConfig()
+        config2.interval = 100
+        config2.intervalAnalysis = 100
+        
+        audioStreamManager.prepareRecording(with: config2) { error in
+            XCTAssertNil(error, "Should prepare successfully")
+        }
+        
+        XCTAssertEqual(audioStreamManager.emissionInterval, 0.1, accuracy: 0.001)
+        XCTAssertEqual(audioStreamManager.emissionIntervalAnalysis, 0.1, accuracy: 0.001)
+        
+        // Test case 3: Interval above minimum (200ms)
+        let config3 = RecordingConfig()
+        config3.interval = 200
+        config3.intervalAnalysis = 200
+        
+        audioStreamManager.prepareRecording(with: config3) { error in
+            XCTAssertNil(error, "Should prepare successfully")
+        }
+        
+        XCTAssertEqual(audioStreamManager.emissionInterval, 0.2, accuracy: 0.001)
+        XCTAssertEqual(audioStreamManager.emissionIntervalAnalysis, 0.2, accuracy: 0.001)
+    }
+    
+    func testEventEmissionTiming() {
+        let expectation = self.expectation(description: "Should emit events at correct intervals")
+        var eventTimestamps: [TimeInterval] = []
+        let testDuration: TimeInterval = 0.5 // 500ms
+        
+        // Configure for 10ms intervals
+        let config = RecordingConfig()
+        config.interval = 10
+        config.intervalAnalysis = 10
+        config.enableProcessing = true
+        config.features = ["fft": true]
+        
+        // Mock event handler to capture timestamps
+        audioStreamManager.onAudioData = { _ in
+            eventTimestamps.append(Date().timeIntervalSince1970)
+        }
+        
+        audioStreamManager.startRecording(with: config) { error in
+            XCTAssertNil(error, "Should start recording successfully")
+            
+            // Record for test duration
+            DispatchQueue.main.asyncAfter(deadline: .now() + testDuration) {
+                self.audioStreamManager.stopRecording()
+                
+                // Analyze intervals
+                if eventTimestamps.count > 1 {
+                    var intervals: [TimeInterval] = []
+                    for i in 1..<eventTimestamps.count {
+                        intervals.append((eventTimestamps[i] - eventTimestamps[i-1]) * 1000) // Convert to ms
+                    }
+                    
+                    let avgInterval = intervals.reduce(0, +) / Double(intervals.count)
+                    let minInterval = intervals.min() ?? 0
+                    let maxInterval = intervals.max() ?? 0
+                    
+                    print("Event emission intervals - Avg: \(avgInterval)ms, Min: \(minInterval)ms, Max: \(maxInterval)ms")
+                    
+                    // With the fix, average should be close to 10ms
+                    XCTAssertLessThan(abs(avgInterval - 10), 5, "Average interval should be close to 10ms")
+                    XCTAssertGreaterThan(minInterval, 5, "Minimum interval should be at least 5ms")
+                }
+                
+                expectation.fulfill()
+            }
+        }
+        
+        waitForExpectations(timeout: testDuration + 1.0)
+    }
+}

package/ios/tests/README.md

@@ -0,0 +1,41 @@
+# iOS Audio Format Tests
+
+This directory contains test scripts for validating audio format support on iOS/macOS.
+
+## Opus Support Test
+
+The `opus_support_test_macos.swift` script verifies that while `kAudioFormatOpus` is defined in the iOS SDK, AVAudioRecorder cannot actually encode Opus audio.
+
+### Running the Test
+
+```bash
+# On macOS (for quick validation)
+swift opus_support_test_macos.swift
+
+# On iOS device/simulator (requires Xcode)
+# Copy the test to an iOS project and run it
+```
+
+### Test Results
+
+- ✅ `kAudioFormatOpus` constant exists (value: 1869641075)
+- ✅ AVAudioRecorder accepts Opus settings without errors
+- ❌ Recording produces 0-byte files (no actual encoding)
+- ✅ AAC format works correctly as fallback
+
+### Why This Matters
+
+This test proves that expo-audio-studio's automatic fallback from Opus to AAC on iOS is necessary and correct. Despite the SDK defining the Opus format constant, the actual encoding functionality is not implemented in AVAudioRecorder.
+
+## Format Verification
+
+To verify actual file formats:
+
+```bash
+# Check file type
+file recording.m4a  # Should show: ISO Media, MP4 Base Media
+file recording.aac  # Should show: ADTS, AAC
+
+# Get detailed info (requires mediainfo)
+mediainfo recording.m4a
+```

package/ios/tests/opus_support_test_macos.swift

@@ -0,0 +1,154 @@
+#!/usr/bin/env swift
+
+import AVFoundation
+import Foundation
+
+// Test script to verify if AVAudioRecorder actually supports Opus encoding
+// This version is macOS-compatible for testing purposes
+
+func testOpusSupport() {
+    print("Testing AVAudioRecorder Opus Support (macOS test)...")
+    print("--------------------------------------------------")
+    
+    // Test 1: Check if kAudioFormatOpus is defined
+    let opusFormat = kAudioFormatOpus
+    print("✓ kAudioFormatOpus is defined: \(opusFormat) (0x\(String(opusFormat, radix: 16)))")
+    
+    // Convert to FourCC string
+    let fourCC = String(format: "%c%c%c%c",
+                       (opusFormat >> 24) & 0xff,
+                       (opusFormat >> 16) & 0xff,
+                       (opusFormat >> 8) & 0xff,
+                       opusFormat & 0xff)
+    print("  FourCC: '\(fourCC)'")
+    print()
+    
+    // Test 2: Try to create AVAudioRecorder with Opus settings
+    print("Testing AVAudioRecorder with Opus settings...")
+    
+    let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
+    let opusURL = documentsPath.appendingPathComponent("test_opus.opus")
+    let aacURL = documentsPath.appendingPathComponent("test_aac.m4a")
+    
+    // Opus settings
+    let opusSettings: [String: Any] = [
+        AVFormatIDKey: kAudioFormatOpus,
+        AVSampleRateKey: 48000,
+        AVNumberOfChannelsKey: 1,
+        AVEncoderBitRateKey: 64000
+    ]
+    
+    // AAC settings for comparison
+    let aacSettings: [String: Any] = [
+        AVFormatIDKey: kAudioFormatMPEG4AAC,
+        AVSampleRateKey: 48000,
+        AVNumberOfChannelsKey: 1,
+        AVEncoderBitRateKey: 64000
+    ]
+    
+    // Test Opus recorder
+    do {
+        let opusRecorder = try AVAudioRecorder(url: opusURL, settings: opusSettings)
+        print("✓ Opus recorder created successfully")
+        print("  URL: \(opusURL.lastPathComponent)")
+        print("  Settings provided: \(opusSettings)")
+        print("  Settings after init: \(opusRecorder.settings)")
+        print("  Format: \(opusRecorder.format)")
+        
+        // Check if recorder can prepare
+        if opusRecorder.prepareToRecord() {
+            print("✓ Opus recorder prepared successfully")
+            
+            // Try to record for a brief moment
+            if opusRecorder.record() {
+                print("✓ Opus recorder started recording")
+                Thread.sleep(forTimeInterval: 0.5)
+                opusRecorder.stop()
+                print("✓ Opus recorder stopped")
+                
+                // Check if file was created
+                if FileManager.default.fileExists(atPath: opusURL.path) {
+                    let attributes = try FileManager.default.attributesOfItem(atPath: opusURL.path)
+                    let fileSize = attributes[.size] as? Int64 ?? 0
+                    print("✓ Opus file created: \(fileSize) bytes")
+                    
+                    // Check file format by reading header
+                    if fileSize > 0 {
+                        let fileHandle = try FileHandle(forReadingFrom: opusURL)
+                        let headerData = fileHandle.readData(ofLength: 32)
+                        fileHandle.closeFile()
+                        
+                        print("  File header (hex): \(headerData.map { String(format: "%02X", $0) }.prefix(16).joined(separator: " "))")
+                        
+                        // Check for common audio file signatures
+                        if headerData.count >= 4 {
+                            let signature = headerData.prefix(4)
+                            if signature.starts(with: "OggS".data(using: .ascii)!) {
+                                print("  ✓ File has OGG container signature")
+                            } else if signature.starts(with: [0x00, 0x00, 0x00]) {
+                                print("  File might be MP4/M4A container")
+                            } else {
+                                print("  Unknown file signature")
+                            }
+                        }
+                    }
+                    
+                    // Clean up
+                    try FileManager.default.removeItem(at: opusURL)
+                } else {
+                    print("✗ No Opus file was created")
+                }
+            } else {
+                print("✗ Opus recorder failed to start recording")
+            }
+        } else {
+            print("✗ Opus recorder failed to prepare")
+        }
+    } catch {
+        print("✗ Failed to create Opus recorder: \(error)")
+        print("  Error details: \(error.localizedDescription)")
+    }
+    
+    print()
+    
+    // Test AAC recorder for comparison
+    print("Testing AVAudioRecorder with AAC settings (for comparison)...")
+    do {
+        let aacRecorder = try AVAudioRecorder(url: aacURL, settings: aacSettings)
+        print("✓ AAC recorder created successfully")
+        print("  Settings after init: \(aacRecorder.settings)")
+        print("  Format: \(aacRecorder.format)")
+        
+        if aacRecorder.prepareToRecord() && aacRecorder.record() {
+            print("✓ AAC recorder working normally")
+            Thread.sleep(forTimeInterval: 0.5)
+            aacRecorder.stop()
+            
+            if FileManager.default.fileExists(atPath: aacURL.path) {
+                let attributes = try FileManager.default.attributesOfItem(atPath: aacURL.path)
+                let fileSize = attributes[.size] as? Int64 ?? 0
+                print("✓ AAC file created: \(fileSize) bytes")
+                
+                // Check file header
+                let fileHandle = try FileHandle(forReadingFrom: aacURL)
+                let headerData = fileHandle.readData(ofLength: 16)
+                fileHandle.closeFile()
+                
+                print("  File header (hex): \(headerData.map { String(format: "%02X", $0) }.joined(separator: " "))")
+                
+                try FileManager.default.removeItem(at: aacURL)
+            }
+        }
+    } catch {
+        print("✗ Failed to create AAC recorder: \(error)")
+    }
+    
+    print()
+    print("Test complete!")
+    print()
+    print("Note: This test runs on macOS which may have different codec support than iOS.")
+    print("The results should be validated on an actual iOS device or simulator.")
+}
+
+// Run the test
+testOpusSupport()

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@siteed/expo-audio-studio",
-    "version": "2.10.5",
+    "version": "2.11.0",
     "description": "Comprehensive audio processing library for React Native and Expo with recording, analysis, visualization, and streaming capabilities across iOS, Android, and web",
     "license": "MIT",
     "type": "commonjs",
@@ -84,7 +84,7 @@
         "test:android:unit": "cd ../../apps/playground/android && ./gradlew :siteed-expo-audio-studio:test",
         "test:android:instrumented": "cd ../../apps/playground/android && ./gradlew :siteed-expo-audio-studio:connectedAndroidTest",
         "test:android:unit:watch": "cd ../../apps/playground/android && ./gradlew :siteed-expo-audio-studio:test --continuous",
-        "test:ios": "cd ios && xcodebuild test -workspace ExpoAudioStudio.xcworkspace -scheme ExpoAudioStudio -destination 'platform=iOS Simulator,name=iPhone 14'",
+        "test:ios": "cd ../../apps/playground/ios && xcodebuild -workspace AudioDevPlayground.xcworkspace -scheme AudioDevPlayground -destination 'platform=iOS Simulator,name=iPhone 15' build",
         "test:coverage": "cd ../../apps/playground/android && ./gradlew :siteed-expo-audio-studio:jacocoTestReport",
         "typecheck": "tsc --noEmit",
         "docgen": "typedoc src/index.ts --plugin typedoc-plugin-markdown --readme none --out ../../documentation_site/docs/api-reference/API",

package/src/ExpoAudioStream.types.ts

@@ -311,6 +311,13 @@ export interface OutputConfig {
         format?: 'aac' | 'opus'
         /** Bitrate for compression in bits per second (default: 128000) */
         bitrate?: number
+        /**
+         * Prefer raw stream over container format (Android only)
+         * - true: Use raw AAC stream (.aac files) like in v2.10.6
+         * - false/undefined: Use M4A container (.m4a files) for better seeking support
+         * Note: iOS always produces M4A containers and ignores this flag
+         */
+        preferRawStream?: boolean
     }
 
     // Future enhancement: Post-processing pipeline
@@ -332,10 +339,10 @@ export interface RecordingConfig {
     /** Encoding type for the recording (pcm_32bit, pcm_16bit, pcm_8bit) */
     encoding?: EncodingType
 
-    /** Interval in milliseconds at which to emit recording data */
+    /** Interval in milliseconds at which to emit recording data (minimum: 10ms) */
     interval?: number
 
-    /** Interval in milliseconds at which to emit analysis data */
+    /** Interval in milliseconds at which to emit analysis data (minimum: 10ms) */
     intervalAnalysis?: number
 
     /** Keep the device awake while recording (default is false) */