Antigravity × SwiftUI + CloudKit：iCloud 同期アプリを本番実装するアドバンスガイド

import CloudKit
import Observation
 
// CloudKit コンテナ識別子（プロジェクトに合わせて変更）
private let containerIdentifier = "iCloud.com.example.myapp.cloudkit"
 
// Task の CloudKit Record Type 定数
enum RecordType {
    static let task = "Task"
    static let tag  = "Tag"
}
 
@Observable
final class TaskStore {
    var tasks: [TaskItem] = []
    var isLoading = false
    var errorMessage: String?
 
    private let container: CKContainer
    private let privateDB: CKDatabase
 
    init() {
        self.container = CKContainer(identifier: containerIdentifier)
        self.privateDB = container.privateCloudDatabase
    }
 
    // --- データ取得（一覧） ---
    func fetchTasks() async {
        isLoading = true
        defer { isLoading = false }
 
        do {
            let predicate = NSPredicate(value: true)
            let query = CKQuery(recordType: RecordType.task, predicate: predicate)
            query.sortDescriptors = [NSSortDescriptor(key: "createdAt", ascending: false)]
 
            let results = try await privateDB.records(matching: query)
            let records = try results.matchResults.compactMap { _, result in
                try result.get()
            }
 
            await MainActor.run {
                self.tasks = records.compactMap(TaskItem.init)
            }
        } catch {
            await MainActor.run {
                self.errorMessage = error.localizedDescription
            }
        }
    }
 
    // --- 新規タスクの保存 ---
    func saveTask(_ item: TaskItem) async throws {
        let record = item.toCKRecord()
        let savedRecord = try await privateDB.save(record)
        let savedItem = TaskItem(record: savedRecord)!
 
        await MainActor.run {
            if let index = self.tasks.firstIndex(where: { $0.id == item.id }) {
                self.tasks[index] = savedItem
            } else {
                self.tasks.insert(savedItem, at: 0)
            }
        }
    }
}
 
// --- TaskItem モデル ---
struct TaskItem: Identifiable, Hashable {
    let id: CKRecord.ID
    var title: String
    var isCompleted: Bool
    var dueDate: Date?
    var priority: Int
 
    // CKRecord から初期化
    init?(record: CKRecord) {
        guard let title = record["title"] as? String else { return nil }
        self.id = record.recordID
        self.title = title
        self.isCompleted = (record["isCompleted"] as? Int64 ?? 0) == 1
        self.dueDate = record["dueDate"] as? Date
        self.priority = Int(record["priority"] as? Int64 ?? 0)
    }
 
    // CKRecord へ変換
    func toCKRecord() -> CKRecord {
        let record = CKRecord(recordType: RecordType.task, recordID: id)
        record["title"] = title
        record["isCompleted"] = isCompleted ? 1 : 0
        record["dueDate"] = dueDate
        record["priority"] = Int64(priority)
        return record
    }
}

import SwiftUI
import CloudKit
 
// --- タスク一覧ビュー ---
struct TaskListView: View {
    @State private var store = TaskStore()
    @State private var showAddTask = false
 
    var body: some View {
        NavigationStack {
            Group {
                if store.isLoading && store.tasks.isEmpty {
                    ProgressView("読み込み中...")
                } else {
                    List {
                        ForEach(store.tasks) { task in
                            TaskRowView(task: task) { updated in
                                Task { try? await store.saveTask(updated) }
                            }
                        }
                    }
                }
            }
            .navigationTitle("タスク")
            .toolbar {
                ToolbarItem(placement: .primaryAction) {
                    Button { showAddTask = true } label: {
                        Image(systemName: "plus")
                    }
                }
            }
            .sheet(isPresented: $showAddTask) {
                AddTaskView { newTask in
                    Task { try? await store.saveTask(newTask) }
                }
            }
            .task {
                // 初回データ取得
                await store.fetchTasks()
                // CKSubscription でリアルタイム変更を購読
                await store.subscribeToChanges()
            }
            .onReceive(NotificationCenter.default.publisher(
                for: .CKAccountChanged
            )) { _ in
                // iCloud アカウント変更時に再取得
                Task { await store.fetchTasks() }
            }
        }
    }
}
 
// --- TaskStore に購読機能を追加 ---
extension TaskStore {
    func subscribeToChanges() async {
        let subscriptionID = "task-changes"
 
        // 既存の購読を確認（重複登録防止）
        do {
            _ = try await privateDB.subscription(for: subscriptionID)
            print("✅ 既存の CKSubscription を確認")
        } catch {
            // 未登録の場合は新規作成
            let subscription = CKQuerySubscription(
                recordType: RecordType.task,
                predicate: NSPredicate(value: true),
                subscriptionID: subscriptionID,
                options: [
                    .firesOnRecordCreation,
                    .firesOnRecordUpdate,
                    .firesOnRecordDeletion
                ]
            )
 
            // サイレントプッシュ設定（バックグラウンドでデータ取得）
            let notificationInfo = CKSubscription.NotificationInfo()
            notificationInfo.shouldSendContentAvailable = true
            subscription.notificationInfo = notificationInfo
 
            do {
                try await privateDB.save(subscription)
                print("✅ CKSubscription 登録完了")
            } catch {
                print("⚠️ CKSubscription 登録エラー: \(error.localizedDescription)")
            }
        }
    }
}

extension TaskStore {
    // --- コンフリクト対応付きの保存 ---
    func saveWithConflictResolution(_ item: TaskItem) async throws {
        do {
            try await saveTask(item)
        } catch let error as CKError where error.code == .serverRecordChanged {
            // サーバー側の最新レコードを取得
            guard
                let serverRecord = error.userInfo[CKRecordChangedErrorServerRecordKey] as? CKRecord,
                let clientRecord = error.userInfo[CKRecordChangedErrorClientRecordKey] as? CKRecord
            else { throw error }
 
            // マージ戦略:
            // - タイトルはクライアント（ユーザーが今編集中）を優先
            // - 完了状態はサーバー最新値を維持（他デバイスでの完了を尊重）
            let mergedRecord = serverRecord
            mergedRecord["title"] = clientRecord["title"]
            // isCompleted はサーバー値をそのまま使用
 
            let savedRecord = try await privateDB.save(mergedRecord)
            let savedItem = TaskItem(record: savedRecord)!
 
            await MainActor.run {
                if let index = self.tasks.firstIndex(where: { $0.id == item.id }) {
                    self.tasks[index] = savedItem
                }
            }
        }
    }
 
    // --- ネットワーク不通時のオフライン待機 ---
    func saveOfflineIfNeeded(_ item: TaskItem) async {
        do {
            try await saveWithConflictResolution(item)
        } catch let error as CKError
            where error.code == .networkUnavailable || error.code == .networkFailure
        {
            // オフライン時はローカルキューに追加
            PendingChangesQueue.shared.enqueue(item)
            print("⚡ オフラインキューに追加: \(item.title)（待機件数: \(PendingChangesQueue.shared.count)）")
        } catch {
            // その他のエラーは UI に表示
            await MainActor.run {
                self.errorMessage = error.localizedDescription
            }
        }
    }
}
 
// --- オフライン待機キュー ---
final class PendingChangesQueue {
    static let shared = PendingChangesQueue()
 
    private var queue: [TaskItem] = []
    var count: Int { queue.count }
 
    func enqueue(_ item: TaskItem) {
        // 同一 ID の既存エントリを上書き（最新変更のみ保持）
        queue.removeAll { $0.id == item.id }
        queue.append(item)
    }
 
    // ネットワーク復帰時に一括フラッシュ
    func flushAll(to store: TaskStore) async {
        let pending = queue
        queue.removeAll()
 
        for item in pending {
            try? await store.saveWithConflictResolution(item)
        }
        print("✅ オフラインキューをフラッシュ完了（\(pending.count) 件）")
    }
}

// アプリ起動時に iCloud ログイン状態を確認
let status = try await CKContainer.default().accountStatus()
if status != .available {
    // ユーザーに iCloud サインインを促すアラートを表示
    showICloudSignInAlert = true
}

// ページング対応クエリ（大量データ対応）
func fetchTasksPaged() async throws -> [CKRecord] {
    var allRecords: [CKRecord] = []
 
    let query = CKQuery(
        recordType: RecordType.task,
        predicate: NSPredicate(value: true)
    )
 
    var cursor: CKQueryOperation.Cursor? = nil
 
    repeat {
        let (results, newCursor) = try await privateDB.records(
            matching: query,
            resultsLimit: 200,
            // cursor が nil の場合は最初から取得
            // cursor がある場合は続きから取得（CLoudKit API v2）
        )
        let batch = try results.matchResults.map { _, r in try r.get() }
        allRecords.append(contentsOf: batch)
        cursor = newCursor
    } while cursor != nil
 
    return allRecords
}
// 期待する出力: allRecords に全タスクが格納される（件数制限なし）