Move RealtimeSuggestionIndicatorController to its own file

Author: intitni

Core/Sources/Service/GUI/RealtimeSuggestionIndicatorController.swift

@@ -0,0 +1,212 @@
+import AppKit
+import DisplayLink
+import QuartzCore
+import SwiftUI
+import XPCShared
+
+/// Present a tiny dot next to mouse cursor if real-time suggestion is enabled.
+final class RealtimeSuggestionIndicatorController {
+    class IndicatorContentViewModel: ObservableObject {
+        @Published var isPrefetching = false
+        private var prefetchTask: Task<Void, Error>?
+
+        @MainActor
+        func prefetch() {
+            prefetchTask?.cancel()
+            withAnimation(.easeIn(duration: 0.2)) {
+                isPrefetching = true
+            }
+            prefetchTask = Task {
+                try await Task.sleep(nanoseconds: 2 * 1_000_000_000)
+                withAnimation(.easeOut(duration: 0.2)) {
+                    isPrefetching = false
+                }
+            }
+        }
+    }
+
+    struct IndicatorContentView: View {
+        @ObservedObject var viewModel: IndicatorContentViewModel
+        @State var progress: CGFloat = 1
+        var opacityA: CGFloat { min(progress, 0.7) }
+        var opacityB: CGFloat { 1 - progress }
+        var scaleA: CGFloat { progress / 2 + 0.5 }
+        var scaleB: CGFloat { max(1 - progress, 0.01) }
+
+        var body: some View {
+            Circle()
+                .fill(Color.accentColor.opacity(opacityA))
+                .scaleEffect(.init(width: scaleA, height: scaleA))
+                .frame(width: 8, height: 8)
+                .background(
+                    Circle()
+                        .fill(Color.white.opacity(viewModel.isPrefetching ? opacityB : 0))
+                        .scaleEffect(.init(width: scaleB, height: scaleB))
+                        .frame(width: 8, height: 8)
+                )
+                .onAppear {
+                    Task {
+                        await Task.yield() // to avoid unwanted translations.
+                        withAnimation(.easeInOut(duration: 1).repeatForever(autoreverses: true)) {
+                            progress = 0
+                        }
+                    }
+                }
+        }
+    }
+
+    class UserDefaultsObserver: NSObject {
+        var onChange: (() -> Void)?
+
+        override func observeValue(
+            forKeyPath keyPath: String?,
+            of object: Any?,
+            change: [NSKeyValueChangeKey: Any]?,
+            context: UnsafeMutableRawPointer?
+        ) {
+            onChange?()
+        }
+    }
+
+    private let viewModel = IndicatorContentViewModel()
+    private var userDefaultsObserver = UserDefaultsObserver()
+    var isObserving = false {
+        didSet {
+            Task {
+                await updateIndicatorVisibility()
+            }
+        }
+    }
+
+    private var displayLinkTask: Task<Void, Never>?
+
+    @MainActor
+    lazy var window = {
+        let it = NSWindow(
+            contentRect: .zero,
+            styleMask: .borderless,
+            backing: .buffered,
+            defer: false
+        )
+        it.isReleasedWhenClosed = false
+        it.isOpaque = false
+        it.backgroundColor = .white.withAlphaComponent(0)
+        it.level = .statusBar
+        it.contentView = NSHostingView(
+            rootView: IndicatorContentView(viewModel: self.viewModel)
+                .frame(minWidth: 10, minHeight: 10)
+        )
+        return it
+    }()
+
+    init() {
+        Task {
+            let sequence = NSWorkspace.shared.notificationCenter
+                .notifications(named: NSWorkspace.didActivateApplicationNotification)
+            for await notification in sequence {
+                guard let app = notification
+                    .userInfo?[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication
+                else { continue }
+                guard app.bundleIdentifier == "com.apple.dt.Xcode" else { continue }
+                await updateIndicatorVisibility()
+            }
+        }
+
+        Task {
+            let sequence = NSWorkspace.shared.notificationCenter
+                .notifications(named: NSWorkspace.didDeactivateApplicationNotification)
+            for await notification in sequence {
+                guard let app = notification
+                    .userInfo?[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication
+                else { continue }
+                guard app.bundleIdentifier == "com.apple.dt.Xcode" else { continue }
+                await updateIndicatorVisibility()
+            }
+        }
+
+        Task {
+            userDefaultsObserver.onChange = { [weak self] in
+                Task { [weak self] in
+                    await self?.updateIndicatorVisibility()
+                }
+            }
+            UserDefaults.shared.addObserver(
+                userDefaultsObserver,
+                forKeyPath: SettingsKey.realtimeSuggestionToggle,
+                options: .new,
+                context: nil
+            )
+        }
+    }
+
+    private func updateIndicatorVisibility() async {
+        let isVisible = await {
+            let isOn = UserDefaults.shared.bool(forKey: SettingsKey.realtimeSuggestionToggle)
+            let isXcodeActive = await Environment.isXcodeActive()
+            return isOn && isXcodeActive && isObserving
+        }()
+
+        await { @MainActor in
+            guard window.isVisible != isVisible else { return }
+            if isVisible {
+                if displayLinkTask == nil {
+                    displayLinkTask = Task {
+                        for await _ in DisplayLink.createStream() {
+                            self.updateIndicatorLocation()
+                        }
+                    }
+                }
+            } else {
+                displayLinkTask?.cancel()
+                displayLinkTask = nil
+            }
+            window.setIsVisible(isVisible)
+        }()
+    }
+
+    private func updateIndicatorLocation() {
+        Task { @MainActor in
+            if !window.isVisible {
+                return
+            }
+
+            if let activeXcode = NSRunningApplication
+                .runningApplications(withBundleIdentifier: "com.apple.dt.Xcode")
+                .first(where: \.isActive)
+            {
+                let application = AXUIElementCreateApplication(activeXcode.processIdentifier)
+                if let focusElement: AXUIElement = try? application
+                    .copyValue(key: kAXFocusedUIElementAttribute),
+                    let selectedRange: AXValue = try? focusElement
+                    .copyValue(key: kAXSelectedTextRangeAttribute),
+                    let rect: AXValue = try? focusElement.copyParameterizedValue(
+                        key: kAXBoundsForRangeParameterizedAttribute,
+                        parameters: selectedRange
+                    )
+                {
+                    var frame: CGRect = .zero
+                    let found = AXValueGetValue(rect, .cgRect, &frame)
+                    let screen = NSScreen.screens.first
+                    if found, let screen {
+                        frame.origin = .init(
+                            x: frame.maxX + 2,
+                            y: screen.frame.height - frame.minY - 4
+                        )
+                        frame.size = .init(width: 10, height: 10)
+                        window.alphaValue = 1
+                        window.setFrame(frame, display: false, animate: true)
+                        return
+                    }
+                }
+            }
+
+            window.alphaValue = 0
+        }
+    }
+
+    func triggerPrefetchAnimation() {
+        Task { @MainActor in
+            viewModel.prefetch()
+        }
+    }
+}