@siteed/audio-studio 3.0.4 → 3.1.0

package/ios/AudioStreamManager.swift

@@ -14,6 +14,7 @@ import UserNotifications
 
 // Constants
 internal let WAV_HEADER_SIZE: Int64 = 44  // Standard WAV header is 44 bytes
+internal let MIN_AAC_COMPRESSED_SAMPLE_RATE: Double = 44100.0
 
 // Helper to convert to little-endian byte array
 extension UInt32 {
@@ -152,6 +153,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
     
     // Add property to track auto-resume preference
     private var autoResumeAfterInterruption: Bool = false
+    private var pausedBySystemInterruption: Bool = false
     
     // Add these properties
     private var emissionInterval: TimeInterval = 1.0  // Default 1 second
@@ -167,6 +169,28 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
     private var cachedWavFileSize: Int64 = 0
     private var cachedCompressedFileSize: Int64 = 0
 
+    /// Returns an AVAudioRecorder-compatible sample rate for AAC sidecar files.
+    ///
+    /// The primary WAV path can resample emitted PCM to `settings.sampleRate`,
+    /// but the compressed sidecar is produced by AVAudioRecorder directly from
+    /// the active audio session. AVAudioRecorder fails to prepare AAC/M4A files
+    /// below 44.1 kHz, so keep valid requested rates and otherwise use the
+    /// active session rate when available, falling back to 44.1 kHz.
+    internal static func compatibleAACCompressedSampleRate(
+        requestedSampleRate: Double,
+        sessionSampleRate: Double
+    ) -> Double {
+        if requestedSampleRate >= MIN_AAC_COMPRESSED_SAMPLE_RATE {
+            return requestedSampleRate
+        }
+
+        if sessionSampleRate.isFinite && sessionSampleRate >= MIN_AAC_COMPRESSED_SAMPLE_RATE {
+            return sessionSampleRate
+        }
+
+        return MIN_AAC_COMPRESSED_SAMPLE_RATE
+    }
+
     /// Initializes the AudioStreamManager
     override init() {
         super.init()
@@ -231,7 +255,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             // Store the pause start time if not already paused
             if !wasSuspended {
                 currentPauseStart = Date()
-                pauseRecording()
+                pauseRecording(isSystemInterruption: true)
             }
             
             // Always notify delegate of interruption
@@ -248,17 +272,17 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             if let optionsValue = userInfo[AVAudioSessionInterruptionOptionKey] as? UInt {
                 let options = AVAudioSession.InterruptionOptions(rawValue: optionsValue)
                 Logger.debug("AudioStreamManager", "Interruption options - shouldResume: \(options.contains(.shouldResume))")
-                
-                // Calculate pause duration if we have a pause start time
-                if let pauseStart = currentPauseStart {
-                    let pauseDuration = Date().timeIntervalSince(pauseStart)
-                    totalPausedDuration += pauseDuration
-                    currentPauseStart = nil
-                    Logger.debug("AudioStreamManager", "Added interruption pause duration: \(pauseDuration), total paused: \(totalPausedDuration)")
-                }
-                
-                // For phone calls, we should auto-resume if enabled, regardless of previous pause state
-                if autoResumeAfterInterruption && isRecording {
+
+                // Auto-resume only if this interruption paused the recording.
+                // If the user had already paused, preserve that intent.
+                // Keep currentPauseStart active until the actual resume so duration accounting
+                // excludes the full paused interval, including any post-interruption delay.
+                if AutoResumePolicy.shouldAutoResume(
+                    autoResumeAfterInterruption: autoResumeAfterInterruption,
+                    isRecording: isRecording,
+                    isPaused: isPaused,
+                    pausedBySystemInterruption: pausedBySystemInterruption
+                ) {
                     // Add a longer delay for phone calls and ensure proper session setup
                     DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) { [weak self] in
                         guard let self = self else { return }
@@ -484,6 +508,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
                 // If we can't restart, officially pause the recording
                 if !isPaused {
                     isPaused = true
+                    pausedBySystemInterruption = false
                     // Notify delegate
                     delegate?.audioStreamManager(self, didPauseRecording: Date())
                 }
@@ -906,6 +931,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         lastEmittedCompressedSize = 0
         lastEmittedCompressedSizeAnalysis = 0
         isPaused = false
+        pausedBySystemInterruption = false
 
         // Create recording file first (unless primary output is disabled)
         if settings.output.primary.enabled {
@@ -995,10 +1021,27 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
 
             // Setup compressed recording if enabled
             if settings.output.compressed.enabled {
+                let isAACCompressedOutput = settings.output.compressed.format == "aac"
+                let compressedSampleRate: Double
+                if isAACCompressedOutput {
+                    compressedSampleRate = Self.compatibleAACCompressedSampleRate(
+                        requestedSampleRate: settings.sampleRate,
+                        sessionSampleRate: session.sampleRate
+                    )
+                } else {
+                    compressedSampleRate = settings.sampleRate
+                }
+                if isAACCompressedOutput && compressedSampleRate != settings.sampleRate {
+                    Logger.debug(
+                        "AudioStreamManager",
+                        "Adjusted compressed AAC sample rate from \(settings.sampleRate)Hz to \(compressedSampleRate)Hz for AVAudioRecorder compatibility"
+                    )
+                }
+
                 // Create compressed settings
                 let compressedSettings: [String: Any] = [
-                    AVFormatIDKey: settings.output.compressed.format == "aac" ? kAudioFormatMPEG4AAC : kAudioFormatOpus,
-                    AVSampleRateKey: Float64(settings.sampleRate),
+                    AVFormatIDKey: isAACCompressedOutput ? kAudioFormatMPEG4AAC : kAudioFormatOpus,
+                    AVSampleRateKey: compressedSampleRate,
                     AVNumberOfChannelsKey: settings.numberOfChannels,
                     AVEncoderBitRateKey: settings.output.compressed.bitrate,
                     AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue,
@@ -1135,6 +1178,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             lastEmissionTimeAnalysis = Date()
             isRecording = true
             isPaused = false
+            pausedBySystemInterruption = false
             
             // Start the audio engine
             try audioEngine.start()
@@ -1221,6 +1265,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         compressedFileURL = nil // Restore
         audioProcessor = nil // Restore
         recordingSettings = nil
+        pausedBySystemInterruption = false
         isPrepared = false // Restore
         // --- End restored lines and removed log ---
         
@@ -1228,7 +1273,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
     }
 
     /// Pauses the current audio recording.
-    func pauseRecording() {
+    func pauseRecording(isSystemInterruption: Bool = false) {
         guard isRecording, !isPaused else { return }
         
         Logger.debug("Pausing recording...")
@@ -1254,6 +1299,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         
         // Update state
         isPaused = true
+        pausedBySystemInterruption = isSystemInterruption
         
         // Stop the engine but don't remove the tap
         audioEngine.pause()
@@ -1302,6 +1348,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             
             // Update state
             isPaused = false
+            pausedBySystemInterruption = false
             
             // Update notification state if enabled
             if recordingSettings?.showNotification == true {
@@ -1850,6 +1897,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         let wasRecording = isRecording
         isRecording = false
         isPaused = false
+        pausedBySystemInterruption = false
         isPrepared = false // Reset preparation state
         
         // If we were only prepared but never started recording, clean up and return nil
@@ -2352,6 +2400,22 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
     }
 }
 
+internal struct AutoResumePolicy {
+    /// Auto-resume only when a system interruption caused the pause.
+    /// User-initiated pauses must remain paused after the interruption ends.
+    static func shouldAutoResume(
+        autoResumeAfterInterruption: Bool,
+        isRecording: Bool,
+        isPaused: Bool,
+        pausedBySystemInterruption: Bool
+    ) -> Bool {
+        return autoResumeAfterInterruption &&
+            isRecording &&
+            isPaused &&
+            pausedBySystemInterruption
+    }
+}
+
 extension AudioStreamManager: UNUserNotificationCenterDelegate {
     func userNotificationCenter(
         _ center: UNUserNotificationCenter,

package/ios/AudioStudioTests/CompressedOnlyOutputTests.swift

@@ -22,6 +22,46 @@ class CompressedOnlyOutputTests: XCTestCase {
     }
     
     // MARK: - Test Compressed-Only Output (Issue #244)
+
+    func testAACCompressedSampleRateFallsBackForLowRequestedRate() {
+        XCTAssertEqual(
+            AudioStreamManager.compatibleAACCompressedSampleRate(
+                requestedSampleRate: 16000,
+                sessionSampleRate: 48000
+            ),
+            48000,
+            "Low requested sample rates should use the active session rate when it is AAC-compatible"
+        )
+
+        XCTAssertEqual(
+            AudioStreamManager.compatibleAACCompressedSampleRate(
+                requestedSampleRate: 16000,
+                sessionSampleRate: 0
+            ),
+            44100,
+            "Low requested sample rates should never be passed directly to AVAudioRecorder for AAC"
+        )
+    }
+
+    func testAACCompressedSampleRateKeepsCompatibleRequestedRate() {
+        XCTAssertEqual(
+            AudioStreamManager.compatibleAACCompressedSampleRate(
+                requestedSampleRate: 44100,
+                sessionSampleRate: 48000
+            ),
+            44100,
+            "Already-compatible requested sample rates should preserve existing behavior"
+        )
+
+        XCTAssertEqual(
+            AudioStreamManager.compatibleAACCompressedSampleRate(
+                requestedSampleRate: 48000,
+                sessionSampleRate: 44100
+            ),
+            48000,
+            "High requested sample rates should not be reduced to the session rate"
+        )
+    }
     
     func testCompressedOnlyOutputWithAAC() {
         // Given: Recording settings with primary disabled and compressed enabled (AAC)
@@ -291,4 +331,4 @@ class TestAudioStreamDelegate: AudioStreamManagerDelegate {
     func audioStreamManager(_ manager: AudioStreamManager, didFailWithError error: String) {
         onError?(error)
     }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@siteed/audio-studio",
-    "version": "3.0.4",
+    "version": "3.1.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",

package/src/AudioStudio.types.ts

@@ -160,7 +160,10 @@ export interface AudioRecording {
     createdAt?: number
     /** Array of transcription data if available */
     transcripts?: TranscriberData[]
-    /** Analysis data for the recording if processing was enabled */
+    /**
+     * Full analysis data for the recording if processing was enabled and
+     * `keepFullAnalysis` was not set to `false`.
+     */
     analysisData?: AudioAnalysis
     /** Information about compression if enabled, including the URI to the compressed file */
     compression?: CompressionInfo & {
@@ -432,6 +435,17 @@ export interface RecordingConfig {
     /** Enable audio processing (default is false) */
     enableProcessing?: boolean
 
+    /**
+     * Whether `useAudioRecorder` should retain every audio-analysis data point
+     * and attach the full history to `stopRecording().analysisData`.
+     *
+     * Defaults to `true` for backwards compatibility. Set to `false` for
+     * long-running recordings when you only need live `analysisData` state or
+     * per-callback `onAudioAnalysis` chunks; this avoids unbounded JS memory
+     * growth in the hook without disabling native analysis processing.
+     */
+    keepFullAnalysis?: boolean
+
     /** iOS-specific configuration */
     ios?: IOSConfig
 

package/src/useAudioRecorder.tsx

@@ -156,6 +156,10 @@ interface HandleAudioAnalysisProps {
     visualizationDuration: number
 }
 
+function shouldKeepFullAnalysis(config?: RecordingConfig | null): boolean {
+    return config?.keepFullAnalysis !== false
+}
+
 export function useAudioRecorder({
     logger,
     audioWorkletUrl,
@@ -232,10 +236,15 @@ export function useAudioRecorder({
                 ...analysis.dataPoints,
             ]
 
-            const fullCombinedDataPoints = [
-                ...(fullAnalysisRef.current?.dataPoints ?? []),
-                ...analysis.dataPoints,
-            ]
+            const keepFullAnalysis = shouldKeepFullAnalysis(
+                recordingConfigRef.current
+            )
+            const fullCombinedDataPoints = keepFullAnalysis
+                ? [
+                      ...(fullAnalysisRef.current?.dataPoints ?? []),
+                      ...analysis.dataPoints,
+                  ]
+                : undefined
 
             // Calculate the new duration
             // The number of segments is based on how many segments of segmentDurationMs can fit in visualizationDuration
@@ -257,13 +266,15 @@ export function useAudioRecorder({
                 )
             }
 
-            // Keep the full data points
-            fullAnalysisRef.current = {
-                ...fullAnalysisRef.current,
-                dataPoints: fullCombinedDataPoints,
+            // Keep the full data points when requested for stopRecording().analysisData.
+            if (keepFullAnalysis && fullCombinedDataPoints) {
+                fullAnalysisRef.current = {
+                    ...fullAnalysisRef.current,
+                    dataPoints: fullCombinedDataPoints,
+                }
+                fullAnalysisRef.current.durationMs =
+                    fullCombinedDataPoints.length * analysis.segmentDurationMs
             }
-            fullAnalysisRef.current.durationMs =
-                fullCombinedDataPoints.length * analysis.segmentDurationMs
             savedAnalysisData.dataPoints = combinedDataPoints
             savedAnalysisData.bitDepth =
                 analysis.bitDepth || savedAnalysisData.bitDepth
@@ -284,9 +295,11 @@ export function useAudioRecorder({
                 min: newMin,
                 max: newMax,
             }
-            fullAnalysisRef.current.amplitudeRange = {
-                min: newMin,
-                max: newMax,
+            if (keepFullAnalysis) {
+                fullAnalysisRef.current.amplitudeRange = {
+                    min: newMin,
+                    max: newMax,
+                }
             }
 
             logger?.debug(
@@ -523,6 +536,7 @@ export function useAudioRecorder({
                 onAudioStream,
                 onRecordingInterrupted,
                 onAudioAnalysis,
+                keepFullAnalysis: _keepFullAnalysis,
                 ...options
             } = validatedOptions
             const { enableProcessing } = options
@@ -579,6 +593,7 @@ export function useAudioRecorder({
                 onAudioStream,
                 onRecordingInterrupted,
                 onAudioAnalysis,
+                keepFullAnalysis: _keepFullAnalysis,
                 ...options
             } = recordingOptions
 
@@ -603,7 +618,14 @@ export function useAudioRecorder({
         logger?.debug(`stoping recording`)
 
         const stopResult: AudioRecording = await audioStudio.stopRecording()
-        stopResult.analysisData = fullAnalysisRef.current
+        if (shouldKeepFullAnalysis(recordingConfigRef.current)) {
+            stopResult.analysisData = fullAnalysisRef.current
+        } else {
+            // `keepFullAnalysis` is a hook-level retention policy. If a platform
+            // starts returning native analysisData in the future, keep opt-out
+            // semantics explicit and avoid leaking a full history here.
+            delete stopResult.analysisData
+        }
 
         if (analysisListenerRef.current) {
             analysisListenerRef.current.remove()