Add accessibility api malfunction check

Author: intitni

Core/Sources/HostApp/DebugView.swift

@@ -21,6 +21,10 @@ final class DebugSettings: ObservableObject {
     var disableFileContentManipulationByCheatsheet
     @AppStorage(\.restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning)
     var restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning
+    @AppStorage(\.restartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer)
+    var restartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer
+    @AppStorage(\.toastForTheReasonWhyXcodeInspectorNeedsToBeRestarted)
+    var toastForTheReasonWhyXcodeInspectorNeedsToBeRestarted
     init() {}
 }
 
@@ -76,9 +80,30 @@ struct DebugSettingsView: View {
                     Toggle(isOn: $settings.disableFileContentManipulationByCheatsheet) {
                         Text("Disable file content manipulation by cheatsheet")
                     }
-                    
-                    Toggle(isOn: $settings.restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning) {
-                        Text("Re-activate Xcode Inspector when Accessibility API malfunctioning detected")
+
+                    Group {
+                        Toggle(
+                            isOn: $settings
+                                .restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning
+                        ) {
+                            Text(
+                                "Re-activate Xcode Inspector when Accessibility API malfunctioning detected"
+                            )
+                        }
+
+                        Toggle(
+                            isOn: $settings
+                                .restartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer
+                        ) {
+                            Text("Trigger malfunctioning detection only with events")
+                        }
+
+                        Toggle(
+                            isOn: $settings
+                                .toastForTheReasonWhyXcodeInspectorNeedsToBeRestarted
+                        ) {
+                            Text("Toast for the reason of re-activation of Xcode Inspector")
+                        }
                     }
 
                     Button("Reset migration version to 0") {

Core/Sources/Service/RealtimeSuggestionController.swift

@@ -71,12 +71,10 @@ public actor RealtimeSuggestionController {
 
                 switch notification.kind {
                 case .valueChanged:
-                    Logger.service.debug("Receive valueChanged from editor")
                     await cancelInFlightTasks()
                     await self.triggerPrefetchDebounced()
                     await self.notifyEditingFileChange(editor: sourceEditor.element)
                 case .selectedTextChanged:
-                    Logger.service.debug("Receive selectedTextChanged from editor")
                     guard let fileURL = XcodeInspector.shared.activeDocumentURL
                     else { break }
                     await PseudoCommandHandler().invalidateRealtimeSuggestionsIfNeeded(

Core/Sources/SuggestionWidget/FeatureReducers/WidgetFeature.swift

@@ -356,8 +356,6 @@ public struct WidgetFeature: ReducerProtocol {
                     await send(.panel(.switchToAnotherEditorAndUpdateContent))
 
                     for await notification in notifications {
-                        Logger.service.debug("Receive \(notification.kind) from Xcode")
-
                         try Task.checkCancellation()
 
                         // Hide the widgets before switching to another window/editor
@@ -402,11 +400,10 @@ public struct WidgetFeature: ReducerProtocol {
 
                 return .run { send in
                     if #available(macOS 13.0, *) {
-                        for await notification in merge(
+                        for await _ in merge(
                             selectionRangeChange.debounce(for: Duration.milliseconds(500)),
                             scroll
                         ) {
-                            Logger.service.debug("Receive \(notification.kind) from editor")
                             guard xcodeInspector.latestActiveXcode != nil else { return }
                             try Task.checkCancellation()
                             await send(.updateWindowLocation(animated: false))

Tool/Package.swift

@@ -168,6 +168,8 @@ let package = Package(
                 "SuggestionModel",
                 "AXNotificationStream",
                 "Logger",
+                "Toast",
+                "Preferences",
                 .product(name: "AsyncExtensions", package: "AsyncExtensions"),
                 .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
             ]

Tool/Sources/Preferences/Keys.swift

@@ -572,9 +572,23 @@ public extension UserDefaultPreferenceKeys {
 
     var restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning: FeatureFlag {
         .init(
-            defaultValue: false,
+            defaultValue: true,
             key: "FeatureFlag-RestartXcodeInspectorIfAccessibilityAPIIsMalfunctioning"
         )
     }
+    
+    var restartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer: FeatureFlag {
+        .init(
+            defaultValue: true,
+            key: "FeatureFlag-RestartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer"
+        )
+    }
+    
+    var toastForTheReasonWhyXcodeInspectorNeedsToBeRestarted: FeatureFlag {
+        .init(
+            defaultValue: false,
+            key: "FeatureFlag-ToastForTheReasonWhyXcodeInspectorNeedsToBeRestarted"
+        )
+    }
 }
 

Tool/Sources/XcodeInspector/Apps/XcodeAppInstanceInspector.swift

@@ -135,7 +135,7 @@ public final class XcodeAppInstanceInspector: AppInstanceInspector {
             observeAXNotifications()
 
             try await Task.sleep(nanoseconds: 3_000_000_000)
-            // Sometimes the focused window may not be rea?dy on app launch.
+            // Sometimes the focused window may not be ready on app launch.
             if !(focusedWindow is WorkspaceXcodeWindowInspector) {
                 observeFocusedWindow()
             }
@@ -200,7 +200,7 @@ public final class XcodeAppInstanceInspector: AppInstanceInspector {
     }
 
     @MainActor
-    private func observeAXNotifications() {
+    func observeAXNotifications() {
         longRunningTasks.forEach { $0.cancel() }
         longRunningTasks = []
 

Tool/Sources/XcodeInspector/XcodeInspector.swift

@@ -196,99 +196,42 @@ public final class XcodeInspector: ObservableObject {
                     group.addTask { [weak self] in
                         while true {
                             guard let self else { return }
-                            try await Task.sleep(nanoseconds: 10_000_000_000)
-                            Logger.service.debug("""
-                            Check for Accessibility Malfunctioning:
-                            Source Editor: \({
-                                if let editor = self.focusedEditor {
-                                    return editor.element.description
-                                }
-                                return "Not Found"
-                            }())
-                            Focused Element: \({
-                                if let element = self.focusedElement {
-                                    return "\(element.description), \(element.identifier), \(element.role)"
-                                }
-                                return "Not Found"
-                            }())
-
-                            Accessibility API Permission: \(
-                                AXIsProcessTrusted() ? "Granted" :
-                                    "Not Granted"
-                            )
-                            App: \(
-                                self.activeApplication?.runningApplication
-                                    .bundleIdentifier ?? ""
-                            )
-                            Focused Element: \({
-                                guard let element = self.activeApplication?.appElement
-                                    .focusedElement
-                                else {
-                                    return "Not Found"
-                                }
-                                return "\(element.description), \(element.identifier), \(element.role)"
-                            }())
-                            First Source Editor: \({
-                                guard let element = self.activeApplication?.appElement
-                                    .firstChild(where: \.isSourceEditor)
-                                else {
-                                    return "Not Found"
-                                }
-                                return "\(element.description), \(element.identifier), \(element.role)"
-                            }())
-                            """)
-
-                            if let editor = self.focusedEditor, !editor.element.isSourceEditor {
-                                NSWorkspace.shared.notificationCenter.post(
-                                    name: .accessibilityAPIMalfunctioning,
-                                    object: "Source Editor Element Corrupted"
-                                )
-                            } else if let element = self.activeXcode?.appElement.focusedElement {
-                                if element.description != self.focusedElement?.description ||
-                                    element.identifier != self.focusedElement?.role
-                                {
-                                    NSWorkspace.shared.notificationCenter.post(
-                                        name: .accessibilityAPIMalfunctioning,
-                                        object: "Element Inconsistency"
-                                    )
-                                }
+                            if UserDefaults.shared.value(
+                                for: \.restartXcodeInspectorIfAccessibilityAPIIsMalfunctioningNoTimer
+                            ) {
+                                return
                             }
-                        }
-                    }
-                    
-                    group.addTask {
-                        let sequence = DistributedNotificationCenter.default()
-                            .notifications(named: .init("com.apple.accessibility.api"))
-                        for await notification in sequence {
-                            if AXIsProcessTrusted() {
-                                Logger.service.debug("Accessibility API Permission Granted")
-                            } else {
-                                Logger.service.debug("Accessibility API Permission Not Granted")
-                                NSWorkspace.shared.notificationCenter.post(
-                                    name: .accessibilityAPIMalfunctioning,
-                                    object: "Accessibility API Permission Check"
-                                )
+
+                            try await Task.sleep(nanoseconds: 10_000_000_000)
+                            await MainActor.run {
+                                self.checkForAccessibilityMalfunction("Timer")
                             }
                         }
                     }
                 }
-                
-                
 
                 group.addTask { [weak self] in // malfunctioning
                     let sequence = NSWorkspace.shared.notificationCenter
                         .notifications(named: .accessibilityAPIMalfunctioning)
                     for await notification in sequence {
                         guard let self else { return }
                         let toast = self.toast
-                        toast.toast(
-                            content: "Accessibility API malfunction detected: \(notification.object as? String ?? "")",
-                            type: .warning
-                        )
+                        if UserDefaults.shared
+                            .value(for: \.toastForTheReasonWhyXcodeInspectorNeedsToBeRestarted)
+                        {
+                            toast.toast(
+                                content: """
+                                Accessibility API malfunction detected: \
+                                \(notification.object as? String ?? "").
+                                Resetting active Xcode.
+                                """,
+                                type: .warning
+                            )
+                        }
                         if let activeXcode {
-                            toast.toast(content: "Resetting active Xcode", type: .warning)
                             await MainActor.run {
                                 self.setActiveXcode(activeXcode)
+                                activeXcode.observeAXNotifications()
                             }
                         }
                     }
@@ -318,12 +261,10 @@ public final class XcodeInspector: ObservableObject {
         activeWorkspaceURL = xcode.workspaceURL
         focusedWindow = xcode.focusedWindow
 
-        let setFocusedElement = { [weak self] in
+        let setFocusedElement = { @MainActor [weak self] in
             guard let self else { return }
             focusedElement = xcode.appElement.focusedElement
-            Logger.service.debug("Update focused element.")
             if let editorElement = focusedElement, editorElement.isSourceEditor {
-                Logger.service.debug("Focused on source editor.")
                 focusedEditor = .init(
                     runningApplication: xcode.runningApplication,
                     element: editorElement
@@ -345,15 +286,35 @@ public final class XcodeInspector: ObservableObject {
         setFocusedElement()
         let focusedElementChanged = Task { @MainActor in
             for await notification in xcode.axNotifications {
-                guard notification.kind == .focusedUIElementChanged else { continue }
-                Logger.service.debug("Update focused element")
-                try Task.checkCancellation()
-                setFocusedElement()
+                if notification.kind == .focusedUIElementChanged {
+                    Logger.service.debug("Update focused element")
+                    try Task.checkCancellation()
+                    setFocusedElement()
+                }
             }
         }
 
         activeXcodeObservations.insert(focusedElementChanged)
 
+        if UserDefaults.shared
+            .value(for: \.restartXcodeInspectorIfAccessibilityAPIIsMalfunctioning)
+        {
+            let malfunctionCheck = Task { @MainActor [weak self] in
+                if #available(macOS 13.0, *) {
+                    let notifications = xcode.axNotifications.filter {
+                        $0.kind == .uiElementDestroyed
+                    }.debounce(for: .milliseconds(500))
+                    for await _ in notifications {
+                        guard let self else { return }
+                        try Task.checkCancellation()
+                        self.checkForAccessibilityMalfunction("Element Destroyed")
+                    }
+                }
+            }
+
+            activeXcodeObservations.insert(malfunctionCheck)
+        }
+
         xcode.$completionPanel.receive(on: DispatchQueue.main).sink { [weak self] element in
             self?.completionPanel = element
         }.store(in: &activeXcodeCancellable)
@@ -374,5 +335,57 @@ public final class XcodeInspector: ObservableObject {
             self?.focusedWindow = window
         }.store(in: &activeXcodeCancellable)
     }
+
+    @MainActor
+    private func checkForAccessibilityMalfunction(_ source: String) {
+        Logger.service.debug("""
+        Check for Accessibility Malfunctioning:
+        Source Editor: \({
+            if let editor = self.focusedEditor {
+                return editor.element.description
+            }
+            return "Not Found"
+        }())
+        Focused Element: \({
+            if let element = self.focusedElement {
+                return "\(element.description), \(element.identifier), \(element.role)"
+            }
+            return "Not Found"
+        }())
+
+        Accessibility API Permission: \(
+            AXIsProcessTrusted() ? "Granted" :
+                "Not Granted"
+        )
+        App: \(
+            activeApplication?.runningApplication
+                .bundleIdentifier ?? ""
+        )
+        Focused Element: \({
+            guard let element = self.activeApplication?.appElement
+                .focusedElement
+            else {
+                return "Not Found"
+            }
+            return "\(element.description), \(element.identifier), \(element.role)"
+        }())
+        """)
+
+        if let editor = focusedEditor, !editor.element.isSourceEditor {
+            NSWorkspace.shared.notificationCenter.post(
+                name: .accessibilityAPIMalfunctioning,
+                object: "Source Editor Element Corrupted: \(source)"
+            )
+        } else if let element = activeXcode?.appElement.focusedElement {
+            if element.description != focusedElement?.description ||
+                element.role != focusedElement?.role
+            {
+                NSWorkspace.shared.notificationCenter.post(
+                    name: .accessibilityAPIMalfunctioning,
+                    object: "Element Inconsistency:  \(source)"
+                )
+            }
+        }
+    }
 }