From 1316eb276911446831d24f553732fc55e65531d4 Mon Sep 17 00:00:00 2001 From: lwouis Date: Fri, 19 Sep 2025 21:37:24 +0200 Subject: [PATCH] fix: windows order was not updating correctly (closes #4754) (regression introduced in v7.28.0) --- src/api-wrappers/AXUIElement.swift | 23 ++++++--- src/logic/Application.swift | 59 ++++++++++++---------- src/logic/Applications.swift | 2 +- src/logic/Window.swift | 18 ++++--- src/logic/Windows.swift | 2 +- src/logic/events/AccessibilityEvents.swift | 8 +-- src/logic/events/DockEvents.swift | 2 +- 7 files changed, 68 insertions(+), 46 deletions(-) diff --git a/src/api-wrappers/AXUIElement.swift b/src/api-wrappers/AXUIElement.swift index 883314ed..c3342321 100644 --- a/src/api-wrappers/AXUIElement.swift +++ b/src/api-wrappers/AXUIElement.swift @@ -21,9 +21,19 @@ extension AXUIElement { AXUIElementSetMessagingTimeout(AXUIElementCreateSystemWide(), globalMessagingTimeoutInSeconds) } + enum AXCallType { + case subscribeToAppNotification + case subscribeToWindowNotification + case subscribeToDockNotification + case updateWindow + case updateAppWindows + case updateDockBadges + case axEventEntrypoint + } + /// if the window server is busy, it may not reply to AX calls. We retry right before the call times-out and returns a bogus value - static func retryAxCallUntilTimeout(file: String = #file, function: String = #function, line: Int = #line, context: String = "", after: DispatchTime? = nil, debounceType: DebounceType? = nil, pid: pid_t? = nil, wid: CGWindowID? = nil, retriesQueue: Bool = false, startTimeInNanoseconds: UInt64 = DispatchTime.now().uptimeNanoseconds, block: @escaping () throws -> Void) { - let closure = { retryAxCallUntilTimeout_(file: file, function: function, line: line, context: context, after: after, debounceType: debounceType, pid: pid, wid: wid, retriesQueue: retriesQueue, startTimeInNanoseconds: startTimeInNanoseconds, block: block) } + static func retryAxCallUntilTimeout(file: String = #file, function: String = #function, line: Int = #line, context: String = "", after: DispatchTime? = nil, debounceType: DebounceType? = nil, pid: pid_t? = nil, wid: CGWindowID? = nil, retriesQueue: Bool = false, startTimeInNanoseconds: UInt64 = DispatchTime.now().uptimeNanoseconds, callType: AXCallType, block: @escaping () throws -> Void) { + let closure = { retryAxCallUntilTimeout_(file: file, function: function, line: line, context: context, after: after, debounceType: debounceType, pid: pid, wid: wid, retriesQueue: retriesQueue, startTimeInNanoseconds: startTimeInNanoseconds, callType: callType, block: block) } let queue = retriesQueue ? BackgroundWork.axCallsRetriesQueue : BackgroundWork.axCallsFirstAttemptQueue if let after { queue!.addOperationAfter(deadline: after, block: closure) @@ -45,13 +55,14 @@ extension AXUIElement { } } - private static func retryAxCallUntilTimeout_(file: String, function: String, line: Int, context: String, after: DispatchTime?, debounceType: DebounceType?, pid: pid_t?, wid: CGWindowID?, retriesQueue: Bool, startTimeInNanoseconds: UInt64, block: @escaping () throws -> Void) { + private static func retryAxCallUntilTimeout_(file: String, function: String, line: Int, context: String, after: DispatchTime?, debounceType: DebounceType?, pid: pid_t?, wid: CGWindowID?, retriesQueue: Bool, startTimeInNanoseconds: UInt64, callType: AXCallType, block: @escaping () throws -> Void) { // attempt the AX call if (try? block()) != nil { return } - // do we already have ongoing retries for this pid? - if let pid { + // do we already have ongoing retries for this pid? The app is likely unresponsive + // if their are common updates, we avoid congestion by only retrying the latest update + if let pid, callType == .updateWindow || callType == .updateAppWindows { axCallsRetriesQueueUnresponsiveAppsMap.lock.lock() let time = axCallsRetriesQueueUnresponsiveAppsMap.map[pid] axCallsRetriesQueueUnresponsiveAppsMap.lock.unlock() @@ -81,7 +92,7 @@ extension AXUIElement { } // retry Logger.info(logFromContext(file, function, line, context)) - retryAxCallUntilTimeout(file: file, function: function, line: line, context: context, after: .now() + humanPerceptionDelay, debounceType: debounceType, pid: pid, wid: wid, retriesQueue: true, startTimeInNanoseconds: startTimeInNanoseconds, block: block) + retryAxCallUntilTimeout(file: file, function: function, line: line, context: context, after: .now() + humanPerceptionDelay, debounceType: debounceType, pid: pid, wid: wid, retriesQueue: true, startTimeInNanoseconds: startTimeInNanoseconds, callType: callType, block: block) } private static func logFromContext(_ file: String, _ function: String, _ line: Int, _ context: String) -> String { diff --git a/src/logic/Application.swift b/src/logic/Application.swift index d90ccbd3..edf9f42f 100644 --- a/src/logic/Application.swift +++ b/src/logic/Application.swift @@ -21,6 +21,15 @@ class Application: NSObject { var alreadyRequestedToQuit = false var debugId: String { "(pid:\(String(describing: pid)) \(bundleIdentifier ?? bundleURL?.absoluteString ?? executableURL?.absoluteString ?? localizedName ?? "nil"))" } + static let notifications = [ + kAXApplicationActivatedNotification, + kAXMainWindowChangedNotification, + kAXFocusedWindowChangedNotification, + kAXWindowCreatedNotification, + kAXApplicationHiddenNotification, + kAXApplicationShownNotification, + ] + init(_ runningApplication: NSRunningApplication) { self.runningApplication = runningApplication pid = runningApplication.processIdentifier @@ -61,15 +70,19 @@ class Application: NSObject { } func observeEventsIfEligible() { - if runningApplication.activationPolicy != .prohibited && axUiElement == nil { - axUiElement = AXUIElementCreateApplication(pid) - AXObserverCreate(pid, axObserverCallback, &axObserver) + if runningApplication.activationPolicy != .prohibited && !isReallyFinishedLaunching { + if axUiElement == nil { + axUiElement = AXUIElementCreateApplication(pid) + } + if axObserver == nil { + AXObserverCreate(pid, axObserverCallback, &axObserver) + } observeEvents() } } func manuallyUpdateWindows() { - AXUIElement.retryAxCallUntilTimeout(context: debugId, pid: pid) { [weak self] in + AXUIElement.retryAxCallUntilTimeout(context: debugId, pid: pid, callType: .updateAppWindows) { [weak self] in guard let self else { return } var atLeastOneActualWindow = false guard let axWindows = try self.axUiElement?.allWindows(self.pid) else { return } @@ -163,29 +176,23 @@ class Application: NSObject { private func observeEvents() { guard let axObserver else { return } - for notification in [ - kAXApplicationActivatedNotification, - kAXMainWindowChangedNotification, - kAXFocusedWindowChangedNotification, - kAXWindowCreatedNotification, - kAXApplicationHiddenNotification, - kAXApplicationShownNotification, - ] { - AXUIElement.retryAxCallUntilTimeout(context: debugId, pid: pid) { [weak self] in - guard let self else { return } - if try self.axUiElement!.subscribeToNotification(axObserver, notification) { - if notification == kAXApplicationActivatedNotification { - Logger.debug("Subscribed to app", self.debugId) + AXUIElement.retryAxCallUntilTimeout(context: debugId, pid: pid, callType: .subscribeToAppNotification) { [weak self] in + guard let self else { return } + if try self.axUiElement!.subscribeToNotification(axObserver, Application.notifications.first!) { + Logger.debug("Subscribed to app", self.debugId) + for notification in Application.notifications.dropFirst() { + AXUIElement.retryAxCallUntilTimeout(context: self.debugId, pid: self.pid, callType: .subscribeToAppNotification) { [weak self] in + try self?.axUiElement!.subscribeToNotification(axObserver, notification) } - DispatchQueue.main.async { [weak self] in - guard let self else { return } - // some apps have `isFinishedLaunching == true` but are actually not finished, and will return .cannotComplete - // we consider them ready when the first subscription succeeds - // windows opened before that point won't send a notification, so check those windows manually here - if !self.isReallyFinishedLaunching { - self.isReallyFinishedLaunching = true - self.manuallyUpdateWindows() - } + } + DispatchQueue.main.async { [weak self] in + guard let self else { return } + // some apps have `isFinishedLaunching == true` but are actually not finished, and will return .cannotComplete + // we consider them ready when the first subscription succeeds + // windows opened before that point won't send a notification, so check those windows manually here + if !self.isReallyFinishedLaunching { + self.isReallyFinishedLaunching = true + self.manuallyUpdateWindows() } } } diff --git a/src/logic/Applications.swift b/src/logic/Applications.swift index 226f1cce..196d2eb7 100644 --- a/src/logic/Applications.swift +++ b/src/logic/Applications.swift @@ -63,7 +63,7 @@ class Applications { static func refreshBadgesAsync() { if !App.app.appIsBeingUsed || Preferences.hideAppBadges { return } - AXUIElement.retryAxCallUntilTimeout { + AXUIElement.retryAxCallUntilTimeout(callType: .updateDockBadges) { if let dockPid = (list.first { $0.bundleIdentifier == "com.apple.dock" }?.pid), let axList = (try AXUIElementCreateApplication(dockPid).children()?.first { try $0.role() == kAXListRole }), let axAppDockItem = (try axList.children()?.filter { try $0.subrole() == kAXApplicationDockItemSubrole && ($0.appIsRunning() ?? false) }) { diff --git a/src/logic/Window.swift b/src/logic/Window.swift index e253ade0..630abac9 100644 --- a/src/logic/Window.swift +++ b/src/logic/Window.swift @@ -48,6 +48,9 @@ class Window { Window.globalCreationCounter += 1 creationOrder = Window.globalCreationCounter application.removeWindowslessAppWindow() + // the app may have timed out trying to subscribe to app notifications + // It may be responsive now since it has a window; we attempt again + application.observeEventsIfEligible() checkIfFocused(application, wid) Logger.debug(debugId) observeEvents() @@ -68,7 +71,7 @@ class Window { /// some apps will not trigger AXApplicationActivated, where we usually update application.focusedWindow /// workaround: we check and possibly do it here func checkIfFocused(_ application: Application, _ wid: CGWindowID) { - AXUIElement.retryAxCallUntilTimeout(context: debugId, pid: application.pid) { + AXUIElement.retryAxCallUntilTimeout(context: debugId, pid: application.pid, callType: .updateWindow) { let focusedWid = try application.axUiElement?.focusedWindow()?.cgWindowId() if wid == focusedWid { application.focusedWindow = self @@ -85,12 +88,13 @@ class Window { private func observeEvents() { AXObserverCreate(application.pid, axObserverCallback, &axObserver) guard let axObserver else { return } - for notification in Window.notifications { - AXUIElement.retryAxCallUntilTimeout(context: debugId, pid: application.pid) { [weak self] in - guard let self else { return } - if try self.axUiElement!.subscribeToNotification(axObserver, notification) { - if notification == kAXUIElementDestroyedNotification { - Logger.debug("Subscribed to window", self.debugId) + AXUIElement.retryAxCallUntilTimeout(context: debugId, pid: application.pid, callType: .subscribeToWindowNotification) { [weak self] in + guard let self else { return } + if try self.axUiElement!.subscribeToNotification(axObserver, Window.notifications.first!) { + Logger.debug("Subscribed to window", self.debugId) + for notification in Window.notifications.dropFirst() { + AXUIElement.retryAxCallUntilTimeout(context: self.debugId, pid: self.application.pid, callType: .subscribeToWindowNotification) { [weak self] in + try self?.axUiElement!.subscribeToNotification(axObserver, notification) } } } diff --git a/src/logic/Windows.swift b/src/logic/Windows.swift index 1e10afa5..a8eb4c2f 100644 --- a/src/logic/Windows.swift +++ b/src/logic/Windows.swift @@ -74,7 +74,7 @@ class Windows { static func updateIsFullscreenOnCurrentSpace() { let windowsOnCurrentSpace = Windows.list.filter { !$0.isWindowlessApp } for window in windowsOnCurrentSpace { - AXUIElement.retryAxCallUntilTimeout(context: window.debugId, after: .now() + humanPerceptionDelay) { [weak window] in + AXUIElement.retryAxCallUntilTimeout(context: window.debugId, after: .now() + humanPerceptionDelay, callType: .updateWindow) { [weak window] in guard let window else { return } try updateWindowSizeAndPositionAndFullscreen(window.axUiElement!, window.cgWindowId!, window) } diff --git a/src/logic/events/AccessibilityEvents.swift b/src/logic/events/AccessibilityEvents.swift index ae5577f4..e42756b0 100644 --- a/src/logic/events/AccessibilityEvents.swift +++ b/src/logic/events/AccessibilityEvents.swift @@ -5,7 +5,7 @@ import ApplicationServices.HIServices.AXNotificationConstants let axObserverCallback: AXObserverCallback = { _, element, notificationName, _ in let type = notificationName as String Logger.debug(type) - AXUIElement.retryAxCallUntilTimeout { try handleEvent(type, element) } + AXUIElement.retryAxCallUntilTimeout(callType: .axEventEntrypoint) { try handleEvent(type, element) } } fileprivate func handleEvent(_ type: String, _ element: AXUIElement) throws { @@ -100,7 +100,7 @@ fileprivate func focusedWindowChanged(_ element: AXUIElement, _ pid: pid_t) thro if let windows = Windows.updateLastFocus(element, wid) { App.app.refreshOpenUi(windows, .refreshUiAfterExternalEvent) } else { - AXUIElement.retryAxCallUntilTimeout(context: "wid:\(wid) pid:\(pid)", pid: pid) { + AXUIElement.retryAxCallUntilTimeout(context: "wid:\(wid) pid:\(pid)", pid: pid, callType: .updateWindow) { if let (title, role, subrole, isMinimized, isFullscreen) = try element.windowAttributes() { let position = try element.position() let size = try element.size() @@ -156,7 +156,7 @@ fileprivate func windowMiniaturizedOrDeminiaturized(_ element: AXUIElement, _ ty fileprivate func windowTitleChanged(_ element: AXUIElement, _ pid: pid_t) throws { let wid = try element.cgWindowId() - AXUIElement.retryAxCallUntilTimeout(context: "\(wid)", debounceType: .windowTitleChanged, pid: pid, wid: wid) { + AXUIElement.retryAxCallUntilTimeout(context: "\(wid)", debounceType: .windowTitleChanged, pid: pid, wid: wid, callType: .updateWindow) { if let (title, _, _, isMinimized, isFullscreen) = try element.windowAttributes() { DispatchQueue.main.async { if let window = (Windows.list.first { $0.isEqualRobust(element, wid) }), title != window.title { @@ -172,7 +172,7 @@ fileprivate func windowTitleChanged(_ element: AXUIElement, _ pid: pid_t) throws fileprivate func windowResizedOrMoved(_ element: AXUIElement, _ pid: pid_t) throws { let wid = try element.cgWindowId() - AXUIElement.retryAxCallUntilTimeout(context: "\(wid)", debounceType: .windowResizedOrMoved, pid: pid, wid: wid) { + AXUIElement.retryAxCallUntilTimeout(context: "\(wid)", debounceType: .windowResizedOrMoved, pid: pid, wid: wid, callType: .updateWindow) { try updateWindowSizeAndPositionAndFullscreen(element, wid, nil) } } diff --git a/src/logic/events/DockEvents.swift b/src/logic/events/DockEvents.swift index 86b84a64..f4eac7c0 100644 --- a/src/logic/events/DockEvents.swift +++ b/src/logic/events/DockEvents.swift @@ -10,7 +10,7 @@ class DockEvents { AXObserverCreate(dockPid, handleEvent, &axObserver) // are we sure we always get a non-nil axObserver? for notification in MissionControlState.allCases { - AXUIElement.retryAxCallUntilTimeout { + AXUIElement.retryAxCallUntilTimeout(callType: .subscribeToDockNotification) { if try axUiElement!.subscribeToNotification(axObserver!, notification.rawValue, nil) { if notification == MissionControlState.showDesktop { Logger.debug("Subscribed to Dock")