@siteed/audio-studio 3.0.3 → 3.0.4

package/ios/AudioStreamManager.swift

@@ -65,6 +65,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
     internal var lastEmittedCompressedSize: Int64 = 0
     private var totalDataSize: Int64 = 0
     private var lastBufferTime: AVAudioTime?
+    /// Guarded by `accumulatedDataLock`.
     private var accumulatedData = Data()
 
     // Data emission for onAudioAnalysis
@@ -73,8 +74,57 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
     internal var lastEmittedCompressedSizeAnalysis: Int64 = 0
     private var totalDataSizeAnalysis: Int64 = 0
     private var lastBufferTimeAnalysis: AVAudioTime?
+    /// Guarded by `accumulatedDataLock`.
     private var accumulatedAnalysisData = Data()
 
+    // Guards accumulatedData and accumulatedAnalysisData. The audio tap
+    // appends from the render thread while emit/pause/stop snapshot-and-clear
+    // from other threads. Without this lock, base64EncodedString crashed
+    // mid-flush (issue #314) and short emissions were occasionally dropped.
+    private let accumulatedDataLock = NSLock()
+
+    /// Append the same chunk to both buffers under the lock.
+    /// Called from the audio tap thread.
+    private func appendAccumulated(_ data: Data) {
+        accumulatedDataLock.lock()
+        accumulatedData.append(data)
+        accumulatedAnalysisData.append(data)
+        accumulatedDataLock.unlock()
+    }
+
+    /// Atomically snapshot accumulatedData and clear it. Empty Data if buffer was empty.
+    private func takeAccumulatedSnapshot() -> Data {
+        accumulatedDataLock.lock()
+        defer { accumulatedDataLock.unlock() }
+        let snapshot = accumulatedData
+        accumulatedData.removeAll()
+        return snapshot
+    }
+
+    /// Atomically snapshot accumulatedAnalysisData and clear it.
+    private func takeAccumulatedAnalysisSnapshot() -> Data {
+        accumulatedDataLock.lock()
+        defer { accumulatedDataLock.unlock() }
+        let snapshot = accumulatedAnalysisData
+        accumulatedAnalysisData.removeAll()
+        return snapshot
+    }
+
+    /// Clear both buffers atomically (lifecycle resets).
+    private func resetAccumulated() {
+        accumulatedDataLock.lock()
+        accumulatedData.removeAll()
+        accumulatedAnalysisData.removeAll()
+        accumulatedDataLock.unlock()
+    }
+
+    /// Current size of accumulatedData for logs/probes.
+    private func accumulatedDataSize() -> Int {
+        accumulatedDataLock.lock()
+        defer { accumulatedDataLock.unlock() }
+        return accumulatedData.count
+    }
+
 
 
     private var fileManager = FileManager.default
@@ -830,16 +880,14 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             return false
         }
 
-        // Reset audio session before preparing new recording
+        // Deactivate the session for a clean slate before reconfiguring.
+        // configureAudioSession() below will activate it once — no need for
+        // the previous deactivate→sleep→activate→reconfigure→activate cycle.
         do {
             let session = AVAudioSession.sharedInstance()
             try session.setActive(false, options: .notifyOthersOnDeactivation)
-            Thread.sleep(forTimeInterval: 0.1) // Brief pause to ensure clean state
-            try session.setActive(true, options: .notifyOthersOnDeactivation)
         } catch {
-            Logger.debug("AudioStreamManager", "Failed to reset audio session: \(error)")
-            delegate?.audioStreamManager(self, didFailWithError: "Failed to reset audio session: \(error.localizedDescription)")
-            return false
+            Logger.debug("AudioStreamManager", "Failed to deactivate audio session (non-fatal): \(error)")
         }
 
         // Update auto-resume preference from settings
@@ -850,8 +898,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         emissionIntervalAnalysis = max(10.0, Double(settings.intervalAnalysis ?? 500)) / 1000.0
         lastEmissionTime = nil // Will be set when recording starts
         lastEmissionTimeAnalysis = nil // Will be set when recording starts
-        accumulatedData.removeAll()
-        accumulatedAnalysisData.removeAll()
+        resetAccumulated()
         totalDataSize = 0
         totalDataSizeAnalysis = 0
         totalPausedDuration = 0
@@ -943,8 +990,9 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
 
             recordingSettings = newSettings  // Keep original settings with desired sample rate
 
-            audioEngine.prepare() // Prepare the engine without starting it
-            
+            // audioEngine.prepare() is already called inside installTapWithHardwareFormat()
+            // (default prepareEngine: true). Don't call it twice.
+
             // Setup compressed recording if enabled
             if settings.output.compressed.enabled {
                 // Create compressed settings
@@ -1010,9 +1058,18 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             Logger.debug("AudioStreamManager", "AudioProcessor activated successfully.")
         }
         
-        // Prepare notifications if enabled but don't show yet
+        // initializeNotifications schedules a Timer that needs main's RunLoop,
+        // and notificationManager must exist before prepareRecording returns
+        // (the recursive startRecording → prepareRecording path uses it
+        // immediately). .sync is safe: nothing on main blocks on audioLifecycleQueue.
         if settings.showNotification {
-            initializeNotifications()
+            if Thread.isMainThread {
+                initializeNotifications()
+            } else {
+                DispatchQueue.main.sync {
+                    self.initializeNotifications()
+                }
+            }
         }
         
         // Mark preparation as complete
@@ -1177,16 +1234,12 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         Logger.debug("Pausing recording...")
         
         // Emit any remaining audio data before pausing
-        if !accumulatedData.isEmpty {
-            Logger.debug("Emitting final audio chunk of \(accumulatedData.count) bytes before pausing")
+        let finalData = takeAccumulatedSnapshot()
+        if !finalData.isEmpty {
+            Logger.debug("Emitting final audio chunk of \(finalData.count) bytes before pausing")
             let recordingTime = currentRecordingDuration()
             let finalTotalSize = self.totalDataSize
-            
-            // Create a copy of accumulated data to avoid race conditions
-            let finalData = accumulatedData
-            accumulatedData.removeAll()
-            
-            // Notify delegate with final audio data
+
             delegate?.audioStreamManager(
                 self,
                 didReceiveAudioData: finalData,
@@ -1542,9 +1595,9 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         }
 
         // --- Event Emission & Analysis (Always Happens) ---
-        // Audio streaming is independent of file output settings
-        accumulatedData.append(dataToWrite)
-        accumulatedAnalysisData.append(dataToWrite)
+        // Audio streaming is independent of file output settings.
+        // Lock-protected append: see accumulatedDataLock for rationale.
+        appendAccumulated(dataToWrite)
 
         if recordingSettings?.showNotification == true {
             updateNotificationDuration()
@@ -1555,34 +1608,36 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
 
         // Emit AudioData event
         if let lastEmission = self.lastEmissionTime {
-            // Log emission evaluation every 10th buffer
             if debugBufferCounter % 10 == 0 {
                 let timeGap = currentTime.timeIntervalSince(lastEmission)
                 let isTimeReady = timeGap >= emissionInterval
-                Logger.debug("EMISSION DEBUG: Time since last: \(timeGap)s, Threshold: \(emissionInterval)s, Ready: \(isTimeReady), DataSize: \(accumulatedData.count) bytes")
+                Logger.debug("EMISSION DEBUG: Time since last: \(timeGap)s, Threshold: \(emissionInterval)s, Ready: \(isTimeReady), DataSize: \(accumulatedDataSize()) bytes")
             }
-            
-            if currentTime.timeIntervalSince(lastEmission) >= emissionInterval,
-               !accumulatedData.isEmpty {
-                let dataToEmit = accumulatedData
-                let recordingTime = currentRecordingDuration()
-                self.lastEmissionTime = currentTime
-                self.lastEmittedSize = currentTotalSize
-                accumulatedData.removeAll()
-                let compressionInfo = buildCompressionInfo()
-                
-                Logger.debug("EMISSION SUCCESS: Emitting \(dataToEmit.count) bytes at recording time \(recordingTime)s")
-                
-                delegate?.audioStreamManager(
-                    self,
-                    didReceiveAudioData: dataToEmit,
-                    recordingTime: recordingTime,
-                    totalDataSize: currentTotalSize,
-                    compressionInfo: compressionInfo
-                )
+
+            if currentTime.timeIntervalSince(lastEmission) >= emissionInterval {
+                // Atomic snapshot+clear avoids the race that crashed
+                // base64EncodedString in the delegate (issue #314) and
+                // stops short writes from being dropped between read
+                // and clear.
+                let dataToEmit = takeAccumulatedSnapshot()
+                if !dataToEmit.isEmpty {
+                    let recordingTime = currentRecordingDuration()
+                    self.lastEmissionTime = currentTime
+                    self.lastEmittedSize = currentTotalSize
+                    let compressionInfo = buildCompressionInfo()
+
+                    Logger.debug("EMISSION SUCCESS: Emitting \(dataToEmit.count) bytes at recording time \(recordingTime)s")
+
+                    delegate?.audioStreamManager(
+                        self,
+                        didReceiveAudioData: dataToEmit,
+                        recordingTime: recordingTime,
+                        totalDataSize: currentTotalSize,
+                        compressionInfo: compressionInfo
+                    )
+                }
             }
         } else {
-            // This case occurs when lastEmissionTime is nil (either first run or after reset)
             Logger.debug("EMISSION DEBUG: lastEmissionTime is nil, setting to current time")
             lastEmissionTime = currentTime
         }
@@ -1591,12 +1646,11 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         if let lastEmissionAnalysis = self.lastEmissionTimeAnalysis,
            currentTime.timeIntervalSince(lastEmissionAnalysis) >= emissionIntervalAnalysis,
            settings.enableProcessing,
-           let _ = self.audioProcessor,
-           !accumulatedAnalysisData.isEmpty {
-            let dataToAnalyze = accumulatedAnalysisData
+           let _ = self.audioProcessor {
+            let dataToAnalyze = takeAccumulatedAnalysisSnapshot()
             self.lastEmissionTimeAnalysis = currentTime
-            accumulatedAnalysisData.removeAll()
 
+            if !dataToAnalyze.isEmpty {
             DispatchQueue.global(qos: .userInitiated).async { [weak self] in
                 guard let self = self, let processor = self.audioProcessor, let settings = self.recordingSettings else {
                     // Logger.debug("Analysis Dispatch SKIP: self, processor, or settings nil")
@@ -1627,6 +1681,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
                     }
                 }
             }
+            }
             // Logger.debug("Dispatched analysis task.") // Optional: Re-enable if needed
         }
     }
@@ -1744,24 +1799,23 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
         
         Logger.debug("Stopping recording...")
         
-        // IMPORTANT: Emit any remaining audio data before stopping the engine
-        if isRecording && !accumulatedData.isEmpty {
-            Logger.debug("Emitting final audio chunk of \(accumulatedData.count) bytes before stopping")
-            let recordingTime = currentRecordingDuration()
-            let finalTotalSize = self.totalDataSize // Use current total size
-            
-            // Create a copy of accumulated data to avoid race conditions
-            let finalData = accumulatedData
-            accumulatedData.removeAll()
-            
-            // Notify delegate with final audio data
-            delegate?.audioStreamManager(
-                self,
-                didReceiveAudioData: finalData,
-                recordingTime: recordingTime,
-                totalDataSize: finalTotalSize,
-                compressionInfo: buildCompressionInfo()
-            )
+        // IMPORTANT: Emit any remaining audio data before stopping the engine.
+        // Atomic snapshot avoids the race documented in #314.
+        if isRecording {
+            let finalData = takeAccumulatedSnapshot()
+            if !finalData.isEmpty {
+                Logger.debug("Emitting final audio chunk of \(finalData.count) bytes before stopping")
+                let recordingTime = currentRecordingDuration()
+                let finalTotalSize = self.totalDataSize
+
+                delegate?.audioStreamManager(
+                    self,
+                    didReceiveAudioData: finalData,
+                    recordingTime: recordingTime,
+                    totalDataSize: finalTotalSize,
+                    compressionInfo: buildCompressionInfo()
+                )
+            }
         }
 
         disableWakeLock()
@@ -1904,8 +1958,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             lastEmittedSize = 0
             lastEmittedSizeAnalysis = 0
             lastEmittedCompressedSize = 0
-            accumulatedData.removeAll()
-            accumulatedAnalysisData.removeAll()
+            resetAccumulated()
             recordingUUID = nil
             totalDataSize = 0
             
@@ -1970,8 +2023,7 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
             self.lastEmittedSize = 0
             self.lastEmittedSizeAnalysis = 0
             self.lastEmittedCompressedSize = 0
-            self.accumulatedData.removeAll()
-            self.accumulatedAnalysisData.removeAll()
+            self.resetAccumulated()
             self.recordingUUID = nil
             self.totalDataSize = 0
             self.cachedWavFileSize = 0
@@ -2173,16 +2225,16 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
                 Logger.debug("Recording was manually paused, leaving engine paused after fallback.")
             }
 
-            // Emit any remaining audio data from the previous device before resetting timers
-            if !accumulatedData.isEmpty {
-                Logger.debug("Emitting final audio chunk of \(accumulatedData.count) bytes from previous device")
+            // Emit any remaining audio data from the previous device, then
+            // wipe both buffers atomically (analysis buffer is discarded since
+            // we want to start fresh on the fallback device).
+            let finalData = takeAccumulatedSnapshot()
+            _ = takeAccumulatedAnalysisSnapshot()
+            if !finalData.isEmpty {
+                Logger.debug("Emitting final audio chunk of \(finalData.count) bytes from previous device")
                 let recordingTime = currentRecordingDuration()
                 let finalTotalSize = self.totalDataSize
-                
-                // Create a copy of accumulated data to avoid race conditions
-                let finalData = accumulatedData
-                
-                // Notify delegate with final audio data from previous device
+
                 delegate?.audioStreamManager(
                     self,
                     didReceiveAudioData: finalData,
@@ -2191,15 +2243,10 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
                     compressionInfo: buildCompressionInfo()
                 )
             }
-            
+
             // Reset emission timers to force new data emission with the fallback device
             lastEmissionTime = Date() // Reset to force immediate emission
             lastEmissionTimeAnalysis = Date() // Reset analysis timer too
-            
-            // Important: Do not reset totalDataSize here - it needs to be maintained
-            // We only clear the buffers to start accumulating new data from the fallback device
-            accumulatedData.removeAll() // Clear any partial data from previous device
-            accumulatedAnalysisData.removeAll() // Clear analysis data buffer
             Logger.debug("Emission timers reset. Current totalDataSize: \(totalDataSize)")
 
             // CRITICAL: Multiple scheduled recovery attempts
@@ -2209,14 +2256,13 @@ class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
                     Logger.debug("FALLBACK RECOVERY: Checking for data at \(delaySeconds)s")
                     
                     // Force an immediate emission if data is being received but not emitted
-                    if !self.accumulatedData.isEmpty {
+                    let dataToEmit = self.takeAccumulatedSnapshot()
+                    if !dataToEmit.isEmpty {
                         Logger.debug("FALLBACK RECOVERY: Forcing emission from accumulated data after \(delaySeconds)s (total size: \(self.totalDataSize))")
-                        let dataToEmit = self.accumulatedData
                         let recordingTime = self.currentRecordingDuration()
                         let totalSize = self.totalDataSize
-                        
+
                         self.lastEmissionTime = Date() // Reset the emission timer
-                        self.accumulatedData.removeAll() // Clear the buffer
                         
                         // Direct delegate call with accumulated data
                         self.delegate?.audioStreamManager(