Antigravity × SwiftUI Live Activities & Dynamic Island: An Implementation Guide for iOS 26

import ActivityKit
 
class LiveActivityManager {
    static let shared = LiveActivityManager()
 
    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 initialState = DeliveryAttributes.ContentState(
            status: .preparing,
            estimatedArrival: order.estimatedDeliveryTime,
            currentLocation: "Preparing at restaurant",
            progressPercentage: 0.1
        )
 
        let content = ActivityContent(
            state: initialState,
            staleDate: Calendar.current.date(byAdding: .minute, value: 30, to: .now)
        )
 
        // Enable server-side push updates via APNs
        let activity = try Activity.request(
            attributes: attributes,
            content: content,
            pushType: .token
        )
 
        // Capture push token and send to your server
        Task {
            for await tokenData in activity.pushTokenUpdates {
                let token = tokenData.map { String(format: "%02x", $0) }.joined()
                await sendPushTokenToServer(token: token, activityID: activity.id)
            }
        }
 
        return 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)
    }
 
    func endDeliveryActivity(activity: Activity<DeliveryAttributes>) async {
        let finalState = DeliveryAttributes.ContentState(
            status: .delivered,
            estimatedArrival: .now,
            currentLocation: "Delivered!",
            progressPercentage: 1.0
        )
 
        let finalContent = ActivityContent(state: finalState, staleDate: nil)
 
        // Dismiss from lock screen 5 minutes after delivery
        await activity.end(finalContent, dismissalPolicy: .after(.now + 300))
    }
}
 
enum LiveActivityError: Error {
    case notAuthorized
    case activityNotFound
}

func observePushTokenUpdates(activity: Activity<DeliveryAttributes>) {
    Task {
        for await tokenData in activity.pushTokenUpdates {
            let tokenHex = tokenData.map { String(format: "%02x", $0) }.joined()
 
            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": "3rd Ave, near Oak St",
      "progressPercentage": 0.6
    },
    "stale-date": 1712003600,
    "alert": {
      "title": "Your order has been picked up",
      "body": "Estimated arrival in ~15 minutes"
    }
  }
}

struct DeliveryLiveActivity: Widget {
    var body: some WidgetConfiguration {
        ActivityConfiguration(for: DeliveryAttributes.self) { context in
            // Lock screen / StandBy display
            LockScreenView(context: context)
        } dynamicIsland: { context in
            DynamicIsland {
                // Expanded — user tapped the island
                DynamicIslandExpandedRegion(.leading) {
                    ExpandedLeadingView(context: context)
                }
                DynamicIslandExpandedRegion(.trailing) {
                    ExpandedTrailingView(context: context)
                }
                DynamicIslandExpandedRegion(.bottom) {
                    ExpandedBottomView(context: context)
                }
                DynamicIslandExpandedRegion(.center) {
                    ExpandedCenterView(context: context)
                }
            } compactLeading: {
                // Compact left — shown when no other activities are active
                Image(systemName: deliveryIcon(for: context.state.status))
                    .foregroundStyle(.orange)
            } compactTrailing: {
                // Compact right
                Text(context.state.progressPercentage.formatted(.percent.precision(.fractionLength(0))))
                    .font(.caption2.bold())
                    .foregroundStyle(.white)
            } minimal: {
                // Minimal — shown when another Live Activity is also active
                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(" remaining")
                        .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) {
            // Step indicator
            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("Location")
                        .font(.caption2)
                        .foregroundStyle(.secondary)
                    Text(context.state.currentLocation)
                        .font(.caption.bold())
                }
                Spacer()
                VStack(alignment: .trailing) {
                    Text("ETA")
                        .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 {}

#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: "Sakura Kitchen",
            itemSummary: "Teriyaki Bento, Miso Soup"
        )
    }
}
 
extension DeliveryAttributes.ContentState {
    static var preparing: DeliveryAttributes.ContentState {
        .init(status: .preparing,
              estimatedArrival: Date().addingTimeInterval(1800),
              currentLocation: "Preparing at Sakura Kitchen",
              progressPercentage: 0.1)
    }
    static var pickedUp: DeliveryAttributes.ContentState {
        .init(status: .pickedUp,
              estimatedArrival: Date().addingTimeInterval(900),
              currentLocation: "Main St & 5th Ave",
              progressPercentage: 0.6)
    }
    static var nearBy: DeliveryAttributes.ContentState {
        .init(status: .nearBy,
              estimatedArrival: Date().addingTimeInterval(180),
              currentLocation: "Around the corner",
              progressPercentage: 0.9)
    }
    static var delivered: DeliveryAttributes.ContentState {
        .init(status: .delivered,
              estimatedArrival: Date(),
              currentLocation: "Delivered!",
              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, "Preparing at restaurant", 0.1),
            (.pickedUp, "Oak Street, heading your way", 0.5),
            (.nearBy, "200m from your location", 0.9),
            (.delivered, "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
            )
            await activity.update(ActivityContent(state: state, staleDate: nil))
            try? await Task.sleep(nanoseconds: 2_000_000_000)
        }
    }
}
#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 {
            if case .denied = error { throw LiveActivityError.notAuthorized }
            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
}

func getActiveActivities() -> [Activity<DeliveryAttributes>] {
    return Activity<DeliveryAttributes>.activities.filter {
        $0.activityState == .active || $0.activityState == .stale
    }
}
 
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)   // re-send it every update
    )
    await activity.update(content)
}

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 = "Live tracking active"
        case .stale:
            trackingStatusLabel.text = "Information may be outdated"
        case .ended, .dismissed:
            trackingStatusLabel.text = "Tracking ended"
        @unknown default:
            break
        }
    }
}

// ❌ Relying only on the Live Activity update
func notifyDeliveryArrival(activity: Activity<DeliveryAttributes>) async {
    try? await activity.update(using: .init(status: .arrived, eta: 0))
}
 
// ✅ Live Activity update + regular notification fallback
func notifyDeliveryArrival(activity: Activity<DeliveryAttributes>) async {
    try? await activity.update(using: .init(status: .arrived, eta: 0))
 
    let content = UNMutableNotificationContent()
    content.title = "Your delivery has arrived"
    content.body = "Left at your front door."
    content.sound = .default
 
    let request = UNNotificationRequest(
        identifier: "delivery_arrived_\(activity.id)",
        content: content,
        trigger: nil
    )
    try? await UNUserNotificationCenter.current().add(request)
}

// Set staleDate to the maximum useful lifetime of this Activity
let staleDate = Date().addingTimeInterval(60 * 60) // 1 hour
 
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()  // greyed out + "refreshing" hint
    } else {
        DeliveryLockScreenView(state: context.state)
    }
}

Task {
    for await tokenData in activity.pushTokenUpdates {
        let token = tokenData.map { String(format: "%02x", $0) }.joined()
        try await DeliveryAPIClient.shared.upsertPushToken(
            activityId: activity.id,
            token: token,
            appVersion: Bundle.main.appVersion
        )
    }
}

DynamicIsland {
    // expanded — this is where you actually convey information
    ...
} compactLeading: {
    Image(systemName: "shippingbox.fill")   // one icon, nothing else
        .foregroundStyle(.blue)
} compactTrailing: {
    Text("15m")                              // a number + one short unit
        .monospacedDigit()
        .font(.caption)
} minimal: {
    Image(systemName: "shippingbox.fill")   // smallest mode = icon only
}

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

enum DeliveryRelevance {
    /// A pure function of ContentState, so the app, the post-APNs path,
    /// and the resume path all compute the same score.
    static func score(for state: DeliveryAttributes.ContentState) -> Double {
        switch state.status {
        case .arrived:
            return 100
        case .delivering:
            // Continuous, rising as ETA shrinks. Avoiding ties is the point.
            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 {
        // existing home-screen widget
        DeliveryHomeWidget()
        // Live Activity added on top
        DeliveryLiveActivity()
    }
}