public import Foundation import Observation public import ParcelPlatform @MainActor @Observable public final class ActivityCollector { public private(set) var ledger = ActivityLedger() public private(set) var isEnabled = false public private(set) var generation: UInt64 = 0 public private(set) var failure: (any Error)? public var onFailure: (@MainActor (any Error) -> Void)? public let store: ActivityStore @ObservationIgnored private let scheduler: any EngineScheduler @ObservationIgnored private let clock: any EngineClock @ObservationIgnored private let date: @MainActor () -> Date @ObservationIgnored private var pending: (any EngineCancellation)? @ObservationIgnored private var lastWrite: Double? @ObservationIgnored private var dirty = false @ObservationIgnored private var loaded = false public init( store: ActivityStore, scheduler: any EngineScheduler = RunLoopEngineScheduler(), clock: any EngineClock = SystemEngineClock(), date: @escaping @MainActor () -> Date = { Date() } ) { self.store = store self.scheduler = scheduler self.clock = clock self.date = date } public func configure(enabled: Bool) { guard !loaded || isEnabled != enabled else { return } pending?.cancel() pending = nil isEnabled = enabled generation += 1 do { if enabled { ledger = try store.load() } else { ledger = ActivityLedger() dirty = false try store.reset() } loaded = true failure = nil } catch { loaded = false report(error) } } public func record(placements: Int, source: ActivitySource, feature: ActivityFeature? = nil) { guard isEnabled, loaded, placements > 0 else { return } ledger.record(placements: placements, source: source, at: date()) if let feature { ledger.record(feature: feature) } dirty = true scheduleWrite() } public func record(feature: ActivityFeature) { guard isEnabled, loaded, !ledger.usedFeatures.contains(feature) else { return } ledger.record(feature: feature) dirty = true scheduleWrite() } public func reset() throws { generation += 1 pending?.cancel() pending = nil ledger = ActivityLedger() dirty = false do { try store.reset() loaded = true failure = nil } catch { report(error) throw error } } public func flushOnQuit() { pending?.cancel() pending = nil flush() } private func scheduleWrite() { guard pending == nil else { return } let delay = lastWrite.map { max(0, 60 - (clock.now - $0)) } ?? 60 pending = scheduler.schedule(after: delay) { [weak self] in guard let self else { return } self.pending = nil self.flush() } } private func flush() { guard isEnabled, loaded, dirty else { return } lastWrite = clock.now do { try store.save(ledger) dirty = false failure = nil } catch { report(error) } } private func report(_ error: any Error) { failure = error onFailure?(error) } isolated deinit { pending?.cancel() } }