Repository Public
1import Foundation2import Observation34/// Decides *when* to synchronize: shortly after local changes (debounced), when the app becomes active,5/// at a slow interval while it is in use, and with exponential backoff after failures. Nothing runs while6/// sync is turned off, the user is signed out or the device has no account key.7@MainActor8@Observable9final class SyncCoordinator {10 enum Phase: Equatable, Sendable {11 case off, signedOut, waitingForKey, idle, syncing, offline12 case failed(String)13 }1415 private(set) var phase: Phase = .signedOut16 private(set) var lastSync: Date?17 private(set) var lastReport = SyncReport()18 private(set) var pendingChanges = 01920 @ObservationIgnored let mirror: SyncDatabase21 @ObservationIgnored let account: AccountService22 @ObservationIgnored private let engine: SyncEngine23 @ObservationIgnored private let isEnabled: @MainActor () -> Bool24 /// Gathers local changes into the mirror just before a cycle (history, bookmarks, open tabs).25 @ObservationIgnored var captureLocalChanges: (@MainActor () -> Void)?26 /// Applies what a cycle pulled to the rest of the app.27 @ObservationIgnored var applyRemoteChanges: (@MainActor (Set<String>) -> Void)?2829 @ObservationIgnored private var scheduled: Task<Void, Never>?30 @ObservationIgnored private var periodic: Task<Void, Never>?31 @ObservationIgnored private var failures = 032 @ObservationIgnored private var active = false3334 nonisolated static let backoff: [TimeInterval] = [5, 15, 60, 300, 900]35 static let interval: TimeInterval = 3003637 init(account: AccountService, mirror: SyncDatabase, isEnabled: @escaping @MainActor () -> Bool) {38 self.account = account39 self.mirror = mirror40 self.isEnabled = isEnabled41 engine = SyncEngine(database: mirror, backend: account.backend, accountKey: account.accountKeyProvider)42 lastSync = mirror.meta("lastSync").flatMap(Double.init).map(Date.init(timeIntervalSince1970:))43 refreshPhase()44 }4546 /// Delay before retry number `failures` (1-based), capped.47 nonisolated static func retryDelay(afterFailures failures: Int) -> TimeInterval { backoff[min(max(failures, 1), backoff.count) - 1] }4849 private var canSync: Bool { isEnabled() && account.isSignedIn && account.keyStatus == .ready }5051 func refreshPhase() {52 if !isEnabled() { phase = .off }53 else if !account.isSignedIn { phase = .signedOut }54 else if account.keyStatus != .ready { phase = .waitingForKey }55 else if phase == .off || phase == .signedOut || phase == .waitingForKey { phase = .idle }56 pendingChanges = mirror.dirtyCount57 }5859 /// The app became active (launch, foreground): sync now and keep a slow heartbeat while it stays active.60 func start() {61 active = true62 periodic?.cancel()63 periodic = Task { [weak self] in64 while !Task.isCancelled {65 try? await Task.sleep(for: .seconds(Self.interval))66 guard !Task.isCancelled else { return }67 await self?.syncNow()68 }69 }70 requestSync(after: 0.5)71 }7273 /// The app went to the background or is quitting: no more timers (battery), pending changes stay queued on disk.74 func stop() {75 active = false76 periodic?.cancel(); periodic = nil77 scheduled?.cancel(); scheduled = nil78 }7980 /// Something changed locally: sync soon, coalescing bursts of changes into one cycle.81 func requestSync(after delay: TimeInterval = 4) {82 refreshPhase()83 guard canSync, active else { return }84 scheduled?.cancel()85 scheduled = Task { [weak self] in86 try? await Task.sleep(for: .seconds(delay))87 guard !Task.isCancelled else { return }88 await self?.syncNow()89 }90 }9192 /// Account or key state changed (signed in, approved, signed out).93 func accountStateChanged() {94 failures = 095 refreshPhase()96 if canSync { requestSync(after: 0.2) }97 }9899 @discardableResult100 func syncNow() async -> SyncReport? {101 refreshPhase()102 if account.isSignedIn, isEnabled(), account.keyStatus != .ready {103 // Maybe another device approved this one in the meantime.104 _ = try? await account.refreshKey()105 refreshPhase()106 }107 guard canSync, phase != .syncing else { return nil }108 phase = .syncing109 captureLocalChanges?()110 do {111 let report = try await engine.sync()112 failures = 0113 lastReport = report114 lastSync = Date()115 if !report.changedCollections.isEmpty { applyRemoteChanges?(report.changedCollections) }116 phase = .idle117 pendingChanges = mirror.dirtyCount118 return report119 } catch let error as BackendError {120 if error.kind == .unauthenticated {121 account.sessionWasRejected()122 refreshPhase()123 } else if error.code == "sync_not_initialized" {124 _ = try? await account.refreshKey()125 refreshPhase()126 } else {127 phase = error.kind == .offline || error.kind == .timeout ? .offline : .failed(error.message)128 scheduleRetry(minimum: error.retryAfter)129 }130 } catch SyncFailure.keyUnavailable, SyncFailure.keyMismatch {131 _ = try? await account.refreshKey()132 refreshPhase()133 } catch is CancellationError {134 phase = .idle135 } catch {136 phase = .failed(error.localizedDescription)137 scheduleRetry(minimum: nil)138 }139 pendingChanges = mirror.dirtyCount140 return nil141 }142143 private func scheduleRetry(minimum: TimeInterval?) {144 failures += 1145 guard active else { return }146 let delay = max(Self.retryDelay(afterFailures: failures), minimum ?? 0)147 scheduled?.cancel()148 scheduled = Task { [weak self] in149 try? await Task.sleep(for: .seconds(delay))150 guard !Task.isCancelled else { return }151 await self?.syncNow()152 }153 }154}155