Antigravity × SwiftUI Live Activities & Dynamic Island：iOS 26 対応実装ガイド

import ActivityKit
 
class LiveActivityManager {
    static let shared = LiveActivityManager()
 
    // Live Activity を開始する
    func startDeliveryActivity(order: Order) async throws -> Activity<DeliveryAttributes> {
        // まず許可状態を確認
        guard ActivityAuthorizationInfo().areActivitiesEnabled else {
            throw LiveActivityError.notAuthorized
        }
 
        let attributes = DeliveryAttributes(
            orderID: order.id,
            restaurantName: order.restaurantName,
            itemSummary: order.itemsSummary
        )
 
        let initialContentState = DeliveryAttributes.ContentState(
            status: .preparing,
            estimatedArrival: order.estimatedDeliveryTime,
            currentLocation: "店舗で準備中",
            progressPercentage: 0.1
        )
 
        let content = ActivityContent(
            state: initialContentState,
            staleDate: Calendar.current.date(byAdding: .minute, value: 30, to: .now)
        )
 
        // iOS 16.2+ では pushType を指定してサーバーサイドプッシュにも対応
        let activity = try Activity.request(
            attributes: attributes,
            content: content,
            pushType: .token  // APNs 経由の更新を有効化
        )
 
        // pushToken を取得してサーバーに送信
        Task {
            for await tokenData in activity.pushTokenUpdates {
                let tokenString = tokenData.map { String(format: "%02x", $0) }.joined()
                await sendPushTokenToServer(token: tokenString, activityID: activity.id)
            }
        }
 
        return activity
    }
 
    // Live Activity を更新する
    func updateDeliveryActivity(
        activity: Activity<DeliveryAttributes>,
        newStatus: DeliveryStatus,
        location: String,
        progress: Double
    ) async {
        let updatedState = DeliveryAttributes.ContentState(
            status: newStatus,
            estimatedArrival: activity.content.state.estimatedArrival,
            currentLocation: location,
            progressPercentage: progress
        )
 
        let updatedContent = ActivityContent(
            state: updatedState,
            staleDate: Calendar.current.date(byAdding: .minute, value: 15, to: .now)
        )
 
        await activity.update(updatedContent)
    }
 
    // Live Activity を終了する
    func endDeliveryActivity(activity: Activity<DeliveryAttributes>) async {
        let finalState = DeliveryAttributes.ContentState(
            status: .delivered,
            estimatedArrival: .now,
            currentLocation: "配達完了",
            progressPercentage: 1.0
        )
 
        let finalContent = ActivityContent(
            state: finalState,
            staleDate: nil
        )
 
        // 配達完了後 5 分でロックスクリーンから消える
        await activity.end(finalContent, dismissalPolicy: .after(.now + 300))
    }
}
 
enum LiveActivityError: Error {
    case notAuthorized
    case activityNotFound
}

// AppDelegate または App struct で pushToken を監視
func observePushTokenUpdates(activity: Activity<DeliveryAttributes>) {
    Task {
        for await tokenData in activity.pushTokenUpdates {
            let tokenHex = tokenData.map { String(format: "%02x", $0) }.joined()
 
            // サーバー API にトークンを送信
            var request = URLRequest(url: URL(string: "https://api.yourapp.com/live-activity/token")!)
            request.httpMethod = "POST"
            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
            request.httpBody = try? JSONEncoder().encode([
                "activityID": activity.id,
                "pushToken": tokenHex,
                "bundleID": Bundle.main.bundleIdentifier ?? ""
            ])
 
            _ = try? await URLSession.shared.data(for: request)
        }
    }
}

{
  "aps": {
    "timestamp": 1712000000,
    "event": "update",
    "content-state": {
      "status": "pickedUp",
      "estimatedArrival": "2026-04-03T12:30:00Z",
      "currentLocation": "〇〇通り付近",
      "progressPercentage": 0.6
    },
    "stale-date": 1712003600,
    "alert": {
      "title": "配達員が集荷しました",
      "body": "あと約15分で到着予定です"
    }
  }
}

// Widget Extension の LiveActivity.swift
 
struct DeliveryLiveActivity: Widget {
    var body: some WidgetConfiguration {
        ActivityConfiguration(for: DeliveryAttributes.self) { context in
            // ロックスクリーン・スタンバイ表示
            LockScreenView(context: context)
        } dynamicIsland: { context in
            DynamicIsland {
                // 展開時（ユーザーがタップして展開した状態）
                DynamicIslandExpandedRegion(.leading) {
                    ExpandedLeadingView(context: context)
                }
                DynamicIslandExpandedRegion(.trailing) {
                    ExpandedTrailingView(context: context)
                }
                DynamicIslandExpandedRegion(.bottom) {
                    ExpandedBottomView(context: context)
                }
                DynamicIslandExpandedRegion(.center) {
                    ExpandedCenterView(context: context)
                }
            } compactLeading: {
                // コンパクト左側（通話中の赤い点のような位置）
                Image(systemName: deliveryIcon(for: context.state.status))
                    .foregroundStyle(.orange)
            } compactTrailing: {
                // コンパクト右側
                Text(context.state.progressPercentage.formatted(.percent.precision(.fractionLength(0))))
                    .font(.caption2.bold())
                    .foregroundStyle(.white)
            } minimal: {
                // 最小表示（他の Live Activity がある場合）
                Image(systemName: "bag.fill")
                    .foregroundStyle(.orange)
            }
            .keylineTint(.orange)
        }
    }
 
    func deliveryIcon(for status: DeliveryStatus) -> String {
        switch status {
        case .preparing: return "fork.knife"
        case .pickedUp: return "bicycle"
        case .nearBy: return "location.fill"
        case .delivered: return "checkmark.circle.fill"
        }
    }
}

struct LockScreenView: View {
    let context: ActivityViewContext<DeliveryAttributes>
 
    var body: some View {
        VStack(spacing: 12) {
            // ヘッダー
            HStack {
                Image(systemName: "bag.fill")
                    .foregroundStyle(.orange)
                Text(context.attributes.restaurantName)
                    .font(.headline)
                Spacer()
                Text(context.state.status.rawValue)
                    .font(.caption)
                    .padding(.horizontal, 8)
                    .padding(.vertical, 4)
                    .background(statusColor(context.state.status).opacity(0.2))
                    .foregroundStyle(statusColor(context.state.status))
                    .clipShape(Capsule())
            }
 
            // 進捗バー
            VStack(alignment: .leading, spacing: 4) {
                ProgressView(value: context.state.progressPercentage)
                    .tint(.orange)
                HStack {
                    Text(context.state.currentLocation)
                        .font(.caption2)
                        .foregroundStyle(.secondary)
                    Spacer()
                    // 到着予定時刻
                    Text(context.state.estimatedArrival, style: .relative)
                        .font(.caption2.bold())
                        + Text("後に到着予定")
                        .font(.caption2)
                }
            }
 
            // 注文内容サマリー
            Text(context.attributes.itemSummary)
                .font(.caption2)
                .foregroundStyle(.secondary)
                .lineLimit(1)
        }
        .padding(16)
        .activityBackgroundTint(Color.black.opacity(0.8))
        .activitySystemActionForegroundColor(.white)
    }
 
    func statusColor(_ status: DeliveryStatus) -> Color {
        switch status {
        case .preparing: return .blue
        case .pickedUp: return .orange
        case .nearBy: return .green
        case .delivered: return .gray
        }
    }
}

struct ExpandedBottomView: View {
    let context: ActivityViewContext<DeliveryAttributes>
 
    var body: some View {
        VStack(spacing: 8) {
            // 進捗バー（展開時はより詳細に）
            HStack {
                ForEach(DeliveryStatus.allCases, id: \.self) { step in
                    Circle()
                        .fill(isCompleted(step, current: context.state.status) ? Color.orange : Color.gray.opacity(0.3))
                        .frame(width: 8, height: 8)
                    if step != DeliveryStatus.allCases.last {
                        Rectangle()
                            .fill(isCompleted(step, current: context.state.status) ? Color.orange : Color.gray.opacity(0.3))
                            .frame(height: 2)
                    }
                }
            }
 
            HStack {
                VStack(alignment: .leading) {
                    Text("現在地")
                        .font(.caption2)
                        .foregroundStyle(.secondary)
                    Text(context.state.currentLocation)
                        .font(.caption.bold())
                }
                Spacer()
                VStack(alignment: .trailing) {
                    Text("到着予定")
                        .font(.caption2)
                        .foregroundStyle(.secondary)
                    Text(context.state.estimatedArrival, style: .time)
                        .font(.caption.bold())
                        .foregroundStyle(.orange)
                }
            }
        }
        .padding(.horizontal, 16)
        .padding(.bottom, 12)
    }
 
    func isCompleted(_ step: DeliveryStatus, current: DeliveryStatus) -> Bool {
        let order: [DeliveryStatus] = [.preparing, .pickedUp, .nearBy, .delivered]
        guard let stepIndex = order.firstIndex(of: step),
              let currentIndex = order.firstIndex(of: current) else { return false }
        return stepIndex <= currentIndex
    }
}
 
extension DeliveryStatus: CaseIterable {}

// Antigravity に「DeliveryAttributes の全状態をプレビューするコードを生成して」
#Preview("Dynamic Island - Compact", as: .dynamicIsland(.compact),
         using: DeliveryAttributes.preview) {
    DeliveryLiveActivity()
} contentStates: {
    DeliveryAttributes.ContentState.preparing
    DeliveryAttributes.ContentState.pickedUp
    DeliveryAttributes.ContentState.nearBy
    DeliveryAttributes.ContentState.delivered
}
 
#Preview("Dynamic Island - Expanded", as: .dynamicIsland(.expanded),
         using: DeliveryAttributes.preview) {
    DeliveryLiveActivity()
} contentStates: {
    DeliveryAttributes.ContentState.nearBy
}
 
#Preview("Lock Screen", as: .content, using: DeliveryAttributes.preview) {
    DeliveryLiveActivity()
} contentStates: {
    DeliveryAttributes.ContentState.preparing
    DeliveryAttributes.ContentState.pickedUp
}
 
// プレビュー用の拡張
extension DeliveryAttributes {
    static var preview: DeliveryAttributes {
        DeliveryAttributes(
            orderID: "ORD-2026-001",
            restaurantName: "さくら食堂",
            itemSummary: "唐揚げ定食、みそ汁"
        )
    }
}
 
extension DeliveryAttributes.ContentState {
    static var preparing: DeliveryAttributes.ContentState {
        .init(status: .preparing,
              estimatedArrival: Date().addingTimeInterval(1800),
              currentLocation: "さくら食堂で準備中",
              progressPercentage: 0.1)
    }
 
    static var pickedUp: DeliveryAttributes.ContentState {
        .init(status: .pickedUp,
              estimatedArrival: Date().addingTimeInterval(900),
              currentLocation: "〇〇通り付近",
              progressPercentage: 0.6)
    }
 
    static var nearBy: DeliveryAttributes.ContentState {
        .init(status: .nearBy,
              estimatedArrival: Date().addingTimeInterval(180),
              currentLocation: "あなたの近く",
              progressPercentage: 0.9)
    }
 
    static var delivered: DeliveryAttributes.ContentState {
        .init(status: .delivered,
              estimatedArrival: Date(),
              currentLocation: "配達完了",
              progressPercentage: 1.0)
    }
}

struct AnimatedProgressView: View {
    let progress: Double
    @State private var animatedProgress: Double = 0
 
    var body: some View {
        ProgressView(value: animatedProgress)
            .tint(.orange)
            .animation(.spring(response: 0.6, dampingFraction: 0.8), value: animatedProgress)
            .onAppear {
                animatedProgress = progress
            }
            .onChange(of: progress) { _, newValue in
                withAnimation(.spring(response: 0.6, dampingFraction: 0.8)) {
                    animatedProgress = newValue
                }
            }
    }
}

// デバッグ用：状態を素早く切り替えるテストヘルパー
#if DEBUG
class LiveActivityTestHelper {
    static func simulateDeliveryProgress() async {
        guard let activity = Activity<DeliveryAttributes>.activities.first else { return }
 
        let states: [(DeliveryStatus, String, Double)] = [
            (.preparing, "さくら食堂で準備中", 0.1),
            (.pickedUp, "渋谷区道玄坂", 0.5),
            (.nearBy, "目的地まで200m", 0.9),
            (.delivered, "配達完了", 1.0)
        ]
 
        for (status, location, progress) in states {
            let state = DeliveryAttributes.ContentState(
                status: status,
                estimatedArrival: Date().addingTimeInterval(Double(states.count) * 60),
                currentLocation: location,
                progressPercentage: progress
            )
            let content = ActivityContent(state: state, staleDate: nil)
            await activity.update(content)
 
            try? await Task.sleep(nanoseconds: 2_000_000_000) // 2秒待機
        }
    }
}
#endif

// 本番品質のエラーハンドリング
func startActivityWithRetry(order: Order, maxRetries: Int = 3) async throws -> Activity<DeliveryAttributes> {
    var lastError: Error?
 
    for attempt in 1...maxRetries {
        do {
            return try await LiveActivityManager.shared.startDeliveryActivity(order: order)
        } catch let error as ActivityAuthorizationError {
            switch error {
            case .denied:
                // ユーザーが許可を拒否 → 設定アプリへ誘導
                throw LiveActivityError.notAuthorized
            default:
                lastError = error
                if attempt < maxRetries {
                    try await Task.sleep(nanoseconds: UInt64(pow(2.0, Double(attempt))) * 1_000_000_000)
                }
            }
        } catch {
            lastError = error
            if attempt < maxRetries {
                try await Task.sleep(nanoseconds: 1_000_000_000)
            }
        }
    }
 
    throw lastError ?? LiveActivityError.activityNotFound
}

// アクティブな Live Activity を安全に取得
func getActiveActivities() -> [Activity<DeliveryAttributes>] {
    return Activity<DeliveryAttributes>.activities.filter {
        $0.activityState == .active || $0.activityState == .stale
    }
}
 
// 特定の注文IDに紐づく Live Activity を更新
func updateActivity(forOrderID orderID: String, newState: DeliveryAttributes.ContentState) async {
    guard let activity = Activity<DeliveryAttributes>.activities.first(where: {
        $0.attributes.orderID == orderID
    }) else { return }
 
    let content = ActivityContent(
        state: newState,
        staleDate: Calendar.current.date(byAdding: .minute, value: 20, to: .now),
        relevanceScore: DeliveryRelevance.score(for: newState)   // ← 更新のたびに渡し直す
    )
    await activity.update(content)
}

// UIKit の ViewController から Live Activity を管理
class OrderDetailViewController: UIViewController {
    private var liveActivityTask: Task<Void, Never>?
 
    func startTracking(order: Order) {
        liveActivityTask = Task {
            do {
                let activity = try await startActivityWithRetry(order: order)
                // アクティビティの状態変化を監視
                for await state in activity.activityStateUpdates {
                    await MainActor.run {
                        self.updateUI(for: state)
                    }
                }
            } catch {
                await MainActor.run {
                    self.showError(error)
                }
            }
        }
    }
 
    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        liveActivityTask?.cancel()
    }
 
    func updateUI(for state: ActivityState) {
        switch state {
        case .active:
            trackingStatusLabel.text = "ライブ追跡中"
        case .stale:
            trackingStatusLabel.text = "情報が古くなっています"
        case .ended, .dismissed:
            trackingStatusLabel.text = "追跡終了"
        @unknown default:
            break
        }
    }
}

// ❌ Live Activity の更新だけに依存する設計
func notifyDeliveryArrival(activity: Activity<DeliveryAttributes>) async {
    try? await activity.update(using: .init(status: .arrived, eta: 0))
}
 
// ✅ Live Activity + 通常通知の二重化
func notifyDeliveryArrival(activity: Activity<DeliveryAttributes>) async {
    try? await activity.update(using: .init(status: .arrived, eta: 0))
 
    // 重要な状態遷移は UNUserNotificationCenter からも送る
    let content = UNMutableNotificationContent()
    content.title = "配達が完了しました"
    content.body = "玄関先に置きました"
    content.sound = .default
 
    let request = UNNotificationRequest(
        identifier: "delivery_arrived_\(activity.id)",
        content: content,
        trigger: nil
    )
    try? await UNUserNotificationCenter.current().add(request)
}

// 開始時に staleDate を「想定される最大の有効時間」で設定
let staleDate = Date().addingTimeInterval(60 * 60) // 1時間後
 
let content = ActivityContent(
    state: DeliveryAttributes.ContentState(status: .delivering, eta: 15),
    staleDate: staleDate,
    relevanceScore: 50
)
 
let activity = try Activity<DeliveryAttributes>.request(
    attributes: attributes,
    content: content,
    pushType: .token
)

ActivityConfiguration(for: DeliveryAttributes.self) { context in
    if context.isStale {
        DeliveryStaleView()  // グレーアウト + 取得中表示
    } else {
        DeliveryLockScreenView(state: context.state)
    }
}

Task {
    for await tokenData in activity.pushTokenUpdates {
        let token = tokenData.map { String(format: "%02x", $0) }.joined()
        // 古いトークンを置き換えるため、activity.id を主キーに upsert
        try await DeliveryAPIClient.shared.upsertPushToken(
            activityId: activity.id,
            token: token,
            appVersion: Bundle.main.appVersion
        )
    }
}

DynamicIsland {
    // expanded — 情報量を最も載せられる
    ...
} compactLeading: {
    Image(systemName: "shippingbox.fill")   // ← アイコン1個だけ
        .foregroundStyle(.blue)
} compactTrailing: {
    Text("15m")                              // ← 数字 + 最小限の単位
        .monospacedDigit()
        .font(.caption)
} minimal: {
    Image(systemName: "shippingbox.fill")   // ← 最も小さいモードはアイコンのみ
}

struct ActiveLiveActivityListView: View {
    @State private var activities: [Activity<DeliveryAttributes>] = []
 
    var body: some View {
        List(activities, id: \.id) { activity in
            VStack(alignment: .leading) {
                Text("配達 #\(activity.id.prefix(6))")
                Text(activity.content.state.status.label)
                    .font(.caption)
                    .foregroundStyle(.secondary)
            }
            .swipeActions {
                Button("終了", role: .destructive) {
                    Task {
                        await activity.end(nil, dismissalPolicy: .immediate)
                    }
                }
            }
        }
        .task {
            for await update in Activity<DeliveryAttributes>.activityUpdates {
                activities = Activity<DeliveryAttributes>.activities
                _ = update
            }
        }
    }
}

enum DeliveryRelevance {
    /// ContentState だけから決まる純粋関数にしておくと、
    /// アプリ側・APNs 受信後・再開時のどこから呼んでも同じ点数になります
    static func score(for state: DeliveryAttributes.ContentState) -> Double {
        switch state.status {
        case .arrived:
            return 100
        case .delivering:
            // ETA が縮むほど上がる連続値。同点を作らないことが肝心です
            return max(30, 95 - Double(state.eta))
        case .preparing:
            return 20
        }
    }
}
 
func pushState(
    _ activity: Activity<DeliveryAttributes>,
    _ state: DeliveryAttributes.ContentState
) async {
    let content = ActivityContent(
        state: state,
        staleDate: Date().addingTimeInterval(60 * 20),
        relevanceScore: DeliveryRelevance.score(for: state)
    )
    await activity.update(content)
}

@main
struct AppWidgets: WidgetBundle {
    var body: some Widget {
        // 既存のホーム画面 Widget
        DeliveryHomeWidget()
        // 後から追加した Live Activity
        DeliveryLiveActivity()
    }
}