@siteed/expo-audio-studio 2.4.0 → 2.5.0

package/ios/AudioStreamManager.swift

@@ -30,18 +30,26 @@ extension UInt16 {
     }
 }
 
-class AudioStreamManager: NSObject {
+// Define DeviceDisconnectionBehavior enum mirroring ExpoAudioStream.types.ts
+enum DeviceDisconnectionBehavior: String {
+    case PAUSE = "pause"
+    case FALLBACK = "fallback"
+}
+
+class AudioStreamManager: NSObject, AudioDeviceManagerDelegate {
     private let audioEngine = AVAudioEngine()
     private var inputNode: AVAudioInputNode {
         return audioEngine.inputNode
     }
     internal var recordingFileURL: URL?
     private var audioProcessor: AudioProcessor?
+    private var fileHandle: FileHandle?
     private var startTime: Date?
     private var totalPausedDuration: TimeInterval = 0  // Track total paused time
     private var currentPauseStart: Date?              // Track current pause start
-    private var isRecording = false
-    private var isPaused = false
+    var isRecording = false
+    var isPaused = false
+    var isPrepared = false  // Add this new state flag
     
     // Wake lock related properties
     private var wasIdleTimerDisabled: Bool = false  // Track previous idle timer state
@@ -96,9 +104,13 @@ class AudioStreamManager: NSObject {
     private var emissionInterval: TimeInterval = 1.0  // Default 1 second
     private var emissionIntervalAnalysis: TimeInterval = 0.5  // Default 0.5 seconds
 
+    // ---> ADD BACK deviceManager PROPERTY <--- 
+    private let deviceManager = AudioDeviceManager()
+
     /// Initializes the AudioStreamManager
     override init() {
         super.init()
+        deviceManager.delegate = self // Set the delegate
         // Only keep audio session interruption observer here
         NotificationCenter.default.addObserver(
             self,
@@ -304,8 +316,7 @@ class AudioStreamManager: NSObject {
             return lastDuration
         }
         
-        guard let settings = recordingSettings,
-              let startTime = self.startTime else { return 0 }
+        guard let startTime = self.startTime else { return 0 }
         
         let now = Date()
         var duration = now.timeIntervalSince(startTime)
@@ -554,11 +565,22 @@ class AudioStreamManager: NSObject {
             "isRecording": isRecording,
             "isPaused": isPaused,
             "mimeType": mimeType,
-            "size": totalDataSize,
-            "interval": settings.interval,
-            "intervalAnalysis": settings.intervalAnalysis
+            "size": totalDataSize
         ]
         
+        // Safely handle optional interval values
+        if let interval = settings.interval {
+            status["interval"] = interval
+        } else {
+            status["interval"] = 1000 // Default value
+        }
+        
+        if let intervalAnalysis = settings.intervalAnalysis {
+            status["intervalAnalysis"] = intervalAnalysis
+        } else {
+            status["intervalAnalysis"] = 500 // Default value
+        }
+        
         // Add compression info if enabled
         if settings.enableCompressedOutput,
            let compressedURL = compressedFileURL,
@@ -594,22 +616,29 @@ class AudioStreamManager: NSObject {
                audioSession.currentRoute.outputs.contains { $0.portType == .builtInReceiver }
     }
 
-    /// Starts a new audio recording with the specified settings.
+    /// Prepares the audio recording with the specified settings without starting it.
+    /// This reduces latency when startRecording is called later.
     /// - Parameters:
     ///   - settings: The recording settings to use.
-    /// - Returns: A StartRecordingResult object if recording starts successfully, or nil otherwise.
-    func startRecording(settings: RecordingSettings) -> StartRecordingResult? {
+    /// - Returns: A boolean indicating if preparation was successful.
+    func prepareRecording(settings: RecordingSettings) -> Bool {
+        // Store settings first before doing anything else
+        recordingSettings = settings
+        
+        // Skip if already prepared or recording
+        guard !isPrepared && !isRecording else {
+            Logger.debug("Already prepared or recording in progress.")
+            return isPrepared
+        }
+
         // Check for active call using the new method
         if isPhoneCallActive() {
-            Logger.debug("Cannot start recording during an active phone call")
-            delegate?.audioStreamManager(self, didFailWithError: "Cannot start recording during an active phone call")
-            return nil
+            Logger.debug("Cannot prepare recording during an active phone call")
+            delegate?.audioStreamManager(self, didFailWithError: "Cannot prepare recording during an active phone call")
+            return false
         }
 
-        // Store settings first before doing anything else
-        recordingSettings = settings
-        
-        // Reset audio session before starting new recording
+        // Reset audio session before preparing new recording
         do {
             let session = AVAudioSession.sharedInstance()
             try session.setActive(false, options: .notifyOthersOnDeactivation)
@@ -618,29 +647,16 @@ class AudioStreamManager: NSObject {
         } catch {
             Logger.debug("Failed to reset audio session: \(error)")
             delegate?.audioStreamManager(self, didFailWithError: "Failed to reset audio session: \(error.localizedDescription)")
-            return nil
+            return false
         }
 
         // Update auto-resume preference from settings
         autoResumeAfterInterruption = settings.autoResumeAfterInterruption
         
-        guard !isRecording else {
-            Logger.debug("Debug: Recording is already in progress.")
-            return nil
-        }
-        
-        guard !audioEngine.isRunning else {
-            Logger.debug("Debug: Audio engine already running.")
-            return nil
-        }
-        
-        let session = AVAudioSession.sharedInstance()
-        var newSettings = settings
-        
         emissionInterval = max(100.0, Double(settings.interval ?? 1000)) / 1000.0
         emissionIntervalAnalysis = max(100.0, Double(settings.intervalAnalysis ?? 500)) / 1000.0
-        lastEmissionTime = Date()
-        lastEmissionTimeAnalysis = Date()
+        lastEmissionTime = nil // Will be set when recording starts
+        lastEmissionTimeAnalysis = nil // Will be set when recording starts
         accumulatedData.removeAll()
         accumulatedAnalysisData.removeAll()
         totalDataSize = 0
@@ -650,18 +666,40 @@ class AudioStreamManager: NSObject {
         lastEmittedCompressedSizeAnalysis = 0
         isPaused = false
 
-        
         // Create recording file first
         recordingFileURL = createRecordingFile()
-        if recordingFileURL == nil {
-            Logger.debug("Error: Failed to create recording file.")
-            return nil
+        if let url = recordingFileURL {
+            do {
+                // Ensure directory exists if needed (createRecordingFile should handle this, but belt-and-suspenders)
+                try fileManager.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true, attributes: nil)
+                // Create the file if it doesn't exist (createRecordingFile should also handle this)
+                if !fileManager.fileExists(atPath: url.path) {
+                    fileManager.createFile(atPath: url.path, contents: nil, attributes: nil)
+                }
+                // Open the handle for writing
+                self.fileHandle = try FileHandle(forWritingTo: url)
+                // Write initial dummy header immediately
+                let header = createWavHeader(dataSize: 0)
+                self.fileHandle?.write(header)
+                self.totalDataSize = Int64(WAV_HEADER_SIZE) // Initialize size with header size
+                Logger.debug("File handle opened and initial header written for \(url.path). Initial size: \(self.totalDataSize)")
+            } catch {
+                Logger.debug("Error creating/opening file handle: \(error.localizedDescription)")
+                // No need to call cleanupPreparation here, return false will handle it
+                return false
+            }
+        } else {
+            Logger.debug("Error: Failed to create recording file URL.")
+            return false
         }
         
+        var newSettings = settings
+        
         // Then set up audio session and tap
         do {
             Logger.debug("Configuring audio session with sample rate: \(settings.sampleRate) Hz")
             
+            let session = AVAudioSession.sharedInstance()
             if let currentRoute = session.currentRoute.outputs.first {
                 Logger.debug("Current audio output: \(currentRoute.portType)")
                 newSettings.sampleRate = settings.sampleRate  // Keep original sample rate
@@ -692,161 +730,127 @@ class AudioStreamManager: NSObject {
             
             // Apply the final configuration
             try session.setCategory(category, mode: mode, options: options)
+            // NOTE: We intentionally DO NOT call session.setPreferredSampleRate().
+            // Trying to force a sample rate different from the hardware's actual rate
+            // often prevents the input node's tap from receiving any buffers.
+            // Instead, we let the session negotiate the rate.
+            // Resampling to the desired settings.sampleRate happens later in processAudioBuffer.
+            try session.setPreferredIOBufferDuration(1024 / Double(settings.sampleRate)) // Use desired rate for buffer duration hint
             try session.setActive(true, options: .notifyOthersOnDeactivation)
-            
-            Logger.debug("""
-                Audio session configured:
-                - category: \(category)
-                - mode: \(mode)
-                - options: \(options)
-                - keepAwake: \(settings.keepAwake)
-                - emission interval: \(emissionInterval * 1000)ms
-                - analysis interval: \(emissionIntervalAnalysis * 1000)ms
-                - sample rate: \(settings.sampleRate)Hz
-                - channels: \(settings.numberOfChannels)
-                - bit depth: \(settings.bitDepth)-bit
-                - compression enabled: \(settings.enableCompressedOutput)
-            """)
-            
-            // Set preferred sample rate but don't rely on it being applied
-            try session.setPreferredSampleRate(Double(settings.sampleRate))
-            try session.setPreferredIOBufferDuration(1024 / Double(settings.sampleRate))
-            try session.setActive(true)
-            Logger.debug("Audio session activated successfully.")
-            
-            // CRITICAL FIX: In iOS, the hardware sometimes doesn't honor our preferred sample rate.
-            // Here we query the *actual* hardware input format to ensure we match exactly what the hardware gives us.
-            let reportedSessionRate = session.sampleRate
-            
-            // Get the format directly from the input node, which is the most reliable way to determine the hardware format
-            let inputNodeFormat = audioEngine.inputNode.outputFormat(forBus: 0)
-            let actualHardwareSampleRate = inputNodeFormat.sampleRate
-            
-            Logger.debug("""
-                Sample rate detection:
-                - Requested rate: \(settings.sampleRate)Hz
-                - iOS session reported rate: \(reportedSessionRate)Hz
-                - Input node actual rate: \(actualHardwareSampleRate)Hz
-                - Will use input node rate for tap and resample to requested rate
-                """)
-            
-            recordingSettings = newSettings  // Keep original settings with desired sample rate
-            enableWakeLock()
-            
-            // CRITICAL FIX: Create format matching ACTUAL hardware capabilities from the input node
-            guard let hardwareFormat = AVAudioFormat(
-                commonFormat: .pcmFormatFloat32,
-                sampleRate: actualHardwareSampleRate,
-                channels: AVAudioChannelCount(settings.numberOfChannels),
-                interleaved: true
+
+            // Log session config details as single lines for clarity
+            Logger.debug("Audio session configured:")
+            Logger.debug("  - category: \(category)")
+            Logger.debug("  - mode: \(mode)")
+            Logger.debug("  - options: \(options)")
+            Logger.debug("  - keepAwake: \(settings.keepAwake)")
+            Logger.debug("  - emission interval: \(emissionInterval * 1000)ms")
+            Logger.debug("  - analysis interval: \(emissionIntervalAnalysis * 1000)ms")
+            Logger.debug("  - requested sample rate: \(settings.sampleRate)Hz")
+            Logger.debug("  - actual session sample rate: \(session.sampleRate)Hz") // Log actual rate
+            Logger.debug("  - channels: \(settings.numberOfChannels)")
+            Logger.debug("  - bit depth: \(settings.bitDepth)-bit")
+            Logger.debug("  - compression enabled: \(settings.enableCompressedOutput)")
+
+            // --- Revised Tap Format Logic ---
+            // Get the input node's format primarily for channel count and data type.
+            let nodeFormat = audioEngine.inputNode.outputFormat(forBus: 0)
+            let actualSessionRate = session.sampleRate // Use the session's negotiated rate.
+
+            Logger.debug("Node format suggests: \(describeAudioFormat(nodeFormat))")
+            Logger.debug("Session reports actual rate: \(actualSessionRate) Hz")
+
+            // Create the tap format using the ACTUAL session sample rate, but node's channel count/type.
+            // This aims to match the hardware stream (like 16kHz HFP) more reliably.
+            guard let tapFormat = AVAudioFormat(
+                commonFormat: nodeFormat.commonFormat, // Keep node's format (e.g., Float32)
+                sampleRate: actualSessionRate,         // Use ACTUAL session rate
+                channels: nodeFormat.channelCount,     // Use node's channel count
+                interleaved: nodeFormat.isInterleaved  // Use node's interleaving
             ) else {
-                Logger.debug("Failed to create hardware format")
-                return nil
+                Logger.debug("Failed to create tap format with session rate \(actualSessionRate) and node details.")
+                // Throw an error to prevent proceeding with invalid setup
+                throw NSError(domain: "AudioStreamManager", code: 1, userInfo: [NSLocalizedDescriptionKey: "Failed to create tap format for installation."])
             }
-            
-            Logger.debug("""
-                Audio format configuration:
-                - Hardware input format: \(describeAudioFormat(inputNodeFormat))
-                - Tap format: \(describeAudioFormat(hardwareFormat))
-                - Final output format: \(settings.bitDepth)-bit at \(settings.sampleRate)Hz
-                - Channels: \(settings.numberOfChannels)
-                """)
 
-            // CRITICAL FIX: Install tap with the ACTUAL hardware format from the input node
-            audioEngine.inputNode.installTap(onBus: 0, bufferSize: 1024, format: hardwareFormat) { [weak self] (buffer, time) in
+            // Log tap config details as single lines
+            Logger.debug("Final Tap Configuration (Using Session Rate):")
+            Logger.debug("  - Tap Format: \(describeAudioFormat(tapFormat))")
+            Logger.debug("  - Node Format Was: \(describeAudioFormat(nodeFormat))")
+            Logger.debug("  - Requested Output Format: \(settings.bitDepth)-bit at \(settings.sampleRate)Hz")
+
+            recordingSettings = newSettings  // Keep original settings with desired sample rate
+
+            // Install tap with the format derived from session sample rate
+            audioEngine.inputNode.installTap(onBus: 0, bufferSize: 1024, format: tapFormat) { [weak self] (buffer, time) in // Use newly constructed tapFormat
                 guard let self = self,
-                      let fileURL = self.recordingFileURL else {
-                    Logger.debug("Error: File URL or self is nil during buffer processing.")
+                      let fileURL = self.recordingFileURL,
+                      self.isRecording else { // Only process buffer if actually recording
+                    // Logger.debug("Tap received buffer but self, fileURL, or isRecording is invalid. Ignoring.")
                     return
                 }
+                // processAudioBuffer will handle resampling if tapFormat.sampleRate != settings.sampleRate
                 self.processAudioBuffer(buffer, fileURL: fileURL)
                 self.lastBufferTime = time
             }
+
+            audioEngine.prepare() // Prepare the engine without starting it
             
             // Setup compressed recording if enabled
             if settings.enableCompressedOutput {
-                do {
-                    let compressedSettings: [String: Any] = [
-                        AVFormatIDKey: settings.compressedFormat == "aac" ? kAudioFormatMPEG4AAC : kAudioFormatOpus,
-                        AVSampleRateKey: Float64(settings.sampleRate),
-                        AVNumberOfChannelsKey: settings.numberOfChannels,
-                        AVEncoderBitRateKey: settings.compressedBitRate,
-                        AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue,
-                        AVEncoderBitDepthHintKey: settings.bitDepth
-                    ]
-                    
-                    Logger.debug("Initializing compressed recording with settings: \(compressedSettings)")
-                    
-                    compressedFileURL = createRecordingFile(isCompressed: true)
+                // Create compressed settings
+                let compressedSettings: [String: Any] = [
+                    AVFormatIDKey: settings.compressedFormat == "aac" ? kAudioFormatMPEG4AAC : kAudioFormatOpus,
+                    AVSampleRateKey: Float64(settings.sampleRate),
+                    AVNumberOfChannelsKey: settings.numberOfChannels,
+                    AVEncoderBitRateKey: settings.compressedBitRate,
+                    AVEncoderAudioQualityKey: AVAudioQuality.high.rawValue,
+                    AVEncoderBitDepthHintKey: settings.bitDepth
+                ]
+                
+                Logger.debug("Initializing compressed recording with settings: \(compressedSettings)")
+                
+                // Create file for compressed recording
+                compressedFileURL = createRecordingFile(isCompressed: true)
+                
+                if let url = compressedFileURL {
+                    Logger.debug("Using compressed file URL: \(url.path)")
                     
-                    if let url = compressedFileURL {
-                        Logger.debug("Using compressed file URL: \(url.path)")
-                        
-                        // Initialize recorder with proper error handling
-                        do {
-                            compressedRecorder = try AVAudioRecorder(url: url, settings: compressedSettings)
-                            if let recorder = compressedRecorder {
-                                recorder.delegate = self
-                                
-                                if !recorder.prepareToRecord() {
-                                    Logger.debug("Failed to prepare recorder")
-                                    throw NSError(domain: "AudioStreamManager", code: -1, 
-                                        userInfo: [NSLocalizedDescriptionKey: "Failed to prepare recorder"])
-                                }
-                                
-                                if !recorder.record() {
-                                    Logger.debug("Failed to start recorder")
-                                    throw NSError(domain: "AudioStreamManager", code: -2, 
-                                        userInfo: [NSLocalizedDescriptionKey: "Failed to start recorder"])
-                                }
-                                
-                                Logger.debug("Compressed recording started successfully")
+                    // Initialize recorder with proper error handling
+                    do {
+                        compressedRecorder = try AVAudioRecorder(url: url, settings: compressedSettings)
+                        if let recorder = compressedRecorder {
+                            recorder.delegate = self
+                            
+                            if !recorder.prepareToRecord() {
+                                Logger.debug("Failed to prepare recorder")
+                                compressedFileURL = nil
+                                compressedRecorder = nil
+                            } else {
+                                // Note: We don't start the recorder yet, just prepare it
+                                Logger.debug("Compressed recording prepared successfully")
                                 compressedFormat = settings.compressedFormat
                                 compressedBitRate = settings.compressedBitRate
                             }
-                        } catch {
-                            Logger.debug("Failed to initialize compressed recorder: \(error)")
-                            compressedFileURL = nil
-                            compressedRecorder = nil
                         }
+                    } catch {
+                        Logger.debug("Failed to initialize compressed recorder: \(error)")
+                        compressedFileURL = nil
+                        compressedRecorder = nil
                     }
-                } catch {
-                    Logger.debug("Failed to setup compressed recording: \(error)")
-                    compressedFileURL = nil
-                    compressedRecorder = nil
+                } else {
+                    Logger.debug("Failed to create compressed recording file")
                 }
             }
             
         } catch {
             Logger.debug("Error: Failed to set up audio session with preferred settings: \(error.localizedDescription)")
-            return nil
+            return false
         }
         
         NotificationCenter.default.addObserver(self, selector: #selector(handleAudioSessionInterruption), name: AVAudioSession.interruptionNotification, object: nil)
         
-        // Create audio format based on recording settings
-        let commonFormat: AVAudioCommonFormat
-        switch newSettings.bitDepth {
-        case 16:
-            commonFormat = .pcmFormatInt16
-        case 32:
-            commonFormat = .pcmFormatFloat32
-        default:
-            Logger.debug("Unsupported bit depth: \(newSettings.bitDepth), falling back to 16-bit")
-            commonFormat = .pcmFormatInt16
-        }
-        
-        guard let audioFormat = AVAudioFormat(
-            commonFormat: commonFormat,
-            sampleRate: newSettings.sampleRate,
-            channels: UInt32(newSettings.numberOfChannels),
-            interleaved: true
-        ) else {
-            Logger.debug("Error: Failed to create audio format with bit depth: \(newSettings.bitDepth)")
-            return nil
-        }
-        
-        if newSettings.enableProcessing == true {
+        if settings.enableProcessing == true {
             // Initialize the AudioProcessor for buffer-based processing
             self.audioProcessor = AudioProcessor(resolve: { result in
                 // Handle the result here if needed
@@ -856,20 +860,79 @@ class AudioStreamManager: NSObject {
             Logger.debug("AudioProcessor activated successfully.")
         }
         
+        // Prepare notifications if enabled but don't show yet
         if settings.showNotification {
             initializeNotifications()
         }
         
+        // Mark preparation as complete
+        isPrepared = true
+        Logger.debug("Recording prepared successfully. Ready to start.")
+        
+        return true
+    }
+
+    /// Starts a new audio recording with the specified settings.
+    /// - Parameters:
+    ///   - settings: The recording settings to use.
+    /// - Returns: A StartRecordingResult object if recording starts successfully, or nil otherwise.
+    func startRecording(settings: RecordingSettings) -> StartRecordingResult? {
+        // If already prepared, use the prepared state
+        if isPrepared {
+            Logger.debug("Using prepared recording state")
+        } else {
+            // If not prepared, prepare now
+            Logger.debug("Not prepared, preparing recording first")
+            if !prepareRecording(settings: settings) {
+                Logger.debug("Failed to prepare recording")
+                return nil
+            }
+        }
+        
+        // Check for active phone call again, in case one started after preparation
+        if isPhoneCallActive() {
+            Logger.debug("Cannot start recording during an active phone call")
+            delegate?.audioStreamManager(self, didFailWithError: "Cannot start recording during an active phone call")
+            cleanupPreparation()
+            return nil
+        }
+        
+        guard !isRecording else {
+            Logger.debug("Recording already in progress")
+            return nil
+        }
+        
+        guard let settings = recordingSettings, 
+              let fileUri = recordingFileURL?.absoluteString else {
+            Logger.debug("Missing settings or file URI")
+            return nil
+        }
+        
         do {
+            enableWakeLock()
+            
+            // Set recording state *before* starting engine to avoid race condition
             startTime = Date()
-            totalPausedDuration = 0     // Reset pause tracking
+            totalPausedDuration = 0
             currentPauseStart = nil
-            Logger.debug("Starting new recording - Reset pause tracking")
-            
-            try audioEngine.start()
+            lastEmissionTime = Date()
+            lastEmissionTimeAnalysis = Date()
             isRecording = true
             isPaused = false
-            Logger.debug("Debug: Recording started successfully.")
+            
+            // Start the audio engine
+            try audioEngine.start()
+            
+            // Start the compressed recorder if prepared
+            compressedRecorder?.record()
+            
+            // Show notifications if enabled
+            if settings.showNotification {
+                notificationManager?.startUpdates(startTime: startTime ?? Date())
+                updateNowPlayingInfo(isPaused: false)
+            }
+            
+            Logger.debug("Recording started successfully")
             
             var compression = compressedRecorder != nil ? CompressedRecordingInfo(
                 compressedFileUri: compressedFileURL?.absoluteString ?? "",
@@ -886,7 +949,7 @@ class AudioStreamManager: NSObject {
             }
 
             return StartRecordingResult(
-                fileUri: recordingFileURL!.path,
+                fileUri: fileUri,
                 mimeType: mimeType,
                 channels: settings.numberOfChannels,
                 bitDepth: settings.bitDepth,
@@ -895,495 +958,271 @@ class AudioStreamManager: NSObject {
             )
             
         } catch {
-            Logger.debug("Error: Could not start the audio engine: \(error.localizedDescription)")
+            Logger.debug("Error starting audio engine: \(error.localizedDescription)")
             isRecording = false
+            cleanupPreparation()
             return nil
         }
     }
-    
-    /// Pauses the current audio recording.
-    public func pauseRecording() {
-        guard isRecording && !isPaused else { return }
+
+    /// Cleans up resources if preparation was done but recording didn't start.
+    private func cleanupPreparation() {
+        // Only run if prepared but not recording
+        guard isPrepared && !isRecording else { return }
         
-        // Store the current duration when pausing
-        lastValidDuration = currentRecordingDuration()
-        Logger.debug("Storing duration at pause: \(lastValidDuration ?? 0)")
+        Logger.debug("Cleaning up prepared resources that weren't used")
         
-        disableWakeLock()
-        audioEngine.pause()
-        isPaused = true
+        // Remove input tap
+        audioEngine.inputNode.removeTap(onBus: 0)
         
-        updateNowPlayingInfo(isPaused: true)
-        notificationManager?.updateState(isPaused: true)
-        delegate?.audioStreamManager(self, didPauseRecording: Date())
-        delegate?.audioStreamManager(self, didUpdateNotificationState: true)
+        // Stop compressed recorder if created but not started
+        compressedRecorder?.stop()
+        compressedRecorder = nil
         
-        // Pause compressed recording if active
-        compressedRecorder?.pause()
+        // Delete created files that weren't used
+        if let fileURL = recordingFileURL, FileManager.default.fileExists(atPath: fileURL.path) {
+            try? FileManager.default.removeItem(at: fileURL)
+        }
+        
+        if let compressedURL = compressedFileURL, FileManager.default.fileExists(atPath: compressedURL.path) {
+            try? FileManager.default.removeItem(at: compressedURL)
+        }
+        
+        // Reset audio session
+        do {
+            try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+        } catch {
+            Logger.debug("Error deactivating audio session: \(error)")
+        }
+        
+        // Clear notification setup if it was initialized
+        notificationManager?.stopUpdates()
+        notificationManager = nil
+        
+        // --- Restore missing cleanup lines and remove log ---
+        // Logger.debug("cleanupPreparation: Clearing recordingSettings. Current deviceId: \(recordingSettings?.deviceId ?? \"nil\")")
+        recordingFileURL = nil // Restore
+        compressedFileURL = nil // Restore
+        audioProcessor = nil // Restore
+        recordingSettings = nil
+        isPrepared = false // Restore
+        // --- End restored lines and removed log ---
+        
+        Logger.debug("Preparation cleanup completed")
     }
-    
-    private func initializeNotifications() {
-        guard recordingSettings?.showNotification == true else { return }
+
+    /// Pauses the current audio recording.
+    func pauseRecording() {
+        guard isRecording, !isPaused else { return }
         
-        // Setup notification manager if not already initialized
-        if notificationManager == nil {
-            UNUserNotificationCenter.current().delegate = self
+        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 recordingTime = currentRecordingDuration()
+            let finalTotalSize = self.totalDataSize
             
-            notificationManager = AudioNotificationManager()
+            // Create a copy of accumulated data to avoid race conditions
+            let finalData = accumulatedData
+            accumulatedData.removeAll()
             
-            // Request permissions first
-            UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
-                if granted {
-                    DispatchQueue.main.async {
-                        self.notificationManager?.initialize(with: self.recordingSettings?.notification)
-                        self.setupNowPlayingInfo()
-                        
-                        // Start media info update timer
-                        self.mediaInfoUpdateTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
-                           self?.updateMediaInfo()
-                        }
-                        
-                        // Setup notification observers
-                        NotificationCenter.default.addObserver(
-                            self,
-                            selector: #selector(self.handlePauseNotification),
-                            name: .pauseRecording,
-                            object: nil
-                        )
-                        
-                        NotificationCenter.default.addObserver(
-                            self,
-                            selector: #selector(self.handleResumeNotification),
-                            name: .resumeRecording,
-                            object: nil
-                        )
-                        
-                        // Start updates if recording is already in progress
-                        if let startTime = self.startTime {
-                            self.notificationManager?.startUpdates(startTime: startTime)
-                        }
-                    }
-                } else if let error = error {
-                    Logger.debug("Failed to get notification permission: \(error.localizedDescription)")
-                }
-            }
+            // Notify delegate with final audio data
+            delegate?.audioStreamManager(
+                self,
+                didReceiveAudioData: finalData,
+                recordingTime: recordingTime,
+                totalDataSize: finalTotalSize,
+                compressionInfo: nil
+            )
+        }
+        
+        // Store when we paused
+        currentPauseStart = Date()
+        
+        // Update state
+        isPaused = true
+        
+        // Stop the engine but don't remove the tap
+        audioEngine.pause()
+        
+        // Pause the compressed recorder if active
+        compressedRecorder?.pause()
+        
+        // Update notification state if enabled
+        if recordingSettings?.showNotification == true {
+            updateNotificationState(isPaused: true)
         }
+        
+        // Store valid duration for notifications
+        lastValidDuration = currentRecordingDuration()
+        
+        // Notify delegate
+        delegate?.audioStreamManager(self, didPauseRecording: Date())
+        
+        Logger.debug("Recording paused")
     }
     
-    /// Resumes the current audio recording.
-    public func resumeRecording() {
-        // Check for active phone call
-        if isPhoneCallActive() {
-            Logger.debug("Cannot resume recording during an active phone call")
-            delegate?.audioStreamManager(self, didFailWithError: "Cannot resume recording during an active phone call")
-            return
-        }
-
-        guard isRecording && isPaused else { return }
+    /// Resumes a paused recording.
+    func resumeRecording() {
+        guard isRecording, isPaused else { return }
         
-        lastValidDuration = nil  // Clear the stored duration when resuming
+        Logger.debug("Resuming recording...")
+        
+        // Calculate and add the pause duration if we have a pause start time
+        if let pauseStart = currentPauseStart {
+            let pauseDuration = Date().timeIntervalSince(pauseStart)
+            totalPausedDuration += pauseDuration
+            currentPauseStart = nil // Reset pause start time
+            Logger.debug("Added pause duration: \(pauseDuration), total paused: \(totalPausedDuration)")
+        }
         
-        enableWakeLock()
-        audioEngine.prepare()
         do {
+            // Try to restart the engine
             try audioEngine.start()
             
-            // Add the completed pause duration to total
-            if let pauseStart = currentPauseStart {
-                let currentPauseDuration = Date().timeIntervalSince(pauseStart)
-                totalPausedDuration += currentPauseDuration
-                currentPauseStart = nil
-                
-                Logger.debug("""
-                    Resume completed:
-                    - Added pause duration: \(currentPauseDuration)
-                    - New total pause duration: \(totalPausedDuration)
-                    """)
-            }
+            // Resume the compressed recorder if active
+            compressedRecorder?.record()
             
+            // Update state
             isPaused = false
             
-            updateNowPlayingInfo(isPaused: false)
-            notificationManager?.updateState(isPaused: false)
+            // Update notification state if enabled
+            if recordingSettings?.showNotification == true {
+                updateNotificationState(isPaused: false)
+            }
+            
+            // Clear the stored valid duration
+            lastValidDuration = nil
+            
+            // Notify delegate
             delegate?.audioStreamManager(self, didResumeRecording: Date())
-            delegate?.audioStreamManager(self, didUpdateNotificationState: false)
             
-            // Resume compressed recording if active
-            compressedRecorder?.record()
+            Logger.debug("Recording resumed")
             
         } catch {
-            Logger.debug("Error: Failed to resume recording: \(error.localizedDescription)")
-        }
-    }
-    
-    /// Describes the format of the given audio format.
-    /// - Parameter format: The AVAudioFormat object to describe.
-    /// - Returns: A string description of the audio format.
-    func describeAudioFormat(_ format: AVAudioFormat) -> String {
-        let formatDescription = """
-            - Sample rate: \(format.sampleRate)Hz
-            - Channels: \(format.channelCount)
-            - Interleaved: \(format.isInterleaved)
-            - Common format: \(describeCommonFormat(format.commonFormat))
-            """
-        return formatDescription
-    }
-    
-    func describeCommonFormat(_ format: AVAudioCommonFormat) -> String {
-        switch format {
-        case .pcmFormatFloat32:
-            return "32-bit float"
-        case .pcmFormatFloat64:
-            return "64-bit float"
-        case .pcmFormatInt16:
-            return "16-bit int"
-        case .pcmFormatInt32:
-            return "32-bit int"
-        default:
-            return "Unknown format"
+            Logger.debug("Failed to resume recording: \(error.localizedDescription)")
+            delegate?.audioStreamManager(self, didFailWithError: "Failed to resume recording: \(error.localizedDescription)")
         }
     }
     
-    /// Stops the current audio recording.
-    /// - Returns: A RecordingResult object if the recording stopped successfully, or nil otherwise.
-    func stopRecording() -> RecordingResult? {
-        guard isRecording else { return nil }
+    /// Initializes the notification manager to show recording notifications.
+    private func initializeNotifications() {
+        guard let settings = recordingSettings else { return }
         
-        Logger.debug("Stopping recording...")
+        // Create notification manager
+        notificationManager = AudioNotificationManager()
+        notificationManager?.initialize(with: settings.notification)
         
-        disableWakeLock()
-        audioEngine.stop()
-        audioEngine.inputNode.removeTap(onBus: 0)
+        // Add pause/resume handlers via notification observers
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handlePauseNotification),
+            name: Notification.Name("PAUSE_RECORDING"),
+            object: nil
+        )
         
-        // Stop compressed recording if active
-        compressedRecorder?.stop()
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleResumeNotification),
+            name: Notification.Name("RESUME_RECORDING"),
+            object: nil
+        )
         
-        // Get the final duration before changing state
-        let finalDuration = currentRecordingDuration()
+        // Setup media controls (iOS control center) if enabled
+        setupNowPlayingInfo()
         
-        isRecording = false
-        isPaused = false
-        
-        if recordingSettings?.showNotification == true {
-            // Stop and clean up timer
-            mediaInfoUpdateTimer?.invalidate()
-            mediaInfoUpdateTimer = nil
-            
-            // Clean up notification manager
-            notificationManager?.stopUpdates()
-            notificationManager = nil
-            
-            // Clean up media controls
-            DispatchQueue.main.async {
-                UIApplication.shared.endReceivingRemoteControlEvents()
-                self.remoteCommandCenter?.pauseCommand.isEnabled = false
-                self.remoteCommandCenter?.playCommand.isEnabled = false
-                self.notificationView?.nowPlayingInfo = nil
-            }
-        }
-        
-        // Reset audio session
-        do {
-            try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
-        } catch {
-            Logger.debug("Error deactivating audio session: \(error)")
-        }
-        
-        // Reset audio engine
-        audioEngine.reset()
-        
-        guard let fileURL = recordingFileURL,
-              let settings = recordingSettings else {
-            Logger.debug("Recording or file URL is nil.")
-            return nil
-        }
-        
-        // Validate WAV file
-        let wavPath = fileURL.path
-        do {
-            // Check if WAV file exists
-            let wavFileAttributes = try FileManager.default.attributesOfItem(atPath: wavPath)
-            let wavFileSize = wavFileAttributes[FileAttributeKey.size] as? Int64 ?? 0
-            
-            Logger.debug("""
-                WAV File validation:
-                - Path: \(wavPath)
-                - Exists: true
-                - Size: \(wavFileSize) bytes
-                - Duration: \(finalDuration) seconds
-                - Expected minimum size: \(WAV_HEADER_SIZE) bytes (WAV header)
-                """)
-            
-            
-            
-            // Return nil if the file is too small
-            if wavFileSize <= WAV_HEADER_SIZE {
-                Logger.debug("Recording file is too small (≤ \(WAV_HEADER_SIZE) bytes), likely no audio data was recorded")
-                return nil
-            }
-            
-            // Update the WAV header with the correct file size
-            updateWavHeader(fileURL: fileURL, totalDataSize: wavFileSize - WAV_HEADER_SIZE)
-            
-            // Validate compressed file if enabled
-            var compression: CompressedRecordingInfo?
-            if let compressedURL = compressedFileURL {
-                let compressedPath = compressedURL.path
-                if FileManager.default.fileExists(atPath: compressedPath) {
-                    let compressedAttributes = try FileManager.default.attributesOfItem(atPath: compressedPath)
-                    let compressedSize = compressedAttributes[FileAttributeKey.size] as? Int64 ?? 0
-                    
-                    Logger.debug("""
-                        Compressed File validation:
-                        - Path: \(compressedPath)
-                        - Format: \(compressedFormat ?? "unknown")
-                        - Size: \(compressedSize) bytes
-                        - Bitrate: \(compressedBitRate ?? 0) bps
-                        """)
-                    
-                    if compressedSize > 0 {
-                        compression = CompressedRecordingInfo(
-                            compressedFileUri: compressedURL.absoluteString,
-                            mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
-                            bitrate: compressedBitRate,
-                            format: compressedFormat,
-                            size: compressedSize
-                        )
-                    } else {
-                        Logger.debug("Warning: Compressed file exists but is empty")
-                    }
-                } else {
-                    Logger.debug("Warning: Compressed file not found at path: \(compressedPath)")
-                }
-            }
-            
-            let durationMs = Int64(finalDuration * 1000)
-            
-            let result = RecordingResult(
-                fileUri: fileURL.absoluteString,
-                filename: fileURL.lastPathComponent,
-                mimeType: mimeType,
-                duration: durationMs,
-                size: wavFileSize,
-                channels: settings.numberOfChannels,
-                bitDepth: settings.bitDepth,
-                sampleRate: settings.sampleRate,
-                compression: compression
-            )
-            
-            Logger.debug("""
-                Recording completed successfully:
-                - WAV file: \(fileURL.lastPathComponent)
-                - Size: \(wavFileSize) bytes
-                - Duration: \(durationMs)ms
-                - Sample rate: \(settings.sampleRate)Hz
-                - Bit depth: \(settings.bitDepth)-bit
-                - Channels: \(settings.numberOfChannels)
-                - Compressed: \(compression != nil ? "yes" : "no")
-                """)
-            
-            // Additional cleanup
-            recordingFileURL = nil
-            lastBufferTime = nil
-            lastValidDuration = nil
-            compressedRecorder = nil
-            compressedFileURL = nil
-            recordingSettings = nil
-            startTime = nil
-            totalPausedDuration = 0
-            currentPauseStart = nil
-            lastEmissionTime = nil
-            lastEmissionTimeAnalysis = nil
-            lastEmittedSize = 0
-            lastEmittedSizeAnalysis = 0
-            lastEmittedCompressedSize = 0
-            accumulatedData.removeAll()
-            accumulatedAnalysisData.removeAll()
-            recordingUUID = nil
-            
-            return result
-            
-        } catch {
-            Logger.debug("Failed to validate recording files: \(error)")
-            return nil
+        // Set up timer to update media info
+        mediaInfoUpdateTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
+            self?.updateMediaInfo()
         }
     }
     
-    /// Resamples the audio buffer using vDSP. If it fails, falls back to manual resampling.
+    /// Resample an audio buffer to a different sample rate.
     /// - Parameters:
-    ///   - buffer: The original audio buffer to be resampled.
-    ///   - originalSampleRate: The sample rate of the original audio buffer.
-    ///   - targetSampleRate: The desired sample rate to resample to.
-    /// - Returns: A new audio buffer resampled to the target sample rate, or nil if resampling fails.
-    private func resampleAudioBuffer(_ buffer: AVAudioPCMBuffer, from originalSampleRate: Double, to targetSampleRate: Double) -> AVAudioPCMBuffer? {
-        guard let settings = recordingSettings else {
-            Logger.debug("Recording settings not available")
-            return nil
+    ///   - buffer: The source audio buffer.
+    ///   - sourceRate: The source sample rate.
+    ///   - targetRate: The target sample rate.
+    /// - Returns: The resampled audio buffer or nil if resampling failed.
+    private func resampleAudioBuffer(_ buffer: AVAudioPCMBuffer, from sourceRate: Double, to targetRate: Double) -> AVAudioPCMBuffer? {
+        // If the rates are the same, no need to resample
+        if sourceRate == targetRate {
+            return buffer
         }
         
-        Logger.debug("""
-            Starting resampling:
-            - Original format: \(describeAudioFormat(buffer.format))
-            - Original frames: \(buffer.frameLength)
-            - Target settings:
-              • Sample rate: \(targetSampleRate)Hz
-              • Bit depth: \(settings.bitDepth)
-              • Channels: \(settings.numberOfChannels)
-            """)
-        
-        // Use settings bit depth for output format
-        let targetFormat: AVAudioCommonFormat = settings.bitDepth == 32 ? .pcmFormatFloat32 : .pcmFormatInt16
-        
-        // Create output format matching recording settings exactly
+        // Create source and target formats
         guard let outputFormat = AVAudioFormat(
-            commonFormat: targetFormat,
-            sampleRate: targetSampleRate,
-            channels: AVAudioChannelCount(settings.numberOfChannels),
-            interleaved: true
+            commonFormat: buffer.format.commonFormat,
+            sampleRate: targetRate,
+            channels: buffer.format.channelCount,
+            interleaved: buffer.format.isInterleaved
         ) else {
-            Logger.debug("Failed to create output format")
+            Logger.debug("Failed to create output format for resampling")
+            return nil
+        }
+        
+        // Create a converter
+        guard let converter = AVAudioConverter(from: buffer.format, to: outputFormat) else {
+            Logger.debug("Failed to create audio converter")
             return nil
         }
         
         // Calculate new buffer size
-        let ratio = targetSampleRate / originalSampleRate
-        let newFrameCount = AVAudioFrameCount(Double(buffer.frameLength) * ratio)
+        let ratio = targetRate / sourceRate
+        let estimatedFrames = AVAudioFrameCount(Double(buffer.frameLength) * ratio)
         
         // Create output buffer
         guard let outputBuffer = AVAudioPCMBuffer(
             pcmFormat: outputFormat,
-            frameCapacity: newFrameCount
+            frameCapacity: estimatedFrames
         ) else {
             Logger.debug("Failed to create output buffer")
             return nil
         }
-        outputBuffer.frameLength = newFrameCount
         
-        // Create intermediate format for high-quality conversion if needed
-        let needsIntermediate = buffer.format.commonFormat != outputFormat.commonFormat
-        if needsIntermediate {
-            Logger.debug("Using intermediate Float32 format for high-quality conversion")
-            guard let intermediateFormat = AVAudioFormat(
-                commonFormat: .pcmFormatFloat32,
-                sampleRate: targetSampleRate,
-                channels: AVAudioChannelCount(settings.numberOfChannels),
-                interleaved: true
-            ) else {
-                Logger.debug("Failed to create intermediate format")
-                return nil
-            }
-            
-            // First convert to intermediate float format
-            guard let converter = AVAudioConverter(from: buffer.format, to: intermediateFormat),
-                  let intermediateBuffer = AVAudioPCMBuffer(
-                    pcmFormat: intermediateFormat,
-                    frameCapacity: newFrameCount
-                  ) else {
-                Logger.debug("Failed to create converter or intermediate buffer")
-                return nil
-            }
-            intermediateBuffer.frameLength = newFrameCount
-            
-            var error: NSError?
-            let inputBlock: AVAudioConverterInputBlock = { inNumPackets, outStatus in
-                outStatus.pointee = AVAudioConverterInputStatus.haveData
-                return buffer
-            }
-            
-            converter.convert(to: intermediateBuffer, error: &error, withInputFrom: inputBlock)
-            
-            if let error = error {
-                Logger.debug("Intermediate conversion failed: \(error.localizedDescription)")
-                return nil
-            }
-            
-            // Then convert to final format
-            guard let finalConverter = AVAudioConverter(from: intermediateFormat, to: outputFormat) else {
-                Logger.debug("Failed to create final converter")
-                return nil
-            }
-            
-            finalConverter.convert(to: outputBuffer, error: &error) { inNumPackets, outStatus in
-                outStatus.pointee = AVAudioConverterInputStatus.haveData
-                return intermediateBuffer
-            }
-            
-            if let error = error {
-                Logger.debug("Final conversion failed: \(error.localizedDescription)")
-                return nil
-            }
-        } else {
-            // Direct conversion if formats are compatible
-            guard let converter = AVAudioConverter(from: buffer.format, to: outputFormat) else {
-                Logger.debug("Failed to create converter")
-                return nil
-            }
-            
-            var error: NSError?
-            let inputBlock: AVAudioConverterInputBlock = { inNumPackets, outStatus in
-                outStatus.pointee = AVAudioConverterInputStatus.haveData
-                return buffer
-            }
-            
-            converter.convert(to: outputBuffer, error: &error, withInputFrom: inputBlock)
-            
-            if let error = error {
-                Logger.debug("Conversion failed: \(error.localizedDescription)")
-                return nil
-            }
+        // Perform conversion
+        var error: NSError?
+        converter.convert(to: outputBuffer, error: &error) { inNumPackets, outStatus in
+            outStatus.pointee = .haveData
+            return buffer
         }
         
-        Logger.debug("""
-            Resampling completed:
-            - Final format: \(describeAudioFormat(outputBuffer.format))
-            - Final frames: \(outputBuffer.frameLength)
-            - Conversion path: \(needsIntermediate ? "With intermediate Float32" : "Direct")
-            """)
+        if let error = error {
+            Logger.debug("Error resampling audio: \(error.localizedDescription)")
+            return nil
+        }
         
         return outputBuffer
     }
+
+    /// Describes the format of the given audio format.
+    /// - Parameter format: The AVAudioFormat object to describe.
+    /// - Returns: A string description of the audio format.
+    func describeAudioFormat(_ format: AVAudioFormat) -> String {
+        let formatDescription = """
+            - Sample rate: \(format.sampleRate)Hz
+            - Channels: \(format.channelCount)
+            - Interleaved: \(format.isInterleaved)
+            - Common format: \(describeCommonFormat(format.commonFormat))
+            """
+        return formatDescription
+    }
     
-    /// Manually resamples the audio buffer using linear interpolation.
-    /// - Parameters:
-    ///   - buffer: The original audio buffer to be resampled.
-    ///   - originalSampleRate: The sample rate of the original audio buffer.
-    ///   - targetSampleRate: The desired sample rate to resample to.
-    /// - Returns: A new audio buffer resampled to the target sample rate, or nil if resampling fails.
-    private func manualResampleAudioBuffer(_ buffer: AVAudioPCMBuffer, from originalSampleRate: Double, to targetSampleRate: Double) -> AVAudioPCMBuffer? {
-        guard let channelData = buffer.floatChannelData else { return nil }
-        
-        let sourceFrameCount = Int(buffer.frameLength)
-        let sourceChannels = Int(buffer.format.channelCount)
-        let targetFrameCount = Int(Double(sourceFrameCount) * targetSampleRate / originalSampleRate)
-        
-        guard let targetBuffer = AVAudioPCMBuffer(pcmFormat: buffer.format, frameCapacity: AVAudioFrameCount(targetFrameCount)) else { return nil }
-        targetBuffer.frameLength = AVAudioFrameCount(targetFrameCount)
-        
-        let resamplingFactor = Float(targetSampleRate / originalSampleRate)
-        
-        for channel in 0..<sourceChannels {
-            let input = UnsafeBufferPointer(start: channelData[channel], count: sourceFrameCount)
-            let output = UnsafeMutableBufferPointer(start: targetBuffer.floatChannelData![channel], count: targetFrameCount)
-            
-            var y = Array(repeating: Float(0), count: targetFrameCount)
-            for i in 0..<targetFrameCount {
-                let index = Float(i) / resamplingFactor
-                let low = Int(floor(index))
-                let high = min(low + 1, sourceFrameCount - 1)
-                let weight = index - Float(low)
-                y[i] = (1 - weight) * input[low] + weight * input[high]
-            }
-            
-            for i in 0..<targetFrameCount {
-                output[i] = y[i]
-            }
+    func describeCommonFormat(_ format: AVAudioCommonFormat) -> String {
+        switch format {
+        case .pcmFormatFloat32:
+            return "32-bit float"
+        case .pcmFormatFloat64:
+            return "64-bit float"
+        case .pcmFormatInt16:
+            return "16-bit int"
+        case .pcmFormatInt32:
+            return "32-bit int"
+        default:
+            return "Unknown format"
         }
-        
-        return targetBuffer
     }
     
-    
-    
     /// Updates the WAV header with the correct file size.
     /// - Parameters:
     ///   - fileURL: The URL of the WAV file.
@@ -1434,208 +1273,154 @@ class AudioStreamManager: NSObject {
         }
     }
     
-    /// Processes the audio buffer and writes data to the file. Also handles audio processing if enabled.
+    /// Processes the audio buffer: handles resampling/format conversion if necessary,
+    /// writes the result to the WAV file on a background thread, and triggers
+    /// analysis processing and event emission based on intervals.
     /// - Parameters:
-    ///   - buffer: The audio buffer to process.
-    ///   - fileURL: The URL of the file to write the data to.
+    ///   - buffer: The audio buffer received from the input node tap.
+    ///   - fileURL: The URL of the file to write the data to (ignored, uses self.fileHandle).
     private func processAudioBuffer(_ buffer: AVAudioPCMBuffer, fileURL: URL) {
         guard let settings = recordingSettings else {
-            Logger.debug("Recording settings not available")
-            return
-        }
-        
-        guard let fileHandle = try? FileHandle(forWritingTo: fileURL) else {
-            Logger.debug("Failed to open file handle for URL: \(fileURL)")
+            Logger.debug("processAudioBuffer: Recording settings not available")
             return
         }
-        defer {
-            fileHandle.closeFile()  // Ensure file is always closed
-        }
-        
+
+        // targetSampleRate and targetFormat remain the user's requested final format
         let targetSampleRate = Double(settings.sampleRate)
         let targetFormat: AVAudioCommonFormat = settings.bitDepth == 32 ? .pcmFormatFloat32 : .pcmFormatInt16
-        
-        // First handle resampling if needed
-        let resampledBuffer: AVAudioPCMBuffer
+
+        // Buffer to be processed - initially the input buffer
+        var bufferToProcess: AVAudioPCMBuffer = buffer
+
+        // 1. Resample if the buffer's sample rate doesn't match the target
         if buffer.format.sampleRate != targetSampleRate {
             if let resampled = resampleAudioBuffer(buffer, from: buffer.format.sampleRate, to: targetSampleRate) {
-                resampledBuffer = resampled
+                bufferToProcess = resampled
             } else {
-                Logger.debug("Resampling failed")
+                Logger.debug("processAudioBuffer: Resampling FAILED")
                 return
             }
-        } else {
-            resampledBuffer = buffer
         }
-        
-        // Then ensure format matches user settings
-        let finalBuffer: AVAudioPCMBuffer
-        if resampledBuffer.format.commonFormat != targetFormat {
-            guard let converted = convertBufferFormat(resampledBuffer, to: AVAudioFormat(
+
+        // 2. Convert format if the (potentially resampled) buffer's format doesn't match the target
+        if bufferToProcess.format.commonFormat != targetFormat {
+            guard let targetAVFormat = AVAudioFormat(
                 commonFormat: targetFormat,
-                sampleRate: targetSampleRate,
+                sampleRate: targetSampleRate, // Use target rate for final format
                 channels: AVAudioChannelCount(settings.numberOfChannels),
-                interleaved: true
-            )!) else {
-                Logger.debug("Format conversion failed")
+                interleaved: bufferToProcess.format.isInterleaved // Match interleaving of current buffer
+            ) else {
+                Logger.debug("processAudioBuffer: Failed to create target AVAudioFormat for conversion.")
+                return
+            }
+            if let converted = convertBufferFormat(bufferToProcess, to: targetAVFormat) {
+                bufferToProcess = converted
+            } else {
+                Logger.debug("processAudioBuffer: Format conversion FAILED")
                 return
             }
-            finalBuffer = converted
-        } else {
-            finalBuffer = resampledBuffer
         }
-        
-        let audioData = finalBuffer.audioBufferList.pointee.mBuffers
+
+        // Now bufferToProcess contains the audio data in the desired sample rate and format
+        let audioData = bufferToProcess.audioBufferList.pointee.mBuffers
         guard let bufferData = audioData.mData else {
-            Logger.debug("Buffer data is nil.")
+            Logger.debug("Buffer data is nil after processing.")
             return
         }
-        
-        var data = Data(bytes: bufferData, count: Int(audioData.mDataByteSize))
-        
-        // Check if this is the first buffer to process
-        if totalDataSize == 0 {
-            let header = createWavHeader(dataSize: 0)
-            data.insert(contentsOf: header, at: 0)
+
+        // Create an immutable copy for background/event emission
+        let dataToWrite = Data(bytes: bufferData, count: Int(audioData.mDataByteSize))
+
+        // --- Background File Writing ---
+        // Use the persistent fileHandle opened during preparation.
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            guard let self = self, let handle = self.fileHandle else {
+                Logger.debug("BG Write Error: File handle is nil.")
+                return
+            }
+            do {
+                try handle.seekToEnd()
+                try handle.write(contentsOf: dataToWrite)
+                // Update total size state
+                self.totalDataSize += Int64(dataToWrite.count)
+            } catch {
+                 Logger.debug("BG Write Error: Failed to seek/write: \(error.localizedDescription)")
+            }
         }
-        
-        // Write to file
-        fileHandle.seekToEndOfFile()
-        fileHandle.write(data)
-        
-        // Update total size and accumulated data
-        totalDataSize += Int64(data.count)
-        accumulatedData.append(data)
-        accumulatedAnalysisData.append(data)
-        
-        // Handle notifications if enabled
+
+        // --- Event Emission & Analysis ---
+        accumulatedData.append(dataToWrite)
+        accumulatedAnalysisData.append(dataToWrite)
+
         if recordingSettings?.showNotification == true {
             updateNotificationDuration()
         }
-        
-        // Emit data based on interval
+
         let currentTime = Date()
-        if let lastEmissionTime = lastEmissionTime,
-           let startTime = startTime,
-           currentTime.timeIntervalSince(lastEmissionTime) >= emissionInterval {
-            
-            let recordingTime = currentTime.timeIntervalSince(startTime)
-            let dataToProcess = accumulatedData
-            
-            // Prepare compression info if enabled
-            var compressionInfo: [String: Any]? = nil
-            if settings.enableCompressedOutput, let compressedURL = compressedFileURL {
-                do {
-                    // Ensure file exists and has data
-                    if FileManager.default.fileExists(atPath: compressedURL.path) {
-                        let compressedAttributes = try FileManager.default.attributesOfItem(atPath: compressedURL.path)
-                        if let compressedSize = compressedAttributes[.size] as? Int64 {
-                            let eventDataSize = compressedSize - lastEmittedCompressedSize
-                            
-                            Logger.debug("Compressed file status - Total size: \(compressedSize), New data size: \(eventDataSize)")
-                            
-                            // Read the new compressed data if there's new data
-                            var compressedData: String? = nil
-                            if eventDataSize > 0 {
-                                do {
-                                    let fileHandle = try FileHandle(forReadingFrom: compressedURL)
-                                    defer { fileHandle.closeFile() }
-                                    
-                                    fileHandle.seek(toFileOffset: UInt64(lastEmittedCompressedSize))
-                                    let data = fileHandle.readData(ofLength: Int(eventDataSize))
-                                    compressedData = data.base64EncodedString()
-                                    
-                                    Logger.debug("Read compressed data of size: \(data.count)")
-                                } catch {
-                                    Logger.debug("Error reading compressed data: \(error)")
-                                }
-                            }
-                            
-                            lastEmittedCompressedSize = compressedSize
-                            
-                            compressionInfo = [
-                                "position": recordingTime * 1000, // Convert to milliseconds
-                                "fileUri": compressedURL.absoluteString,
-                                "eventDataSize": eventDataSize,
-                                "totalSize": compressedSize,
-                                "data": compressedData ?? ""
-                            ]
-                            
-                            Logger.debug("Compression info prepared: \(String(describing: compressionInfo))")
-                        } else {
-                            Logger.debug("Could not get compressed file size")
-                        }
-                    } else {
-                        Logger.debug("Compressed file does not exist at path: \(compressedURL.path)")
-                    }
-                } catch {
-                    Logger.debug("Error preparing compression info: \(error)")
-                }
-            }
-            
-            // Emit the audio data with compression info
+        let currentTotalSize = self.totalDataSize // Use the most up-to-date size for events
+
+        // Emit AudioData event
+        if let lastEmission = self.lastEmissionTime,
+           currentTime.timeIntervalSince(lastEmission) >= emissionInterval,
+           !accumulatedData.isEmpty {
+            let dataToEmit = accumulatedData
+            let recordingTime = currentRecordingDuration()
+            self.lastEmissionTime = currentTime
+            self.lastEmittedSize = currentTotalSize
+            accumulatedData.removeAll()
+            var compressionInfo: [String: Any]? = nil
+            // TODO: Get actual compressed file size if needed for this event
             delegate?.audioStreamManager(
                 self,
-                didReceiveAudioData: dataToProcess,
+                didReceiveAudioData: dataToEmit,
                 recordingTime: recordingTime,
-                totalDataSize: totalDataSize,
+                totalDataSize: currentTotalSize,
                 compressionInfo: compressionInfo
             )
-            
-            // Update state after emission
-            self.lastEmissionTime = currentTime
-            self.lastEmittedSize = totalDataSize
-            accumulatedData.removeAll()
+            // Logger.debug("Emitted didReceiveAudioData event.") // Optional: Re-enable if needed
         }
 
+        // Dispatch analysis task
+        if let lastEmissionAnalysis = self.lastEmissionTimeAnalysis,
+           currentTime.timeIntervalSince(lastEmissionAnalysis) >= emissionIntervalAnalysis,
+           settings.enableProcessing,
+           let processor = self.audioProcessor,
+           !accumulatedAnalysisData.isEmpty {
+            let dataToAnalyze = accumulatedAnalysisData
+            self.lastEmissionTimeAnalysis = currentTime
+            accumulatedAnalysisData.removeAll()
 
-        if let lastEmissionTimeAnalysis = lastEmissionTimeAnalysis,
-           let startTime = startTime,
-           currentTime.timeIntervalSince(lastEmissionTimeAnalysis) >= emissionIntervalAnalysis {
-            
-            let recordingTime = currentTime.timeIntervalSince(startTime)
-            let dataToProcess = accumulatedAnalysisData
-
-                       // Process audio if enabled
-            if settings.enableProcessing {
-                DispatchQueue.global().async { [weak self] in
-                    guard let self = self else { return }
-                    if let processor = self.audioProcessor {
-                        Logger.debug("Processing audio buffer of size: \(dataToProcess.count)")
-                        
-                        // Strip WAV header from the first buffer to avoid false amplitude detection
-                        let dataToAnalyze: Data
-                        if self.totalDataSizeAnalysis == 0 && dataToProcess.count > Int(WAV_HEADER_SIZE) {
-                            // This is the first buffer and may contain the WAV header
-                            dataToAnalyze = dataToProcess.subdata(in: Int(WAV_HEADER_SIZE)..<dataToProcess.count)
-                            Logger.debug("Removed WAV header (\(WAV_HEADER_SIZE) bytes) from first buffer for analysis")
-                        } else {
-                            dataToAnalyze = dataToProcess
-                        }
-                        
-                        let processingResult = processor.processAudioBuffer(
-                            data: dataToAnalyze,
-                            sampleRate: Float(settings.sampleRate),
-                            segmentDurationMs: settings.segmentDurationMs,
-                            featureOptions: settings.featureOptions ?? [:],
-                            bitDepth: settings.bitDepth,
-                            numberOfChannels: settings.numberOfChannels
-                        )
-                        
-                        DispatchQueue.main.async {
-                            if let result = processingResult {
-                                self.delegate?.audioStreamManager(self, didReceiveProcessingResult: result)
-                            }
-                        }
+            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")
+                    return
+                }
+                guard !dataToAnalyze.isEmpty else {
+                    // Logger.debug("Analysis Dispatch SKIP: dataToAnalyze is empty")
+                    return
+                }
+
+                // Logger.debug("Analysis Dispatch: Processing \(dataToAnalyze.count) bytes...")
+                let processingResult = processor.processAudioBuffer(
+                    data: dataToAnalyze,
+                    sampleRate: Float(settings.sampleRate),
+                    segmentDurationMs: settings.segmentDurationMs,
+                    featureOptions: settings.featureOptions ?? [:],
+                    bitDepth: settings.bitDepth,
+                    numberOfChannels: settings.numberOfChannels
+                )
 
-                        // Update state after emission
-                        self.lastEmissionTimeAnalysis = currentTime
-                        // Update the total analysis data size to mark that we've processed data
-                        self.totalDataSizeAnalysis = self.totalDataSize
-                        accumulatedAnalysisData.removeAll()
+                // Dispatch result back to main thread
+                DispatchQueue.main.async {
+                    if let result = processingResult {
+                         // Logger.debug("Analysis Dispatch: Success, calling delegate.")
+                        self.delegate?.audioStreamManager(self, didReceiveProcessingResult: result)
+                    } else {
+                         Logger.debug("Analysis Dispatch FAIL: processor.processAudioBuffer returned nil")
                     }
                 }
             }
+            // Logger.debug("Dispatched analysis task.") // Optional: Re-enable if needed
         }
     }
 
@@ -1666,7 +1451,7 @@ class AudioStreamManager: NSObject {
               let outputBuffer = AVAudioPCMBuffer(
                 pcmFormat: targetFormat,
                 frameCapacity: buffer.frameLength
-              ) else {
+        ) else {
             return nil
         }
         
@@ -1685,6 +1470,425 @@ class AudioStreamManager: NSObject {
         
         return outputBuffer
     }
+
+    /// Attempts to update the audio session with the preferred input device from current settings.
+    /// Called externally when the device selection changes.
+    /// Note: Avoids changing sample rate or buffer duration while engine might be running.
+    public func updateAudioSessionWithCurrentSettings() {
+        guard let settings = self.recordingSettings, let deviceId = settings.deviceId else {
+            Logger.debug("Cannot update audio session preference, settings or deviceId missing")
+            return
+        }
+        
+        let session = AVAudioSession.sharedInstance()
+        
+        // Find the requested device port
+        let selectedPort = session.availableInputs?.first { port in
+            // Normalize IDs for comparison, especially for Bluetooth
+            let portNormalizedId = deviceManager.normalizeBluetoothDeviceId(port.uid)
+            let requestedNormalizedId = deviceManager.normalizeBluetoothDeviceId(deviceId)
+            return portNormalizedId == requestedNormalizedId
+        }
+        
+        if let portToSet = selectedPort {
+            do {
+                try session.setPreferredInput(portToSet)
+                Logger.debug("Attempted to set preferred input to: \(portToSet.portName) (ID: \(portToSet.uid))")
+                 // We add a small delay hoping the system applies the change before potential next operations
+                Thread.sleep(forTimeInterval: 0.1)
+            } catch {
+                Logger.debug("Failed to set preferred input device \(portToSet.portName): \(error.localizedDescription)")
+            }
+        } else {
+            Logger.debug("Could not find device with ID \(deviceId) to set as preferred input.")
+        }
+    }
+
+    /// Stops the current audio recording.
+    /// - Returns: A RecordingResult object if the recording stopped successfully, or nil otherwise.
+    func stopRecording() -> RecordingResult? {
+        guard isRecording || isPrepared else { return nil }
+        
+        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: nil
+            )
+        }
+        
+        disableWakeLock()
+        audioEngine.stop()
+        audioEngine.inputNode.removeTap(onBus: 0)
+        
+        // Stop compressed recording if active
+        compressedRecorder?.stop()
+        
+        // Get the final duration before changing state
+        let finalDuration = currentRecordingDuration()
+        
+        let wasRecording = isRecording
+        isRecording = false
+        isPaused = false
+        isPrepared = false // Reset preparation state
+        
+        // If we were only prepared but never started recording, clean up and return nil
+        if !wasRecording {
+            cleanupPreparation()
+            return nil
+        }
+        
+        if recordingSettings?.showNotification == true {
+            // Stop and clean up timer
+            mediaInfoUpdateTimer?.invalidate()
+            mediaInfoUpdateTimer = nil
+            
+            // Clean up notification manager
+            notificationManager?.stopUpdates()
+            notificationManager = nil
+            
+            // Clean up media controls
+            DispatchQueue.main.async {
+                UIApplication.shared.endReceivingRemoteControlEvents()
+                self.remoteCommandCenter?.pauseCommand.isEnabled = false
+                self.remoteCommandCenter?.playCommand.isEnabled = false
+                self.notificationView?.nowPlayingInfo = nil
+            }
+        }
+        
+        // Reset audio session
+        do {
+            try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+        } catch {
+            Logger.debug("Error deactivating audio session: \(error)")
+        }
+
+        // Reset audio engine
+        audioEngine.reset()
+        
+        guard let fileURL = recordingFileURL,
+              let settings = recordingSettings else {
+            Logger.debug("Recording or file URL is nil.")
+            return nil
+        }
+        
+        // Validate WAV file
+        let wavPath = fileURL.path
+        do {
+            // Check if WAV file exists
+            let wavFileAttributes = try FileManager.default.attributesOfItem(atPath: wavPath)
+            let wavFileSize = wavFileAttributes[FileAttributeKey.size] as? Int64 ?? 0
+            
+            Logger.debug("""
+                WAV File validation:
+                - Path: \(wavPath)
+                - Exists: true
+                - Size: \(wavFileSize) bytes
+                - Duration: \(finalDuration) seconds
+                - Expected minimum size: \(WAV_HEADER_SIZE) bytes (WAV header)
+                """)
+            
+            // Use the final totalDataSize tracked by the background queue
+            let finalDataChunkSize = self.totalDataSize - Int64(WAV_HEADER_SIZE)
+            if finalDataChunkSize <= 0 {
+                Logger.debug("Recording file data chunk size is zero or negative (\(finalDataChunkSize) bytes), likely no audio data was recorded successfully after header")
+                // Optionally delete the empty file?
+                // try? FileManager.default.removeItem(at: fileURL)
+                return nil
+            }
+
+            // Update the WAV header with the correct final file size
+            updateWavHeader(fileURL: fileURL, totalDataSize: finalDataChunkSize)
+            Logger.debug("Final WAV header updated. Data chunk size: \(finalDataChunkSize)")
+            
+            // Validate compressed file if enabled
+            var compression: CompressedRecordingInfo?
+            if let compressedURL = compressedFileURL {
+                let compressedPath = compressedURL.path
+                if FileManager.default.fileExists(atPath: compressedPath) {
+                    let compressedAttributes = try FileManager.default.attributesOfItem(atPath: compressedPath)
+                    let compressedSize = compressedAttributes[FileAttributeKey.size] as? Int64 ?? 0
+                    
+                    Logger.debug("""
+                        Compressed File validation:
+                        - Path: \(compressedPath)
+                        - Format: \(compressedFormat)
+                        - Size: \(compressedSize) bytes
+                        - Bitrate: \(compressedBitRate) bps
+                        """)
+                    
+                    if compressedSize > 0 {
+                        compression = CompressedRecordingInfo(
+                            compressedFileUri: compressedURL.absoluteString,
+                            mimeType: compressedFormat == "aac" ? "audio/aac" : "audio/opus",
+                            bitrate: compressedBitRate,
+                            format: compressedFormat,
+                            size: compressedSize
+                        )
+                    } else {
+                        Logger.debug("Warning: Compressed file exists but is empty")
+                    }
+                } else {
+                    Logger.debug("Warning: Compressed file not found at path: \(compressedPath)")
+                }
+            }
+            
+            let durationMs = Int64(finalDuration * 1000)
+            
+            let result = RecordingResult(
+                fileUri: fileURL.absoluteString,
+                filename: fileURL.lastPathComponent,
+                mimeType: mimeType,
+                duration: durationMs,
+                size: wavFileSize,
+                channels: settings.numberOfChannels,
+                bitDepth: settings.bitDepth,
+                sampleRate: settings.sampleRate,
+                compression: compression
+            )
+            
+            Logger.debug("""
+                Recording completed successfully:
+                - WAV file: \(fileURL.lastPathComponent)
+                - Size: \(wavFileSize) bytes
+                - Duration: \(durationMs)ms
+                - Sample rate: \(settings.sampleRate)Hz
+                - Bit depth: \(settings.bitDepth)-bit
+                - Channels: \(settings.numberOfChannels)
+                - Compressed: \(compression != nil ? "yes" : "no")
+                """)
+            
+            // Additional cleanup
+            recordingFileURL = nil
+            lastBufferTime = nil
+            lastValidDuration = nil
+            compressedRecorder = nil
+            compressedFileURL = nil
+            recordingSettings = nil
+            startTime = nil
+            totalPausedDuration = 0
+            currentPauseStart = nil
+            lastEmissionTime = nil
+            lastEmissionTimeAnalysis = nil
+            lastEmittedSize = 0
+            lastEmittedSizeAnalysis = 0
+            lastEmittedCompressedSize = 0
+            accumulatedData.removeAll()
+            accumulatedAnalysisData.removeAll()
+            recordingUUID = nil
+            
+            return result
+            
+        } catch {
+            Logger.debug("Failed to validate recording files: \(error)")
+            return nil
+        }
+    }
+
+    // MARK: - AudioDeviceManagerDelegate Implementation
+
+    func audioDeviceManager(_ manager: AudioDeviceManager, didDetectDisconnectionOfDevice disconnectedDeviceId: String) {
+        // This method will be called by AudioDeviceManager when a disconnection occurs
+        // Run on main thread to safely interact with AVAudioEngine and state
+        DispatchQueue.main.async {
+            self.handleDeviceDisconnection(disconnectedDeviceId: disconnectedDeviceId)
+        }
+    }
+
+    // MARK: - Device Disconnection Handling
+
+    // Define interruption reasons matching ExpoAudioStream.types.ts
+    enum RecordingInterruptionReason: String {
+        case deviceDisconnected = "deviceDisconnected"
+        case deviceFallback = "deviceFallback"
+        case deviceSwitchFailed = "deviceSwitchFailed"
+        // Add other reasons if needed (e.g., from handleAudioSessionInterruption)
+        case audioFocusLoss = "audioFocusLoss"
+        case audioFocusGain = "audioFocusGain"
+        case phoneCall = "phoneCall"
+        case phoneCallEnded = "phoneCallEnded"
+        case recordingStopped = "recordingStopped"
+        case deviceConnected = "deviceConnected"
+    }
+
+    private func handleDeviceDisconnection(disconnectedDeviceId: String) {
+        Logger.debug("handleDeviceDisconnection entered. isRecording: \(isRecording), settingsExist: \(recordingSettings != nil), deviceIdExists: \(recordingSettings?.deviceId != nil), currentDeviceId: \(recordingSettings?.deviceId ?? "nil")")
+
+        // --- Modify Guard: Only require settings object, handle nil deviceId later ---
+        guard let settings = recordingSettings else {
+             // If settings are nil, we truly can't determine behavior, so pause.
+             Logger.debug("Device disconnected (\(disconnectedDeviceId)), but recordingSettings object is missing. Pausing.")
+             performPauseAction(reason: .deviceDisconnected)
+             return
+        }
+        // We now have settings, proceed even if deviceId might be nil inside it.
+        let currentRecordingDeviceId = settings.deviceId // This might be nil, handle below
+        // --- End Modify Guard ---
+
+        // Normalize BOTH IDs for reliable comparison
+        // Use "nil" if currentRecordingDeviceId is actually nil
+        let normalizedCurrentId = deviceManager.normalizeBluetoothDeviceId(currentRecordingDeviceId ?? "nil") 
+        let normalizedDisconnectedId = deviceManager.normalizeBluetoothDeviceId(disconnectedDeviceId)
+
+        Logger.debug("Handling disconnection. Current device: \(normalizedCurrentId), Disconnected device: \(normalizedDisconnectedId)")
+
+        // Check if the disconnected device is the one we *thought* we were recording from
+        if normalizedCurrentId == normalizedDisconnectedId || currentRecordingDeviceId == nil {
+            // If the IDs match OR if the stored deviceId was nil (meaning we lost track),
+            // assume this disconnection applies to our current recording session.
+            
+            Logger.debug("Disconnection event matches current recording session (or session deviceId was lost). Applying behavior...")
+
+            // Get the string value from settings using the correct property name
+            // The property in RecordingSettings likely matches the TS interface: deviceDisconnectionBehavior
+            let behaviorString = settings.deviceDisconnectionBehavior ?? "pause" // Use the correct property name
+            let behavior = DeviceDisconnectionBehavior(rawValue: behaviorString) ?? .PAUSE // Convert to enum, default to .PAUSE
+
+            Logger.debug("Recording device disconnected! Applying behavior: \(behavior.rawValue)")
+
+            delegate?.audioStreamManager(self, didReceiveInterruption: [
+                "reason": RecordingInterruptionReason.deviceDisconnected.rawValue,
+                "isPaused": isPaused
+            ])
+
+            // Switch on the *enum* value
+            switch behavior {
+            case .PAUSE:
+                performPauseAction(reason: .deviceDisconnected)
+
+            case .FALLBACK:
+                 Task { 
+                    await performFallbackAction()
+                 }
+            }
+        } else {
+             Logger.debug("A different device disconnected (\(normalizedDisconnectedId)). Current recording device (\(normalizedCurrentId)) is still active. Ignoring.")
+        }
+    }
+
+    private func performPauseAction(reason: RecordingInterruptionReason) {
+        if !isPaused { // Only pause if not already paused
+            Logger.debug("Pausing recording due to \(reason.rawValue)")
+            pauseRecording() // Use existing pause function
+        } else {
+            Logger.debug("Recording was already paused when \(reason.rawValue) occurred.")
+        }
+        // Note: pauseRecording already notifies the delegate about the pause state change.
+        // Send an additional interruption notification specifically for the reason
+         delegate?.audioStreamManager(self, didReceiveInterruption: [
+             "reason": reason.rawValue,
+             "isPaused": true // Since we are pausing or were already paused
+         ])
+    }
+
+    private func performFallbackAction() async {
+        Logger.debug("Attempting to fallback to default device...")
+
+        do {
+            // 1. Get the new default device (using the async version)
+            guard let defaultDevice = await deviceManager.getDefaultInputDevice() else {
+                 Logger.debug("Fallback failed: Could not get default input device. Pausing.")
+                 performPauseAction(reason: .deviceSwitchFailed) // Fallback to pause if no default
+                 return
+            }
+            Logger.debug("Found default device for fallback: \(defaultDevice.name) (ID: \(defaultDevice.id))")
+
+            // 2. Stop engine temporarily & Remove existing tap
+            let wasManuallyPaused = isPaused
+            if audioEngine.isRunning {
+                audioEngine.pause()
+            }
+            audioEngine.inputNode.removeTap(onBus: 0)
+            Logger.debug("Fallback: Paused engine and removed existing tap.")
+
+            // 3. Update settings and select the new device in the session
+            recordingSettings?.deviceId = defaultDevice.id // Update setting
+            let selectionSuccess = await deviceManager.selectDevice(defaultDevice.id)
+            if !selectionSuccess {
+                Logger.debug("Fallback failed: Could not select default device in session. Pausing.")
+                performPauseAction(reason: .deviceSwitchFailed)
+                return
+            }
+            Logger.debug("Successfully selected default device \(defaultDevice.id) in session.")
+
+            // --- Reinstall Tap --- 
+            // 4. Get the tap format for the *new* device
+            let session = AVAudioSession.sharedInstance()
+            let nodeFormat = audioEngine.inputNode.outputFormat(forBus: 0)
+            let actualSessionRate = session.sampleRate
+            Logger.debug("Fallback: New device node format: \(describeAudioFormat(nodeFormat))")
+            Logger.debug("Fallback: New device session rate: \(actualSessionRate) Hz")
+            
+            guard let newTapFormat = AVAudioFormat(
+                commonFormat: nodeFormat.commonFormat,
+                sampleRate: actualSessionRate,
+                channels: nodeFormat.channelCount,
+                interleaved: nodeFormat.isInterleaved
+            ) else {
+                Logger.debug("Fallback failed: Could not create tap format for new device.")
+                performPauseAction(reason: .deviceSwitchFailed)
+                return
+            }
+            Logger.debug("Fallback: Determined new tap format: \(describeAudioFormat(newTapFormat))")
+
+            // 5. Install the new tap
+            audioEngine.inputNode.installTap(onBus: 0, bufferSize: 1024, format: newTapFormat) { [weak self] (buffer, time) in
+                guard let self = self, self.isRecording else { return }
+                self.processAudioBuffer(buffer, fileURL: self.recordingFileURL!)
+                self.lastBufferTime = time
+            }
+            Logger.debug("Fallback: Re-installed tap with new format.")
+            
+            // 6. Prepare and Restart engine if it wasn't manually paused before
+            audioEngine.prepare()
+            Logger.debug("Fallback: Prepared audio engine.")
+
+            if !wasManuallyPaused {
+                 // Only start if it's not running (it should have been paused earlier)
+                 if !audioEngine.isRunning {
+                     do {
+                         try audioEngine.start()
+                         Logger.debug("Audio engine restarted for fallback.")
+                     } catch {
+                         Logger.debug("Fallback failed: Could not restart audio engine after tap reinstall. Pausing. Error: \(error)")
+                         performPauseAction(reason: .deviceSwitchFailed)
+                         return
+                     }
+                 } else {
+                    Logger.debug("Audio engine was already running during fallback attempt? Unexpected state.")
+                 }
+             } else {
+                 Logger.debug("Recording was manually paused, leaving engine paused after fallback.")
+             }
+
+            // 7. Notify JS about successful fallback
+            delegate?.audioStreamManager(self, didReceiveInterruption: [
+                "reason": RecordingInterruptionReason.deviceFallback.rawValue,
+                "newDeviceId": defaultDevice.id, // Include new device ID
+                "isPaused": isPaused // Report current state
+            ])
+            Logger.debug("Fallback to device \(defaultDevice.id) successful.")
+
+        } catch {
+             Logger.debug("Fallback failed with error: \(error). Pausing.")
+             performPauseAction(reason: .deviceSwitchFailed)
+        }
+    }
+
 }
 
 extension AudioStreamManager: UNUserNotificationCenterDelegate {