import AppKit
|
import QuartzCore
|
import AlignerCore
|
|
@MainActor
|
final class QuickSwitchSessionController {
|
static let overlayTitle = "Aligner Quick Switch"
|
|
private let view = QuickSwitchRootView()
|
private let snapshotLoader: any QuickSwitchSnapshotLoading
|
private let screenshotProvider: any ScreenshotProviderProtocol
|
private let windowActivationService: any WindowActivationServiceProtocol
|
private let systemCriticalWindowDetector: any SystemCriticalWindowDetecting
|
private let disableScreenshotRefresh: Bool
|
private let debugOverlayWidth: CGFloat?
|
private let debugKeySequence: [String]
|
private let debugMouseSequence: [String]
|
private let debugSystemCriticalAfter: TimeInterval?
|
private lazy var coordinator = WindowCoordinator(
|
contentView: view,
|
title: Self.overlayTitle,
|
debugOverlayWidth: debugOverlayWidth
|
)
|
private var currentSnapshot: QuickSwitchSnapshot?
|
private var currentViewModel: QuickSwitchViewModel?
|
private var lastSnapshotError: String?
|
private var snapshotTask: Task<Void, Never>?
|
private var screenshotTask: Task<Void, Never>?
|
private var systemCriticalMonitorTimer: Timer?
|
private var debugSystemCriticalTimer: Timer?
|
private var screenshotSession = ScreenshotCaptureSession()
|
private var sessionGeneration = 0
|
private var showStartTime: CFTimeInterval?
|
private var overlayOpenElapsedMilliseconds: Double?
|
private var snapshotStartElapsedMilliseconds: Double?
|
private var snapshotDurationMilliseconds: Double?
|
private var snapshotRanOnMainThread: Bool?
|
private var lastCommittedSelection: QuickSwitchSelection?
|
private var lastCommitSource: QuickSwitchCommitSource?
|
private var lastActivationWindowID: UInt32?
|
private var lastActivationResult: WindowActivationResult?
|
private var lastActivationError: String?
|
private var lastDismissReason: DismissReason?
|
private var lastSystemCriticalAction: String?
|
private var lastSystemCriticalMonitorSource: String?
|
private var lastSystemCriticalWindowCount = 0
|
private var lastSystemCriticalWindowTitleHashes: [String] = []
|
private var lastSystemCriticalWindowTitleLengths: [Int] = []
|
private var lastSystemCriticalWindowTitleIsEmpty: [Bool] = []
|
private var lastSystemCriticalWindowOwners: [String] = []
|
private var lastSystemCriticalOverlayLevel: CGWindowLevel?
|
private var systemCriticalDetectionCount = 0
|
private var lifecycleTargetCycles = 0
|
private var lifecycleCompletedCycles = 0
|
private var lifecycleMaximumOverlayWindows = 0
|
private var lifecycleMaximumVisibleOverlayWindows = 0
|
private var lifecycleResidualOverlayWindows = 0
|
private var lifecycleResidualVisibleOverlayWindows = 0
|
var onSnapshotUpdated: (() -> Void)?
|
|
init(
|
snapshotLoader: any QuickSwitchSnapshotLoading = LiveQuickSwitchSnapshotLoader(),
|
screenshotProvider: any ScreenshotProviderProtocol = ScreenCaptureKitScreenshotProvider(
|
debugLogger: StderrScreenshotDebugLogger()
|
),
|
windowActivationService: any WindowActivationServiceProtocol = CGWindowAXWindowService(
|
spaceIDsByWindowIDProvider: { _ in [:] }
|
),
|
systemCriticalWindowDetector: any SystemCriticalWindowDetecting = CGWindowSystemCriticalWindowDetector(),
|
disableScreenshotRefresh: Bool = false,
|
debugHoveredAppGroupIndex: Int? = nil,
|
debugOverlayWidth: CGFloat? = nil,
|
debugKeySequence: [String] = [],
|
debugMouseSequence: [String] = [],
|
debugSystemCriticalAfter: TimeInterval? = nil
|
) {
|
self.snapshotLoader = snapshotLoader
|
self.screenshotProvider = screenshotProvider
|
self.windowActivationService = windowActivationService
|
self.systemCriticalWindowDetector = systemCriticalWindowDetector
|
self.disableScreenshotRefresh = disableScreenshotRefresh
|
self.debugOverlayWidth = debugOverlayWidth
|
self.debugKeySequence = debugKeySequence
|
self.debugMouseSequence = debugMouseSequence
|
self.debugSystemCriticalAfter = debugSystemCriticalAfter
|
view.setDebugHoveredAppGroupIndex(debugHoveredAppGroupIndex)
|
}
|
|
var isVisible: Bool {
|
coordinator.isQuickSwitchVisible
|
}
|
|
func show() {
|
sessionGeneration += 1
|
let generation = sessionGeneration
|
DevelopmentDiagnostics.log("quickSwitch.session.show.start", [
|
"generation": generation,
|
"wasVisible": isVisible
|
])
|
showStartTime = CACurrentMediaTime()
|
overlayOpenElapsedMilliseconds = nil
|
snapshotStartElapsedMilliseconds = nil
|
snapshotDurationMilliseconds = nil
|
snapshotRanOnMainThread = nil
|
lastCommittedSelection = nil
|
lastCommitSource = nil
|
lastActivationWindowID = nil
|
lastActivationResult = nil
|
lastActivationError = nil
|
lastDismissReason = nil
|
lastSystemCriticalAction = nil
|
lastSystemCriticalMonitorSource = nil
|
lastSystemCriticalWindowCount = 0
|
lastSystemCriticalWindowTitleHashes = []
|
lastSystemCriticalWindowTitleLengths = []
|
lastSystemCriticalWindowTitleIsEmpty = []
|
lastSystemCriticalWindowOwners = []
|
lastSystemCriticalOverlayLevel = nil
|
systemCriticalDetectionCount = 0
|
invalidateSystemCriticalMonitoring()
|
screenshotTask?.cancel()
|
screenshotTask = nil
|
screenshotSession = ScreenshotCaptureSession()
|
clearSnapshotState()
|
view.onEscape = { [weak self] in
|
self?.hide(reason: .escape)
|
}
|
view.onCommitSelection = { [weak self] selection, source in
|
self?.commitSelection(selection, source: source)
|
}
|
view.apply(viewModel: nil)
|
view.beginPerformanceFirstFrameMeasurement()
|
coordinator.openQuickSwitch()
|
coordinator.promoteForTextInput()
|
view.window?.makeFirstResponder(view)
|
overlayOpenElapsedMilliseconds = elapsedSinceShowStart()
|
updateLifecycleWindowHighWaterMark()
|
startSystemCriticalMonitoring()
|
scheduleSnapshotRefresh(for: generation)
|
DevelopmentDiagnostics.log("quickSwitch.session.show.end", [
|
"generation": generation,
|
"overlayOpenElapsedMilliseconds": overlayOpenElapsedMilliseconds,
|
"overlayLevel": coordinator.currentLevel,
|
"windowVisible": view.window?.isVisible ?? false
|
])
|
}
|
|
func hide(reason: DismissReason = .userClosed) {
|
DevelopmentDiagnostics.log("quickSwitch.session.hide.start", [
|
"reason": Self.dismissReasonString(reason),
|
"wasVisible": isVisible,
|
"generation": sessionGeneration
|
])
|
sessionGeneration += 1
|
lastDismissReason = reason
|
snapshotTask?.cancel()
|
snapshotTask = nil
|
screenshotTask?.cancel()
|
screenshotTask = nil
|
invalidateSystemCriticalMonitoring()
|
coordinator.closeQuickSwitch(reason: reason)
|
lifecycleResidualOverlayWindows = overlayWindowCount()
|
lifecycleResidualVisibleOverlayWindows = visibleOverlayWindowCount()
|
updateLifecycleWindowHighWaterMark()
|
DevelopmentDiagnostics.log("quickSwitch.session.hide.end", [
|
"reason": Self.dismissReasonString(reason),
|
"generation": sessionGeneration,
|
"residualOverlayWindows": lifecycleResidualOverlayWindows,
|
"residualVisibleOverlayWindows": lifecycleResidualVisibleOverlayWindows
|
])
|
}
|
|
func refocus() {
|
DevelopmentDiagnostics.log("quickSwitch.session.refocus")
|
coordinator.promoteForTextInput()
|
view.window?.makeFirstResponder(view)
|
}
|
|
func retriggerFromShortcut() {
|
DevelopmentDiagnostics.log("quickSwitch.session.retriggerFromShortcut")
|
show()
|
}
|
|
func reportDictionary() -> [String: Any] {
|
let spaceCount = currentViewModel?.spaceCount ?? 0
|
let appCount = currentViewModel?.appShelf.count ?? 0
|
let columnCount = currentViewModel?.waterfallColumns.count ?? 0
|
let windowCount = currentViewModel?.windowCount ?? 0
|
|
return [
|
"snapshotLoaded": currentSnapshot != nil,
|
"snapshotError": lastSnapshotError ?? NSNull(),
|
"quickSwitchVisible": isVisible,
|
"diagnosticLogLocationKind": DevelopmentDiagnostics.pathSummary(DevelopmentDiagnostics.logPath)["locationKind"] ?? "unknown",
|
"diagnosticLogBasename": DevelopmentDiagnostics.pathSummary(DevelopmentDiagnostics.logPath)["basename"] ?? "aligner-dev.log",
|
"displayCount": currentViewModel?.displays.count ?? 0,
|
"spaceCount": spaceCount,
|
"appCount": appCount,
|
"columnCount": columnCount,
|
"windowCount": windowCount,
|
"initialSelectionWindowID": currentViewModel?.initialSelection?.windowID ?? NSNull(),
|
"appShelfNames": currentViewModel?.appShelf.map(\.app.name) ?? [],
|
"spaceLabels": currentViewModel?.displays.flatMap { $0.spaces.map(\.label) } ?? [],
|
"overlayOpenElapsedMilliseconds": overlayOpenElapsedMilliseconds ?? NSNull(),
|
"snapshotStartElapsedMilliseconds": snapshotStartElapsedMilliseconds ?? NSNull(),
|
"snapshotDurationMilliseconds": snapshotDurationMilliseconds ?? NSNull(),
|
"snapshotRanOnMainThread": snapshotRanOnMainThread ?? NSNull(),
|
"lastCommittedAppGroupIndex": lastCommittedSelection?.appGroupIndex ?? NSNull(),
|
"lastCommittedWindowIndex": lastCommittedSelection?.windowIndex ?? NSNull(),
|
"lastCommittedWindowID": lastCommittedSelection?.windowID ?? NSNull(),
|
"lastCommitSource": lastCommitSource?.rawValue ?? NSNull(),
|
"lastActivationWindowID": lastActivationWindowID ?? NSNull(),
|
"lastActivationResult": lastActivationResult.map(Self.activationResultString) ?? NSNull(),
|
"lastActivationError": lastActivationError ?? NSNull(),
|
"lastDismissReason": lastDismissReason.map(Self.dismissReasonString) ?? NSNull(),
|
"overlayLevel": Int(coordinator.currentLevel),
|
"overlayMainMenuLevel": Int(CGWindowLevelForKey(.mainMenuWindow)),
|
"overlayBelowRescueSystemWindows": coordinator.currentLevel < CGWindowLevelForKey(.mainMenuWindow),
|
"lastSystemCriticalAction": lastSystemCriticalAction ?? NSNull(),
|
"lastSystemCriticalMonitorSource": lastSystemCriticalMonitorSource ?? NSNull(),
|
"lastSystemCriticalWindowCount": lastSystemCriticalWindowCount,
|
"lastSystemCriticalWindowTitleHashes": lastSystemCriticalWindowTitleHashes,
|
"lastSystemCriticalWindowTitleLengths": lastSystemCriticalWindowTitleLengths,
|
"lastSystemCriticalWindowTitleIsEmpty": lastSystemCriticalWindowTitleIsEmpty,
|
"lastSystemCriticalWindowOwners": lastSystemCriticalWindowOwners,
|
"lastSystemCriticalOverlayLevel": lastSystemCriticalOverlayLevel.map { Int($0) } ?? NSNull(),
|
"systemCriticalDetectionCount": systemCriticalDetectionCount,
|
"lifecycleTargetCycles": lifecycleTargetCycles,
|
"lifecycleCompletedCycles": lifecycleCompletedCycles,
|
"lifecycleMaximumOverlayWindows": lifecycleMaximumOverlayWindows,
|
"lifecycleMaximumVisibleOverlayWindows": lifecycleMaximumVisibleOverlayWindows,
|
"lifecycleResidualOverlayWindows": lifecycleResidualOverlayWindows,
|
"lifecycleResidualVisibleOverlayWindows": lifecycleResidualVisibleOverlayWindows,
|
"lifecycleGatePassed": lifecycleTargetCycles == 0
|
|| (
|
lifecycleCompletedCycles == lifecycleTargetCycles
|
&& lifecycleMaximumOverlayWindows <= 1
|
&& lifecycleMaximumVisibleOverlayWindows <= 1
|
&& lifecycleResidualOverlayWindows <= 1
|
&& lifecycleResidualVisibleOverlayWindows == 0
|
),
|
"rootView": view.reportDictionary()
|
]
|
}
|
|
func prepareLifecycleRun(targetCycles: Int) {
|
lifecycleTargetCycles = max(0, targetCycles)
|
lifecycleCompletedCycles = 0
|
lifecycleMaximumOverlayWindows = 0
|
lifecycleMaximumVisibleOverlayWindows = 0
|
lifecycleResidualOverlayWindows = 0
|
lifecycleResidualVisibleOverlayWindows = 0
|
view.resetPerformanceMeasurements()
|
}
|
|
func markLifecycleCycleCompleted() {
|
lifecycleCompletedCycles += 1
|
updateLifecycleWindowHighWaterMark()
|
}
|
|
func finalizeLifecycleRun() {
|
lifecycleResidualOverlayWindows = overlayWindowCount()
|
lifecycleResidualVisibleOverlayWindows = visibleOverlayWindowCount()
|
updateLifecycleWindowHighWaterMark()
|
}
|
|
private func scheduleSnapshotRefresh(for generation: Int) {
|
DevelopmentDiagnostics.log("quickSwitch.snapshot.schedule", [
|
"generation": generation,
|
"visible": isVisible
|
])
|
snapshotTask?.cancel()
|
let loader = snapshotLoader
|
let showStartTime = showStartTime
|
snapshotTask = Task { [weak self] in
|
guard let self, !Task.isCancelled else { return }
|
|
let loadTask = Task.detached(priority: .userInitiated) {
|
SnapshotLoadResult.load(using: loader, showStartTime: showStartTime)
|
}
|
let result = await withTaskCancellationHandler {
|
await loadTask.value
|
} onCancel: {
|
loadTask.cancel()
|
}
|
|
guard !Task.isCancelled else { return }
|
self.applySnapshotResult(result, generation: generation)
|
}
|
}
|
|
private func clearSnapshotState() {
|
currentSnapshot = nil
|
currentViewModel = nil
|
lastSnapshotError = nil
|
}
|
|
private func startSystemCriticalMonitoring() {
|
invalidateSystemCriticalMonitoring()
|
checkForSystemCriticalWindows(source: "initial")
|
guard isVisible else { return }
|
|
let monitorTimer = Timer(timeInterval: 0.20, repeats: true) { [weak self] _ in
|
Task { @MainActor [weak self] in
|
self?.checkForSystemCriticalWindows(source: "poll")
|
}
|
}
|
RunLoop.main.add(monitorTimer, forMode: .common)
|
systemCriticalMonitorTimer = monitorTimer
|
|
if let debugSystemCriticalAfter {
|
let debugTimer = Timer(timeInterval: debugSystemCriticalAfter, repeats: false) { [weak self] _ in
|
Task { @MainActor [weak self] in
|
self?.handleSystemCriticalWindows(
|
[
|
SystemCriticalWindowRecord(
|
ownerName: "SecurityAgent",
|
title: "Debug Security Confirmation",
|
processIdentifier: 0,
|
layer: Int(CGWindowLevelForKey(.mainMenuWindow)),
|
bounds: .zero
|
)
|
],
|
source: "debug"
|
)
|
}
|
}
|
RunLoop.main.add(debugTimer, forMode: .common)
|
debugSystemCriticalTimer = debugTimer
|
}
|
}
|
|
private func invalidateSystemCriticalMonitoring() {
|
systemCriticalMonitorTimer?.invalidate()
|
systemCriticalMonitorTimer = nil
|
debugSystemCriticalTimer?.invalidate()
|
debugSystemCriticalTimer = nil
|
}
|
|
private func checkForSystemCriticalWindows(source: String) {
|
guard isVisible else { return }
|
|
let criticalWindows = systemCriticalWindowDetector.visibleSystemCriticalWindows()
|
guard !criticalWindows.isEmpty else { return }
|
|
handleSystemCriticalWindows(criticalWindows, source: source)
|
}
|
|
private func handleSystemCriticalWindows(_ windows: [SystemCriticalWindowRecord], source: String) {
|
guard isVisible, !windows.isEmpty else { return }
|
|
systemCriticalDetectionCount += 1
|
lastSystemCriticalAction = "closeOverlay"
|
lastSystemCriticalMonitorSource = source
|
lastSystemCriticalWindowCount = windows.count
|
lastSystemCriticalWindowTitleHashes = windows.map { DevelopmentDiagnostics.stableFingerprint($0.title) }
|
lastSystemCriticalWindowTitleLengths = windows.map { $0.title.count }
|
lastSystemCriticalWindowTitleIsEmpty = windows.map { $0.title.isEmpty }
|
lastSystemCriticalWindowOwners = windows.map(\.ownerName)
|
lastSystemCriticalOverlayLevel = coordinator.currentLevel
|
hide(reason: .systemCriticalWindow)
|
onSnapshotUpdated?()
|
}
|
|
private func commitSelection(_ selection: QuickSwitchSelection, source: QuickSwitchCommitSource) {
|
DevelopmentDiagnostics.log("quickSwitch.activation.commit.start", [
|
"source": source.rawValue,
|
"appGroupIndex": selection.appGroupIndex,
|
"windowIndex": selection.windowIndex,
|
"windowID": selection.windowID
|
])
|
lastCommittedSelection = selection
|
lastCommitSource = source
|
lastActivationWindowID = selection.windowID
|
lastActivationError = nil
|
|
guard let window = window(for: selection) else {
|
lastActivationResult = .windowNotFound
|
DevelopmentDiagnostics.log("quickSwitch.activation.commit.windowNotFound", [
|
"source": source.rawValue,
|
"appGroupIndex": selection.appGroupIndex,
|
"windowIndex": selection.windowIndex,
|
"windowID": selection.windowID
|
])
|
onSnapshotUpdated?()
|
return
|
}
|
|
DevelopmentDiagnostics.log("quickSwitch.activation.commit.hideBeforeActivation", [
|
"source": source.rawValue,
|
"windowID": window.id
|
])
|
hide(reason: .userClosed)
|
|
do {
|
lastActivationResult = try windowActivationService.activate(window: window)
|
DevelopmentDiagnostics.log("quickSwitch.activation.commit.result", [
|
"source": source.rawValue,
|
"windowID": window.id,
|
"appName": window.app.name,
|
"appPID": window.app.processIdentifier,
|
"titleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
|
"titleLength": window.title.count,
|
"titleIsEmpty": window.title.isEmpty,
|
"result": lastActivationResult.map(Self.activationResultString)
|
])
|
} catch {
|
let errorSummary = DevelopmentDiagnostics.errorSummaryString(error)
|
lastActivationResult = .failed(errorSummary)
|
lastActivationError = errorSummary
|
var fields: [String: CustomStringConvertible?] = [
|
"source": source.rawValue,
|
"windowID": window.id,
|
"appName": window.app.name,
|
"titleHash": DevelopmentDiagnostics.stableFingerprint(window.title),
|
"titleLength": window.title.count,
|
"titleIsEmpty": window.title.isEmpty
|
]
|
DevelopmentDiagnostics.errorSummaryFields(error).forEach { fields[$0.key] = $0.value }
|
DevelopmentDiagnostics.log("quickSwitch.activation.commit.error", fields)
|
}
|
|
if shouldCloseAfterActivation(lastActivationResult) {
|
DevelopmentDiagnostics.log("quickSwitch.activation.commit.closeAfterActivation", [
|
"result": lastActivationResult.map(Self.activationResultString)
|
])
|
} else {
|
DevelopmentDiagnostics.log("quickSwitch.activation.commit.refreshAfterActivation", [
|
"result": lastActivationResult.map(Self.activationResultString)
|
])
|
}
|
onSnapshotUpdated?()
|
}
|
|
private func shouldCloseAfterActivation(_ result: WindowActivationResult?) -> Bool {
|
switch result {
|
case .activated, .restored, .appActivatedOnly:
|
return true
|
case .windowNotFound, .unsupported, .activationFailed, .failed, nil:
|
return false
|
}
|
}
|
|
private func window(for selection: QuickSwitchSelection) -> AlignerWindow? {
|
currentViewModel?
|
.waterfallColumns
|
.flatMap(\.windows)
|
.first { card in
|
card.appGroupIndex == selection.appGroupIndex
|
&& card.windowIndex == selection.windowIndex
|
&& card.window.id == selection.windowID
|
}?
|
.window
|
}
|
|
private func applySnapshotResult(_ result: SnapshotLoadResult, generation: Int) {
|
guard generation == sessionGeneration, isVisible else {
|
DevelopmentDiagnostics.log("quickSwitch.snapshot.drop", [
|
"resultGeneration": generation,
|
"currentGeneration": sessionGeneration,
|
"visible": isVisible
|
])
|
return
|
}
|
|
switch result {
|
case .success(let success):
|
currentSnapshot = success.snapshot
|
currentViewModel = success.viewModel
|
lastSnapshotError = nil
|
snapshotStartElapsedMilliseconds = success.timing.startElapsedMilliseconds
|
snapshotDurationMilliseconds = success.timing.durationMilliseconds
|
snapshotRanOnMainThread = success.timing.ranOnMainThread
|
view.apply(viewModel: success.viewModel)
|
view.recordPerformanceFirstFrameIfNeeded()
|
view.performDebugKeyboardCommands(debugKeySequence)
|
view.performDebugMouseCommands(debugMouseSequence)
|
DevelopmentDiagnostics.log("quickSwitch.snapshot.success", [
|
"generation": generation,
|
"displayCount": success.viewModel.displays.count,
|
"spaceCount": success.viewModel.spaceCount,
|
"appCount": success.viewModel.appShelf.count,
|
"windowCount": success.viewModel.windowCount,
|
"durationMilliseconds": success.timing.durationMilliseconds,
|
"ranOnMainThread": success.timing.ranOnMainThread,
|
"initialSelectionWindowID": success.viewModel.initialSelection?.windowID
|
])
|
guard isVisible else { return }
|
if disableScreenshotRefresh {
|
view.markScreenshotsNotRequested(for: success.viewModel, reason: "disabledByLaunchOption")
|
screenshotTask?.cancel()
|
screenshotTask = nil
|
DevelopmentDiagnostics.log("quickSwitch.screenshot.disabledByLaunchOption", [
|
"generation": generation
|
])
|
} else {
|
scheduleScreenshotRefresh(for: success.viewModel, generation: generation)
|
}
|
case .failure(let failure):
|
currentSnapshot = nil
|
currentViewModel = nil
|
lastSnapshotError = failure.message
|
snapshotStartElapsedMilliseconds = failure.timing.startElapsedMilliseconds
|
snapshotDurationMilliseconds = failure.timing.durationMilliseconds
|
snapshotRanOnMainThread = failure.timing.ranOnMainThread
|
view.apply(viewModel: nil)
|
screenshotTask?.cancel()
|
screenshotTask = nil
|
DevelopmentDiagnostics.log("quickSwitch.snapshot.failure", [
|
"generation": generation,
|
"message": failure.message,
|
"durationMilliseconds": failure.timing.durationMilliseconds,
|
"ranOnMainThread": failure.timing.ranOnMainThread
|
])
|
}
|
|
onSnapshotUpdated?()
|
}
|
|
private func scheduleScreenshotRefresh(
|
for viewModel: QuickSwitchViewModel,
|
generation: Int
|
) {
|
screenshotTask?.cancel()
|
let provider = screenshotProvider
|
let session = screenshotSession
|
let allWindows = viewModel.waterfallColumns.flatMap { column in
|
column.windows.map(\.window)
|
}
|
let windows = allWindows.filter(Self.shouldRequestScreenshot)
|
let skippedWindows = allWindows.filter { !Self.shouldRequestScreenshot(for: $0) }
|
DevelopmentDiagnostics.log("quickSwitch.screenshot.schedule", [
|
"generation": generation,
|
"eligibleCount": windows.count,
|
"skippedCount": skippedWindows.count
|
])
|
|
for window in skippedWindows {
|
view.markScreenshotNotRequested(for: window.id, reason: "skeletonPreferred")
|
}
|
if !skippedWindows.isEmpty {
|
onSnapshotUpdated?()
|
}
|
guard !windows.isEmpty else {
|
screenshotTask = nil
|
return
|
}
|
|
screenshotTask = Task { [weak self] in
|
guard let self else { return }
|
|
var retryWindows: [AlignerWindow] = []
|
for window in windows {
|
guard !Task.isCancelled else { return }
|
let resolution = await provider.resolvedScreenshot(for: window, in: session)
|
guard !Task.isCancelled, generation == self.sessionGeneration, self.isVisible else { return }
|
self.view.applyScreenshot(resolution, for: window.id)
|
DevelopmentDiagnostics.log("quickSwitch.screenshot.resolved", [
|
"generation": generation,
|
"windowID": window.id,
|
"appName": window.app.name,
|
"source": Self.screenshotSourceString(resolution.source)
|
])
|
self.onSnapshotUpdated?()
|
|
if case .skeletonFallback(let reason) = resolution.source,
|
Self.shouldRetryScreenshot(after: reason) {
|
retryWindows.append(window)
|
}
|
}
|
|
for window in retryWindows {
|
guard !Task.isCancelled else { return }
|
let retryResolution = await provider.resolvedScreenshot(for: window, in: session)
|
guard !Task.isCancelled, generation == self.sessionGeneration, self.isVisible else { return }
|
self.view.applyScreenshot(retryResolution, for: window.id)
|
DevelopmentDiagnostics.log("quickSwitch.screenshot.retryResolved", [
|
"generation": generation,
|
"windowID": window.id,
|
"appName": window.app.name,
|
"source": Self.screenshotSourceString(retryResolution.source)
|
])
|
self.onSnapshotUpdated?()
|
}
|
}
|
}
|
|
private static func shouldRequestScreenshot(for window: AlignerWindow) -> Bool {
|
switch ThumbnailPolicy.preferredStrategy(for: window.app.category) {
|
case .screenshotPreferred:
|
return true
|
case .skeletonPreferred, .fallbackSkeleton:
|
return false
|
}
|
}
|
|
private static func shouldRetryScreenshot(after reason: ScreenshotFallbackReason) -> Bool {
|
switch reason {
|
case .screenRecordingDenied, .syntheticWindowID, .retryLimitReached:
|
return false
|
case .captureFailed, .timedOut, .invalidCapture:
|
return true
|
}
|
}
|
|
private func elapsedSinceShowStart() -> Double? {
|
guard let showStartTime else { return nil }
|
return (CACurrentMediaTime() - showStartTime) * 1000
|
}
|
|
private func updateLifecycleWindowHighWaterMark() {
|
lifecycleMaximumOverlayWindows = max(
|
lifecycleMaximumOverlayWindows,
|
overlayWindowCount()
|
)
|
lifecycleMaximumVisibleOverlayWindows = max(
|
lifecycleMaximumVisibleOverlayWindows,
|
visibleOverlayWindowCount()
|
)
|
}
|
|
private func overlayWindowCount() -> Int {
|
NSApp.windows.filter { window in
|
window.title == Self.overlayTitle
|
}.count
|
}
|
|
private func visibleOverlayWindowCount() -> Int {
|
NSApp.windows.filter { window in
|
window.title == Self.overlayTitle && window.isVisible
|
}.count
|
}
|
|
private static func activationResultString(_ result: WindowActivationResult) -> String {
|
switch result {
|
case .activated:
|
return "activated"
|
case .restored:
|
return "restored"
|
case .appActivatedOnly:
|
return "appActivatedOnly"
|
case .windowNotFound:
|
return "windowNotFound"
|
case .unsupported:
|
return "unsupported"
|
case .activationFailed:
|
return "activationFailed"
|
case .failed(let message):
|
return "failed(\(message))"
|
}
|
}
|
|
private static func screenshotSourceString(_ source: ScreenshotResolutionSource) -> String {
|
switch source {
|
case .realScreenshot:
|
return "realScreenshot"
|
case .skeletonFallback(let reason):
|
return "skeletonFallback(\(reason))"
|
}
|
}
|
|
private static func dismissReasonString(_ reason: DismissReason) -> String {
|
switch reason {
|
case .escape:
|
return "escape"
|
case .focusLost:
|
return "focusLost"
|
case .systemCriticalWindow:
|
return "systemCriticalWindow"
|
case .timeout:
|
return "timeout"
|
case .userClosed:
|
return "userClosed"
|
}
|
}
|
|
}
|
|
private struct SnapshotLoadTiming: Sendable {
|
let startElapsedMilliseconds: Double?
|
let durationMilliseconds: Double
|
let ranOnMainThread: Bool
|
}
|
|
private struct SnapshotLoadSuccess: Sendable {
|
let snapshot: QuickSwitchSnapshot
|
let viewModel: QuickSwitchViewModel
|
let timing: SnapshotLoadTiming
|
}
|
|
private struct SnapshotLoadFailure: Sendable {
|
let message: String
|
let timing: SnapshotLoadTiming
|
}
|
|
private enum SnapshotLoadResult: Sendable {
|
case success(SnapshotLoadSuccess)
|
case failure(SnapshotLoadFailure)
|
|
static func load(
|
using loader: any QuickSwitchSnapshotLoading,
|
showStartTime: CFTimeInterval?
|
) -> SnapshotLoadResult {
|
let startedAt = CACurrentMediaTime()
|
let startedOnMainThread = Thread.isMainThread
|
|
do {
|
let load = try loader.snapshot()
|
let viewModel = QuickSwitchViewModelBuilder.viewModel(
|
from: load.snapshot,
|
currentSpaceIDs: load.currentSpaceIDs
|
)
|
return .success(SnapshotLoadSuccess(
|
snapshot: load.snapshot,
|
viewModel: viewModel,
|
timing: SnapshotLoadTiming(
|
startElapsedMilliseconds: showStartTime.map { (startedAt - $0) * 1000 },
|
durationMilliseconds: (CACurrentMediaTime() - startedAt) * 1000,
|
ranOnMainThread: startedOnMainThread
|
)
|
))
|
} catch {
|
return .failure(SnapshotLoadFailure(
|
message: DevelopmentDiagnostics.errorSummaryString(error),
|
timing: SnapshotLoadTiming(
|
startElapsedMilliseconds: showStartTime.map { (startedAt - $0) * 1000 },
|
durationMilliseconds: (CACurrentMediaTime() - startedAt) * 1000,
|
ranOnMainThread: startedOnMainThread
|
)
|
))
|
}
|
}
|
}
|
|
struct Round1QuickSwitchLaunchOptions {
|
let openQuickSwitch: Bool
|
let simulateAccessibilityDenied: Bool
|
let simulateScreenRecordingDenied: Bool
|
let autoHideAfter: TimeInterval?
|
let quitAfter: TimeInterval?
|
let reportPath: String?
|
let snapshotLoadDelay: TimeInterval?
|
let fixtureAppCount: Int?
|
let fixtureWindowsPerApp: Int?
|
let fixtureCandidateFiltering: Bool
|
let fixtureActivation: Bool
|
let debugHoveredAppGroupIndex: Int?
|
let debugOverlayWidth: CGFloat?
|
let debugKeySequence: [String]
|
let debugMouseSequence: [String]
|
let debugSystemCriticalAfter: TimeInterval?
|
let debugWindowActivation: Bool
|
let disableScreenshotRefresh: Bool
|
let lifecycleCycles: Int?
|
let lifecycleInterval: TimeInterval
|
let lifecycleVisibleDuration: TimeInterval
|
|
static func parse(arguments: [String]) -> Round1QuickSwitchLaunchOptions {
|
Round1QuickSwitchLaunchOptions(
|
openQuickSwitch: arguments.contains("--round01-open-quick-switch"),
|
simulateAccessibilityDenied: arguments.contains("--round01-simulate-accessibility-denied"),
|
simulateScreenRecordingDenied: arguments.contains("--round01-simulate-screen-recording-denied"),
|
autoHideAfter: timeInterval(for: "--round01-quick-switch-auto-hide-after", in: arguments),
|
quitAfter: timeInterval(for: "--round01-quick-switch-quit-after", in: arguments),
|
reportPath: stringValue(for: "--round01-quick-switch-report", in: arguments),
|
snapshotLoadDelay: timeInterval(for: "--round01-snapshot-load-delay", in: arguments),
|
fixtureAppCount: intValue(for: "--round01-fixture-app-count", in: arguments),
|
fixtureWindowsPerApp: intValue(for: "--round01-fixture-windows-per-app", in: arguments),
|
fixtureCandidateFiltering: arguments.contains("--round01-fixture-candidate-filtering"),
|
fixtureActivation: arguments.contains("--round01-fixture-window-activation"),
|
debugHoveredAppGroupIndex: intValue(for: "--round01-debug-hover-app-index", in: arguments),
|
debugOverlayWidth: cgFloatValue(for: "--round01-debug-overlay-width", in: arguments),
|
debugKeySequence: stringListValue(for: "--round01-debug-key-sequence", in: arguments),
|
debugMouseSequence: stringListValue(for: "--round01-debug-mouse-sequence", in: arguments),
|
debugSystemCriticalAfter: timeInterval(for: "--round01-debug-system-critical-after", in: arguments),
|
debugWindowActivation: arguments.contains("--round01-debug-window-activation"),
|
disableScreenshotRefresh: arguments.contains("--round01-disable-screenshot-refresh"),
|
lifecycleCycles: intValue(for: "--round01-quick-switch-lifecycle-cycles", in: arguments),
|
lifecycleInterval: timeInterval(for: "--round01-quick-switch-lifecycle-interval", in: arguments) ?? 0.02,
|
lifecycleVisibleDuration: timeInterval(for: "--round01-quick-switch-lifecycle-visible-duration", in: arguments) ?? 0.16
|
)
|
}
|
|
private static func timeInterval(for key: String, in arguments: [String]) -> TimeInterval? {
|
let prefix = "\(key)="
|
guard let argument = arguments.first(where: { $0.hasPrefix(prefix) }) else {
|
return nil
|
}
|
|
return TimeInterval(argument.dropFirst(prefix.count))
|
}
|
|
private static func stringValue(for key: String, in arguments: [String]) -> String? {
|
let prefix = "\(key)="
|
guard let argument = arguments.first(where: { $0.hasPrefix(prefix) }) else {
|
return nil
|
}
|
|
return String(argument.dropFirst(prefix.count))
|
}
|
|
private static func intValue(for key: String, in arguments: [String]) -> Int? {
|
stringValue(for: key, in: arguments).flatMap(Int.init)
|
}
|
|
private static func cgFloatValue(for key: String, in arguments: [String]) -> CGFloat? {
|
stringValue(for: key, in: arguments)
|
.flatMap(Double.init)
|
.map { CGFloat($0) }
|
}
|
|
private static func stringListValue(for key: String, in arguments: [String]) -> [String] {
|
guard let value = stringValue(for: key, in: arguments) else { return [] }
|
|
return value
|
.split(separator: ",")
|
.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
|
.filter { !$0.isEmpty }
|
}
|
}
|
|
@MainActor
|
private final class StderrScreenshotDebugLogger: ScreenshotDebugLogging {
|
func record(_ event: ScreenshotDebugEvent) {
|
DevelopmentDiagnostics.log("quickSwitch.screenshot.debug", [
|
"event": event.diagnosticDescription
|
])
|
fputs("Round01 screenshot debug: \(event.diagnosticDescription)\n", stderr)
|
}
|
}
|
