crossmate

CrossmateApp.swift (18681B)

---

 import CloudKit
 import SwiftUI
 import UserNotifications
 
 @main
 struct CrossmateApp: App {
     @UIApplicationDelegateAdaptor private var appDelegate: AppDelegate
 
     @State private var services: AppServices
 
     init() {
         self._services = State(initialValue: AppServices())
     }
 
     var body: some Scene {
         WindowGroup {
             RootView(
                 services: services,
                 appDelegate: appDelegate
             )
             .environment(\.managedObjectContext, services.persistence.viewContext)
             .environment(services.driveMonitor)
             .environment(services.inputMonitor)
             .environment(services.syncMonitor)
             .environment(\.syncEngine, services.syncEngine)
             .environment(services.nytAuth)
             .environment(\.nytPuzzleFetcher, services.nytFetcher)
             .environment(\.resetDatabase, { await services.cloudService.resetAllData() })
         }
     }
 }
 
 // MARK: - App Delegate
 
 final class AppDelegate: NSObject, UIApplicationDelegate, @preconcurrency UNUserNotificationCenterDelegate, @unchecked Sendable {
     var onRemoteNotification: ((String, CKDatabase.Scope?) async -> Void)?
     /// Reports the outcome of `registerForRemoteNotifications`. Surfaced in
     /// the diagnostics log so a missing APNs token (e.g. an aps-environment
     /// mismatch between the entitlements and the TestFlight distribution
     /// channel) is visible rather than silently degrading sync to the
     /// CKSyncEngine poll cadence.
     var onAPNsRegistrationResult: ((String) -> Void)?
 
     func application(
         _ application: UIApplication,
         didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
     ) -> Bool {
         application.registerForRemoteNotifications()
         UNUserNotificationCenter.current().delegate = self
         return true
     }
 
     func application(
         _ application: UIApplication,
         didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
     ) {
         let hex = deviceToken.map { String(format: "%02x", $0) }.joined()
         let prefix = hex.prefix(12)
         onAPNsRegistrationResult?("APNs registered token=\(prefix)… (\(deviceToken.count) bytes)")
     }
 
     func application(
         _ application: UIApplication,
         didFailToRegisterForRemoteNotificationsWithError error: Error
     ) {
         let nsError = error as NSError
         onAPNsRegistrationResult?(
             "APNs registration FAILED — domain=\(nsError.domain) code=\(nsError.code) " +
             "\(nsError.localizedDescription)"
         )
     }
 
     /// Foreground notification arrival. If the user is currently viewing the
     /// puzzle the ping refers to, hide it entirely (`[]`); otherwise show it
     /// as a banner with sound. In both cases the dedup map is updated so a
     /// rapid follow-up doesn't refire.
     func userNotificationCenter(
         _ center: UNUserNotificationCenter,
         willPresent notification: UNNotification,
         withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
     ) {
         let userInfo = notification.request.content.userInfo
         guard let gameID = Self.gameID(from: userInfo) else {
             completionHandler([.banner, .sound])
             return
         }
         let isSession = (userInfo["crossmatePingKind"] as? String) == "session"
         if isSession {
             NotificationState.recordShown(gameID: gameID)
         }
         if NotificationState.isActive(gameID: gameID) {
             completionHandler([])
         } else {
             completionHandler([.banner, .sound])
         }
     }
 
     func userNotificationCenter(
         _ center: UNUserNotificationCenter,
         didReceive response: UNNotificationResponse,
         withCompletionHandler completionHandler: @escaping () -> Void
     ) {
         let userInfo = response.notification.request.content.userInfo
         guard let gameID = Self.gameID(from: userInfo) else {
             completionHandler()
             return
         }
 
         Task { @MainActor in
             NotificationNavigationBroker.shared.openGame(gameID)
             completionHandler()
         }
     }
 
     private static func gameID(from userInfo: [AnyHashable: Any]) -> UUID? {
         if let id = userInfo["crossmateGameID"] as? String {
             return UUID(uuidString: id)
         }
         guard let ck = userInfo["ck"] as? [AnyHashable: Any],
               let qry = ck["qry"] as? [AnyHashable: Any],
               let zoneName = qry["zid"] as? String,
               zoneName.hasPrefix("game-")
         else { return nil }
         return UUID(uuidString: String(zoneName.dropFirst("game-".count)))
     }
 
     /// Asks the user for notification permission only if they haven't yet
     /// answered the prompt. Idempotent — once the user has decided either
     /// way, this is a no-op.
     static func requestNotificationAuthorizationIfNeeded() async {
         let center = UNUserNotificationCenter.current()
         let settings = await center.notificationSettings()
         guard settings.authorizationStatus == .notDetermined else { return }
         _ = try? await center.requestAuthorization(options: [.alert, .sound])
     }
 
     func application(
         _ application: UIApplication,
         didReceiveRemoteNotification userInfo: [AnyHashable: Any]
     ) async -> UIBackgroundFetchResult {
         let summary = AppServices.describePush(userInfo: userInfo)
         let scope = AppServices.databaseScope(fromPush: userInfo)
         await onRemoteNotification?(summary, scope)
         return .newData
     }
 
     func application(
         _ application: UIApplication,
         configurationForConnecting connectingSceneSession: UISceneSession,
         options: UIScene.ConnectionOptions
     ) -> UISceneConfiguration {
         let configuration = UISceneConfiguration(
             name: nil,
             sessionRole: connectingSceneSession.role
         )
         configuration.delegateClass = SceneDelegate.self
         return configuration
     }
 }
 
 @MainActor
 final class NotificationNavigationBroker {
     static let shared = NotificationNavigationBroker()
 
     var onOpenGame: ((UUID) -> Void)? {
         didSet { flushPendingGameIDs() }
     }
 
     private var pendingGameIDs: [UUID] = []
 
     private init() {}
 
     func openGame(_ gameID: UUID) {
         guard let onOpenGame else {
             pendingGameIDs.append(gameID)
             return
         }
         onOpenGame(gameID)
     }
 
     private func flushPendingGameIDs() {
         guard let onOpenGame, !pendingGameIDs.isEmpty else { return }
         let gameIDs = pendingGameIDs
         pendingGameIDs.removeAll()
         for gameID in gameIDs {
             onOpenGame(gameID)
         }
     }
 }
 
 @MainActor
 final class CloudShareAcceptanceBroker {
     static let shared = CloudShareAcceptanceBroker()
 
     var onAcceptShare: ((CKShare.Metadata) async -> Void)? {
         didSet { flushPendingAcceptedShares() }
     }
 
     private var pendingAcceptedShares: [CKShare.Metadata] = []
 
     private init() {}
 
     func acceptCloudKitShare(_ metadata: CKShare.Metadata) {
         guard let onAcceptShare else {
             pendingAcceptedShares.append(metadata)
             return
         }
         Task { await onAcceptShare(metadata) }
     }
 
     private func flushPendingAcceptedShares() {
         guard let onAcceptShare, !pendingAcceptedShares.isEmpty else { return }
         let metadatas = pendingAcceptedShares
         pendingAcceptedShares.removeAll()
         for metadata in metadatas {
             Task { await onAcceptShare(metadata) }
         }
     }
 }
 
 final class SceneDelegate: NSObject, UIWindowSceneDelegate {
     func windowScene(
         _ windowScene: UIWindowScene,
         userDidAcceptCloudKitShareWith metadata: CKShare.Metadata
     ) {
         CloudShareAcceptanceBroker.shared.acceptCloudKitShare(metadata)
     }
 }
 
 // MARK: - Root View
 
 struct RootView: View {
     let services: AppServices
     let appDelegate: AppDelegate
 
     @Environment(\.scenePhase) private var scenePhase
     @State private var navigationPath = NavigationPath()
 
     var body: some View {
         NavigationStack(path: $navigationPath) {
             GameListView(
                 store: services.store,
                 shareController: services.shareController,
                 onRefresh: { await services.refreshLibrary() },
                 navigationPath: $navigationPath
             )
             .navigationDestination(for: UUID.self) { gameID in
                 PuzzleDisplayView(
                     gameID: gameID,
                     store: services.store,
                     shareController: services.shareController,
                     services: services
                 )
             }
         }
         .environment(services.preferences)
         .task {
             NotificationState.setActivePuzzleID(nil)
             NotificationNavigationBroker.shared.onOpenGame = { gameID in
                 UIApplication.shared.dismissPresentedViewControllers()
                 navigationPath = NavigationPath()
                 navigationPath.append(gameID)
             }
             await services.start(appDelegate: appDelegate)
         }
         .onOpenURL { url in
             if let id = services.importService.importGame(from: url) {
                 navigationPath.append(id)
             }
         }
         .onReceive(NotificationCenter.default.publisher(for: .cloudShareAcceptanceStarted)) { _ in
             UIApplication.shared.dismissPresentedViewControllers()
         }
         .onReceive(NotificationCenter.default.publisher(for: .cloudShareAcceptanceCompleted)) { notification in
             guard let gameID = notification.userInfo?["gameID"] as? UUID else { return }
             navigationPath.append(gameID)
         }
         .onChange(of: scenePhase) { _, newPhase in
             switch newPhase {
             case .active:
                 Task { await services.syncOnForeground() }
             case .background, .inactive:
                 NotificationState.setActivePuzzleID(nil)
                 Task { await services.syncOnBackground() }
             @unknown default:
                 break
             }
         }
     }
 }
 
 private extension UIApplication {
     func dismissPresentedViewControllers() {
         for scene in connectedScenes {
             guard let windowScene = scene as? UIWindowScene else { continue }
             for window in windowScene.windows where window.isKeyWindow {
                 window.rootViewController?.dismiss(animated: true)
             }
         }
     }
 }
 
 // MARK: - Game Destination
 
 /// Loads a game when navigated to.
 private struct PuzzleDisplayView: View {
     private static let sharedPuzzlePollingInterval: Duration = .seconds(5)
     private var sharedID: UUID? {
         session?.mutator.isShared == true ? gameID : nil
     }
 
     let gameID: UUID
     let store: GameStore
     let shareController: ShareController
     let services: AppServices
 
     @Environment(PlayerPreferences.self) private var preferences
     @Environment(\.scenePhase) private var scenePhase
     @State private var session: PlayerSession?
     @State private var roster: PlayerRoster?
     @State private var loadError: String?
     @State private var openPuzzleFollowUpTask: Task<Void, Never>?
 
     var body: some View {
         Group {
             if let session, let roster {
                 PuzzleView(
                     session: session,
                     shareController: shareController,
                     roster: roster,
                     onComplete: {
                         store.markCompleted(id: gameID)
                         Task {
                             await services.cleanupPingsAfterCompletion(gameID: gameID)
                         }
                     },
                     onResign: { try store.resignGame(id: gameID) },
                     onDelete: { try store.deleteGame(id: gameID) }
                 )
             } else if let loadError {
                 ContentUnavailableView(
                     "Couldn't load puzzle",
                     systemImage: "exclamationmark.triangle",
                     description: Text(loadError)
                 )
             } else {
                 ProgressView("Loading puzzle...")
                     .frame(maxWidth: .infinity, maxHeight: .infinity)
             }
         }
         .navigationTitle("")
         .navigationBarTitleDisplayMode(.inline)
         .task(id: sharedID) {
             guard sharedID != nil else { return }
             await pollOpenSharedPuzzle()
         }
         .task(id: gameID) {
             openPuzzleFollowUpTask?.cancel()
             openPuzzleFollowUpTask = nil
             session = nil
             roster = nil
             loadError = nil
             updateActiveNotificationPuzzleID(for: scenePhase)
             do {
                 let (game, mutator) = try store.loadGame(id: gameID)
                 let newSession = PlayerSession(game: game, mutator: mutator)
                 let newRoster = services.makePlayerRoster(for: gameID, preferences: preferences)
                 roster = newRoster
                 session = newSession
                 openPuzzleFollowUpTask = Task { @MainActor in
                     await finishOpeningPuzzle(
                         session: newSession,
                         roster: newRoster,
                         isShared: mutator.isShared
                     )
                 }
             } catch {
                 loadError = String(describing: error)
             }
         }
         .onChange(of: session?.mutator.isShared) { oldValue, newValue in
             // Fire only on a definite `false → true` transition — that's the
             // mid-session share-create case. Initial loads of an already-shared
             // game go `nil → true` and are handled inline in `task(id: gameID)`.
             guard oldValue == false, newValue == true,
                   let session,
                   preferences.isICloudSyncEnabled
             else { return }
             Task { await activateSharing(for: session) }
         }
         .onChange(of: scenePhase) { _, newPhase in
             updateActiveNotificationPuzzleID(for: newPhase)
         }
         .onDisappear {
             openPuzzleFollowUpTask?.cancel()
             openPuzzleFollowUpTask = nil
             NotificationState.clearActivePuzzleID(if: gameID)
             let selectionPublisher = services.playerSelectionPublisher
             let movesUpdater = services.movesUpdater
             let exitedID = gameID
             Task {
                 await movesUpdater.flush()
                 await selectionPublisher.clear()
                 await movesUpdater.noteSessionEnded(gameID: exitedID)
             }
         }
     }
 
     private func finishOpeningPuzzle(
         session loadedSession: PlayerSession,
         roster loadedRoster: PlayerRoster,
         isShared: Bool
     ) async {
         await loadedRoster.refresh()
         guard !Task.isCancelled, session === loadedSession else { return }
 
         if isShared && preferences.isICloudSyncEnabled {
             services.syncMonitor.note(
                 "PuzzleDisplay[\(gameID.uuidString.prefix(8))]: loaded shared roster"
             )
             await activateSharing(for: loadedSession, refreshRoster: false)
         } else {
             services.syncMonitor.note(
                 "PuzzleDisplay[\(gameID.uuidString.prefix(8))]: loaded local roster"
             )
             await services.playerSelectionPublisher.clear()
         }
     }
 
     private func updateActiveNotificationPuzzleID(for phase: ScenePhase) {
         if phase == .active {
             NotificationState.setActivePuzzleID(gameID)
         } else {
             NotificationState.clearActivePuzzleID(if: gameID)
         }
     }
 
     /// Initialises shared-game state (roster, selection publishing, name broadcast) for
     /// the open session. Called when the puzzle first appears as shared, and
     /// again if a previously-solo game becomes shared mid-session.
     private func activateSharing(for session: PlayerSession, refreshRoster: Bool = true) async {
         Task { await AppDelegate.requestNotificationAuthorizationIfNeeded() }
         let activeRoster: PlayerRoster
         if let roster {
             activeRoster = roster
         } else {
             let newRoster = services.makePlayerRoster(for: gameID, preferences: preferences)
             roster = newRoster
             activeRoster = newRoster
         }
         if refreshRoster {
             await activeRoster.refresh()
         }
         // Fan out the local user's name to every shared/joined game's zone
         // before any selection publish — otherwise the partner sees "Player"
         // until we happen to rename ourselves and trigger PlayerNamePublisher's
         // observer. Idempotent if the name has already been broadcast.
         await services.playerNamePublisher?.broadcastName()
         guard let authorID = services.identity.currentID else { return }
         let selectionPublisher = services.playerSelectionPublisher
         await selectionPublisher.begin(
             gameID: gameID,
             authorID: authorID,
             currentName: preferences.name
         )
         session.onSelectionChanged = { selection in
             Task { await selectionPublisher.publish(selection) }
         }
         let syncEngine = services.syncEngine
         let identity = services.identity
         let preferences = self.preferences
         let eventGameID = gameID
         session.onPlayerEvent = { kind, scope in
             guard preferences.isICloudSyncEnabled,
                   let authorID = identity.currentID
             else { return }
             let playerName = preferences.name
             Task {
                 await syncEngine.enqueuePing(
                     kind: kind,
                     scope: scope,
                     gameID: eventGameID,
                     authorID: authorID,
                     playerName: playerName
                 )
             }
         }
         let initial = PlayerSelection(
             row: session.selectedRow,
             col: session.selectedCol,
             direction: session.direction
         )
         await selectionPublisher.publish(initial)
     }
 
     private func pollOpenSharedPuzzle() async {
         await services.syncOpenSharedPuzzle()
         while !Task.isCancelled {
             do {
                 try await Task.sleep(for: Self.sharedPuzzlePollingInterval)
             } catch {
                 break
             }
             guard !Task.isCancelled else { break }
             await services.syncOpenSharedPuzzle()
         }
     }
 }