Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170import AppKitimport ApplicationServicesimport Darwinimport Foundation
@MainActorfinal class InputEventTap { typealias Handler = @MainActor (CGEventType, CGEvent) -> Bool private(set) var port: CFMachPort? private var source: CFRunLoopSource? private var permissionMonitor: InputPermissionMonitor? private let handler: Handler private let onFailure: @MainActor (InputError) -> Void
init( mask: CGEventMask, trustObserver: AccessibilityTrustObserver = .shared, readTrust: @escaping @MainActor () -> Bool = { AXIsProcessTrusted() }, handler: @escaping Handler, onFailure: @escaping @MainActor (InputError) -> Void ) throws { self.handler = handler self.onFailure = onFailure guard readTrust() else { throw InputError.accessibilityRequired } guard let port = CGEvent.tapCreate( tap: .cgSessionEventTap, place: .headInsertEventTap, options: .defaultTap, eventsOfInterest: mask, callback: { _, type, event, context in guard let context else { return Unmanaged.passUnretained(event) } // This source is attached only to the main run loop; delivery never hops threads. let consumed = MainActor.assumeIsolated { let owner = Unmanaged<InputEventTap>.fromOpaque(context).takeUnretainedValue() return owner.receive(type, event) } return consumed ? nil : Unmanaged.passUnretained(event) }, userInfo: Unmanaged.passUnretained(self).toOpaque()) else { throw InputError.tapCreationFailed } self.port = port guard let source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, port, 0) else { CFMachPortInvalidate(port) self.port = nil throw InputError.tapRunLoopSourceFailed } self.source = source CFRunLoopAddSource(CFRunLoopGetMain(), source, .commonModes) CGEvent.tapEnable(tap: port, enable: true) guard CGEvent.tapIsEnabled(tap: port) else { stop() throw InputError.tapEnableFailed } permissionMonitor = InputPermissionMonitor( appCenter: .default, workspaceCenter: NSWorkspace.shared.notificationCenter, trustObserver: trustObserver, readTrust: readTrust, onRevoked: { [weak self] in guard let self else { return } self.stop() self.onFailure(.accessibilityRequired) }) }
isolated deinit { stop() }
func stop() { permissionMonitor?.stop() permissionMonitor = nil if let port { CGEvent.tapEnable(tap: port, enable: false) CFMachPortInvalidate(port) } if let source { CFRunLoopRemoveSource(CFRunLoopGetMain(), source, .commonModes) } source = nil port = nil }
static func dispatch( _ type: CGEventType, _ event: CGEvent, trace: any ParcelTraceSink = SignpostTraceSink.shared, handler: Handler ) -> Bool { let interval = trace.beginIfEnabled(.tapCallback, value: UInt64(type.rawValue), detail: event.timestamp) var consumed = false defer { trace.endIfStarted(.tapCallback, interval, value: consumed ? 1 : 0) } if event.timestamp != 0, trace.emits(.inputLatency) { let now = clock_gettime_nsec_np(CLOCK_UPTIME_RAW) if now >= event.timestamp { // Signposts start when emitted; the event clock preserves the queueing latency separately. trace.event(.inputLatency, value: event.timestamp, detail: now - event.timestamp) } } consumed = handler(type, event) return consumed }
func receive(_ type: CGEventType, _ event: CGEvent) -> Bool { Self.dispatch(type, event) { type, event in handle(type, event) } }
private func handle(_ type: CGEventType, _ event: CGEvent) -> Bool { guard port != nil, permissionMonitor?.isTrusted == true else { return false } if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput { guard permissionMonitor?.checkPermission() == true else { return false } _ = handler(type, event) if let port { CGEvent.tapEnable(tap: port, enable: true) if !CGEvent.tapIsEnabled(tap: port) { stop() onFailure(.tapEnableFailed) } } return false } return handler(type, event) }}
@MainActorfinal class InputPermissionMonitor { private(set) var isTrusted = true private let readTrust: @MainActor () -> Bool private let trustObserver: AccessibilityTrustObserver private let onRevoked: @MainActor () -> Void private var observers: [(NotificationCenter, any NSObjectProtocol)] = [] private var trustObservation: AccessibilityTrustObservation? private var isStopped = false
init( appCenter: NotificationCenter, workspaceCenter: NotificationCenter, trustObserver: AccessibilityTrustObserver = .shared, readTrust: @escaping @MainActor () -> Bool, onRevoked: @escaping @MainActor () -> Void ) { self.readTrust = readTrust self.trustObserver = trustObserver self.onRevoked = onRevoked observe(NSApplication.didBecomeActiveNotification, in: appCenter) observe(NSWorkspace.didActivateApplicationNotification, in: workspaceCenter) observe(NSWorkspace.didWakeNotification, in: workspaceCenter) observe(NSWorkspace.screensDidWakeNotification, in: workspaceCenter) trustObservation = trustObserver.observe { [weak self] in _ = self?.checkPermission() } }
isolated deinit { stop() }
@discardableResult func checkPermission() -> Bool { guard !isStopped else { return false } isTrusted = readTrust() guard isTrusted else { stop() onRevoked() return false } return true }
func stop() { guard !isStopped else { return } isStopped = true isTrusted = false trustObservation?.cancel() trustObservation = nil for (center, token) in observers { center.removeObserver(token) } observers.removeAll() }
private func observe(_ name: Notification.Name, in center: NotificationCenter) { let token = center.addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in MainActor.assumeIsolated { _ = self?.checkPermission() } } observers.append((center, token)) }}