import AppKit
|
import ApplicationServices
|
@preconcurrency import CoreGraphics
|
import Foundation
|
import AlignerCore
|
|
@MainActor
|
final class CGEventTapTriggerService: TriggerServiceProtocol {
|
enum ServiceError: Error, CustomStringConvertible {
|
case eventTapUnavailable
|
|
var description: String {
|
switch self {
|
case .eventTapUnavailable:
|
return "CGEventTapCreate returned nil. Accessibility may be missing, or macOS may require a different trigger route."
|
}
|
}
|
}
|
|
var onQuickSwitch: (() -> Void)?
|
var onStartFailure: ((ServiceError) -> Void)?
|
private(set) var isRunning = false
|
|
private let shortcut: KeyboardShortcut
|
private let overlayVisibleProvider: () -> Bool
|
private let accessibilityTrustedProvider: () -> Bool
|
private let consumeInitialQuickSwitch: Bool
|
private var eventTap: CFMachPort?
|
private var runLoopSource: CFRunLoopSource?
|
|
init(
|
shortcut: KeyboardShortcut = TriggerDefaults.quickSwitchShortcut,
|
overlayVisibleProvider: @escaping () -> Bool,
|
accessibilityTrustedProvider: @escaping () -> Bool = {
|
AXIsProcessTrusted()
|
},
|
consumeInitialQuickSwitch: Bool = true
|
) {
|
self.shortcut = shortcut
|
self.overlayVisibleProvider = overlayVisibleProvider
|
self.accessibilityTrustedProvider = accessibilityTrustedProvider
|
self.consumeInitialQuickSwitch = consumeInitialQuickSwitch
|
}
|
|
func start() {
|
do {
|
try startEventTap()
|
} catch let error as ServiceError {
|
onStartFailure?(error)
|
} catch {
|
onStartFailure?(.eventTapUnavailable)
|
}
|
}
|
|
func startEventTap() throws {
|
guard eventTap == nil else { return }
|
|
let eventMask = CGEventMask(1 << CGEventType.keyDown.rawValue)
|
guard let tap = CGEvent.tapCreate(
|
tap: .cgSessionEventTap,
|
place: .headInsertEventTap,
|
options: .defaultTap,
|
eventsOfInterest: eventMask,
|
callback: Self.eventCallback,
|
userInfo: Unmanaged.passUnretained(self).toOpaque()
|
) else {
|
throw ServiceError.eventTapUnavailable
|
}
|
|
let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, tap, 0)
|
CFRunLoopAddSource(CFRunLoopGetMain(), source, .commonModes)
|
CGEvent.tapEnable(tap: tap, enable: true)
|
|
eventTap = tap
|
runLoopSource = source
|
isRunning = true
|
}
|
|
func stop() {
|
if let eventTap {
|
CGEvent.tapEnable(tap: eventTap, enable: false)
|
}
|
if let runLoopSource {
|
CFRunLoopRemoveSource(CFRunLoopGetMain(), runLoopSource, .commonModes)
|
}
|
|
runLoopSource = nil
|
eventTap = nil
|
isRunning = false
|
}
|
|
deinit {
|
MainActor.assumeIsolated {
|
stop()
|
}
|
}
|
|
private func handle(event: CGEvent, type: CGEventType) -> Unmanaged<CGEvent>? {
|
switch type {
|
case .tapDisabledByTimeout, .tapDisabledByUserInput:
|
guard accessibilityTrustedProvider() else {
|
Task { @MainActor [weak self] in
|
self?.stop()
|
}
|
return Unmanaged.passUnretained(event)
|
}
|
if let eventTap {
|
CGEvent.tapEnable(tap: eventTap, enable: true)
|
}
|
return Unmanaged.passUnretained(event)
|
case .keyDown:
|
break
|
default:
|
return Unmanaged.passUnretained(event)
|
}
|
|
guard accessibilityTrustedProvider() else {
|
Task { @MainActor [weak self] in
|
self?.stop()
|
}
|
return Unmanaged.passUnretained(event)
|
}
|
|
let receivedShortcut = KeyboardShortcut(
|
keyCode: UInt16(event.getIntegerValueField(.keyboardEventKeycode)),
|
modifiers: Self.shortcutModifiers(from: event.flags)
|
)
|
let decision = TriggerEventPolicy.decision(
|
for: receivedShortcut,
|
configuredQuickSwitch: shortcut,
|
overlayVisible: overlayVisibleProvider(),
|
consumeInitialQuickSwitch: consumeInitialQuickSwitch
|
)
|
|
switch decision {
|
case .quickSwitch(let consumeEvent):
|
Task { @MainActor [weak self] in
|
self?.onQuickSwitch?()
|
}
|
return consumeEvent ? nil : Unmanaged.passUnretained(event)
|
case .passThrough:
|
return Unmanaged.passUnretained(event)
|
}
|
}
|
|
private static let eventCallback: CGEventTapCallBack = { _, type, event, userInfo in
|
guard let userInfo else {
|
return Unmanaged.passUnretained(event)
|
}
|
|
let service = Unmanaged<CGEventTapTriggerService>.fromOpaque(userInfo).takeUnretainedValue()
|
return MainActor.assumeIsolated {
|
return service.handle(event: event, type: type)
|
}
|
}
|
|
private static func shortcutModifiers(from flags: CGEventFlags) -> ShortcutModifiers {
|
var modifiers = ShortcutModifiers()
|
|
if flags.contains(.maskAlternate) {
|
modifiers.insert(.option)
|
}
|
if flags.contains(.maskCommand) {
|
modifiers.insert(.command)
|
}
|
if flags.contains(.maskShift) {
|
modifiers.insert(.shift)
|
}
|
if flags.contains(.maskControl) {
|
modifiers.insert(.control)
|
}
|
|
return modifiers
|
}
|
}
|
