import os public struct Animator: Sendable { public private(set) var policy: MotionPolicy public private(set) var settings: MotionSettings public private(set) var timestamp: Double? public var isIdle: Bool { plans.isEmpty } public var activeWindowIDs: [MotionWindowID] { orderedWindows } public var activeWindowCount: Int { plans.count } private var orderedWindows: [MotionWindowID] = [] private var plans: [MotionWindowID: FramePlan] = [:] private var lastEmission: [MotionWindowID: Double] = [:] private var emissionCount: [MotionWindowID: Int] = [:] private var nextRevision: UInt64 = 0 public init(policy: MotionPolicy = MotionPolicy(), settings: MotionSettings = MotionSettings()) { self.policy = policy self.settings = settings } public mutating func schedule(_ requests: [MotionRequest], at timestamp: Double) throws { try validateTime(timestamp) var identifiers: Set = [] var replacements: [MotionWindowID: FramePlan] = [:] for request in requests { guard identifiers.insert(request.windowID).inserted else { throw MotionError.duplicateWindow(request.windowID) } let replacement = try FramePlanner.makePlan( request, at: timestamp, policy: policy, settings: settings, inherited: inheritedState(for: request, at: timestamp), revision: nextRevision + 1 ) if let existing = plans[request.windowID], canContinue(existing, toward: replacement) { continue } replacements[request.windowID] = replacement } nextRevision += 1 var added = false for (identifier, plan) in replacements { if plans[identifier] == nil { orderedWindows.append(identifier) added = true } plans[identifier] = plan lastEmission[identifier] = nil emissionCount[identifier] = nil let signposter = MotionSignposts.signposter if signposter.isEnabled, plan.duration == 0, plan.request.surface == .window, plan.request.metrics.isSlow(at: timestamp), case .animate = policy.behavior(for: .window, level: settings.level) { let app = plan.request.appID.rawValue let reason = plan.request.metrics.lastTimeout.map { timestamp - $0 < 5 } == true ? 2 : 1 signposter.emitEvent("Snap", "app=\(app, privacy: .public) reason=\(reason, privacy: .public)") } } if added { orderedWindows.sort() } self.timestamp = timestamp } public func contains(_ windowID: MotionWindowID) -> Bool { plans[windowID] != nil } public func plan(for windowID: MotionWindowID) -> FramePlan? { plans[windowID] } public mutating func tick(at timestamp: Double) throws -> [MotionFrame] { let signposter = MotionSignposts.signposter let windows = plans.count let interval = signposter.isEnabled ? signposter.beginInterval( "Sample", id: signposter.makeSignpostID(), "windows=\(windows, privacy: .public)") : nil defer { if let interval { signposter.endInterval("Sample", interval) } } try validateTime(timestamp) self.timestamp = timestamp var frames: [MotionFrame] = [] frames.reserveCapacity(orderedWindows.count) var finished = false for identifier in orderedWindows { guard let plan = plans[identifier] else { continue } guard timestamp >= plan.startTime else { continue } let isFinal = timestamp >= plan.endTime if !isFinal, let maximumRedraws = plan.spec.maximumRedraws { if emissionCount[identifier, default: 0] >= maximumRedraws - 1 { continue } if let last = lastEmission[identifier], timestamp - last < plan.duration / Double(maximumRedraws - 1) { continue } } if lastEmission[identifier] == timestamp { continue } frames.append(try plan.sample(at: timestamp).frame) lastEmission[identifier] = timestamp emissionCount[identifier, default: 0] += 1 if isFinal { finished = true plans[identifier] = nil lastEmission[identifier] = nil emissionCount[identifier] = nil } } if finished { orderedWindows.removeAll { plans[$0] == nil } } return frames } public func presentation(for windowID: MotionWindowID, at timestamp: Double) throws -> MotionSample? { guard timestamp.isFinite else { throw MotionError.invalidTimestamp } return try plans[windowID]?.sample(at: timestamp) } public mutating func cancel(_ windowID: MotionWindowID) { orderedWindows.removeAll { $0 == windowID } plans[windowID] = nil lastEmission[windowID] = nil emissionCount[windowID] = nil } public mutating func cancelAll() { orderedWindows.removeAll(keepingCapacity: true) plans.removeAll(keepingCapacity: true) lastEmission.removeAll(keepingCapacity: true) emissionCount.removeAll(keepingCapacity: true) } public mutating func updatePolicy(_ policy: MotionPolicy, at timestamp: Double) throws { try replan(policy: policy, settings: settings, at: timestamp) } public mutating func updateSettings(_ settings: MotionSettings, at timestamp: Double) throws { try replan(policy: policy, settings: settings, at: timestamp) } private mutating func replan(policy: MotionPolicy, settings: MotionSettings, at timestamp: Double) throws { try validateTime(timestamp) var replacements: [MotionWindowID: FramePlan] = [:] for (identifier, plan) in plans { replacements[identifier] = try FramePlanner.makePlan( plan.request, at: timestamp, policy: policy, settings: settings, inherited: plan.state(at: timestamp), revision: nextRevision + 1 ) } self.policy = policy self.settings = settings self.timestamp = timestamp nextRevision += 1 plans = replacements lastEmission.removeAll(keepingCapacity: true) emissionCount.removeAll(keepingCapacity: true) } private func inheritedState(for request: MotionRequest, at timestamp: Double) -> PresentationState? { guard let plan = plans[request.windowID], plan.request.generation == request.generation, plan.request.appID == request.appID else { return nil } return plan.state(at: timestamp) } private func canContinue(_ existing: FramePlan, toward replacement: FramePlan) -> Bool { var request = replacement.request // Readback advances the observed start and write metrics, not the destination or its deadline. request.start = existing.request.start request.metrics = existing.request.metrics return request == existing.request && existing.spec == replacement.spec && existing.duration == replacement.duration && existing.curve == replacement.curve } private func validateTime(_ timestamp: Double) throws { guard timestamp.isFinite else { throw MotionError.invalidTimestamp } if let previous = self.timestamp, timestamp < previous { throw MotionError.timestampWentBackwards } } }