Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more
fix(audio): recover route changes safely
altic-deveaa8efe05db4
diff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swiftindex dcaa7252..e6ed7e22 100644--- a/Sources/Fluid/Services/ASRService.swift+++ b/Sources/Fluid/Services/ASRService.swift@@ -501,6 +501,10 @@ final class ASRService: ObservableObject {private var streamingChunkAnalyticsSuccessCount: Int = 0private var lastStreamingChunkFailureAnalyticsAt: Date?private let transcriptionExecutor = TranscriptionExecutor() // Serializes all CoreML access+ private var engineConfigurationChangeObserver: NSObjectProtocol?+ private var audioRouteRecoveryTask: Task<Void, Never>?+ private let audioRouteRecoveryDelayNanoseconds: UInt64 = 1_000_000_000+ private var isRecoveringAudioRoute = false/// Tracks whether we paused system media for this recording session./// Used to resume playback only if we were the ones who paused it.@@ -637,6 +641,7 @@ final class ASRService: ObservableObject {self.micPermissionGranted = (self.micStatus == .authorized)self.registerDefaultDeviceChangeListener()+ self.registerEngineConfigurationChangeObserver()self.registerDeviceListChangeListener()// Initialize device list cache@@ -745,6 +750,9 @@ final class ASRService: ObservableObject {// Reset media pause state for this sessionself.didPauseMediaForThisSession = false+ self.audioRouteRecoveryTask?.cancel()+ self.audioRouteRecoveryTask = nil+ self.isRecoveringAudioRoute = falseDebugLogger.shared.debug("🧹 Clearing buffers and state", source: "ASRService")self.finalText.removeAll()@@ -879,6 +887,10 @@ final class ASRService: ObservableObject {}defer { self.applyPendingParakeetVocabularyReloadIfNeeded() }+ self.audioRouteRecoveryTask?.cancel()+ self.audioRouteRecoveryTask = nil+ self.isRecoveringAudioRoute = false+// Capture media pause state before we reset it, for resuming at the endlet shouldResumeMedia = SettingsStore.shared.pauseMediaDuringTranscription && self.didPauseMediaForThisSessionself.didPauseMediaForThisSession = false // Reset for next session@@ -1054,6 +1066,10 @@ final class ASRService: ObservableObject {guard self.isRunning else { return }defer { self.applyPendingParakeetVocabularyReloadIfNeeded() }+ self.audioRouteRecoveryTask?.cancel()+ self.audioRouteRecoveryTask = nil+ self.isRecoveringAudioRoute = false+// Capture media pause state before we reset it, for resuming at the endlet shouldResumeMedia = SettingsStore.shared.pauseMediaDuringTranscription && self.didPauseMediaForThisSessionself.didPauseMediaForThisSession = false // Reset for next session@@ -1595,6 +1611,78 @@ final class ASRService: ObservableObject {DebugLogger.shared.debug("✅ setupEngineTap() - COMPLETED", source: "ASRService")}+ private func scheduleAudioRouteRecovery(reason: String) {+ guard self.isRunning else {+ self.audioLevelSubject.send(0.0)+ return+ }+ guard self.isRecoveringAudioRoute == false else {+ DebugLogger.shared.debug("Ignoring audio route recovery request during active recovery (\(reason))", source: "ASRService")+ return+ }++ DebugLogger.shared.warning("Audio route changed while recording; scheduling recovery (\(reason))", source: "ASRService")+ self.audioCapturePipeline.setRecordingEnabled(false)+ self.audioLevelSubject.send(0.0)++ self.audioRouteRecoveryTask?.cancel()+ let recoveryDelayNanoseconds = self.audioRouteRecoveryDelayNanoseconds+ self.audioRouteRecoveryTask = Task { [weak self] in+ do {+ try await Task.sleep(nanoseconds: recoveryDelayNanoseconds)+ } catch {+ return+ }+ await self?.recoverAudioRoute(reason: reason)+ }+ }++ @MainActor+ private func recoverAudioRoute(reason: String) async {+ guard self.isRunning else { return }+ guard self.isRecoveringAudioRoute == false else { return }++ self.isRecoveringAudioRoute = true+ defer {+ self.isRecoveringAudioRoute = false+ self.audioRouteRecoveryTask = nil+ }++ DebugLogger.shared.info("Recovering audio route after \(reason)", source: "ASRService")+ self.audioCapturePipeline.setRecordingEnabled(false)++ self.stopMonitoringDevice()+ self.removeEngineTap()+ self.engine.stop()++ let oldEngine = self.engineStorage+ self.engineStorage = nil+ if let oldEngine {+ DispatchQueue.global(qos: .utility).async { _ = oldEngine }+ }++ do {+ try self.configureSession()+ try self.startEngine()+ try self.setupEngineTap()+ self.audioCapturePipeline.setRecordingEnabled(true)++ if let currentDevice = self.getCurrentlyBoundInputDevice() {+ self.startMonitoringDevice(currentDevice.id)+ }++ DebugLogger.shared.info("Audio route recovery succeeded", source: "ASRService")+ } catch {+ DebugLogger.shared.error("Audio route recovery failed: \(error)", source: "ASRService")+ await self.stopWithoutTranscription()+ NotificationCenter.default.post(+ name: NSNotification.Name("ASRServiceDeviceDisconnected"),+ object: nil,+ userInfo: ["errorMessage": "Recording stopped because the audio device changed."]+ )+ }+ }+private func handleDefaultInputChanged() {// If we're not syncing with macOS system settings, ignore system-default changes.// In independent mode, we explicitly bind to `preferredInputDeviceUID` on start/restart.@@ -1603,48 +1691,103 @@ final class ASRService: ObservableObject {return}- // Restart engine to bind to the new default input and resume level publishing- if self.isRunning {- self.removeEngineTap()- self.engine.stop()- // Recreate engine for system device change- self.engineStorage = nil- do {- try self.configureSession()- try self.startEngine()- try self.setupEngineTap()- } catch {}+ self.scheduleAudioRouteRecovery(reason: "default input changed")+ }++ private func handleDefaultOutputChanged() {+ guard SettingsStore.shared.syncAudioDevicesWithSystem else {+ DebugLogger.shared.debug("Ignoring system default output change (sync disabled)", source: "ASRService")+ return+ }++ self.scheduleAudioRouteRecovery(reason: "default output changed")+ }++ private func handleEngineConfigurationChanged(_ changedEngine: AVAudioEngine?) {+ guard let changedEngine,+ let currentEngine = self.engineStorage as? AVAudioEngine,+ changedEngine === currentEngine+ else { return }++ self.scheduleAudioRouteRecovery(reason: "engine configuration changed")+ }++ private func registerEngineConfigurationChangeObserver() {+ guard self.engineConfigurationChangeObserver == nil else { return }++ self.engineConfigurationChangeObserver = NotificationCenter.default.addObserver(+ forName: .AVAudioEngineConfigurationChange,+ object: nil,+ queue: .main+ ) { [weak self] notification in+ guard let changedEngine = notification.object as? AVAudioEngine else { return }+ Task { @MainActor [weak self, weak changedEngine] in+ self?.handleEngineConfigurationChanged(changedEngine)+ }}- // Nudge visualizer- DispatchQueue.main.async { self.audioLevelSubject.send(0.0) }}private var defaultInputListenerInstalled = falseprivate var defaultInputListenerToken: AudioObjectPropertyListenerBlock?+ private var defaultOutputListenerToken: AudioObjectPropertyListenerBlock?private func registerDefaultDeviceChangeListener() {guard self.defaultInputListenerInstalled == false else { return }- var address = AudioObjectPropertyAddress(+ var inputAddress = AudioObjectPropertyAddress(mSelector: kAudioHardwarePropertyDefaultInputDevice,mScope: kAudioObjectPropertyScopeGlobal,mElement: kAudioObjectPropertyElementMain)- let token: AudioObjectPropertyListenerBlock = { [weak self] _, _ in+ var outputAddress = AudioObjectPropertyAddress(+ mSelector: kAudioHardwarePropertyDefaultOutputDevice,+ mScope: kAudioObjectPropertyScopeGlobal,+ mElement: kAudioObjectPropertyElementMain+ )+ let inputToken: AudioObjectPropertyListenerBlock = { [weak self] _, _ in// Defer to next runloop pass — CoreAudio may hold an internal lock during// this callback, and our handler makes synchronous CoreAudio queries that// would deadlock waiting for the same lock.DispatchQueue.main.async { self?.handleDefaultInputChanged() }}- let status = AudioObjectAddPropertyListenerBlock(+ let outputToken: AudioObjectPropertyListenerBlock = { [weak self] _, _ in+ DispatchQueue.main.async { self?.handleDefaultOutputChanged() }+ }++ let inputStatus = AudioObjectAddPropertyListenerBlock(AudioObjectID(kAudioObjectSystemObject),- &address,+ &inputAddress,DispatchQueue.main,- token+ inputToken)- if status == noErr { self.defaultInputListenerInstalled = true }- if status == noErr {- self.defaultInputListenerToken = token+ let outputStatus = AudioObjectAddPropertyListenerBlock(+ AudioObjectID(kAudioObjectSystemObject),+ &outputAddress,+ DispatchQueue.main,+ outputToken+ )++ if inputStatus == noErr, outputStatus == noErr {+ self.defaultInputListenerInstalled = true+ self.defaultInputListenerToken = inputToken+ self.defaultOutputListenerToken = outputToken} else {+ if inputStatus == noErr {+ _ = AudioObjectRemovePropertyListenerBlock(+ AudioObjectID(kAudioObjectSystemObject),+ &inputAddress,+ DispatchQueue.main,+ inputToken+ )+ }+ if outputStatus == noErr {+ _ = AudioObjectRemovePropertyListenerBlock(+ AudioObjectID(kAudioObjectSystemObject),+ &outputAddress,+ DispatchQueue.main,+ outputToken+ )+ }self.defaultInputListenerToken = nil+ self.defaultOutputListenerToken = nil}}@@ -1771,8 +1914,11 @@ final class ASRService: ObservableObject {)if self.isRunning {- DebugLogger.shared.info("Recording in progress - restarting engine with preferred device", source: "ASRService")- self.restartEngineWithDevice(preferredDevice)+ DebugLogger.shared.info(+ "Recording in progress - deferring preferred device switch until audio route recovery",+ source: "ASRService"+ )+ self.scheduleAudioRouteRecovery(reason: "preferred input reconnected")} else {DebugLogger.shared.info("Not recording - updating binding for next session", source: "ASRService")_ = self.setEngineInputDevice(@@ -1799,8 +1945,11 @@ final class ASRService: ObservableObject {DebugLogger.shared.debug("Updated preferred input device to: \(device.uid)", source: "ASRService")if self.isRunning {- DebugLogger.shared.info("Recording in progress - restarting engine with new Bluetooth device", source: "ASRService")- self.restartEngineWithDevice(device)+ DebugLogger.shared.info(+ "Recording in progress - deferring Bluetooth switch until audio route recovery",+ source: "ASRService"+ )+ self.scheduleAudioRouteRecovery(reason: "bluetooth input connected")} else {DebugLogger.shared.info("Not recording - Bluetooth device will be used on next recording", source: "ASRService")}@@ -1836,60 +1985,11 @@ final class ASRService: ObservableObject {self.stopMonitoringDevice()if self.isRunning {- // Instead of cancelling, try to hot-swap to another available device- // so the recording continues seamlessly.DebugLogger.shared.info(- "🔄 Device died during recording — attempting hot-swap to fallback device",+ "Device changed during recording - deferring rebuild until audio route recovery",source: "ASRService")-- self.removeEngineTap()- self.engine.stop()- // Release dead engine on background thread (dealloc can block in CoreAudio)- let oldEngine = self.engineStorage- self.engineStorage = nil- if let oldEngine {- DispatchQueue.global(qos: .utility).async { _ = oldEngine }- }-- // Query available devices off-main after a short delay for CoreAudio to settle- DispatchQueue.global(qos: .userInitiated).async { [weak self] in- Thread.sleep(forTimeInterval: 0.3)- let availableInputs = AudioDevice.listInputDevices()- let defaultDevice = AudioDevice.getDefaultInputDevice()-- DispatchQueue.main.async { [weak self] in- guard let self, self.isRunning else { return }-- guard let fallback = defaultDevice ?? availableInputs.first else {- DebugLogger.shared.error("🛑 No fallback device — cancelling recording", source: "ASRService")- Task { @MainActor in- await self.stopWithoutTranscription()- NotificationCenter.default.post(- name: NSNotification.Name("ASRServiceDeviceDisconnected"),- object: nil,- userInfo: ["errorMessage": "Recording cancelled: No audio device available"]- )- }- return- }-- DebugLogger.shared.info("🔄 Hot-swapping to: '\(fallback.name)'", source: "ASRService")- do {- try self.configureSession()- _ = self.setEngineInputDevice(- deviceID: fallback.id, deviceUID: fallback.uid, deviceName: fallback.name- )- try self.startEngine()- try self.setupEngineTap()- self.startMonitoringDevice(fallback.id)- DebugLogger.shared.info("✅ Hot-swap successful — recording continues with '\(fallback.name)'", source: "ASRService")- } catch {- DebugLogger.shared.error("❌ Hot-swap failed: \(error)", source: "ASRService")- Task { @MainActor in await self.stopWithoutTranscription() }- }- }- }+ self.scheduleAudioRouteRecovery(reason: "monitored input disconnected")} else {DebugLogger.shared.info("Not recording - device disconnect handled gracefully", source: "ASRService")}@@ -1898,52 +1998,6 @@ final class ASRService: ObservableObject {}}- /// Restarts the engine with a new device (used for hot-swapping)- private func restartEngineWithDevice(_ device: AudioDevice.Device) {- guard self.isRunning else {- DebugLogger.shared.warning("restartEngineWithDevice() called but not recording", source: "ASRService")- return- }-- DebugLogger.shared.info("🔄 HOT-SWAPPING device to: '\(device.name)' (uid: \(device.uid))", source: "ASRService")-- // Note: This will cause a brief interruption in recording- // The user requested to cancel recording on device change, but we're allowing- // auto-switch for convenience. If issues arise, we can make this stricter.-- DebugLogger.shared.debug("Removing engine tap...", source: "ASRService")- self.removeEngineTap()-- DebugLogger.shared.debug("Stopping engine...", source: "ASRService")- self.engine.stop()-- do {- // Recreate engine for hot-swap instead of reset- DebugLogger.shared.debug("Recreating engine for device switch...", source: "ASRService")- self.engineStorage = nil- _ = self.engine.inputNode // Create fresh engine with new node- _ = self.setEngineInputDevice(deviceID: device.id, deviceUID: device.uid, deviceName: device.name)-- DebugLogger.shared.debug("Starting engine with new device...", source: "ASRService")- try self.startEngine()-- DebugLogger.shared.debug("Setting up engine tap...", source: "ASRService")- try self.setupEngineTap()-- // Start monitoring the new device- self.startMonitoringDevice(device.id)-- DebugLogger.shared.info("✅ HOT-SWAP successful - now recording with '\(device.name)'", source: "ASRService")- } catch {- DebugLogger.shared.error("❌ HOT-SWAP FAILED: \(error)", source: "ASRService")-- // Cancel recording on failure- Task { @MainActor in- await self.stopWithoutTranscription()- }- }- }-/// Gets the currently bound input device (if determinable)private func getCurrentlyBoundInputDevice() -> AudioDevice.Device? {// Check if engine exists before accessing inputNodediff --git a/Sources/Fluid/Views/BottomOverlayView.swift b/Sources/Fluid/Views/BottomOverlayView.swiftindex dbc227f4..b94a75e2 100644--- a/Sources/Fluid/Views/BottomOverlayView.swift+++ b/Sources/Fluid/Views/BottomOverlayView.swift@@ -123,6 +123,10 @@ final class BottomOverlayWindowController {return}+ NotchContentState.shared.setBottomOverlayReleaseTransitioning(true)+ NotchContentState.shared.setBottomOverlayDismissOffsetY(28)+ NotchContentState.shared.setBottomOverlayDismissing(true)+NSAnimationContext.runAnimationGroup { context incontext.duration = 0.2context.timingFunction = CAMediaTimingFunction(name: .easeIn)@@ -166,8 +170,6 @@ final class BottomOverlayWindowController {self.audioSubscription = nilNotchContentState.shared.bottomOverlayAudioLevel = 0NotchContentState.shared.setBottomOverlayReleaseTransitioning(true)- NotchContentState.shared.setBottomOverlayDismissOffsetY(28)- NotchContentState.shared.setBottomOverlayDismissing(true)}func endReleaseTransition(flushDeferredUpdate: Bool = true) {@@ -2135,7 +2137,7 @@ struct BottomOverlayView: View {}private var overlayAnimatedOpacity: Double {- self.contentState.isBottomOverlayDismissing ? 0.08 : 1.0+ 1.0}private func chipBackground(isHovered: Bool, disabled: Bool) -> some View {