Skip to content

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 hotkey capture, release ownership, and false-trigger regressions

altic-devd9bb6b4eeff1
diff --git a/Sources/Fluid/ContentView.swift b/Sources/Fluid/ContentView.swift
index 98857c52..fc283dcf 100644
--- a/Sources/Fluid/ContentView.swift
+++ b/Sources/Fluid/ContentView.swift
@@ -471,7 +471,7 @@ struct ContentView: View {
.sheet(isPresented: self.$showsFluidIntelligenceDemo) {
FluidIntelligenceDemoView(
asr: self.asr,
- onStart: self.startRecording,
+ onStart: { _ = self.startRecording() },
onStop: { await self.stopAndProcessTranscription() },
onCancel: { _ = self.handleCancelShortcut() },
onSetup: {
@@ -870,13 +870,18 @@ struct ContentView: View {
}
let keyCode = event.keyCode
- if keyCode == 53, recordingTarget != .cancel {
+ if keyCode == 53, eventModifiers.isEmpty, recordingTarget != .cancel {
DebugLogger.shared.debug("NSEvent monitor: Escape pressed, cancelling shortcut recording", source: "ContentView")
self.clearShortcutRecordingMode()
return nil
}
- let newShortcut = HotkeyShortcut(keyCode: keyCode, modifierFlags: self.pendingModifierFlags.union(eventModifiers))
+ let newShortcut = HotkeyShortcut(keyCode: keyCode, modifierFlags: eventModifiers)
+ if recordingTarget != .cancel, recordingTarget != .pasteLast, newShortcut.requiresModifierForRecording {
+ self.shortcutRecordingMessage = "\(newShortcut.displayString) needs a modifier key"
+ self.resetPendingShortcutState()
+ return nil
+ }
DebugLogger.shared.debug("NSEvent monitor: Recording new shortcut: \(newShortcut.displayString)", source: "ContentView")
if let recordingTarget,
@@ -909,7 +914,7 @@ struct ContentView: View {
return event
}
- let newShortcut = HotkeyShortcut(mouseButton: event.buttonNumber, modifierFlags: self.pendingModifierFlags.union(eventModifiers))
+ let newShortcut = HotkeyShortcut(mouseButton: event.buttonNumber, modifierFlags: eventModifiers)
DebugLogger.shared.debug("NSEvent monitor: Recording new mouse shortcut: \(newShortcut.displayString)", source: "ContentView")
if newShortcut.isUnmodifiedLeftOrRightClick, let mouseButton = newShortcut.mouseButton {
@@ -1188,9 +1193,11 @@ struct ContentView: View {
if self.isPromptModeShortcutEnabled {
configuredShortcuts.append((.secondaryDictation, self.promptModeHotkeyShortcut))
}
+ if self.isCommandModeShortcutEnabled, let commandModeHotkeyShortcut = self.commandModeHotkeyShortcut {
+ configuredShortcuts.append((.command, commandModeHotkeyShortcut))
+ }
let optionalConfiguredShortcuts: [(ShortcutRecordingTarget, HotkeyShortcut?)] = [
(.cancel, self.cancelRecordingHotkeyShortcut),
- (.command, self.commandModeHotkeyShortcut),
(.pasteLast, self.pasteLastTranscriptionHotkeyShortcut),
]
@@ -2146,7 +2153,7 @@ struct ContentView: View {
copyToClipboard: self.$copyToClipboard,
hotkeyManager: self.hotkeyManager,
menuBarManager: self.menuBarManager,
- startRecording: self.startRecording,
+ startRecording: { _ = self.startRecording() },
refreshDevices: self.refreshDevices,
openAccessibilitySettings: self.openAccessibilitySettings,
restartApp: self.restartApp,
@@ -2160,7 +2167,7 @@ struct ContentView: View {
RecordingView(
appear: self.$appear,
stopAndProcessTranscription: { await self.stopAndProcessTranscription() },
- startRecording: self.startRecording
+ startRecording: { _ = self.startRecording() }
)
}
@@ -4460,10 +4467,10 @@ struct ContentView: View {
}
/// Capture app context at start to avoid mismatches if the user switches apps mid-session
- private func startRecording() {
+ private func startRecording() -> Task<Void, Never>? {
// Browsing the demo must not send dictation to a previously focused app.
- guard !self.showsFluidIntelligenceDemo || (DictationPromptTestCoordinator.shared.isActive && !DictationPromptTestCoordinator.shared.isProcessing) else { return }
- guard !self.presentExclusiveActivityBlockIfNeeded() else { return }
+ guard !self.showsFluidIntelligenceDemo || (DictationPromptTestCoordinator.shared.isActive && !DictationPromptTestCoordinator.shared.isProcessing) else { return nil }
+ guard !self.presentExclusiveActivityBlockIfNeeded() else { return nil }
let model = SettingsStore.shared.selectedSpeechModel
DebugLogger.shared.info(
"ContentView: startRecording() for model=\(model.displayName), supportsStreaming=\(model.supportsStreaming)",
@@ -4471,7 +4478,7 @@ struct ContentView: View {
)
guard !self.asr.isRunningOrStarting else {
DebugLogger.shared.debug("ContentView: start ignored because capture is already active", source: "ContentView")
- return
+ return nil
}
self.advanceOverlayLifecycle()
self.setActiveRecordingMode(.dictate)
@@ -4493,7 +4500,12 @@ struct ContentView: View {
)
}
- Task {
+ let captureOverlayLifecycleID = self.overlayLifecycleID
+ let captureTask = Task {
+ guard !Task.isCancelled else {
+ self.clearCancelledCaptureStart(lifecycleID: captureOverlayLifecycleID, mode: .dictate)
+ return
+ }
let startOutcome = await self.asr.start(onCaptureStarted: {
if shouldPlayStartSound {
TranscriptionSoundPlayer.shared.playStartSound()
@@ -4506,6 +4518,10 @@ struct ContentView: View {
source: "AppBenchmark"
)
})
+ guard !Task.isCancelled else {
+ self.clearCancelledCaptureStart(lifecycleID: captureOverlayLifecycleID, mode: .dictate)
+ return
+ }
if startOutcome == .failed {
self.menuBarManager.hideRecordingOverlayImmediately(reason: "asr_start_failed")
}
@@ -4523,6 +4539,26 @@ struct ContentView: View {
DebugLogger.shared.error("Failed to pre-load model: \(error)", source: "ContentView")
}
}
+ return captureTask
+ }
+
+ private func awaitCaptureStart(_ captureTask: Task<Void, Never>?) async {
+ guard let captureTask else { return }
+ await withTaskCancellationHandler {
+ await captureTask.value
+ } onCancel: {
+ captureTask.cancel()
+ }
+ }
+
+ private func clearCancelledCaptureStart(lifecycleID: UInt64, mode: ActiveRecordingMode) {
+ guard self.overlayLifecycleID == lifecycleID,
+ !self.asr.isRunningOrStarting,
+ self.activeRecordingMode == mode || self.activeRecordingMode == .none
+ else { return }
+ self.cancelPrewarmDictationIfNeeded()
+ self.clearActiveRecordingMode()
+ self.menuBarManager.hideRecordingOverlayImmediately(reason: "capture_start_cancelled")
}
private func presentExclusiveActivityBlockIfNeeded() -> Bool {
@@ -4728,7 +4764,7 @@ struct ContentView: View {
rewriteModeShortcutEnabled: self.isRewriteModeShortcutEnabled,
startRecordingCallback: {
DebugLogger.shared.debug("ContentView: startRecordingCallback invoked by hotkey", source: "ContentView")
- self.startRecording()
+ await self.awaitCaptureStart(self.startRecording())
},
dictationModeCallback: {
DebugLogger.shared.info("Dictate mode triggered", source: "ContentView")
@@ -4736,7 +4772,7 @@ struct ContentView: View {
"ContentView: selected model for dictate hotkey=\(SettingsStore.shared.selectedSpeechModel.displayName)",
source: "ContentView"
)
- self.beginDictationRecording(for: .primary, mode: .dictate)
+ await self.awaitCaptureStart(self.beginDictationRecording(for: .primary, mode: .dictate))
},
stopAndProcessCallback: { toggleStopRequestedAt in
let route = self.currentDictationOutputRouteForHotkeyStop()
@@ -4748,11 +4784,11 @@ struct ContentView: View {
},
promptModeCallback: {
DebugLogger.shared.info("Prompt mode triggered", source: "ContentView")
- self.beginDictationRecording(for: .secondary, mode: .promptMode)
+ await self.awaitCaptureStart(self.beginDictationRecording(for: .secondary, mode: .promptMode))
},
promptSelectionCallback: { selection in
DebugLogger.shared.info("Prompt selection shortcut triggered", source: "ContentView")
- self.beginDictationRecording(for: selection, mode: .promptMode)
+ await self.awaitCaptureStart(self.beginDictationRecording(for: selection, mode: .promptMode))
},
commandModeCallback: {
guard !self.presentExclusiveActivityBlockIfNeeded() else { return }
@@ -4774,17 +4810,27 @@ struct ContentView: View {
"Starting voice recording for command",
source: "ContentView"
)
- Task {
+ let captureOverlayLifecycleID = self.overlayLifecycleID
+ let captureTask = Task {
+ guard !Task.isCancelled else {
+ self.clearCancelledCaptureStart(lifecycleID: captureOverlayLifecycleID, mode: .command)
+ return
+ }
let startOutcome = await self.asr.start(onCaptureStarted: {
TranscriptionSoundPlayer.shared.playStartSound()
self.appBench("overlay_phase phase=recording trigger=first_pcm mode=command")
})
+ guard !Task.isCancelled else {
+ self.clearCancelledCaptureStart(lifecycleID: captureOverlayLifecycleID, mode: .command)
+ return
+ }
if startOutcome == .failed {
self.menuBarManager.hideRecordingOverlayImmediately(
reason: "command_asr_start_failed"
)
}
}
+ await self.awaitCaptureStart(captureTask)
},
rewriteModeCallback: {
guard !self.presentExclusiveActivityBlockIfNeeded() else { return }
@@ -4820,17 +4866,27 @@ struct ContentView: View {
// Start recording immediately for the edit instruction
DebugLogger.shared.info("Starting voice recording for edit mode", source: "ContentView")
- Task {
+ let captureOverlayLifecycleID = self.overlayLifecycleID
+ let captureTask = Task {
+ guard !Task.isCancelled else {
+ self.clearCancelledCaptureStart(lifecycleID: captureOverlayLifecycleID, mode: .edit)
+ return
+ }
let startOutcome = await self.asr.start(onCaptureStarted: {
TranscriptionSoundPlayer.shared.playStartSound()
self.appBench("overlay_phase phase=recording trigger=first_pcm mode=edit")
})
+ guard !Task.isCancelled else {
+ self.clearCancelledCaptureStart(lifecycleID: captureOverlayLifecycleID, mode: .edit)
+ return
+ }
if startOutcome == .failed {
self.menuBarManager.hideRecordingOverlayImmediately(
reason: "edit_asr_start_failed"
)
}
}
+ await self.awaitCaptureStart(captureTask)
},
isDictateRecordingProvider: {
self.activeRecordingMode == .dictate
@@ -4846,6 +4902,9 @@ struct ContentView: View {
},
isShortcutCaptureActiveProvider: {
self.isRecordingAnyShortcutCapture
+ },
+ shortcutCaptureHandler: {
+ self.handleShortcutCaptureEvent($0)
}
)
self.hotkeyManager?.registerDebugToggleTriggerIfEnabled()
@@ -5146,8 +5205,8 @@ extension ContentView {
for slot: SettingsStore.DictationShortcutSlot,
mode: ActiveRecordingMode,
startMethod: AnalyticsOnboardingTryoutStartMethod = .hotkey
- ) {
- guard !self.presentExclusiveActivityBlockIfNeeded() else { return }
+ ) -> Task<Void, Never>? {
+ guard !self.presentExclusiveActivityBlockIfNeeded() else { return nil }
DebugLogger.shared.debug("Begin dictation recording for slot \(slot.rawValue)", source: "ContentView")
DebugLogger.shared.debug("CLOSE_DETAIL nextStartRequested uptime=\(ProcessInfo.processInfo.systemUptime)", source: "StopTiming")
self.appBench("begin_recording slot=\(slot.rawValue) mode=\(mode.rawValue)")
@@ -5164,7 +5223,7 @@ extension ContentView {
guard !self.asr.isRunningOrStarting else {
self.appBench("asr_start_skipped reason=already_running_or_starting")
- return
+ return nil
}
let isOnboardingTryout = self.isOnboardingVoicePlaygroundStepActive && mode == .dictate
if isOnboardingTryout {
@@ -5178,7 +5237,12 @@ extension ContentView {
self.appBench("overlay_mode_requested mode=Dictation")
self.appBench("overlay_phase phase=connecting")
}
- Task {
+ let captureOverlayLifecycleID = self.overlayLifecycleID
+ return Task {
+ guard !Task.isCancelled else {
+ self.clearCancelledCaptureStart(lifecycleID: captureOverlayLifecycleID, mode: mode)
+ return
+ }
let asrStartStartedAt = ProcessInfo.processInfo.systemUptime
DebugLogger.shared.benchmark("APP_BENCH", message: "asr_start_call", source: "AppBenchmark")
let startOutcome = await self.asr.start(onCaptureStarted: {
@@ -5189,6 +5253,10 @@ extension ContentView {
self.prewarmPrivateAIDictationIfNeeded(for: slot)
self.appBench("overlay_phase phase=recording trigger=first_pcm")
})
+ guard !Task.isCancelled else {
+ self.clearCancelledCaptureStart(lifecycleID: captureOverlayLifecycleID, mode: mode)
+ return
+ }
if startOutcome == .failed {
self.menuBarManager.hideRecordingOverlayImmediately(reason: "asr_start_failed")
if isOnboardingTryout {
@@ -5206,10 +5274,10 @@ extension ContentView {
}
}
- private func beginDictationRecording(for selection: SettingsStore.DictationPromptSelection, mode: ActiveRecordingMode) {
+ private func beginDictationRecording(for selection: SettingsStore.DictationPromptSelection, mode: ActiveRecordingMode) -> Task<Void, Never>? {
let settings = SettingsStore.shared
settings.setDictationPromptSelection(selection, for: .secondary)
- self.beginDictationRecording(for: .secondary, mode: mode)
+ return self.beginDictationRecording(for: .secondary, mode: mode)
}
private func benchmarkLoadAverage() -> String {
diff --git a/Sources/Fluid/Models/HotkeyShortcut.swift b/Sources/Fluid/Models/HotkeyShortcut.swift
index 17d39e00..72f2f10e 100644
--- a/Sources/Fluid/Models/HotkeyShortcut.swift
+++ b/Sources/Fluid/Models/HotkeyShortcut.swift
@@ -277,6 +277,22 @@ extension HotkeyShortcut {
return self.relevantModifierFlags.union(triggerFlag)
}
+ /// Physical letter/digit and editing keys need a modifier; punctuation and modifier-only keys remain available.
+ var requiresModifierForRecording: Bool {
+ guard !self.isMouseShortcut, !self.isModifierOnlyShortcut, self.relevantModifierFlags.isEmpty else { return false }
+ switch self.keyCode {
+ case 0...9, 11...23, 25, 26, 28, 29, 31, 32, 34...38, 40, 45, 46,
+ 48, 49, 51, 53, 76, 82...89, 91, 92, 117:
+ return true
+ default:
+ return false
+ }
+ }
+
+ func matchesRecordingShortcut(keyCode: UInt16, modifiers: NSEvent.ModifierFlags) -> Bool {
+ !self.requiresModifierForRecording && self.matches(keyCode: keyCode, modifiers: modifiers)
+ }
+
func matches(keyCode: UInt16, modifiers: NSEvent.ModifierFlags) -> Bool {
guard !self.isMouseShortcut else { return false }
return keyCode == self.keyCode && modifiers.intersection(Self.relevantModifierMask) == self.relevantModifierFlags
diff --git a/Sources/Fluid/Persistence/SettingsStore.swift b/Sources/Fluid/Persistence/SettingsStore.swift
index 39276ad6..4e8ab39b 100644
--- a/Sources/Fluid/Persistence/SettingsStore.swift
+++ b/Sources/Fluid/Persistence/SettingsStore.swift
@@ -565,7 +565,9 @@ final class SettingsStore: ObservableObject {
guard let key = self.dictationPromptConfigurationKey(for: selection) else {
return DictationPromptConfiguration()
}
- return self.dictationPromptConfigurations[key] ?? DictationPromptConfiguration()
+ var configuration = self.dictationPromptConfigurations[key] ?? DictationPromptConfiguration()
+ if configuration.shortcut?.requiresModifierForRecording == true { configuration.shortcut = nil }
+ return configuration
}
func setDictationPromptConfiguration(_ configuration: DictationPromptConfiguration, for selection: DictationPromptSelection) {
@@ -594,7 +596,7 @@ final class SettingsStore: ObservableObject {
func dictationPromptShortcutAssignments() -> [(selection: DictationPromptSelection, shortcut: HotkeyShortcut)] {
self.dictationPromptConfigurations.compactMap { key, configuration in
- guard let shortcut = configuration.shortcut else { return nil }
+ guard let shortcut = configuration.shortcut, !shortcut.requiresModifierForRecording else { return nil }
if key == "__default__" {
return (.default, shortcut)
}
@@ -1858,7 +1860,7 @@ final class SettingsStore: ObservableObject {
{
return Self.normalizedPrimaryDictationShortcuts(shortcuts)
}
- return [fallback]
+ return Self.normalizedPrimaryDictationShortcuts([fallback])
}
set {
objectWillChange.send()
@@ -1885,7 +1887,7 @@ final class SettingsStore: ObservableObject {
_ shortcuts: [HotkeyShortcut]
) -> [HotkeyShortcut] {
var unique: [HotkeyShortcut] = []
- for shortcut in shortcuts where !unique.contains(shortcut) {
+ for shortcut in shortcuts where !shortcut.requiresModifierForRecording && !unique.contains(shortcut) {
unique.append(shortcut)
}
return unique
@@ -3041,7 +3043,7 @@ final class SettingsStore: ObservableObject {
var promptModeShortcutEnabled: Bool {
get {
let value = self.defaults.object(forKey: Keys.promptModeShortcutEnabled)
- return value as? Bool ?? false
+ return (value as? Bool ?? false) && !self.promptModeHotkeyShortcut.requiresModifierForRecording
}
set {
objectWillChange.send()
@@ -3096,7 +3098,7 @@ final class SettingsStore: ObservableObject {
var commandModeShortcutEnabled: Bool {
get {
let value = self.defaults.object(forKey: Keys.commandModeShortcutEnabled)
- return value as? Bool ?? false
+ return (value as? Bool ?? false) && self.commandModeHotkeyShortcut?.requiresModifierForRecording != true
}
set {
objectWillChange.send()
@@ -3322,7 +3324,7 @@ final class SettingsStore: ObservableObject {
var rewriteModeShortcutEnabled: Bool {
get {
let value = self.defaults.object(forKey: Keys.rewriteModeShortcutEnabled)
- return value as? Bool ?? true
+ return (value as? Bool ?? true) && !self.rewriteModeHotkeyShortcut.requiresModifierForRecording
}
set {
objectWillChange.send()
diff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swift
index 076622d9..50f59f06 100644
--- a/Sources/Fluid/Services/ASRService.swift
+++ b/Sources/Fluid/Services/ASRService.swift
@@ -2880,12 +2880,7 @@ final class ASRService: ObservableObject {
attemptID: readinessAttemptID,
timeoutNanoseconds: self.firstPCMTimeoutNanoseconds
)
- guard startGeneration == self.audioCaptureStartGeneration,
- self.isTerminating == false,
- self.isPronunciationTrainingStartCurrent
- else {
- throw CancellationError()
- }
+ try self.checkCaptureStartGeneration(startGeneration)
let routeStayedStable =
routeGenerationAtStart == self.audioRouteRecoveryGeneration &&
self.pendingAudioRouteRecovery == nil &&
diff --git a/Sources/Fluid/Services/GlobalHotkeyManager.swift b/Sources/Fluid/Services/GlobalHotkeyManager.swift
index 75000fb5..6b626831 100644
--- a/Sources/Fluid/Services/GlobalHotkeyManager.swift
+++ b/Sources/Fluid/Services/GlobalHotkeyManager.swift
@@ -10,8 +10,24 @@ nonisolated enum HotkeyHoldModeType: Hashable {
}
private nonisolated enum ActivePrimaryShortcutPress: Equatable {
- case keyboard(UInt16)
- case mouse(Int)
+ case keyboard(HotkeyShortcut)
+ case mouse(HotkeyShortcut)
+
+ var shortcut: HotkeyShortcut {
+ switch self {
+ case let .keyboard(shortcut), let .mouse(shortcut): return shortcut
+ }
+ }
+
+ var keyboardKeyCode: UInt16? {
+ guard case let .keyboard(shortcut) = self else { return nil }
+ return shortcut.keyCode
+ }
+
+ var mouseButton: Int? {
+ guard case let .mouse(shortcut) = self else { return nil }
+ return shortcut.mouseButton
+ }
}
/// Input timing only: never changes shortcut routing or retains a keyboard event.
@@ -108,6 +124,7 @@ struct ModifierOnlyShortcutFlagsDecision: Equatable {
// subsequent release reads as a clean tap and falsely starts recording (#688).
if activeModifierOnlyType == nil,
pressedKeyCodes == expectedModifierKeyCodes,
+ relevantModifiers == shortcut.expectedModifierFlags,
expectedModifierKeyCodes.contains(keyCode)
{
return .init(
@@ -191,7 +208,7 @@ struct ModifierOnlyShortcutFlagsDecision: Equatable {
}
guard isActiveModifierOnlyPress || isLegacyModePress,
- keyCode == shortcut.keyCode,
+ HotkeyShortcut.modifierFlag(forKeyCode: keyCode) == triggerFlag,
!relevantModifiers.contains(triggerFlag)
else {
return .init(
@@ -258,6 +275,10 @@ final class GlobalHotkeyManager: NSObject {
private nonisolated(unsafe) var mouseShortcutSource: CFRunLoopSource?
private nonisolated(unsafe) var monitoredMouseButtons: Set<Int> = []
private let asrService: ASRService
+ private var recordingActionRevisions: [HotkeyHoldModeType: UInt64] = [:]
+ private var pendingRecordingActionCounts: [HotkeyHoldModeType: Int] = [:]
+ private var activeRecordingActionShortcuts: [HotkeyHoldModeType: HotkeyShortcut] = [:]
+ private var pendingRecordingActions: [HotkeyHoldModeType: Task<Void, Never>] = [:]
private var primaryShortcuts: [HotkeyShortcut]
private var promptModeShortcut: HotkeyShortcut
private var commandModeShortcut: HotkeyShortcut?
@@ -278,6 +299,7 @@ final class GlobalHotkeyManager: NSObject {
private var isCommandRecordingProvider: (() -> Bool)?
private var isRewriteRecordingProvider: (() -> Bool)?
private var isShortcutCaptureActiveProvider: (() -> Bool)?
+ private var shortcutCaptureHandler: ((NSEvent) -> NSEvent?)?
private var cancelCallback: (() -> Bool)? // Returns true if handled
private var pasteLastTranscriptionCallback: (() -> Void)?
private var hotkeyMode: HotkeyActivationMode = SettingsStore.shared.hotkeyMode
@@ -285,6 +307,7 @@ final class GlobalHotkeyManager: NSObject {
private var currentInputTiming: HotkeyInputTiming?
private var modifierPressReceivedAt: TimeInterval?
private var currentStopPressReceivedAt: TimeInterval?
+ private var activePromptAssignmentPress: (selection: SettingsStore.DictationPromptSelection, shortcut: HotkeyShortcut)?
private struct ModifierOnlyShortcutBehavior {
let shortcut: HotkeyShortcut
@@ -509,7 +532,8 @@ final class GlobalHotkeyManager: NSObject {
isPromptModeRecordingProvider: (() -> Bool)? = nil,
isCommandRecordingProvider: (() -> Bool)? = nil,
isRewriteRecordingProvider: (() -> Bool)? = nil,
- isShortcutCaptureActiveProvider: (() -> Bool)? = nil
+ isShortcutCaptureActiveProvider: (() -> Bool)? = nil,
+ shortcutCaptureHandler: ((NSEvent) -> NSEvent?)? = nil
) {
self.asrService = asrService
self.primaryShortcuts = primaryShortcuts
@@ -532,6 +556,7 @@ final class GlobalHotkeyManager: NSObject {
self.isCommandRecordingProvider = isCommandRecordingProvider
self.isRewriteRecordingProvider = isRewriteRecordingProvider
self.isShortcutCaptureActiveProvider = isShortcutCaptureActiveProvider
+ self.shortcutCaptureHandler = shortcutCaptureHandler
super.init()
self.initializeWithDelay()
@@ -562,6 +587,13 @@ final class GlobalHotkeyManager: NSObject {
}
func updatePrimaryShortcuts(_ newShortcuts: [HotkeyShortcut]) {
+ let ownedShortcut = self.activePrimaryShortcutPress?.shortcut
+ ?? (self.activeModifierOnlyType == .transcription ? self.activeModifierOnlyShortcut : nil)
+ ?? self.activeRecordingActionShortcuts[.transcription]
+ if newShortcuts != self.primaryShortcuts,
+ ownedShortcut.map({ !newShortcuts.contains($0) })
+ ?? newShortcuts.isEmpty
+ { self.discardShortcutPress(for: .transcription) }
self.primaryShortcuts = newShortcuts
DebugLogger.shared.info("Updated transcription hotkeys", source: "GlobalHotkeyManager")
self.refreshMouseShortcutTapIfNeeded()
@@ -572,10 +604,11 @@ final class GlobalHotkeyManager: NSObject {
guard self.eventTap != nil else { return }
let mouseButtons = self.configuredMouseButtons()
guard mouseButtons != self.monitoredMouseButtons else { return }
- self.setupMouseShortcutTap(mouseButtons: mouseButtons)
+ self.setupMouseShortcutTap(mouseButtons: mouseButtons, preservePrimaryPress: true)
}
func updateCommandModeShortcut(_ newShortcut: HotkeyShortcut?) {
+ if newShortcut != self.commandModeShortcut { self.discardShortcutPress(for: .commandMode) }
self.commandModeShortcut = newShortcut
DebugLogger.shared.info("Updated command mode hotkey", source: "GlobalHotkeyManager")
self.scheduleActiveShortcutLog(reason: "shortcuts updated")
@@ -586,6 +619,7 @@ final class GlobalHotkeyManager: NSObject {
}
func updateRewriteModeShortcut(_ newShortcut: HotkeyShortcut) {
+ if newShortcut != self.rewriteModeShortcut { self.discardShortcutPress(for: .rewriteMode) }
self.rewriteModeShortcut = newShortcut
DebugLogger.shared.info("Updated rewrite mode hotkey", source: "GlobalHotkeyManager")
self.scheduleActiveShortcutLog(reason: "shortcuts updated")
@@ -593,9 +627,7 @@ final class GlobalHotkeyManager: NSObject {
func updateCommandModeShortcutEnabled(_ enabled: Bool) {
self.commandModeShortcutEnabled = enabled
- if !enabled {
- self.isCommandModeKeyPressed = false
- }
+ if !enabled { self.discardShortcutPress(for: .commandMode) }
DebugLogger.shared.info(
"Command mode shortcut \(enabled ? "enabled" : "disabled")",
source: "GlobalHotkeyManager"
@@ -605,9 +637,7 @@ final class GlobalHotkeyManager: NSObject {
func updateRewriteModeShortcutEnabled(_ enabled: Bool) {
self.rewriteModeShortcutEnabled = enabled
- if !enabled {
- self.isRewriteKeyPressed = false
- }
+ if !enabled { self.discardShortcutPress(for: .rewriteMode) }
DebugLogger.shared.info(
"Rewrite mode shortcut \(enabled ? "enabled" : "disabled")",
source: "GlobalHotkeyManager"
@@ -620,6 +650,7 @@ final class GlobalHotkeyManager: NSObject {
}
func updatePromptModeShortcut(_ newShortcut: HotkeyShortcut) {
+ if newShortcut != self.promptModeShortcut { self.discardShortcutPress(for: .promptMode) }
self.promptModeShortcut = newShortcut
DebugLogger.shared.info("Updated prompt mode hotkey", source: "GlobalHotkeyManager")
self.scheduleActiveShortcutLog(reason: "shortcuts updated")
@@ -627,9 +658,7 @@ final class GlobalHotkeyManager: NSObject {
func updatePromptModeShortcutEnabled(_ enabled: Bool) {
self.promptModeShortcutEnabled = enabled
- if !enabled {
- self.isPromptModeKeyPressed = false
- }
+ if !enabled { self.discardShortcutPress(for: .promptMode) }
DebugLogger.shared.info(
"Prompt mode shortcut \(enabled ? "enabled" : "disabled")",
source: "GlobalHotkeyManager"
@@ -638,6 +667,11 @@ final class GlobalHotkeyManager: NSObject {
}
func updatePromptShortcutAssignments(_ assignments: [(selection: SettingsStore.DictationPromptSelection, shortcut: HotkeyShortcut)]) {
+ let previous = self.activePromptAssignmentPress.map { [$0] }
+ ?? self.promptShortcutAssignments.filter { $0.shortcut == self.activeRecordingActionShortcuts[.promptAssignment] }
+ if !previous.allSatisfy({ old in assignments.contains { $0.selection == old.selection && $0.shortcut == old.shortcut } }) {
+ self.discardShortcutPress(for: .promptAssignment)
+ }
self.promptShortcutAssignments = assignments
DebugLogger.shared.info("Updated prompt shortcut assignments", source: "GlobalHotkeyManager")
self.scheduleActiveShortcutLog(reason: "shortcuts updated")
@@ -692,7 +726,7 @@ final class GlobalHotkeyManager: NSObject {
place: .headInsertEventTap,
options: .defaultTap,
eventsOfInterest: Self.keyboardEventMask(),
- callback: { proxy, type, event, refcon -> Unmanaged<CGEvent>? in
+ callback: { _, type, event, refcon -> Unmanaged<CGEvent>? in
guard let refcon = refcon else { return Unmanaged.passUnretained(event) }
ClipboardAudit.recordShortcut(type: type, event: event)
if GlobalHotkeyManager.isSynthesizedTypingEvent(event) {
@@ -702,12 +736,12 @@ final class GlobalHotkeyManager: NSObject {
.takeUnretainedValue()
if Thread.isMainThread {
return MainActor.assumeIsolated {
- manager.handleKeyEvent(proxy: proxy, type: type, event: event)
+ manager.handleKeyEvent(type: type, event: event)
}
}
return DispatchQueue.main.sync {
MainActor.assumeIsolated {
- manager.handleKeyEvent(proxy: proxy, type: type, event: event)
+ manager.handleKeyEvent(type: type, event: event)
}
}
},
@@ -788,12 +822,6 @@ final class GlobalHotkeyManager: NSObject {
return runLoop
}
- nonisolated static func keyboardEventMask() -> CGEventMask {
- (CGEventMask(1) << CGEventType.keyDown.rawValue)
- | (CGEventMask(1) << CGEventType.keyUp.rawValue)
- | (CGEventMask(1) << CGEventType.flagsChanged.rawValue)
- }
-
nonisolated static func mouseObserverEventMask() -> CGEventMask {
(CGEventMask(1) << CGEventType.leftMouseDown.rawValue)
| (CGEventMask(1) << CGEventType.rightMouseDown.rawValue)
@@ -959,9 +987,16 @@ final class GlobalHotkeyManager: NSObject {
}
// Filter tap, created only for the button families that have a shortcut.
- private func setupMouseShortcutTap(mouseButtons: Set<Int>) {
- self.finishInterruptedMouseShortcutPress(reason: "mouse shortcut tap rebuilt")
- self.cleanupMouseShortcutTap()
+ private func setupMouseShortcutTap(mouseButtons: Set<Int>, preservePrimaryPress: Bool = false) {
+ let preservesHeldPress = preservePrimaryPress && self.activePrimaryShortcutPress?.mouseButton != nil
+ if !preservesHeldPress { self.finishInterruptedMouseShortcutPress(reason: "mouse shortcut tap rebuilt") }
+ self.cleanupMouseShortcutTap(preservePrimaryPress: preservesHeldPress)
+ var installedTap = false
+ defer {
+ if preservesHeldPress, !installedTap {
+ self.finishInterruptedMouseShortcutPress(reason: "mouse shortcut tap rebuild failed")
+ }
+ }
let mask = Self.mouseShortcutEventMask(mouseButtons: mouseButtons)
guard mask != 0 else {
@@ -996,6 +1031,7 @@ final class GlobalHotkeyManager: NSObject {
self.monitoredMouseButtons = mouseButtons
CFRunLoopAddSource(CFRunLoopGetMain(), source, .commonModes)
CGEvent.tapEnable(tap: tap, enable: true)
+ installedTap = Self.isTapEnabled(tap)
let summary = mouseButtons.sorted().map(String.init).joined(separator: ",")
DebugLogger.shared.info("Mouse shortcut tap enabled [mouseButtons=\(summary)]", source: "GlobalHotkeyManager")
}
@@ -1025,12 +1061,12 @@ final class GlobalHotkeyManager: NSObject {
self.mouseObserverSource = nil
}
- private nonisolated func cleanupMouseShortcutTap() {
+ private nonisolated func cleanupMouseShortcutTap(preservePrimaryPress: Bool = false) {
Self.tearDown(tap: self.mouseShortcutTap, source: self.mouseShortcutSource)
self.mouseShortcutTap = nil
self.mouseShortcutSource = nil
self.monitoredMouseButtons = []
- self.clearPrimaryShortcutPressState(mouseOnly: true)
+ if !preservePrimaryPress { self.clearPrimaryShortcutPressState(mouseOnly: true) }
}
private func handleMouseObserverEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
@@ -1047,7 +1083,7 @@ final class GlobalHotkeyManager: NSObject {
return Unmanaged.passUnretained(event)
}
- private func handleMouseShortcutEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
+ func handleMouseShortcutEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
let previousInput = self.currentInputTiming
self.currentInputTiming = HotkeyInputTiming(
receivedAt: ProcessInfo.processInfo.systemUptime,
@@ -1136,16 +1172,6 @@ final class GlobalHotkeyManager: NSObject {
Int(event.getIntegerValueField(.mouseEventButtonNumber))
}
- private func beginPrimaryShortcutPress(_ press: ActivePrimaryShortcutPress) -> Bool {
- self.state.withLock {
- guard self.state.activePrimaryShortcutPress == nil, !self.state.isKeyPressed else {
- return false
- }
- self.state.activePrimaryShortcutPress = press
- return true
- }
- }
-
private func finishInterruptedMouseShortcutPress(reason: String) {
guard case .mouse? = self.activePrimaryShortcutPress else { return }
@@ -1172,16 +1198,6 @@ final class GlobalHotkeyManager: NSObject {
activationMode != .toggle
}
- private func finishPrimaryShortcutPress(_ press: ActivePrimaryShortcutPress) -> Bool {
- self.state.withLock {
- guard self.state.activePrimaryShortcutPress == press else {
- return false
- }
- self.state.activePrimaryShortcutPress = nil
- return true
- }
- }
-
private func primaryModifierOnlyBehavior(for shortcut: HotkeyShortcut) -> ModifierOnlyShortcutBehavior {
.init(
shortcut: shortcut,
@@ -1192,7 +1208,7 @@ final class GlobalHotkeyManager: NSObject {
toggleIgnoredMessage: "Transcription modifier released but another key was pressed - ignoring",
isModeKeyPressed: { self.isKeyPressed },
setModeKeyPressed: { self.isKeyPressed = $0 },
- onHoldStart: { self.startRecordingIfNeeded() },
+ onHoldStart: { self.startRecordingIfNeeded(shortcut: shortcut) },
onToggleRelease: {
if self.asrService.isRunningOrStarting {
let isSameMode = self.isDictateRecordingProvider?() ?? false
@@ -1201,23 +1217,23 @@ final class GlobalHotkeyManager: NSObject {
source: "GlobalHotkeyManager"
)
if isSameMode {
- self.stopRecordingAfterToggle()
+ self.triggerDictationMode(shortcut: shortcut)
} else {
- self.triggerDictationMode()
+ self.triggerDictationMode(shortcut: shortcut)
}
} else {
DebugLogger.shared.info(
"Hotkey route | pressed=dictate(mod) | active=none | asrRunning=false | action=start",
source: "GlobalHotkeyManager"
)
- self.triggerDictationMode()
+ self.triggerDictationMode(shortcut: shortcut)
}
},
isTargetModeActive: { self.isDictateRecordingProvider?() ?? false }
)
}
- private func handleKeyEvent(proxy: CGEventTapProxy, type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
+ func handleKeyEvent(type: CGEventType, event: CGEvent) -> Unmanaged<CGEvent>? {
let previousInput = self.currentInputTiming
self.currentInputTiming = HotkeyInputTiming(
receivedAt: ProcessInfo.processInfo.systemUptime,
@@ -1237,19 +1253,27 @@ final class GlobalHotkeyManager: NSObject {
if self.isShortcutCaptureActiveProvider?() ?? false {
self.resetModifierOnlyShortcutTracking()
+ if Self.captureKeyboardEvent(type: type, event: event, isAppActive: NSApp.isActive, handler: self.shortcutCaptureHandler) { return nil }
return Unmanaged.passUnretained(event)
}
let keyCode = UInt16(event.getIntegerValueField(.keyboardEventKeycode))
let eventModifiers = Self.modifierFlags(from: event.flags)
+ let isAutorepeat = event.getIntegerValueField(.keyboardEventAutorepeat) != 0
switch type {
case .keyDown:
+ // A fresh down proves the previous same-key release was missed. Do not let its
+ // stale ownership turn ordinary typing into a shortcut on the next key-up.
+ if self.hotkeyMode == .toggle,
+ !isAutorepeat,
+ self.activePrimaryShortcutPress?.keyboardKeyCode == keyCode
+ { self.activePrimaryShortcutPress = nil }
self.markOtherInputDuringModifierOnly()
// Check the configured cancel shortcut first.
if SettingsStore.shared.cancelRecordingHotkeyShortcut?.matches(keyCode: keyCode, modifiers: eventModifiers) == true {
- var handled = false
+ var handled = self.pendingRecordingActionCounts.values.contains { $0 > 0 }
if self.asrService.isRunning || self.asrService.isStarting {
DebugLogger.shared.info("Cancel shortcut pressed - cancelling recording", source: "GlobalHotkeyManager")
@@ -1266,6 +1290,8 @@ final class GlobalHotkeyManager: NSObject {
}
if handled {
+ self.invalidateAllRecordingActions()
+ if self.hotkeyMode == .toggle { self.activePrimaryShortcutPress = nil }
return nil // Consume event only if we did something
}
}
@@ -1282,19 +1308,22 @@ final class GlobalHotkeyManager: NSObject {
return nil
}
- if let assignment = self.promptShortcutAssignments.first(where: { $0.shortcut.matches(keyCode: keyCode, modifiers: eventModifiers) }) {
+ if let assignment = self.promptShortcutAssignments.first(where: { $0.shortcut.matchesRecordingShortcut(keyCode: keyCode, modifiers: eventModifiers) }) {
+ guard !isAutorepeat else { return nil }
switch self.hotkeyMode {
case .hold:
if !self.isPromptAssignmentKeyPressed {
self.cancelPendingReleaseStop(for: .promptAssignment)
self.clearHoldModeStartTriggered(for: .promptAssignment)
+ self.activePromptAssignmentPress = assignment
self.isPromptAssignmentKeyPressed = true
DebugLogger.shared.info("Prompt shortcut pressed (hold mode) - starting", source: "GlobalHotkeyManager")
- self.triggerPromptSelection(assignment.selection)
+ self.triggerPromptSelection(assignment.selection, shortcut: assignment.shortcut)
self.markHoldModeStartTriggered(for: .promptAssignment)
}
case .automatic:
if !self.isPromptAssignmentKeyPressed {
+ self.activePromptAssignmentPress = assignment
self.isPromptAssignmentKeyPressed = true
let isSameMode = self.asrService.isRunning && (self.isPromptModeRecordingProvider?() ?? false)
self.beginAutomaticPress(for: .promptAssignment, wasTargetActive: isSameMode)
@@ -1303,12 +1332,12 @@ final class GlobalHotkeyManager: NSObject {
DebugLogger.shared.info("Prompt shortcut pressed (automatic, same mode) - waiting for release", source: "GlobalHotkeyManager")
} else {
DebugLogger.shared.info("Prompt shortcut pressed (automatic, switch mode)", source: "GlobalHotkeyManager")
- self.triggerPromptSelection(assignment.selection)
+ self.triggerPromptSelection(assignment.selection, shortcut: assignment.shortcut)
self.markAutomaticPressStarted(for: .promptAssignment)
}
} else {
DebugLogger.shared.info("Prompt shortcut triggered (automatic) - starting", source: "GlobalHotkeyManager")
- self.triggerPromptSelection(assignment.selection)
+ self.triggerPromptSelection(assignment.selection, shortcut: assignment.shortcut)
self.markAutomaticPressStarted(for: .promptAssignment)
}
}
@@ -1316,27 +1345,28 @@ final class GlobalHotkeyManager: NSObject {
if self.asrService.isRunningOrStarting {
if self.isPromptModeRecordingProvider?() ?? false {
DebugLogger.shared.info("Prompt shortcut pressed in Prompt mode - stopping", source: "GlobalHotkeyManager")
- self.stopRecordingAfterToggle()
+ self.triggerPromptSelection(assignment.selection, shortcut: assignment.shortcut)
} else {
DebugLogger.shared.info("Prompt shortcut pressed while recording - switching mode", source: "GlobalHotkeyManager")
- self.triggerPromptSelection(assignment.selection)
+ self.triggerPromptSelection(assignment.selection, shortcut: assignment.shortcut)
}
} else {
DebugLogger.shared.info("Prompt shortcut triggered - starting", source: "GlobalHotkeyManager")
- self.triggerPromptSelection(assignment.selection)
+ self.triggerPromptSelection(assignment.selection, shortcut: assignment.shortcut)
}
}
return nil
}
// Check prompt mode hotkey
- if self.handlePromptModeKeyDown(keyCode: keyCode, modifiers: eventModifiers) { return nil }
+ if self.handlePromptModeKeyDown(keyCode: keyCode, modifiers: eventModifiers, isAutorepeat: isAutorepeat) { return nil }
// Check command mode hotkey first
if self.commandModeShortcutEnabled,
let commandModeShortcut = self.commandModeShortcut,
- commandModeShortcut.matches(keyCode: keyCode, modifiers: eventModifiers)
+ commandModeShortcut.matchesRecordingShortcut(keyCode: keyCode, modifiers: eventModifiers)
{
+ guard !isAutorepeat else { return nil }
switch self.hotkeyMode {
case .hold:
// Press and hold: start on keyDown, stop on keyUp
@@ -1372,7 +1402,7 @@ final class GlobalHotkeyManager: NSObject {
if self.asrService.isRunningOrStarting {
if self.isCommandRecordingProvider?() ?? false {
DebugLogger.shared.info("Command mode shortcut pressed in Command mode - stopping", source: "GlobalHotkeyManager")
- self.stopRecordingAfterToggle()
+ self.triggerCommandMode()
} else {
DebugLogger.shared.info("Command mode shortcut pressed while recording - switching mode", source: "GlobalHotkeyManager")
self.triggerCommandMode()
@@ -1387,7 +1417,8 @@ final class GlobalHotkeyManager: NSObject {
// Check dedicated rewrite mode hotkey
if self.rewriteModeShortcutEnabled {
- if self.rewriteModeShortcut.matches(keyCode: keyCode, modifiers: eventModifiers) {
+ if self.rewriteModeShortcut.matchesRecordingShortcut(keyCode: keyCode, modifiers: eventModifiers) {
+ guard !isAutorepeat else { return nil }
switch self.hotkeyMode {
case .hold:
// Press and hold: start on keyDown, stop on keyUp
@@ -1423,7 +1454,7 @@ final class GlobalHotkeyManager: NSObject {
if self.asrService.isRunningOrStarting {
if self.isRewriteRecordingProvider?() ?? false {
DebugLogger.shared.info("Rewrite mode shortcut pressed in Edit mode - stopping", source: "GlobalHotkeyManager")
- self.stopRecordingAfterToggle()
+ self.triggerRewriteMode()
} else {
DebugLogger.shared.info("Rewrite mode shortcut pressed while recording - switching mode", source: "GlobalHotkeyManager")
self.triggerRewriteMode()
@@ -1438,8 +1469,9 @@ final class GlobalHotkeyManager: NSObject {
}
// Then check transcription hotkeys
- if let shortcut = self.primaryShortcuts.first(where: { $0.matches(keyCode: keyCode, modifiers: eventModifiers) }) {
- guard self.beginPrimaryShortcutPress(.keyboard(shortcut.keyCode)) else { return nil }
+ if let shortcut = self.primaryShortcuts.first(where: { $0.matchesRecordingShortcut(keyCode: keyCode, modifiers: eventModifiers) }) {
+ guard !isAutorepeat else { return nil }
+ guard self.beginPrimaryShortcutPress(.keyboard(shortcut)) else { return nil }
self.handlePrimaryDictationTriggerDown()
return nil
}
@@ -1491,9 +1523,9 @@ final class GlobalHotkeyManager: NSObject {
// Prompt assignment key up
// Note: Only check keyCode, not modifiers - user may release modifier before/with main key
if self.isPromptAssignmentKeyPressed,
- let assignment = self.promptShortcutAssignments.first(where: { $0.shortcut.keyCode == keyCode })
+ self.activePromptAssignmentPress?.shortcut.keyCode == keyCode
{
- _ = assignment
+ self.activePromptAssignmentPress = nil
switch self.hotkeyMode {
case .hold:
self.isPromptAssignmentKeyPressed = false
@@ -1511,8 +1543,8 @@ final class GlobalHotkeyManager: NSObject {
// Transcription key up
// Note: Only check keyCode, not modifiers - user may release modifier before/with main key
- if self.finishPrimaryShortcutPress(.keyboard(keyCode)) {
- self.handlePrimaryDictationTriggerUp()
+ if let shortcut = self.finishPrimaryShortcutPress(matching: { $0.keyboardKeyCode == keyCode }) {
+ self.handlePrimaryDictationTriggerUp(shortcut: shortcut)
return nil
}
@@ -1552,7 +1584,7 @@ final class GlobalHotkeyManager: NSObject {
if self.asrService.isRunningOrStarting {
if self.isCommandRecordingProvider?() ?? false {
DebugLogger.shared.info("Command mode modifier released (toggle, same mode) - stopping", source: "GlobalHotkeyManager")
- self.stopRecordingAfterToggle()
+ self.triggerCommandMode()
} else {
DebugLogger.shared.info("Command mode modifier released (toggle, switch mode) - switching", source: "GlobalHotkeyManager")
self.triggerCommandMode()
@@ -1584,7 +1616,7 @@ final class GlobalHotkeyManager: NSObject {
if self.asrService.isRunningOrStarting {
if self.isRewriteRecordingProvider?() ?? false {
DebugLogger.shared.info("Rewrite mode modifier released (toggle, same mode) - stopping", source: "GlobalHotkeyManager")
- self.stopRecordingAfterToggle()
+ self.triggerRewriteMode()
} else {
DebugLogger.shared.info("Rewrite mode modifier released (toggle, switch mode) - switching", source: "GlobalHotkeyManager")
self.triggerRewriteMode()
@@ -1712,10 +1744,6 @@ final class GlobalHotkeyManager: NSObject {
}
}
- nonisolated static func isSynthesizedTypingEvent(_ event: CGEvent) -> Bool {
- event.getIntegerValueField(.eventSourceUserData) == TypingService.synthesizedEventUserData
- }
-
private func handlePrimaryDictationTriggerDown() {
switch self.hotkeyMode {
case .hold:
@@ -1768,6 +1796,20 @@ final class GlobalHotkeyManager: NSObject {
self.markAutomaticPressStarted(for: .transcription)
}
}
+ case .toggle:
+ break // The owning keyboard/mouse release toggles; repeats do not.
+ }
+ }
+
+ private func handlePrimaryDictationTriggerUp(shortcut: HotkeyShortcut) {
+ switch self.hotkeyMode {
+ case .hold:
+ self.isKeyPressed = false
+ _ = self.finishHoldModeStartTriggered(for: .transcription)
+ self.stopRecordingAfterRelease(for: .transcription, label: "Transcription")
+ case .automatic:
+ self.isKeyPressed = false
+ self.handleAutomaticKeyRelease(for: .transcription, label: "Transcription")
case .toggle:
if self.asrService.isRunningOrStarting {
let isSameMode = self.isDictateRecordingProvider?() ?? false
@@ -1780,65 +1822,25 @@ final class GlobalHotkeyManager: NSObject {
source: "GlobalHotkeyManager"
)
if isSameMode {
- self.stopRecordingAfterToggle()
+ self.triggerDictationMode(shortcut: shortcut)
} else {
- self.triggerDictationMode()
+ self.triggerDictationMode(shortcut: shortcut)
}
} else {
DebugLogger.shared.info(
"Hotkey route | pressed=dictate | active=none | asrRunning=false | action=start",
source: "GlobalHotkeyManager"
)
- self.triggerDictationMode()
+ self.triggerDictationMode(shortcut: shortcut)
}
}
}
- private func handlePrimaryDictationTriggerUp() {
- switch self.hotkeyMode {
- case .hold:
- self.isKeyPressed = false
- _ = self.finishHoldModeStartTriggered(for: .transcription)
- self.stopRecordingAfterRelease(for: .transcription, label: "Transcription")
- case .automatic:
- self.isKeyPressed = false
- self.handleAutomaticKeyRelease(for: .transcription, label: "Transcription")
- case .toggle:
- break
- }
- }
-
- private func isRecordingTargetActive(for type: HotkeyHoldModeType) -> Bool {
- switch type {
- case .transcription:
- guard let provider = self.isDictateRecordingProvider else { return true }
- return provider()
- case .promptMode:
- guard let provider = self.isPromptModeRecordingProvider else { return true }
- return provider()
- case .commandMode:
- guard let provider = self.isCommandRecordingProvider else { return true }
- return provider()
- case .rewriteMode:
- guard let provider = self.isRewriteRecordingProvider else { return true }
- return provider()
- case .promptAssignment:
- guard let provider = self.isPromptModeRecordingProvider else { return true }
- return provider()
- }
- }
-
private func stopRecordingAfterRelease(
for type: HotkeyHoldModeType,
label: String,
requireTargetMode: Bool = true
) {
- if self.asrService.isRunning {
- self.cancelPendingReleaseStop(for: type)
- self.stopRecordingIfNeeded()
- return
- }
-
let toggleStopRequestedAt = ProcessInfo.processInfo.systemUptime
self.logStopInput(requestedAt: toggleStopRequestedAt, route: "deferred_release")
let token = self.beginPendingReleaseStop(for: type)
@@ -1960,10 +1962,11 @@ final class GlobalHotkeyManager: NSObject {
}
func resetModifierOnlyShortcutTracking(reason: ModifierTrackingResetReason = .shortcutCapture) {
+ self.invalidateAllRecordingActions()
self.modifierPressReceivedAt = nil
self.currentStopPressReceivedAt = nil
let shouldStopActiveHold = self.hotkeyMode != .toggle
- && self.asrService.isRunning
+ && self.asrService.isRunningOrStarting
&& (self.isKeyPressed || self.isPromptModeKeyPressed || self.isCommandModeKeyPressed || self.isRewriteKeyPressed || self.isPromptAssignmentKeyPressed)
self.pressedModifierKeyCodes = []
@@ -1977,6 +1980,8 @@ final class GlobalHotkeyManager: NSObject {
self.isCommandModeKeyPressed = false
self.isRewriteKeyPressed = false
self.isPromptAssignmentKeyPressed = false
+ self.activePromptAssignmentPress = nil
+ self.activeModifierOnlyShortcut = nil
self.activePrimaryShortcutPress = nil
if shouldStopActiveHold {
@@ -1992,8 +1997,9 @@ final class GlobalHotkeyManager: NSObject {
}
}
- private func handlePromptModeKeyDown(keyCode: UInt16, modifiers: NSEvent.ModifierFlags) -> Bool {
- guard self.promptModeShortcutEnabled, self.promptModeShortcut.matches(keyCode: keyCode, modifiers: modifiers) else { return false }
+ private func handlePromptModeKeyDown(keyCode: UInt16, modifiers: NSEvent.ModifierFlags, isAutorepeat: Bool) -> Bool {
+ guard self.promptModeShortcutEnabled, self.promptModeShortcut.matchesRecordingShortcut(keyCode: keyCode, modifiers: modifiers) else { return false }
+ guard !isAutorepeat else { return true }
switch self.hotkeyMode {
case .hold:
if !self.isPromptModeKeyPressed {
@@ -2027,7 +2033,7 @@ final class GlobalHotkeyManager: NSObject {
if self.asrService.isRunningOrStarting {
if self.isPromptModeRecordingProvider?() ?? false {
DebugLogger.shared.info("Prompt mode shortcut pressed in Prompt mode - stopping", source: "GlobalHotkeyManager")
- self.stopRecordingAfterToggle()
+ self.triggerPromptMode()
} else {
DebugLogger.shared.info("Prompt mode shortcut pressed while recording - switching mode", source: "GlobalHotkeyManager")
self.triggerPromptMode()
@@ -2074,7 +2080,7 @@ final class GlobalHotkeyManager: NSObject {
if self.asrService.isRunningOrStarting {
if self.isPromptModeRecordingProvider?() ?? false {
DebugLogger.shared.info("Prompt mode modifier released (toggle, same mode) - stopping", source: "GlobalHotkeyManager")
- self.stopRecordingAfterToggle()
+ self.triggerPromptMode()
} else {
DebugLogger.shared.info("Prompt mode modifier released (toggle, switch mode) - switching", source: "GlobalHotkeyManager")
self.triggerPromptMode()
@@ -2103,19 +2109,19 @@ final class GlobalHotkeyManager: NSObject {
toggleIgnoredMessage: "Prompt shortcut modifier released but another key was pressed - ignoring",
isModeKeyPressed: { self.isPromptAssignmentKeyPressed },
setModeKeyPressed: { self.isPromptAssignmentKeyPressed = $0 },
- onHoldStart: { self.triggerPromptSelection(assignment.selection) },
+ onHoldStart: { self.triggerPromptSelection(assignment.selection, shortcut: assignment.shortcut) },
onToggleRelease: {
if self.asrService.isRunningOrStarting {
if self.isPromptModeRecordingProvider?() ?? false {
DebugLogger.shared.info("Prompt shortcut modifier released (toggle, same mode) - stopping", source: "GlobalHotkeyManager")
- self.stopRecordingAfterToggle()
+ self.triggerPromptSelection(assignment.selection, shortcut: assignment.shortcut)
} else {
DebugLogger.shared.info("Prompt shortcut modifier released (toggle, switch mode) - switching", source: "GlobalHotkeyManager")
- self.triggerPromptSelection(assignment.selection)
+ self.triggerPromptSelection(assignment.selection, shortcut: assignment.shortcut)
}
} else {
DebugLogger.shared.info("Prompt shortcut modifier released (toggle) - starting", source: "GlobalHotkeyManager")
- self.triggerPromptSelection(assignment.selection)
+ self.triggerPromptSelection(assignment.selection, shortcut: assignment.shortcut)
}
},
isTargetModeActive: { self.isPromptModeRecordingProvider?() ?? false }
@@ -2124,6 +2130,7 @@ final class GlobalHotkeyManager: NSObject {
modifiers: modifiers
)
if handled {
+ self.activePromptAssignmentPress = self.activeModifierOnlyType == .promptAssignment ? assignment : nil
return true
}
}
@@ -2136,6 +2143,9 @@ final class GlobalHotkeyManager: NSObject {
keyCode: UInt16,
modifiers: NSEvent.ModifierFlags
) -> Bool {
+ // A held keyboard/mouse shortcut already owns this route.
+ guard behavior.holdModeType != .transcription || self.activePrimaryShortcutPress == nil else { return false }
+ guard !behavior.isModeKeyPressed() || self.activeModifierOnlyType == behavior.holdModeType else { return false }
let decision = ModifierOnlyShortcutFlagsDecision.evaluate(
shortcut: behavior.shortcut,
holdModeType: behavior.holdModeType,
@@ -2184,7 +2194,7 @@ final class GlobalHotkeyManager: NSObject {
}
private func triggerPromptMode() {
- Task { @MainActor [weak self] in
+ self.queueRecordingAction(for: .promptMode, shortcut: self.promptModeShortcut) { [weak self] in
guard let self = self else { return }
guard self.canTriggerRecordingAction("Prompt mode hotkey") else { return }
DebugLogger.shared.info("Prompt mode hotkey triggered", source: "GlobalHotkeyManager")
@@ -2192,8 +2202,8 @@ final class GlobalHotkeyManager: NSObject {
}
}
- private func triggerPromptSelection(_ selection: SettingsStore.DictationPromptSelection) {
- Task { @MainActor [weak self] in
+ private func triggerPromptSelection(_ selection: SettingsStore.DictationPromptSelection, shortcut: HotkeyShortcut) {
+ self.queueRecordingAction(for: .promptAssignment, shortcut: shortcut, selection: selection) { [weak self] in
guard let self = self else { return }
guard self.canTriggerRecordingAction("Prompt selection hotkey") else { return }
DebugLogger.shared.info("Prompt selection hotkey triggered", source: "GlobalHotkeyManager")
@@ -2202,7 +2212,7 @@ final class GlobalHotkeyManager: NSObject {
}
private func triggerCommandMode() {
- Task { @MainActor [weak self] in
+ self.queueRecordingAction(for: .commandMode, shortcut: self.commandModeShortcut) { [weak self] in
guard let self = self else { return }
guard self.canTriggerRecordingAction("Command mode hotkey") else { return }
DebugLogger.shared.info("Command mode hotkey triggered", source: "GlobalHotkeyManager")
@@ -2215,7 +2225,7 @@ final class GlobalHotkeyManager: NSObject {
}
private func triggerRewriteMode() {
- Task { @MainActor [weak self] in
+ self.queueRecordingAction(for: .rewriteMode, shortcut: self.rewriteModeShortcut) { [weak self] in
guard let self = self else { return }
guard self.canTriggerRecordingAction("Rewrite mode hotkey") else { return }
DebugLogger.shared.info("Rewrite mode hotkey triggered", source: "GlobalHotkeyManager")
@@ -2232,6 +2242,9 @@ final class GlobalHotkeyManager: NSObject {
/// path); primary dictation begins a press here and ends it on mouse-up.
private func handleMouseShortcutDown(_ event: CGEvent, modifiers eventModifiers: NSEvent.ModifierFlags) -> Bool {
let mouseButton = self.mouseButton(from: event)
+ if self.hotkeyMode == .toggle, self.activePrimaryShortcutPress?.mouseButton == mouseButton {
+ self.activePrimaryShortcutPress = nil
+ }
if SettingsStore.shared.pasteLastTranscriptionShortcutEnabled,
let pasteShortcut = SettingsStore.shared.pasteLastTranscriptionHotkeyShortcut,
@@ -2242,8 +2255,8 @@ final class GlobalHotkeyManager: NSObject {
return true
}
- if self.primaryShortcuts.contains(where: { $0.matchesMouse(button: mouseButton, modifiers: eventModifiers) }) {
- guard self.beginPrimaryShortcutPress(.mouse(mouseButton)) else { return false }
+ if let shortcut = self.primaryShortcuts.first(where: { $0.matchesMouse(button: mouseButton, modifiers: eventModifiers) }) {
+ guard self.beginPrimaryShortcutPress(.mouse(shortcut)) else { return false }
self.handlePrimaryDictationTriggerDown()
return true
}
@@ -2264,8 +2277,8 @@ final class GlobalHotkeyManager: NSObject {
return true
}
- guard self.finishPrimaryShortcutPress(.mouse(mouseButton)) else { return false }
- self.handlePrimaryDictationTriggerUp()
+ guard let shortcut = self.finishPrimaryShortcutPress(matching: { $0.mouseButton == mouseButton }) else { return false }
+ self.handlePrimaryDictationTriggerUp(shortcut: shortcut)
return true
}
@@ -2288,8 +2301,9 @@ final class GlobalHotkeyManager: NSObject {
}
}
- private func triggerDictationMode() {
- Task { @MainActor [weak self] in
+ private func triggerDictationMode(shortcut: HotkeyShortcut? = nil) {
+ let shortcut = shortcut ?? self.activePrimaryShortcutPress?.shortcut ?? (self.activeModifierOnlyType == .transcription ? self.activeModifierOnlyShortcut : nil)
+ self.queueRecordingAction(for: .transcription, shortcut: shortcut) { [weak self] in
guard let self = self else { return }
guard self.canTriggerRecordingAction("Dictate mode hotkey") else { return }
let model = SettingsStore.shared.selectedSpeechModel
@@ -2318,22 +2332,11 @@ final class GlobalHotkeyManager: NSObject {
}
func setHotkeyMode(_ mode: HotkeyActivationMode) {
- let shouldStopActivePress = self.hotkeyMode != .toggle
- && self.asrService.isRunning
- && (self.isKeyPressed || self.isPromptModeKeyPressed || self.isCommandModeKeyPressed || self.isRewriteKeyPressed || self.isPromptAssignmentKeyPressed)
-
- self.hotkeyMode = mode
- self.clearAutomaticPressTracking()
- self.isKeyPressed = false
- self.isPromptModeKeyPressed = false
- self.isCommandModeKeyPressed = false
- self.isRewriteKeyPressed = false
- self.isPromptAssignmentKeyPressed = false
- self.activePrimaryShortcutPress = nil
-
- if shouldStopActivePress {
- self.stopRecordingIfNeeded()
+ guard mode != self.hotkeyMode else { return }
+ for type in [HotkeyHoldModeType.transcription, .promptMode, .commandMode, .rewriteMode, .promptAssignment] {
+ self.discardShortcutPress(for: type)
}
+ self.hotkeyMode = mode
DebugLogger.shared.info("Hotkey activation mode set to \(mode.displayName)", source: "GlobalHotkeyManager")
self.scheduleActiveShortcutLog(reason: "shortcuts updated")
}
@@ -2382,8 +2385,9 @@ final class GlobalHotkeyManager: NSObject {
}
}
- private func startRecordingIfNeeded() {
- Task { @MainActor [weak self] in
+ private func startRecordingIfNeeded(shortcut: HotkeyShortcut? = nil) {
+ let shortcut = shortcut ?? self.activePrimaryShortcutPress?.shortcut ?? (self.activeModifierOnlyType == .transcription ? self.activeModifierOnlyShortcut : nil)
+ self.queueRecordingAction(for: .transcription, shortcut: shortcut) { [weak self] in
guard let self = self else { return }
// Prevent starting while stop is processing
@@ -2415,10 +2419,6 @@ final class GlobalHotkeyManager: NSObject {
DebugLogger.shared.benchmark("HOTKEY_BENCH", message: fields, source: "HotkeyBenchmark")
}
- private func stopRecordingAfterToggle() {
- self.stopRecordingIfNeeded()
- }
-
private func stopRecordingIfNeeded(toggleStopRequestedAt: TimeInterval? = nil) {
let toggleStopRequestedAt = toggleStopRequestedAt ?? ProcessInfo.processInfo.systemUptime
self.logStopInput(requestedAt: toggleStopRequestedAt, route: "stop_if_needed")
@@ -2534,6 +2534,152 @@ final class GlobalHotkeyManager: NSObject {
}
private extension GlobalHotkeyManager {
+ func invalidateRecordingActions(for type: HotkeyHoldModeType) {
+ self.recordingActionRevisions[type, default: 0] &+= 1
+ self.pendingRecordingActionCounts[type] = 0
+ self.activeRecordingActionShortcuts.removeValue(forKey: type)
+ self.pendingRecordingActions.removeValue(forKey: type)?.cancel()
+ }
+
+ func invalidateAllRecordingActions() {
+ for type in [HotkeyHoldModeType.transcription, .promptMode, .commandMode, .rewriteMode, .promptAssignment] {
+ self.invalidateRecordingActions(for: type)
+ }
+ }
+
+ /// Keep rapid taps in order through the actual asynchronous capture start/stop.
+ func queueRecordingAction(for type: HotkeyHoldModeType, shortcut: HotkeyShortcut?, selection: SettingsStore.DictationPromptSelection? = nil, action: @escaping @MainActor () async -> Void) {
+ guard self.canTriggerRecordingAction(self.label(for: type)) else { return }
+ let revision = self.recordingActionRevisions[type, default: 0]
+ let previous = self.pendingRecordingActions[type]
+ self.pendingRecordingActionCounts[type, default: 0] += 1
+ self.pendingRecordingActions[type] = Task { @MainActor [weak self] in
+ await withTaskCancellationHandler {
+ await previous?.value
+ } onCancel: {
+ previous?.cancel()
+ }
+ guard !Task.isCancelled else { return }
+ guard let self, self.recordingActionRevisions[type, default: 0] == revision else { return }
+ defer {
+ if self.recordingActionRevisions[type, default: 0] == revision {
+ self.pendingRecordingActionCounts[type, default: 0] -= 1
+ if self.pendingRecordingActionCounts[type] == 0 {
+ self.pendingRecordingActions.removeValue(forKey: type)
+ }
+ }
+ }
+ guard self.canTriggerRecordingAction(self.label(for: type)) else { return }
+ if let shortcut, !self.isRecordingShortcutConfigured(shortcut, for: type, selection: selection) { return }
+ self.activeRecordingActionShortcuts[type] = shortcut
+ defer {
+ if self.recordingActionRevisions[type, default: 0] == revision {
+ self.activeRecordingActionShortcuts.removeValue(forKey: type)
+ }
+ }
+ if self.hotkeyMode == .toggle, self.asrService.isRunningOrStarting, self.isRecordingTargetActive(for: type) {
+ // Changing an input binding must not cancel transcription already processing.
+ await Task { @MainActor in
+ await self.stopRecordingInternal(toggleStopRequestedAt: ProcessInfo.processInfo.systemUptime)
+ }.value
+ return
+ }
+ await action()
+ }
+ }
+
+ private func isRecordingShortcutConfigured(_ shortcut: HotkeyShortcut, for type: HotkeyHoldModeType, selection: SettingsStore.DictationPromptSelection?) -> Bool {
+ switch type {
+ case .transcription: self.primaryShortcuts.contains(shortcut)
+ case .promptMode: self.promptModeShortcutEnabled && self.promptModeShortcut == shortcut
+ case .commandMode: self.commandModeShortcutEnabled && self.commandModeShortcut == shortcut
+ case .rewriteMode: self.rewriteModeShortcutEnabled && self.rewriteModeShortcut == shortcut
+ case .promptAssignment: self.promptShortcutAssignments.contains { $0.shortcut == shortcut && $0.selection == selection }
+ }
+ }
+
+ private func isRecordingTargetActive(for type: HotkeyHoldModeType) -> Bool {
+ switch type {
+ case .transcription:
+ guard let provider = self.isDictateRecordingProvider else { return true }
+ return provider()
+ case .promptMode:
+ guard let provider = self.isPromptModeRecordingProvider else { return true }
+ return provider()
+ case .commandMode:
+ guard let provider = self.isCommandRecordingProvider else { return true }
+ return provider()
+ case .rewriteMode:
+ guard let provider = self.isRewriteRecordingProvider else { return true }
+ return provider()
+ case .promptAssignment:
+ guard let provider = self.isPromptModeRecordingProvider else { return true }
+ return provider()
+ }
+ }
+
+ func discardShortcutPress(for type: HotkeyHoldModeType) {
+ self.invalidateRecordingActions(for: type)
+ if type == .promptAssignment { self.activePromptAssignmentPress = nil }
+ let hadPress = self.state.withLock {
+ let ownsModifier = self.state.activeModifierOnlyType == type
+ var pressed: Bool
+ switch type {
+ case .transcription:
+ pressed = self.state.isKeyPressed || self.state.activePrimaryShortcutPress != nil
+ self.state.isKeyPressed = false
+ self.state.activePrimaryShortcutPress = nil
+ case .promptMode:
+ pressed = self.state.isPromptModeKeyPressed
+ self.state.isPromptModeKeyPressed = false
+ case .commandMode:
+ pressed = self.state.isCommandModeKeyPressed
+ self.state.isCommandModeKeyPressed = false
+ case .rewriteMode:
+ pressed = self.state.isRewriteKeyPressed
+ self.state.isRewriteKeyPressed = false
+ case .promptAssignment:
+ pressed = self.state.isPromptAssignmentKeyPressed
+ self.state.isPromptAssignmentKeyPressed = false
+ }
+ if ownsModifier {
+ self.state.activeModifierOnlyType = nil
+ self.state.activeModifierOnlyShortcut = nil
+ self.state.modifierOnlyKeyDown = false
+ self.state.otherKeyPressedDuringModifier = false
+ self.state.modifierPressStartTime = nil
+ }
+ return pressed || ownsModifier
+ }
+ guard hadPress else { return }
+ self.cancelPendingReleaseStop(for: type)
+ self.clearHoldModeStartTriggered(for: type)
+ _ = self.finishAutomaticPress(for: type)
+ if self.hotkeyMode != .toggle, self.asrService.isRunningOrStarting, self.isRecordingTargetActive(for: type) {
+ self.stopRecordingAfterRelease(for: type, label: self.label(for: type))
+ }
+ }
+
+ private func beginPrimaryShortcutPress(_ press: ActivePrimaryShortcutPress) -> Bool {
+ self.state.withLock {
+ guard self.state.activePrimaryShortcutPress == nil, !self.state.isKeyPressed else {
+ return false
+ }
+ self.state.activePrimaryShortcutPress = press
+ return true
+ }
+ }
+
+ private func finishPrimaryShortcutPress(matching matches: (ActivePrimaryShortcutPress) -> Bool) -> HotkeyShortcut? {
+ self.state.withLock {
+ guard let press = self.state.activePrimaryShortcutPress, matches(press) else {
+ return nil
+ }
+ self.state.activePrimaryShortcutPress = nil
+ return press.shortcut
+ }
+ }
+
func traceStopLocked() -> TimeInterval {
OverlayCloseRunLoopProbe.begin()
self.isProcessingStop = true
@@ -2548,3 +2694,29 @@ private extension GlobalHotkeyManager {
)
}
}
+
+extension GlobalHotkeyManager {
+ nonisolated static func isSynthesizedTypingEvent(_ event: CGEvent) -> Bool {
+ event.getIntegerValueField(.eventSourceUserData) == TypingService.synthesizedEventUserData
+ }
+
+ nonisolated static func keyboardEventMask() -> CGEventMask {
+ (CGEventMask(1) << CGEventType.keyDown.rawValue)
+ | (CGEventMask(1) << CGEventType.keyUp.rawValue)
+ | (CGEventMask(1) << CGEventType.flagsChanged.rawValue)
+ }
+
+ /// Capture before system shortcuts (such as Control-Command-D lookup) can consume the key.
+ /// The local monitor remains a fallback for app-directed events that bypass the session tap.
+ static func captureKeyboardEvent(
+ type: CGEventType,
+ event: CGEvent,
+ isAppActive: Bool,
+ handler: ((NSEvent) -> NSEvent?)?
+ ) -> Bool {
+ guard isAppActive, type == .keyDown || type == .flagsChanged,
+ let handler, let appEvent = NSEvent(cgEvent: event)
+ else { return false }
+ return handler(appEvent) == nil
+ }
+}
diff --git a/Tests/FluidDictationIntegrationTests/DirectAudioReliabilityTests.swift b/Tests/FluidDictationIntegrationTests/DirectAudioReliabilityTests.swift
index 908c0ac3..483c619e 100644
--- a/Tests/FluidDictationIntegrationTests/DirectAudioReliabilityTests.swift
+++ b/Tests/FluidDictationIntegrationTests/DirectAudioReliabilityTests.swift
@@ -900,6 +900,40 @@ final class DirectAudioReliabilityTests: XCTestCase {
XCTAssertEqual(result, .timedOut)
}
+ @MainActor
+ func testReadyPCMDoesNotOverrideConsumerTaskCancellation() async {
+ let gate = AudioCaptureReadinessGate()
+ gate.arm(sessionID: 41, attemptID: 1)
+ gate.signalFirstPCM(sessionID: 41, attemptID: 1)
+ var resumeAfterReady: CheckedContinuation<Void, Never>?
+ let task = Task { @MainActor in
+ let result = await gate.wait(sessionID: 41, attemptID: 1, timeoutNanoseconds: 1_000_000)
+ XCTAssertEqual(result, .ready)
+ await withCheckedContinuation { resumeAfterReady = $0 }
+ do {
+ try Task.checkCancellation()
+ return true
+ } catch { return false }
+ }
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertNotNil(resumeAfterReady)
+ task.cancel()
+ resumeAfterReady?.resume()
+ let publishedCapture = await task.value
+ XCTAssertFalse(publishedCapture, "The capture consumer must check cancellation even after a ready result")
+ }
+
+ func testASRRechecksCaptureCancellationAfterFirstPCMWait() throws {
+ let repositoryRoot = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent()
+ let source = try String(contentsOf: repositoryRoot.appendingPathComponent("Sources/Fluid/Services/ASRService.swift"), encoding: .utf8)
+ let postWait = try XCTUnwrap(source.components(separatedBy: "let readiness = await self.audioCaptureReadinessGate.wait(").dropFirst().first)
+ let readinessBranch = try XCTUnwrap(postWait.range(of: "if readiness == .ready"))
+ let cancellationCheck = try XCTUnwrap(postWait.range(of: "try self.checkCaptureStartGeneration(startGeneration)"))
+ XCTAssertLessThan(cancellationCheck.lowerBound, readinessBranch.lowerBound, "Do not publish ready PCM before checking task cancellation")
+ }
+
func testReadinessWaitRespondsPromptlyToTaskCancellation() async {
let gate = AudioCaptureReadinessGate()
gate.arm(sessionID: 41, attemptID: 1)
diff --git a/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift b/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift
index a3ca8efb..2355f350 100644
--- a/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift
+++ b/Tests/FluidDictationIntegrationTests/HotkeyShortcutTests.swift
@@ -183,6 +183,1603 @@ final class HotkeyShortcutTests: XCTestCase {
XCTAssertTrue(summary.contains("pasteLast=⌘ + Left Click [button=0"), summary)
}
+ @MainActor
+ func testShortcutCaptureConsumesControlCommandDBeforeAppDispatch() throws {
+ let event = try XCTUnwrap(CGEvent(keyboardEventSource: nil, virtualKey: 2, keyDown: true))
+ event.flags = [.maskControl, .maskCommand]
+ var captured: HotkeyShortcut?
+ let consumed = GlobalHotkeyManager.captureKeyboardEvent(type: .keyDown, event: event, isAppActive: true) { appEvent in
+ captured = HotkeyShortcut(keyCode: appEvent.keyCode, modifierFlags: appEvent.modifierFlags)
+ return nil
+ }
+
+ XCTAssertTrue(consumed, "A captured chord must not also reach macOS dictionary lookup or the local monitor")
+ XCTAssertEqual(captured, HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command]))
+ XCTAssertTrue(try XCTUnwrap(captured).matches(keyCode: 2, modifiers: [.control, .command]))
+ XCTAssertFalse(try XCTUnwrap(captured).matches(keyCode: 2, modifiers: [.control]))
+ }
+
+ @MainActor
+ func testShortcutCapturePreservesPassThroughAndInactiveAppInput() throws {
+ let event = try XCTUnwrap(CGEvent(keyboardEventSource: nil, virtualKey: 2, keyDown: true))
+ var deliveries = 0
+ let handler: (NSEvent) -> NSEvent? = { appEvent in
+ deliveries += 1
+ return appEvent
+ }
+
+ XCTAssertFalse(GlobalHotkeyManager.captureKeyboardEvent(type: .keyDown, event: event, isAppActive: true, handler: handler))
+ XCTAssertEqual(deliveries, 1)
+ XCTAssertFalse(GlobalHotkeyManager.captureKeyboardEvent(type: .keyDown, event: event, isAppActive: false, handler: handler))
+ XCTAssertFalse(GlobalHotkeyManager.captureKeyboardEvent(type: .keyUp, event: event, isAppActive: true, handler: handler))
+ XCTAssertFalse(GlobalHotkeyManager.captureKeyboardEvent(type: .leftMouseDown, event: event, isAppActive: true, handler: handler))
+ XCTAssertFalse(GlobalHotkeyManager.captureKeyboardEvent(type: .keyDown, event: event, isAppActive: true, handler: nil))
+ XCTAssertEqual(deliveries, 1, "Only foreground keyboard capture should reach the recorder")
+
+ event.type = .flagsChanged
+ event.setIntegerValueField(.keyboardEventKeycode, value: 59)
+ event.flags = .maskControl
+ XCTAssertTrue(GlobalHotkeyManager.captureKeyboardEvent(type: .flagsChanged, event: event, isAppActive: true) { appEvent in
+ XCTAssertEqual(appEvent.type, .flagsChanged)
+ XCTAssertEqual(appEvent.keyCode, 59)
+ return nil
+ })
+ }
+
+ @MainActor
+ func testPrimaryToggleKeyboardStartsAndStopsOnlyOnOwnedRelease() async throws {
+ let asr = ASRService()
+ defer { asr.isRunning = false }
+ var starts = 0
+ var stops = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: {
+ starts += 1
+ asr.isRunning = true
+ }, onStop: {
+ stops += 1
+ asr.isRunning = false
+ })
+ let down = try self.primaryReleaseTestEvent(type: .keyDown)
+ let up = try self.primaryReleaseTestEvent(type: .keyUp, modifiers: [])
+
+ XCTAssertNil(manager.handleKeyEvent(type: .keyDown, event: down))
+ down.setIntegerValueField(.keyboardEventAutorepeat, value: 1)
+ XCTAssertNil(manager.handleKeyEvent(type: .keyDown, event: down))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "Holding D and auto-repeat must not start recording")
+
+ let modifierUp = try self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 59, modifiers: .maskCommand)
+ _ = manager.handleKeyEvent(type: .flagsChanged, event: modifierUp)
+ let unrelatedUp = try self.primaryReleaseTestEvent(type: .keyUp, keyCode: 3)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: unrelatedUp) != nil)
+ XCTAssertEqual(starts, 0)
+ XCTAssertNil(manager.handleKeyEvent(type: .keyUp, event: up))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "Releasing modifiers before D must still activate the owned D press")
+ XCTAssertEqual(stops, 0)
+
+ down.setIntegerValueField(.keyboardEventAutorepeat, value: 0)
+ XCTAssertNil(manager.handleKeyEvent(type: .keyDown, event: down))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(stops, 0, "The stop toggle must also wait for release")
+ XCTAssertNil(manager.handleKeyEvent(type: .keyUp, event: up))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ XCTAssertEqual(stops, 1)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: up) != nil)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(stops, 1, "Duplicate releases must not toggle again")
+ }
+
+ @MainActor
+ func testPrimaryToggleDiscardsPressAfterShortcutEditCaptureOrModeChange() async throws {
+ let asr = ASRService()
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: { starts += 1 })
+ let shortcut = HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command])
+ let down = try self.primaryReleaseTestEvent(type: .keyDown)
+ let up = try self.primaryReleaseTestEvent(type: .keyUp)
+
+ _ = manager.handleKeyEvent(type: .keyDown, event: down)
+ manager.updatePrimaryShortcuts([HotkeyShortcut(keyCode: 3, modifierFlags: [.control, .command])])
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: up) != nil)
+
+ manager.updatePrimaryShortcuts([shortcut])
+ _ = manager.handleKeyEvent(type: .keyDown, event: down)
+ manager.resetModifierOnlyShortcutTracking(reason: .shortcutCapture)
+ down.setIntegerValueField(.keyboardEventAutorepeat, value: 1)
+ XCTAssertNil(manager.handleKeyEvent(type: .keyDown, event: down))
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: up) != nil)
+
+ down.setIntegerValueField(.keyboardEventAutorepeat, value: 0)
+ _ = manager.handleKeyEvent(type: .keyDown, event: down)
+ manager.setHotkeyMode(.hold)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: up) != nil)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "A stale press must not start recording after an edit, capture, or mode change")
+ }
+
+ @MainActor
+ func testPrimaryHoldAndAutomaticStillStartOnKeyDown() async throws {
+ for mode in [HotkeyActivationMode.hold, .automatic] {
+ let asr = ASRService()
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: { starts += 1 })
+ manager.setHotkeyMode(mode)
+
+ let down = try self.primaryReleaseTestEvent(type: .keyDown)
+ XCTAssertNil(manager.handleKeyEvent(type: .keyDown, event: down))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "\(mode) must start immediately to preserve first-word capture")
+ manager.resetModifierOnlyShortcutTracking()
+ }
+ }
+
+ @MainActor
+ func testPrimaryToggleMouseAlsoWaitsForMatchingRelease() async throws {
+ let asr = ASRService()
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: { starts += 1 })
+ manager.updatePrimaryShortcuts([HotkeyShortcut(mouseButton: 2, modifierFlags: [])])
+ let down = try XCTUnwrap(CGEvent(mouseEventSource: nil, mouseType: .otherMouseDown, mouseCursorPosition: .zero, mouseButton: .center))
+ let up = try XCTUnwrap(CGEvent(mouseEventSource: nil, mouseType: .otherMouseUp, mouseCursorPosition: .zero, mouseButton: .center))
+
+ XCTAssertNil(manager.handleMouseShortcutEvent(type: .otherMouseDown, event: down))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0)
+ XCTAssertNil(manager.handleMouseShortcutEvent(type: .otherMouseUp, event: up))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ XCTAssertTrue(manager.handleMouseShortcutEvent(type: .otherMouseUp, event: up) != nil)
+ }
+
+ @MainActor
+ func testPrimaryShortcutEditPreservesPendingPasteMouseRelease() throws {
+ let settings = SettingsStore.shared
+ let previousShortcut = settings.pasteLastTranscriptionHotkeyShortcut
+ let previousEnabled = settings.pasteLastTranscriptionShortcutEnabled
+ defer {
+ settings.pasteLastTranscriptionHotkeyShortcut = previousShortcut
+ settings.pasteLastTranscriptionShortcutEnabled = previousEnabled
+ }
+ settings.pasteLastTranscriptionHotkeyShortcut = HotkeyShortcut(mouseButton: 2, modifierFlags: [])
+ settings.pasteLastTranscriptionShortcutEnabled = true
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: {})
+ manager.setPasteLastTranscriptionCallback {}
+ let down = try XCTUnwrap(CGEvent(mouseEventSource: nil, mouseType: .otherMouseDown, mouseCursorPosition: .zero, mouseButton: .center))
+ let up = try XCTUnwrap(CGEvent(mouseEventSource: nil, mouseType: .otherMouseUp, mouseCursorPosition: .zero, mouseButton: .center))
+
+ XCTAssertNil(manager.handleMouseShortcutEvent(type: .otherMouseDown, event: down))
+ manager.updatePrimaryShortcuts([HotkeyShortcut(keyCode: 3, modifierFlags: [.control, .command])])
+ XCTAssertNil(manager.handleMouseShortcutEvent(type: .otherMouseUp, event: up), "Editing primary dictation must preserve the consumed paste click's release")
+ }
+
+ @MainActor
+ func testPrimaryToggleMissingReleaseCannotTurnPlainDIntoShortcut() async throws {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ // Simulate a dropped shortcut key-up, then ordinary typing of the same letter.
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, modifiers: []))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "A missed release must not make plain D activate Ctrl+Cmd+D")
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "The next genuine chord must recover without restarting the app")
+ }
+
+ @MainActor
+ func testPrimaryToggleCancelDiscardsPendingRelease() async throws {
+ let settings = SettingsStore.shared
+ let previous = settings.cancelRecordingHotkeyShortcut
+ defer { settings.cancelRecordingHotkeyShortcut = previous }
+ settings.cancelRecordingHotkeyShortcut = HotkeyShortcut(keyCode: 53, modifierFlags: [])
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.setCancelCallback { true }
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: 53, modifiers: []))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "Cancel must not be followed by a pending release starting dictation")
+ }
+
+ @MainActor
+ func testPrimaryToggleUnchangedBindingsPreservePendingRelease() async throws {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ manager.updatePrimaryShortcuts([HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command])])
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "Refreshing identical bindings must not drop a valid press")
+ }
+
+ func testExplicitModifierShortcutRejectsUntrackedExtraFlags() {
+ // Command was already held when monitoring started; only Option's physical press is known.
+ let replay = ModifierOnlyFlagsReplay(shortcut: HotkeyShortcut(keyCode: 58, modifierFlags: [], modifierKeyCodes: [58]))
+ replay.flagsChanged(keyCode: 58, modifiers: [.command, .option], nextPressed: [58])
+ XCTAssertNil(replay.activeModifierOnlyType, "Command+Option must not arm Option-only even if Command's press was missed")
+ replay.flagsChanged(keyCode: 58, modifiers: .command, nextPressed: [])
+ XCTAssertEqual(replay.cleanFinishCount, 0)
+ }
+
+ func testLegacyModifierShortcutCompletesOnEitherSide() {
+ for keyCode: UInt16 in [58, 61] {
+ let replay = ModifierOnlyFlagsReplay(shortcut: HotkeyShortcut(keyCode: 58, modifierFlags: .option))
+ replay.flagsChanged(keyCode: keyCode, modifiers: .option, nextPressed: [keyCode])
+ replay.flagsChanged(keyCode: keyCode, modifiers: [], nextPressed: [])
+ XCTAssertEqual(replay.cleanFinishCount, 1, "Legacy flag-only shortcuts must finish on the side that armed them")
+ XCTAssertNil(replay.activeModifierOnlyType)
+ }
+ }
+
+ func testKeyboardShortcutExactMatchAndPersistenceMatrix() throws {
+ let modifierFlags: [NSEvent.ModifierFlags] = [.function, .command, .option, .control, .shift]
+ let combinations = (0..<32).map { bits in
+ modifierFlags.enumerated().reduce(into: NSEvent.ModifierFlags()) { flags, entry in
+ if bits & (1 << entry.offset) != 0 { flags.insert(entry.element) }
+ }
+ }
+ for storedFlags in combinations {
+ let shortcut = HotkeyShortcut(keyCode: 2, modifierFlags: storedFlags)
+ XCTAssertEqual(try JSONDecoder().decode(HotkeyShortcut.self, from: JSONEncoder().encode(shortcut)), shortcut)
+ for incomingFlags in combinations {
+ for keyCode in UInt16(0)...127 {
+ let shouldMatch = keyCode == 2 && incomingFlags == storedFlags
+ XCTAssertEqual(shortcut.matches(keyCode: keyCode, modifiers: incomingFlags), shouldMatch)
+ XCTAssertEqual(shortcut.matches(keyCode: keyCode, modifiers: incomingFlags.union([.capsLock, .numericPad])), shouldMatch)
+ }
+ }
+ }
+ }
+
+ @MainActor
+ func testPrimaryToggleRejectsEveryOtherKeyAndModifierCombination() async throws {
+ let settings = SettingsStore.shared
+ let previousPasteEnabled = settings.pasteLastTranscriptionShortcutEnabled
+ defer { settings.pasteLastTranscriptionShortcutEnabled = previousPasteEnabled }
+ settings.pasteLastTranscriptionShortcutEnabled = false
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ let flags: [CGEventFlags] = [.maskSecondaryFn, .maskCommand, .maskAlternate, .maskControl, .maskShift]
+ for bits in 0..<32 {
+ let modifiers = flags.enumerated().reduce(into: CGEventFlags()) { result, entry in
+ if bits & (1 << entry.offset) != 0 { result.insert(entry.element) }
+ }
+ for keyCode in UInt16(0)...127 where HotkeyShortcut.modifierFlag(forKeyCode: keyCode) == nil {
+ let down = try self.primaryReleaseTestEvent(type: .keyDown, keyCode: keyCode, modifiers: modifiers)
+ let up = try self.primaryReleaseTestEvent(type: .keyUp, keyCode: keyCode, modifiers: [])
+ let shouldConsume = keyCode == 2 && modifiers == [.maskControl, .maskCommand]
+ XCTAssertEqual(manager.handleKeyEvent(type: .keyDown, event: down) == nil, shouldConsume)
+ XCTAssertEqual(manager.handleKeyEvent(type: .keyUp, event: up) == nil, shouldConsume)
+ }
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "Only Ctrl+Cmd+D may activate among all 3,808 event pairs")
+ }
+
+ @MainActor
+ func testPrimaryToggleSynthesizedTypingAndOrphanRepeatsNeverArm() async throws {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ for type in [CGEventType.keyDown, .keyUp, .flagsChanged] {
+ let event = try self.primaryReleaseTestEvent(type: type)
+ event.setIntegerValueField(.eventSourceUserData, value: TypingService.synthesizedEventUserData)
+ XCTAssertTrue(manager.handleKeyEvent(type: type, event: event) != nil)
+ }
+ let repeatedDown = try self.primaryReleaseTestEvent(type: .keyDown)
+ repeatedDown.setIntegerValueField(.keyboardEventAutorepeat, value: 1)
+ for _ in 0..<100 {
+ _ = manager.handleKeyEvent(type: .keyDown, event: repeatedDown)
+ }
+ let orphanUp = try self.primaryReleaseTestEvent(type: .keyUp)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: orphanUp) != nil)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0)
+ }
+
+ @MainActor
+ func testPrimaryToggleResetsDiscardStaleReleasesAndPermitNextPress() async throws {
+ for reason in [GlobalHotkeyManager.ModifierTrackingResetReason.shortcutCapture, .tapDisabled, .reinitialize] {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ let down = try self.primaryReleaseTestEvent(type: .keyDown)
+ let up = try self.primaryReleaseTestEvent(type: .keyUp)
+ _ = manager.handleKeyEvent(type: .keyDown, event: down)
+ manager.resetModifierOnlyShortcutTracking(reason: reason)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: up) != nil)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0)
+ _ = manager.handleKeyEvent(type: .keyDown, event: down)
+ _ = manager.handleKeyEvent(type: .keyUp, event: up)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ }
+ }
+
+ @MainActor
+ func testPrimaryToggleMouseMissingReleaseCannotActivateUnmodifiedClick() async throws {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.updatePrimaryShortcuts([HotkeyShortcut(mouseButton: 2, modifierFlags: .control)])
+ let down = try XCTUnwrap(CGEvent(mouseEventSource: nil, mouseType: .otherMouseDown, mouseCursorPosition: .zero, mouseButton: .center))
+ let up = try XCTUnwrap(CGEvent(mouseEventSource: nil, mouseType: .otherMouseUp, mouseCursorPosition: .zero, mouseButton: .center))
+ down.flags = .maskControl
+ _ = manager.handleMouseShortcutEvent(type: .otherMouseDown, event: down)
+ down.flags = []
+ XCTAssertTrue(manager.handleMouseShortcutEvent(type: .otherMouseDown, event: down) != nil)
+ XCTAssertTrue(manager.handleMouseShortcutEvent(type: .otherMouseUp, event: up) != nil)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0)
+ down.flags = .maskControl
+ _ = manager.handleMouseShortcutEvent(type: .otherMouseDown, event: down)
+ _ = manager.handleMouseShortcutEvent(type: .otherMouseUp, event: up)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ }
+
+ func testModifierOnlyInterruptionsAcrossFamiliesSidesAndReleaseOrders() {
+ let modifierKeys: [(UInt16, NSEvent.ModifierFlags)] = [
+ (63, .function), (55, .command), (54, .command), (58, .option), (61, .option),
+ (59, .control), (62, .control), (56, .shift), (60, .shift),
+ ]
+ for (owner, ownerFlag) in modifierKeys {
+ for explicitSide in [false, true] {
+ let shortcut = HotkeyShortcut(keyCode: owner, modifierFlags: ownerFlag, modifierKeyCodes: explicitSide ? [owner] : [])
+ for (extra, extraFlag) in modifierKeys where extra != owner {
+ for releaseOwnerFirst in [false, true] {
+ let replay = ModifierOnlyFlagsReplay(shortcut: shortcut)
+ replay.flagsChanged(keyCode: owner, modifiers: ownerFlag, nextPressed: [owner])
+ replay.flagsChanged(keyCode: extra, modifiers: ownerFlag.union(extraFlag), nextPressed: [owner, extra])
+ replay.keyDown()
+ if releaseOwnerFirst {
+ replay.flagsChanged(keyCode: owner, modifiers: extraFlag, nextPressed: [extra])
+ replay.flagsChanged(keyCode: extra, modifiers: [], nextPressed: [])
+ } else {
+ replay.flagsChanged(keyCode: extra, modifiers: ownerFlag, nextPressed: [owner])
+ replay.flagsChanged(keyCode: owner, modifiers: [], nextPressed: [])
+ }
+ XCTAssertEqual(replay.cleanFinishCount, 0, "Typing during a modifier hold must never become a clean tap")
+ XCTAssertNil(replay.activeModifierOnlyType)
+ replay.flagsChanged(keyCode: owner, modifiers: ownerFlag, nextPressed: [owner])
+ replay.flagsChanged(keyCode: owner, modifiers: [], nextPressed: [])
+ XCTAssertEqual(replay.cleanFinishCount, 1, "The next clean tap must still work")
+ }
+ }
+ }
+ }
+ }
+
+ @MainActor
+ func testRealManagerModifierTypingDoesNotStartAndNextCleanTapWorks() async throws {
+ for owner: UInt16 in [58, 61] {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.updatePrimaryShortcuts([HotkeyShortcut(keyCode: owner, modifierFlags: [], modifierKeyCodes: [owner])])
+ let optionDown = try self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: owner, modifiers: .maskAlternate)
+ let optionUp = try self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: owner, modifiers: [])
+ _ = manager.handleKeyEvent(type: .flagsChanged, event: optionDown)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 56, modifiers: [.maskAlternate, .maskShift]))
+ for keyCode: UInt16 in [36, 15] {
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: keyCode, modifiers: [.maskAlternate, .maskShift]))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp, keyCode: keyCode, modifiers: [.maskAlternate, .maskShift]))
+ }
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 56, modifiers: .maskAlternate))
+ _ = manager.handleKeyEvent(type: .flagsChanged, event: optionUp)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0)
+ _ = manager.handleKeyEvent(type: .flagsChanged, event: optionDown)
+ _ = manager.handleKeyEvent(type: .flagsChanged, event: optionUp)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ }
+ }
+
+ @MainActor
+ func testOtherRecordingModesIgnoreAutorepeat() async throws {
+ for activationMode in [HotkeyActivationMode.toggle, .hold, .automatic] {
+ let shortcut = HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command])
+ for mode in [HotkeyHoldModeType.promptMode, .commandMode, .rewriteMode, .promptAssignment] {
+ var starts = 0
+ let manager = GlobalHotkeyManager(
+ asrService: ASRService(),
+ primaryShortcuts: [],
+ promptModeShortcut: shortcut,
+ commandModeShortcut: shortcut,
+ rewriteModeShortcut: shortcut,
+ promptShortcutAssignments: mode == .promptAssignment ? [(selection: SettingsStore.DictationPromptSelection.default, shortcut: shortcut)] : [],
+ promptModeShortcutEnabled: mode == .promptMode,
+ commandModeShortcutEnabled: mode == .commandMode,
+ rewriteModeShortcutEnabled: mode == .rewriteMode,
+ promptModeCallback: { starts += 1 },
+ promptSelectionCallback: { _ in starts += 1 },
+ commandModeCallback: { starts += 1 },
+ rewriteModeCallback: { starts += 1 }
+ )
+ manager.setHotkeyMode(activationMode)
+ let down = try self.primaryReleaseTestEvent(type: .keyDown)
+ down.setIntegerValueField(.keyboardEventAutorepeat, value: 1)
+ XCTAssertNil(manager.handleKeyEvent(type: .keyDown, event: down))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "A repeat without a fresh press must not start \(mode)")
+ down.setIntegerValueField(.keyboardEventAutorepeat, value: 0)
+ XCTAssertNil(manager.handleKeyEvent(type: .keyDown, event: down))
+ down.setIntegerValueField(.keyboardEventAutorepeat, value: 1)
+ for _ in 0..<100 {
+ XCTAssertNil(manager.handleKeyEvent(type: .keyDown, event: down))
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "Holding a shortcut must not repeatedly start or stop \(mode) in \(activationMode)")
+ }
+ }
+ }
+
+ @MainActor
+ func testPrimaryToggleRapidDoubleTapStartsThenStopsOnce() async throws {
+ let asr = ASRService()
+ defer { asr.isRunning = false }
+ var starts = 0
+ var stops = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: {
+ starts += 1
+ asr.isRunning = true
+ }, onStop: {
+ stops += 1
+ asr.isRunning = false
+ })
+ let down = try self.primaryReleaseTestEvent(type: .keyDown)
+ let up = try self.primaryReleaseTestEvent(type: .keyUp)
+ for _ in 0..<2 {
+ _ = manager.handleKeyEvent(type: .keyDown, event: down)
+ _ = manager.handleKeyEvent(type: .keyUp, event: up)
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "Queued start callbacks must not start twice for a rapid double tap")
+ XCTAssertEqual(stops, 1)
+ XCTAssertFalse(asr.isRunning)
+ }
+
+ // Reported sequences stay linked to their issue, including reports closed for inactivity.
+ @MainActor
+ func testIssues1031And909UnconfiguredOAndReturnPassThrough() async throws {
+ for mode in [HotkeyActivationMode.toggle, .hold, .automatic] {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.updatePrimaryShortcuts([HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])])
+ manager.setHotkeyMode(mode)
+ for keyCode: UInt16 in [31, 36, 76] {
+ for modifiers: CGEventFlags in [[], .maskSecondaryFn, .maskAlternate, .maskShift, .maskControl, .maskCommand] {
+ let down = try self.primaryReleaseTestEvent(type: .keyDown, keyCode: keyCode, modifiers: modifiers)
+ let up = try self.primaryReleaseTestEvent(type: .keyUp, keyCode: keyCode, modifiers: modifiers)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyDown, event: down) != nil)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: up) != nil)
+ }
+ }
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 63, modifiers: .maskSecondaryFn))
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: 51, modifiers: .maskSecondaryFn))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 63, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "Plain O/Return and Fn+Delete must not activate Right Option")
+ }
+ }
+
+ @MainActor
+ func testIssues675And609OrdinaryCommandChordsDoNotTriggerOtherModifiers() async throws {
+ for owner: UInt16 in [58, 61, 62] {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.updatePrimaryShortcuts([HotkeyShortcut(keyCode: owner, modifierFlags: [], modifierKeyCodes: [owner])])
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 55, modifiers: .maskCommand))
+ for keyCode: UInt16 in [8, 9, 6, 48, 13, 21] {
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: keyCode, modifiers: .maskCommand))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp, keyCode: keyCode, modifiers: .maskCommand))
+ }
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 55, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0)
+ let modifier = owner == 62 ? CGEventFlags.maskControl : .maskAlternate
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: owner, modifiers: modifier))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: owner, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "The configured shortcut must still work after normal Command shortcuts")
+ }
+ }
+
+ @MainActor
+ func testIssues688And858ShiftTypingDoesNotTriggerModifierChords() async throws {
+ for shortcut in [
+ HotkeyShortcut(keyCode: 58, modifierFlags: [], modifierKeyCodes: [58]),
+ HotkeyShortcut(keyCode: 63, modifierFlags: [], modifierKeyCodes: [63, 59]),
+ HotkeyShortcut(keyCode: 54, modifierFlags: [], modifierKeyCodes: [54, 61]),
+ ] {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.updatePrimaryShortcuts([shortcut])
+ // Literal reported sequence: no configured modifiers held at all.
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 56, modifiers: .maskShift))
+ for keyCode: UInt16 in [36, 15, 9] {
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: keyCode, modifiers: .maskShift))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp, keyCode: keyCode, modifiers: .maskShift))
+ }
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 56, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "Shift+Enter/R/V must not start a different modifier shortcut")
+ }
+ }
+
+ @MainActor
+ func testIssues221And327MultiModifierChordsWorkInEveryPressAndReleaseOrder() async throws {
+ for keys: [UInt16] in [[63, 59], [61, 60], [54, 61]] {
+ for pressOrder in [keys, keys.reversed().map { $0 }] {
+ for releaseOrder in [keys, keys.reversed().map { $0 }] {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.updatePrimaryShortcuts([HotkeyShortcut(keyCode: keys[0], modifierFlags: [], modifierKeyCodes: keys)])
+ var held: Set<UInt16> = []
+ for key in pressOrder {
+ held.insert(key)
+ let flags = held.reduce(into: CGEventFlags()) { result, key in
+ result.formUnion(key == 63 ? .maskSecondaryFn : key == 59 ? .maskControl : key == 60 ? .maskShift : key == 54 ? .maskCommand : .maskAlternate)
+ }
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: key, modifiers: flags))
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "Toggle chords must wait for release")
+ for key in releaseOrder {
+ held.remove(key)
+ let flags = held.reduce(into: CGEventFlags()) { result, key in
+ result.formUnion(key == 63 ? .maskSecondaryFn : key == 59 ? .maskControl : key == 60 ? .maskShift : key == 54 ? .maskCommand : .maskAlternate)
+ }
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: key, modifiers: flags))
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "A full chord must toggle once, whichever modifier is released first")
+ }
+ }
+ }
+ }
+
+ @MainActor
+ func testIssue498DeletingHeldPrimaryModifierDoesNotBlockRemainingShortcut() async throws {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ let command = HotkeyShortcut(keyCode: 55, modifierFlags: [], modifierKeyCodes: [55])
+ let option = HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])
+ manager.updatePrimaryShortcuts([command, option])
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 55, modifiers: .maskCommand))
+ manager.updatePrimaryShortcuts([option])
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 55, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: .maskAlternate))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "Deleting a held modifier must not wedge the remaining binding until restart")
+ }
+
+ @MainActor
+ func testIssue422DisablingHeldModeModifierDoesNotBlockPrimary() async throws {
+ for mode in [HotkeyHoldModeType.promptMode, .commandMode, .rewriteMode, .promptAssignment] {
+ var starts = 0
+ var otherStarts = 0
+ let command = HotkeyShortcut(keyCode: 54, modifierFlags: [], modifierKeyCodes: [54])
+ let option = HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])
+ let manager = GlobalHotkeyManager(
+ asrService: ASRService(), primaryShortcuts: [option], promptModeShortcut: command,
+ commandModeShortcut: command, rewriteModeShortcut: command,
+ promptShortcutAssignments: mode == .promptAssignment ? [(selection: SettingsStore.DictationPromptSelection.default, shortcut: command)] : [],
+ promptModeShortcutEnabled: mode == .promptMode, commandModeShortcutEnabled: mode == .commandMode,
+ rewriteModeShortcutEnabled: mode == .rewriteMode, dictationModeCallback: { starts += 1 },
+ promptModeCallback: { otherStarts += 1 }, promptSelectionCallback: { _ in otherStarts += 1 },
+ commandModeCallback: { otherStarts += 1 }, rewriteModeCallback: { otherStarts += 1 }
+ )
+ manager.setHotkeyMode(.toggle)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 54, modifiers: .maskCommand))
+ switch mode {
+ case .promptMode: manager.updatePromptModeShortcutEnabled(false)
+ case .commandMode: manager.updateCommandModeShortcutEnabled(false)
+ case .rewriteMode: manager.updateRewriteModeShortcutEnabled(false)
+ case .promptAssignment: manager.updatePromptShortcutAssignments([])
+ case .transcription: XCTFail("unexpected test mode")
+ }
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 54, modifiers: []))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: .maskAlternate))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(otherStarts, 0, "Disabled modes must never activate on a pending release")
+ XCTAssertEqual(starts, 1, "Disabling a held mode must not wedge primary dictation")
+ }
+ }
+
+ @MainActor
+ func testIssues94And211HoldStopsWhenModifiersReleaseBeforeTheLetter() async throws {
+ for shortcut in [HotkeyShortcut(keyCode: 2, modifierFlags: .option), HotkeyShortcut(keyCode: 49, modifierFlags: [.option, .shift])] {
+ let asr = ASRService()
+ defer { asr.isRunning = false }
+ var starts = 0
+ var stops = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: { starts += 1; asr.isRunning = true }, onStop: { stops += 1; asr.isRunning = false })
+ manager.updatePrimaryShortcuts([shortcut])
+ manager.setHotkeyMode(.hold)
+ let modifiers: CGEventFlags = shortcut.keyCode == 2 ? .maskAlternate : [.maskAlternate, .maskShift]
+ let down = try self.primaryReleaseTestEvent(type: .keyDown, keyCode: shortcut.keyCode, modifiers: modifiers)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyDown, event: down) == nil)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 58, modifiers: []))
+ let up = try self.primaryReleaseTestEvent(type: .keyUp, keyCode: shortcut.keyCode, modifiers: [])
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: up) == nil, "The shortcut letter's release must not leak into normal typing")
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(stops, 1)
+ XCTAssertFalse(asr.isRunning)
+ }
+ }
+
+ @MainActor
+ func testIssues470And968LiveKeyboardRebindingRemovesOldChordImmediately() async throws {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ let old = HotkeyShortcut(keyCode: 50, modifierFlags: .shift)
+ let new = HotkeyShortcut(keyCode: 50, modifierFlags: [.shift, .control, .option, .command])
+ manager.updatePrimaryShortcuts([old])
+ manager.updatePrimaryShortcuts([new])
+ for flags: CGEventFlags in [.maskShift, [.maskShift, .maskControl, .maskAlternate, .maskCommand], .maskShift] {
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: 50, modifiers: flags))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp, keyCode: 50, modifiers: flags))
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ }
+
+ @MainActor
+ func testIssue849OptionKeyboardChordsContinueWorkingAfterRepeatedUses() async throws {
+ for keyCode: UInt16 in [50, 12, 49] {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.updatePrimaryShortcuts([HotkeyShortcut(keyCode: keyCode, modifierFlags: .option)])
+ for _ in 0..<20 {
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: keyCode, modifiers: .maskAlternate))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp, keyCode: keyCode, modifiers: []))
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 20)
+ }
+ }
+
+ @MainActor
+ func testIssue675ExplicitStyleShortcutsRemainIndependentOfSecondaryToggle() throws {
+ try self.withRestoredDefaults(keys: ["DictationPromptConfigurations", "PromptModeShortcutEnabled", "SecondaryPromptShortcutRemoved", "LegacySecondaryPromptShortcutRetired"]) {
+ let settings = SettingsStore.shared
+ let shortcut = HotkeyShortcut(keyCode: 55, modifierFlags: [], modifierKeyCodes: [55])
+ settings.promptModeShortcutEnabled = false
+ UserDefaults.standard.set(true, forKey: "SecondaryPromptShortcutRemoved")
+ UserDefaults.standard.set(true, forKey: "LegacySecondaryPromptShortcutRetired")
+ let configuration = SettingsStore.DictationPromptConfiguration(shortcut: shortcut, providerID: "provider-keep", modelName: "model-keep")
+ settings.setDictationPromptConfiguration(configuration, for: .default)
+ let assignments = settings.dictationPromptShortcutAssignments()
+ XCTAssertTrue(assignments.contains { $0.selection == .default && $0.shortcut == shortcut }, "Explicit style shortcuts are separate from Secondary; disabling Secondary must not erase them")
+ XCTAssertEqual(settings.dictationPromptConfiguration(for: .default), configuration)
+ }
+ }
+
+ @MainActor
+ func testHeldPrimaryRemovalStopsHoldAndAutomaticWithoutWaitingForOldRelease() async throws {
+ for mode in [HotkeyActivationMode.hold, .automatic] {
+ let asr = ASRService()
+ defer { asr.isRunning = false }
+ var starts = 0
+ var stops = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: { starts += 1; asr.isRunning = true }, onStop: { stops += 1; asr.isRunning = false })
+ let old = HotkeyShortcut(keyCode: 55, modifierFlags: [], modifierKeyCodes: [55])
+ let new = HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])
+ manager.updatePrimaryShortcuts([old])
+ manager.setHotkeyMode(mode)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 55, modifiers: .maskCommand))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ manager.updatePrimaryShortcuts([new])
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(stops, 1)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 55, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(stops, 1, "The removed modifier release must not stop twice or start anything")
+ XCTAssertEqual(starts, 1)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: .maskAlternate))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 2)
+ }
+ }
+
+ @MainActor
+ func testShortcutUpdatesPreserveUnrelatedAndStillConfiguredModifierPresses() async throws {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ let option = HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])
+ manager.updatePrimaryShortcuts([option])
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: .maskAlternate))
+ manager.updatePrimaryShortcuts([option, HotkeyShortcut(keyCode: 2, modifierFlags: .control)])
+ manager.updatePromptModeShortcutEnabled(false)
+ manager.updateCommandModeShortcut(nil)
+ manager.updateRewriteModeShortcut(HotkeyShortcut(keyCode: 15, modifierFlags: .control))
+ manager.updatePromptShortcutAssignments([])
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "Other settings edits and adding a binding must preserve the current valid press")
+ }
+
+ @MainActor
+ func testHeldModeRebindingDiscardsOldReleaseAndAllowsNewModifier() async throws {
+ for mode in [HotkeyHoldModeType.promptMode, .commandMode, .rewriteMode, .promptAssignment] {
+ var starts = 0
+ let old = HotkeyShortcut(keyCode: 54, modifierFlags: [], modifierKeyCodes: [54])
+ let new = HotkeyShortcut(keyCode: 60, modifierFlags: [], modifierKeyCodes: [60])
+ let manager = GlobalHotkeyManager(
+ asrService: ASRService(), primaryShortcuts: [], promptModeShortcut: old,
+ commandModeShortcut: old, rewriteModeShortcut: old,
+ promptShortcutAssignments: mode == .promptAssignment ? [(selection: .default, shortcut: old)] : [],
+ promptModeShortcutEnabled: mode == .promptMode, commandModeShortcutEnabled: mode == .commandMode,
+ rewriteModeShortcutEnabled: mode == .rewriteMode,
+ promptModeCallback: { starts += 1 }, promptSelectionCallback: { _ in starts += 1 },
+ commandModeCallback: { starts += 1 }, rewriteModeCallback: { starts += 1 }
+ )
+ manager.setHotkeyMode(.toggle)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 54, modifiers: .maskCommand))
+ switch mode {
+ case .promptMode: manager.updatePromptModeShortcut(new)
+ case .commandMode: manager.updateCommandModeShortcut(new)
+ case .rewriteMode: manager.updateRewriteModeShortcut(new)
+ case .promptAssignment: manager.updatePromptShortcutAssignments([(selection: .privateAI, shortcut: new)])
+ case .transcription: XCTFail("unexpected test mode")
+ }
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 54, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 60, modifiers: .maskShift))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 60, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ }
+ }
+
+ @MainActor
+ func testIssue622ThirdPartyShortcutEventsAreNotMistakenForFluidVoiceTyping() async throws {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ for sourceTag: Int64 in [0, 42, 0x5354454552] {
+ let down = try self.primaryReleaseTestEvent(type: .keyDown)
+ let up = try self.primaryReleaseTestEvent(type: .keyUp)
+ down.setIntegerValueField(.eventSourceUserData, value: sourceTag)
+ up.setIntegerValueField(.eventSourceUserData, value: sourceTag)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyDown, event: down) == nil)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: up) == nil)
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 3)
+ }
+
+ @MainActor
+ func testIssue556BareTypingBindingsDoNotStartAnyRecordingMode() async throws {
+ for activation in [HotkeyActivationMode.toggle, .hold, .automatic] {
+ for mode in [HotkeyHoldModeType.transcription, .promptMode, .commandMode, .rewriteMode, .promptAssignment] {
+ var starts = 0
+ let bare = HotkeyShortcut(keyCode: 31, modifierFlags: [])
+ let manager = GlobalHotkeyManager(
+ asrService: ASRService(), primaryShortcuts: mode == .transcription ? [bare] : [],
+ promptModeShortcut: bare, commandModeShortcut: bare, rewriteModeShortcut: bare,
+ promptShortcutAssignments: mode == .promptAssignment ? [(selection: .default, shortcut: bare)] : [],
+ promptModeShortcutEnabled: mode == .promptMode, commandModeShortcutEnabled: mode == .commandMode,
+ rewriteModeShortcutEnabled: mode == .rewriteMode, startRecordingCallback: { starts += 1 },
+ dictationModeCallback: { starts += 1 }, promptModeCallback: { starts += 1 },
+ promptSelectionCallback: { _ in starts += 1 }, commandModeCallback: { starts += 1 }, rewriteModeCallback: { starts += 1 }
+ )
+ manager.setHotkeyMode(activation)
+ let down = try self.primaryReleaseTestEvent(type: .keyDown, keyCode: 31, modifiers: [])
+ let up = try self.primaryReleaseTestEvent(type: .keyUp, keyCode: 31, modifiers: [])
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyDown, event: down) != nil, "Bare letters must pass through to the user's app")
+ _ = manager.handleKeyEvent(type: .keyUp, event: up)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "Bare O must not start \(mode) in \(activation)")
+ }
+ }
+ }
+
+ @MainActor
+ func testIssue556SavedBareTypingBindingsAreOffWithoutChangingModelsOrCancel() throws {
+ try self.withRestoredDefaults(keys: [self.primaryDictationShortcutsKey, self.legacyHotkeyShortcutKey, "DictationPromptConfigurations", "PromptModeHotkeyShortcut", "PromptModeShortcutEnabled", "CommandModeHotkeyShortcut", "CommandModeShortcutEnabled", "RewriteModeHotkeyShortcut", "RewriteModeShortcutEnabled", "CancelRecordingHotkeyShortcut"]) {
+ let settings = SettingsStore.shared
+ let bare = HotkeyShortcut(keyCode: 31, modifierFlags: [])
+ let data = try JSONEncoder().encode(bare)
+ UserDefaults.standard.removeObject(forKey: self.primaryDictationShortcutsKey)
+ UserDefaults.standard.set(data, forKey: self.legacyHotkeyShortcutKey)
+ XCTAssertTrue(settings.primaryDictationShortcuts.isEmpty, "Legacy bare bindings must show Off")
+ try UserDefaults.standard.set(JSONEncoder().encode([bare]), forKey: self.primaryDictationShortcutsKey)
+ XCTAssertEqual(settings.primaryDictationShortcutDisplayString, "Off")
+ settings.promptModeHotkeyShortcut = bare
+ settings.promptModeShortcutEnabled = true
+ settings.commandModeHotkeyShortcut = bare
+ settings.commandModeShortcutEnabled = true
+ settings.rewriteModeHotkeyShortcut = bare
+ settings.rewriteModeShortcutEnabled = true
+ XCTAssertFalse(settings.promptModeShortcutEnabled)
+ XCTAssertFalse(settings.commandModeShortcutEnabled)
+ XCTAssertFalse(settings.rewriteModeShortcutEnabled)
+ settings.setDictationPromptConfiguration(.init(shortcut: bare, providerID: "provider-keep", modelName: "model-keep"), for: .default)
+ XCTAssertFalse(settings.dictationPromptShortcutAssignments().contains { $0.selection == .default })
+ let configuration = settings.dictationPromptConfiguration(for: .default)
+ XCTAssertNil(configuration.shortcut)
+ XCTAssertEqual(configuration.providerID, "provider-keep")
+ XCTAssertEqual(configuration.modelName, "model-keep")
+ settings.cancelRecordingHotkeyShortcut = HotkeyShortcut(keyCode: 53, modifierFlags: [])
+ XCTAssertTrue(try XCTUnwrap(settings.cancelRecordingHotkeyShortcut).matches(keyCode: 53, modifiers: []))
+ XCTAssertEqual(UserDefaults.standard.data(forKey: self.legacyHotkeyShortcutKey), data, "Reading invalid bindings must not rewrite preferences")
+ }
+ }
+
+ func testBareKeyPolicyCoversLettersNumbersAndEditingKeysButAllowsPunctuation() {
+ let letters: [UInt16] = [0, 11, 8, 2, 14, 3, 5, 4, 34, 38, 40, 37, 46, 45, 31, 35, 12, 15, 1, 17, 32, 9, 13, 7, 16, 6]
+ let digits: [UInt16] = [29, 18, 19, 20, 21, 23, 22, 26, 28, 25, 82, 83, 84, 85, 86, 87, 88, 89, 91, 92]
+ let editing: [UInt16] = [48, 49, 36, 76, 51, 117, 53]
+ for keyCode in letters + digits + editing {
+ let bare = HotkeyShortcut(keyCode: keyCode, modifierFlags: [])
+ XCTAssertTrue(bare.requiresModifierForRecording, "keyCode=\(keyCode)")
+ XCTAssertFalse(bare.matchesRecordingShortcut(keyCode: keyCode, modifiers: []))
+ XCTAssertFalse(bare.matchesRecordingShortcut(keyCode: keyCode, modifiers: [.capsLock, .numericPad]))
+ XCTAssertTrue(bare.matches(keyCode: keyCode, modifiers: []), "Cancel and generic matching must remain available")
+ for modifier: NSEvent.ModifierFlags in [.control, .command, .option, .shift, .function, [.control, .command]] {
+ XCTAssertTrue(HotkeyShortcut(keyCode: keyCode, modifierFlags: modifier).matchesRecordingShortcut(keyCode: keyCode, modifiers: modifier))
+ }
+ }
+ // ANSI/ISO punctuation, keypad operators, and JIS punctuation.
+ for keyCode: UInt16 in [10, 24, 27, 30, 33, 39, 41, 42, 43, 44, 47, 50, 65, 67, 69, 75, 78, 81, 93, 94, 95] {
+ XCTAssertTrue(HotkeyShortcut(keyCode: keyCode, modifierFlags: []).matchesRecordingShortcut(keyCode: keyCode, modifiers: []), "Punctuation must remain available: \(keyCode)")
+ }
+ for keyCode: UInt16 in [54, 55, 56, 58, 59, 60, 61, 62, 63, 122, 120, 99, 118, 96, 97, 98, 100, 101, 109, 103, 111, 123, 124, 125, 126] {
+ XCTAssertFalse(HotkeyShortcut(keyCode: keyCode, modifierFlags: []).requiresModifierForRecording)
+ }
+ XCTAssertFalse(HotkeyShortcut(mouseButton: 2, modifierFlags: []).requiresModifierForRecording)
+ }
+
+ @MainActor
+ func testBarePunctuationAndModifiedEditingKeysRemainUsableAfterInvalidKeys() async throws {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ for keyCode: UInt16 in [3, 31, 18, 49, 48, 36, 76, 51, 117, 53] {
+ manager.updatePrimaryShortcuts([HotkeyShortcut(keyCode: keyCode, modifierFlags: [])])
+ let down = try self.primaryReleaseTestEvent(type: .keyDown, keyCode: keyCode, modifiers: [])
+ let up = try self.primaryReleaseTestEvent(type: .keyUp, keyCode: keyCode, modifiers: [])
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyDown, event: down) != nil)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: up) != nil)
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0)
+ let allowed = [HotkeyShortcut(keyCode: 50, modifierFlags: []), HotkeyShortcut(keyCode: 43, modifierFlags: []), HotkeyShortcut(keyCode: 47, modifierFlags: []), HotkeyShortcut(keyCode: 36, modifierFlags: .control), HotkeyShortcut(keyCode: 53, modifierFlags: .control)]
+ for shortcut in allowed {
+ manager.updatePrimaryShortcuts([shortcut])
+ let flags: CGEventFlags = shortcut.modifierFlags.isEmpty ? [] : .maskControl
+ let down = try self.primaryReleaseTestEvent(type: .keyDown, keyCode: shortcut.keyCode, modifiers: flags)
+ let up = try self.primaryReleaseTestEvent(type: .keyUp, keyCode: shortcut.keyCode, modifiers: [])
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyDown, event: down) == nil)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: up) == nil)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, allowed.count)
+ }
+
+ @MainActor
+ func testSavedPunctuationAndModifiedBindingsStayEnabled() throws {
+ try self.withRestoredDefaults(keys: [self.primaryDictationShortcutsKey, self.legacyHotkeyShortcutKey, "DictationPromptConfigurations", "PromptModeHotkeyShortcut", "PromptModeShortcutEnabled", "CommandModeHotkeyShortcut", "CommandModeShortcutEnabled", "RewriteModeHotkeyShortcut", "RewriteModeShortcutEnabled"]) {
+ let settings = SettingsStore.shared
+ for shortcut in [HotkeyShortcut(keyCode: 50, modifierFlags: []), HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command]), HotkeyShortcut(keyCode: 61, modifierFlags: [])] {
+ settings.primaryDictationShortcuts = [HotkeyShortcut(keyCode: 3, modifierFlags: []), shortcut]
+ XCTAssertEqual(settings.primaryDictationShortcuts, [shortcut])
+ settings.promptModeHotkeyShortcut = shortcut
+ settings.promptModeShortcutEnabled = true
+ settings.commandModeHotkeyShortcut = shortcut
+ settings.commandModeShortcutEnabled = true
+ settings.rewriteModeHotkeyShortcut = shortcut
+ settings.rewriteModeShortcutEnabled = true
+ XCTAssertTrue(settings.promptModeShortcutEnabled)
+ XCTAssertTrue(settings.commandModeShortcutEnabled)
+ XCTAssertTrue(settings.rewriteModeShortcutEnabled)
+ settings.setDictationPromptConfiguration(.init(shortcut: shortcut, providerID: "provider-keep", modelName: "model-keep"), for: .default)
+ XCTAssertTrue(settings.dictationPromptShortcutAssignments().contains { $0.selection == .default && $0.shortcut == shortcut })
+ XCTAssertEqual(settings.dictationPromptConfiguration(for: .default).shortcut, shortcut)
+ }
+ }
+ }
+
+ @MainActor
+ func testPromptAssignmentEditsPreserveAnUnchangedHeldStyle() async throws {
+ var selections: [SettingsStore.DictationPromptSelection] = []
+ let command = HotkeyShortcut(keyCode: 54, modifierFlags: [], modifierKeyCodes: [54])
+ let shift = HotkeyShortcut(keyCode: 60, modifierFlags: [], modifierKeyCodes: [60])
+ let manager = GlobalHotkeyManager(
+ asrService: ASRService(), primaryShortcuts: [], promptModeShortcut: shift,
+ commandModeShortcut: nil, rewriteModeShortcut: shift,
+ promptShortcutAssignments: [(selection: .default, shortcut: command), (selection: .privateAI, shortcut: shift)],
+ promptModeShortcutEnabled: false, commandModeShortcutEnabled: false, rewriteModeShortcutEnabled: false,
+ promptSelectionCallback: { selections.append($0) }
+ )
+ manager.setHotkeyMode(.toggle)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 54, modifiers: .maskCommand))
+ manager.updatePromptShortcutAssignments([(selection: .privateAI, shortcut: shift), (selection: .default, shortcut: command)])
+ manager.updatePromptShortcutAssignments([(selection: .default, shortcut: command)])
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 54, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(selections, [.default], "Reordering styles or deleting another style must preserve the unchanged active shortcut")
+ }
+
+ @MainActor
+ func testIssue498RemovedIdleModifierNoLongerTriggersWithoutRestart() async throws {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ let command = HotkeyShortcut(keyCode: 55, modifierFlags: [], modifierKeyCodes: [55])
+ let option = HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])
+ manager.updatePrimaryShortcuts([command, option])
+ manager.updatePrimaryShortcuts([option])
+ for keyCode: UInt16 in [55, 61, 55] {
+ let flags: CGEventFlags = keyCode == 55 ? .maskCommand : .maskAlternate
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: keyCode, modifiers: flags))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: keyCode, modifiers: []))
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "Only the remaining Option binding may trigger")
+ }
+
+ @MainActor
+ func testRemovingHeldBindingDoesNotStopADifferentRecordingMode() async throws {
+ let asr = ASRService()
+ defer { asr.isRunning = false }
+ var isDictate = true
+ var starts = 0
+ var stops = 0
+ let shortcut = HotkeyShortcut(keyCode: 55, modifierFlags: [], modifierKeyCodes: [55])
+ let manager = GlobalHotkeyManager(
+ asrService: asr, primaryShortcuts: [shortcut], promptModeShortcut: shortcut,
+ commandModeShortcut: nil, rewriteModeShortcut: shortcut,
+ promptModeShortcutEnabled: false, commandModeShortcutEnabled: false, rewriteModeShortcutEnabled: false,
+ startRecordingCallback: { starts += 1; asr.isRunning = true },
+ dictationModeCallback: { starts += 1; asr.isRunning = true },
+ stopAndProcessCallback: { _ in stops += 1 }, isDictateRecordingProvider: { isDictate }
+ )
+ manager.setHotkeyMode(.hold)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 55, modifiers: .maskCommand))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ // Another recording mode took over while the original shortcut was held.
+ isDictate = false
+ manager.updatePrimaryShortcuts([])
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 55, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(stops, 0)
+ XCTAssertTrue(asr.isRunning, "Editing a Dictate binding must not stop a different active mode")
+ }
+
+ @MainActor
+ func testActivationModeChangeDiscardsHeldModifierRelease() async throws {
+ for previousMode in [HotkeyActivationMode.toggle, .hold, .automatic] {
+ let asr = ASRService()
+ defer { asr.isRunning = false }
+ var starts = 0
+ var stops = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: { starts += 1; asr.isRunning = true }, onStop: { stops += 1; asr.isRunning = false })
+ let option = HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])
+ manager.updatePrimaryShortcuts([option])
+ manager.setHotkeyMode(previousMode)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: .maskAlternate))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ let startsBeforeChange = starts
+ manager.setHotkeyMode(previousMode == .toggle ? .automatic : .toggle)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ let stopsBeforeRelease = stops
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, startsBeforeChange, "Changing \(previousMode) must not let the old press activate a new mode")
+ XCTAssertEqual(stops, stopsBeforeRelease, "The old release must not stop twice")
+ manager.setHotkeyMode(.toggle)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: .maskAlternate))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, startsBeforeChange + 1, "The next clean tap must work")
+ }
+ }
+
+ @MainActor
+ func testUnchangedActivationModePreservesHeldKeyboardAndModifierPresses() async throws {
+ for shortcut in [HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command]), HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])] {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.updatePrimaryShortcuts([shortcut])
+ let downType: CGEventType = shortcut.isModifierOnlyShortcut ? .flagsChanged : .keyDown
+ let upType: CGEventType = shortcut.isModifierOnlyShortcut ? .flagsChanged : .keyUp
+ let flags: CGEventFlags = shortcut.isModifierOnlyShortcut ? .maskAlternate : [.maskControl, .maskCommand]
+ _ = try manager.handleKeyEvent(type: downType, event: self.primaryReleaseTestEvent(type: downType, keyCode: shortcut.keyCode, modifiers: flags))
+ manager.setHotkeyMode(.toggle)
+ _ = try manager.handleKeyEvent(type: upType, event: self.primaryReleaseTestEvent(type: upType, keyCode: shortcut.keyCode, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "Refreshing an unchanged mode must preserve a valid press")
+ }
+ }
+
+ @MainActor
+ func testActivationModeChangeCancelsAStartQueuedByOldHoldPress() async throws {
+ let asr = ASRService()
+ defer { asr.isRunning = false }
+ var starts = 0
+ var stops = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: { starts += 1; asr.isRunning = true }, onStop: { stops += 1; asr.isRunning = false })
+ manager.updatePrimaryShortcuts([HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])])
+ manager.setHotkeyMode(.hold)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: .maskAlternate))
+ // Change mode before the queued recording callback gets a turn.
+ manager.setHotkeyMode(.toggle)
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0)
+ XCTAssertEqual(stops, 0)
+ XCTAssertFalse(asr.isRunning)
+ }
+
+ @MainActor
+ func testAddingUnrelatedPrimaryBindingPreservesHeldKeyboardAndMouse() async throws {
+ for mouse in [false, true] {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ let shortcut = mouse ? HotkeyShortcut(mouseButton: 2, modifierFlags: []) : HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command])
+ manager.updatePrimaryShortcuts([shortcut])
+ if mouse {
+ let down = try XCTUnwrap(CGEvent(mouseEventSource: nil, mouseType: .otherMouseDown, mouseCursorPosition: .zero, mouseButton: .center))
+ _ = manager.handleMouseShortcutEvent(type: .otherMouseDown, event: down)
+ } else {
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ }
+ manager.updatePrimaryShortcuts([shortcut, HotkeyShortcut(keyCode: 3, modifierFlags: .control)])
+ if mouse {
+ let up = try XCTUnwrap(CGEvent(mouseEventSource: nil, mouseType: .otherMouseUp, mouseCursorPosition: .zero, mouseButton: .center))
+ _ = manager.handleMouseShortcutEvent(type: .otherMouseUp, event: up)
+ } else {
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1, "Adding another binding must preserve the held \(mouse ? "mouse" : "keyboard") shortcut")
+ }
+ }
+
+ @MainActor
+ func testRemovingHeldBindingRechecksActiveModeWhenQueuedStopRuns() async throws {
+ let asr = ASRService()
+ defer { asr.isRunning = false }
+ var isDictate = true
+ var stops = 0
+ let shortcut = HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command])
+ let manager = GlobalHotkeyManager(
+ asrService: asr, primaryShortcuts: [shortcut], promptModeShortcut: shortcut,
+ commandModeShortcut: nil, rewriteModeShortcut: shortcut,
+ promptModeShortcutEnabled: false, commandModeShortcutEnabled: false, rewriteModeShortcutEnabled: false,
+ startRecordingCallback: { asr.isRunning = true }, dictationModeCallback: { asr.isRunning = true },
+ stopAndProcessCallback: { _ in stops += 1; asr.isRunning = false }, isDictateRecordingProvider: { isDictate }
+ )
+ manager.setHotkeyMode(.hold)
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ manager.updatePrimaryShortcuts([])
+ isDictate = false // Another mode takes over before the scheduled stop executes.
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(stops, 0)
+ XCTAssertTrue(asr.isRunning)
+ }
+
+ @MainActor
+ func testPrimaryRapidToggleUsesNestedAudioStartBoundary() async throws {
+ let asr = ASRService()
+ defer { asr.isRunning = false }
+ var starts = 0
+ var stops = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: {
+ starts += 1
+ await Task { @MainActor in asr.isRunning = true }.value
+ }, onStop: { stops += 1; asr.isRunning = false })
+ for _ in 0..<2 {
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ }
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ XCTAssertEqual(stops, 1)
+ XCTAssertFalse(asr.isRunning, "Two quick taps must leave recording stopped even when start is nested")
+ }
+
+ @MainActor
+ func testPrimaryRapidHoldRepressCancelsPreviousQueuedReleaseStop() async throws {
+ let asr = ASRService()
+ defer { asr.isRunning = false }
+ var starts = 0
+ var stops = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: { starts += 1; asr.isRunning = true }, onStop: { stops += 1; asr.isRunning = false })
+ manager.setHotkeyMode(.hold)
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ XCTAssertEqual(stops, 0)
+ XCTAssertTrue(asr.isRunning, "A fresh held press must retain recording while invalidating the prior release")
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(stops, 1)
+ }
+
+ @MainActor
+ func testCancelAfterToggleReleaseInvalidatesQueuedStart() async throws {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.setCancelCallback { true }
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: 53, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "Handled cancel must invalidate the already-queued recording start")
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ }
+
+ @MainActor
+ func testRemovingBindingChangingModeOrCaptureInvalidatesQueuedToggleStart() async throws {
+ for interruption in 0..<3 {
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ switch interruption {
+ case 0: manager.updatePrimaryShortcuts([])
+ case 1: manager.setHotkeyMode(.hold)
+ default: manager.resetModifierOnlyShortcutTracking()
+ }
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "Queued start must not survive interruption \(interruption)")
+ }
+ }
+
+ @MainActor
+ func testForeignStyleKeyReleaseCannotStopOwnedStylePress() async throws {
+ let asr = ASRService()
+ defer { asr.isRunning = false }
+ var starts = 0
+ var stops = 0
+ let first = HotkeyShortcut(keyCode: 2, modifierFlags: .control)
+ let second = HotkeyShortcut(keyCode: 3, modifierFlags: .control)
+ let manager = GlobalHotkeyManager(
+ asrService: asr, primaryShortcuts: [], promptModeShortcut: first,
+ commandModeShortcut: nil, rewriteModeShortcut: first,
+ promptShortcutAssignments: [(selection: .default, shortcut: first), (selection: .privateAI, shortcut: second)],
+ promptModeShortcutEnabled: false, commandModeShortcutEnabled: false, rewriteModeShortcutEnabled: false,
+ stopAndProcessCallback: { _ in stops += 1; asr.isRunning = false },
+ promptSelectionCallback: { _ in starts += 1; asr.isRunning = true }, isPromptModeRecordingProvider: { true }
+ )
+ manager.setHotkeyMode(.hold)
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: 2, modifiers: .maskControl))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ let foreignDown = try self.primaryReleaseTestEvent(type: .keyDown, keyCode: 3, modifiers: [])
+ let foreignUp = try self.primaryReleaseTestEvent(type: .keyUp, keyCode: 3, modifiers: [])
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyDown, event: foreignDown) != nil)
+ XCTAssertTrue(manager.handleKeyEvent(type: .keyUp, event: foreignUp) != nil)
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ XCTAssertEqual(stops, 0)
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp, keyCode: 2, modifiers: []))
+ for _ in 0..<10 {
+ await Task.yield()
+ }
+ XCTAssertEqual(stops, 1)
+ }
+
+ @MainActor
+ func testRapidToggleTapParityAcrossNestedStartsAndStops() async throws {
+ for initiallyRunning in [false, true] {
+ for taps in 1...4 {
+ let asr = ASRService()
+ asr.isRunning = initiallyRunning
+ var starts = 0
+ var stops = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: {
+ starts += 1
+ await Task { @MainActor in
+ await Task.yield()
+ asr.isRunning = true
+ }.value
+ }, onStop: {
+ stops += 1
+ await Task { @MainActor in
+ await Task.yield()
+ asr.isRunning = false
+ }.value
+ })
+ for _ in 0..<taps {
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ }
+ for _ in 0..<100 {
+ await Task.yield()
+ }
+ XCTAssertEqual(asr.isRunning, initiallyRunning != (taps % 2 == 1), "Initial recording=\(initiallyRunning), taps=\(taps)")
+ XCTAssertEqual(starts, initiallyRunning ? taps / 2 : (taps + 1) / 2)
+ XCTAssertEqual(stops, initiallyRunning ? (taps + 1) / 2 : taps / 2)
+ asr.isRunning = false
+ }
+ }
+ }
+
+ @MainActor
+ func testCancelOrResetAfterCallbackEntryCancelsNestedCaptureTask() async throws {
+ for reset in [false, true] {
+ let asr = ASRService()
+ var gate: CheckedContinuation<Void, Never>?
+ var captureStarts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: {
+ let captureTask = Task { @MainActor in
+ await withCheckedContinuation { gate = $0 }
+ guard !Task.isCancelled else { return }
+ captureStarts += 1
+ asr.isRunning = true
+ }
+ await withTaskCancellationHandler {
+ await captureTask.value
+ } onCancel: {
+ captureTask.cancel()
+ }
+ })
+ if reset { manager.setHotkeyMode(.hold) }
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ if !reset { _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp)) }
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertNotNil(gate, "Callback must reach the nested capture boundary")
+ if reset {
+ manager.resetModifierOnlyShortcutTracking(reason: .tapDisabled)
+ } else {
+ let result = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, keyCode: 53, modifiers: []))
+ XCTAssertNil(result, "Escape must cancel a pending start even while ASR is still idle")
+ }
+ gate?.resume()
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertEqual(captureStarts, 0)
+ XCTAssertFalse(asr.isRunning)
+ asr.isRunning = false
+ }
+ }
+
+ @MainActor
+ func testQueuedPrimarySurvivesRemovingUnrelatedBinding() async throws {
+ let first = HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command])
+ let second = HotkeyShortcut(keyCode: 3, modifierFlags: .control)
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.updatePrimaryShortcuts([first, second])
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ manager.updatePrimaryShortcuts([first])
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ }
+
+ @MainActor
+ func testReassigningQueuedStyleCannotInvokeItsPreviousSelection() async throws {
+ let shortcut = HotkeyShortcut(keyCode: 2, modifierFlags: .control)
+ var selections: [SettingsStore.DictationPromptSelection] = []
+ let manager = GlobalHotkeyManager(
+ asrService: ASRService(), primaryShortcuts: [], promptModeShortcut: shortcut,
+ commandModeShortcut: nil, rewriteModeShortcut: shortcut,
+ promptShortcutAssignments: [(selection: .default, shortcut: shortcut)],
+ promptModeShortcutEnabled: false, commandModeShortcutEnabled: false, rewriteModeShortcutEnabled: false,
+ promptSelectionCallback: { selections.append($0) }
+ )
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, modifiers: .maskControl))
+ manager.updatePromptShortcutAssignments([(selection: .privateAI, shortcut: shortcut)])
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertTrue(selections.isEmpty)
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, modifiers: .maskControl))
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertEqual(selections, [.privateAI])
+ }
+
+ @MainActor
+ func testModifierShortcutCannotTakeOverHeldKeyboardOwner() async throws {
+ for style in [false, true] {
+ let asr = ASRService()
+ let keyboard = HotkeyShortcut(keyCode: 2, modifierFlags: .control)
+ let modifier = HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])
+ var starts = 0
+ var stops = 0
+ let manager = GlobalHotkeyManager(
+ asrService: asr, primaryShortcuts: style ? [] : [keyboard, modifier], promptModeShortcut: keyboard,
+ commandModeShortcut: nil, rewriteModeShortcut: keyboard,
+ promptShortcutAssignments: style ? [(selection: .default, shortcut: keyboard), (selection: .privateAI, shortcut: modifier)] : [],
+ promptModeShortcutEnabled: false, commandModeShortcutEnabled: false, rewriteModeShortcutEnabled: false,
+ startRecordingCallback: { starts += 1; asr.isRunning = true },
+ stopAndProcessCallback: { _ in stops += 1; asr.isRunning = false },
+ promptSelectionCallback: { _ in starts += 1; asr.isRunning = true },
+ isDictateRecordingProvider: { !style }, isPromptModeRecordingProvider: { style }
+ )
+ manager.setHotkeyMode(.hold)
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown, modifiers: .maskControl))
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 59, modifiers: []))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: .maskAlternate))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: []))
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ XCTAssertEqual(stops, 0, "The keyboard is still held; a second modifier shortcut must not release it")
+ XCTAssertTrue(asr.isRunning)
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp, modifiers: []))
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertEqual(stops, 1)
+ asr.isRunning = false
+ }
+ }
+
+ @MainActor
+ func testBindingRemovalDoesNotCancelOutputAlreadyProcessing() async throws {
+ let asr = ASRService()
+ asr.isRunning = true
+ var finishStop: CheckedContinuation<Void, Never>?
+ var outputWasCancelled = false
+ var stops = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: asr, onStart: {}, onStop: {
+ await withCheckedContinuation { finishStop = $0 }
+ outputWasCancelled = Task.isCancelled
+ stops += 1
+ asr.isRunning = false
+ })
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp))
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertNotNil(finishStop)
+ manager.updatePrimaryShortcuts([])
+ finishStop?.resume()
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertFalse(outputWasCancelled)
+ XCTAssertEqual(stops, 1)
+ XCTAssertFalse(asr.isRunning)
+ asr.isRunning = false
+ }
+
+ @MainActor
+ func testToggleModifierCannotTakeOverHeldKeyboardOrMouseOwner() async throws {
+ for mouse in [false, true] {
+ let first = mouse ? HotkeyShortcut(mouseButton: 2, modifierFlags: []) : HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command])
+ let modifier = HotkeyShortcut(keyCode: 61, modifierFlags: [], modifierKeyCodes: [61])
+ var starts = 0
+ let manager = self.makePrimaryReleaseTestManager(asr: ASRService(), onStart: { starts += 1 })
+ manager.updatePrimaryShortcuts([first, modifier])
+ if mouse {
+ let down = try XCTUnwrap(CGEvent(mouseEventSource: nil, mouseType: .otherMouseDown, mouseCursorPosition: .zero, mouseButton: .center))
+ _ = manager.handleMouseShortcutEvent(type: .otherMouseDown, event: down)
+ } else {
+ _ = try manager.handleKeyEvent(type: .keyDown, event: self.primaryReleaseTestEvent(type: .keyDown))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 59, modifiers: []))
+ }
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: .maskAlternate))
+ _ = try manager.handleKeyEvent(type: .flagsChanged, event: self.primaryReleaseTestEvent(type: .flagsChanged, keyCode: 61, modifiers: []))
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 0, "A second modifier shortcut must not activate before the owning key/button releases")
+ if mouse {
+ let up = try XCTUnwrap(CGEvent(mouseEventSource: nil, mouseType: .otherMouseUp, mouseCursorPosition: .zero, mouseButton: .center))
+ _ = manager.handleMouseShortcutEvent(type: .otherMouseUp, event: up)
+ } else {
+ _ = try manager.handleKeyEvent(type: .keyUp, event: self.primaryReleaseTestEvent(type: .keyUp, modifiers: []))
+ }
+ for _ in 0..<20 {
+ await Task.yield()
+ }
+ XCTAssertEqual(starts, 1)
+ }
+ }
+
+ @MainActor
+ private func makePrimaryReleaseTestManager(
+ asr: ASRService,
+ onStart: @escaping () async -> Void,
+ onStop: @escaping () async -> Void = {}
+ ) -> GlobalHotkeyManager {
+ let manager = GlobalHotkeyManager(
+ asrService: asr,
+ primaryShortcuts: [HotkeyShortcut(keyCode: 2, modifierFlags: [.control, .command])],
+ promptModeShortcut: HotkeyShortcut(keyCode: 60, modifierFlags: []),
+ commandModeShortcut: nil,
+ rewriteModeShortcut: HotkeyShortcut(keyCode: 58, modifierFlags: []),
+ promptModeShortcutEnabled: false,
+ commandModeShortcutEnabled: false,
+ rewriteModeShortcutEnabled: false,
+ startRecordingCallback: onStart,
+ dictationModeCallback: onStart,
+ stopAndProcessCallback: { _ in await onStop() },
+ isDictateRecordingProvider: { true }
+ )
+ manager.setHotkeyMode(.toggle)
+ return manager
+ }
+
+ private func primaryReleaseTestEvent(
+ type: CGEventType,
+ keyCode: CGKeyCode = 2,
+ modifiers: CGEventFlags = [.maskControl, .maskCommand]
+ ) throws -> CGEvent {
+ let event = try XCTUnwrap(CGEvent(keyboardEventSource: nil, virtualKey: keyCode, keyDown: type == .keyDown))
+ event.type = type
+ event.flags = modifiers
+ return event
+ }
+
func testKeyboardEventMaskExcludesMouseEvents() {
let mask = GlobalHotkeyManager.keyboardEventMask()
for type in [CGEventType.keyDown, .keyUp, .flagsChanged] {