Notifications, APNs and Live Activities

// FieldNotes/Notifications/PushRegistration.swift
import Foundation

@MainActor
final class PushRegistration {
    static let shared = PushRegistration()
    private(set) var deviceToken: String?

    private init() {}

    /// Called from application(_:didRegisterForRemoteNotificationsWithDeviceToken:).
    func record(_ token: Data) {
        let hex = token.map { String(format: "%02x", $0) }.joined()
        guard hex != deviceToken else { return }
        deviceToken = hex
        Task { try? await upload(["deviceToken": hex], to: "devices") }
    }

    /// Live Activity tokens (below) go to the same provider, with the activity they belong to.
    func recordActivityToken(_ token: Data, activityID: String?) {
        let hex = token.map { String(format: "%02x", $0) }.joined()
        var body = ["activityToken": hex]
        if let activityID { body["activityID"] = activityID } else { body["kind"] = "push-to-start" }
        Task { try? await upload(body, to: "activity-tokens") }
    }

    private func upload(_ body: [String: String], to path: String) async throws {
        var request = URLRequest(url: URL(string: "https://api.fieldnotes.example.com/\(path)")!)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try JSONEncoder().encode(body)
        _ = try await URLSession.shared.data(for: request)
    }
}

{
  "aps": {
    "alert": {
      "title": "Ana shared a reminder",
      "subtitle": "Coastal survey",
      "body": "Check the heron nest before 10:00"
    },
    "sound": "default",
    "badge": 3,
    "category": "NOTE_REMINDER",
    "thread-id": "notebook-2F6C1C9E",
    "interruption-level": "time-sensitive",
    "mutable-content": 1
  },
  "noteID": "9B1DEB4D-3B7D-4BAD-9BDD-2B0D7B3DCB6D",
  "photoURL": "https://api.fieldnotes.example.com/photos/5f1c.jpg",
  "sealedBody": "q8v3...base64..."
}

# Development test from a terminal; the provider does the same over a persistent HTTP/2 connection.
# AUTHENTICATION_TOKEN is the ES256-signed JWT: header {"alg":"ES256","kid":"<KEY_ID>"},
# claims {"iss":"<TEAM_ID>","iat":<now>}.
curl --http2 \
  --header "authorization: bearer $AUTHENTICATION_TOKEN" \
  --header "apns-topic: com.example.fieldnotes" \
  --header "apns-push-type: alert" \
  --header "apns-priority: 10" \
  --header "apns-expiration: 0" \
  --header "apns-collapse-id: reminder-9B1DEB4D" \
  --data @shared-reminder.json \
  https://api.sandbox.push.apple.com/3/device/$DEVICE_TOKEN

// Packages/FieldNotesKit/Sources/FieldNotesModel/FieldTripAttributes.swift
#if os(iOS)
import ActivityKit
import Foundation

public struct FieldTripAttributes: ActivityAttributes {
    public struct ContentState: Codable, Hashable {
        public var notesCaptured: Int
        public var lastPlaceName: String?

        public init(notesCaptured: Int = 0, lastPlaceName: String? = nil) {
            self.notesCaptured = notesCaptured
            self.lastPlaceName = lastPlaceName
        }
    }

    public var tripName: String
    public var notebookID: UUID
    public var startedAt: Date

    public init(tripName: String, notebookID: UUID, startedAt: Date = .now) {
        self.tripName = tripName
        self.notebookID = notebookID
        self.startedAt = startedAt
    }
}
#endif

// FieldNotesWidgets/FieldTripLiveActivity.swift
#if os(iOS)   // ActivityKit: iPhone and iPad only; the widget extension also builds for Mac and Apple Vision
import ActivityKit
import AppIntents
import SwiftUI
import WidgetKit
import FieldNotesModel

struct FieldTripLiveActivity: Widget {
    var body: some WidgetConfiguration {
        ActivityConfiguration(for: FieldTripAttributes.self) { context in
            FieldTripLockScreenView(context: context)
                .activityBackgroundTint(.green.opacity(0.25))
                .widgetURL(URL(string: "fieldnotes://notebook/\(context.attributes.notebookID)"))
        } dynamicIsland: { context in
            DynamicIsland {
                DynamicIslandExpandedRegion(.leading) {
                    Label("\(context.state.notesCaptured)", systemImage: "note.text")
                        .font(.title3)
                }
                DynamicIslandExpandedRegion(.trailing) {
                    Text(context.attributes.startedAt, style: .timer)
                        .monospacedDigit()
                        .multilineTextAlignment(.trailing)
                }
                DynamicIslandExpandedRegion(.center) {
                    Text(context.attributes.tripName).lineLimit(1)
                }
                DynamicIslandExpandedRegion(.bottom) {
                    HStack {
                        if let place = context.state.lastPlaceName {
                            Text("Last: \(place)").font(.caption)
                        }
                        Spacer()
                        Button(intent: EndFieldTripIntent(activityID: context.activityID)) {
                            Label("End Trip", systemImage: "flag.checkered")
                        }
                    }
                }
            } compactLeading: {
                Image(systemName: "binoculars.fill")
            } compactTrailing: {
                FieldTripCompactTrailing(notesCaptured: context.state.notesCaptured)
            } minimal: {
                Text("\(context.state.notesCaptured)")
            }
            .widgetURL(URL(string: "fieldnotes://notebook/\(context.attributes.notebookID)"))
            .keylineTint(.green)
        }
        .supplementalActivityFamilies([.small])
    }
}
#endif

// FieldNotesWidgets/FieldTripCompactTrailing.swift
import SwiftUI

struct FieldTripCompactTrailing: View {
    let notesCaptured: Int

    var body: some View {
        if #available(iOS 27, *) {
            WidthAwareNoteCount(notesCaptured: notesCaptured)
        } else {
            Text("\(notesCaptured) notes")
        }
    }
}

@available(iOS 27, *)
private struct WidthAwareNoteCount: View {
    @Environment(\.isDynamicIslandLimitedInWidth) private var isLimitedInWidth
    let notesCaptured: Int

    var body: some View {
        if isLimitedInWidth {
            Image(systemName: "note.text")                 // landscape: an icon fits, text does not
                .accessibilityLabel("\(notesCaptured) notes")
        } else {
            Text("\(notesCaptured) notes")
        }
    }
}

// FieldNotesWidgets/FieldTripLockScreenView.swift
#if os(iOS)   // ActivityKit: iPhone and iPad only; the widget extension also builds for Mac and Apple Vision
import ActivityKit
import SwiftUI
import WidgetKit
import FieldNotesModel

struct FieldTripLockScreenView: View {
    @Environment(\.activityFamily) private var activityFamily
    let context: ActivityViewContext<FieldTripAttributes>

    var body: some View {
        switch activityFamily {
        case .small:
            // Apple Watch Smart Stack and CarPlay: two lines, large type.
            VStack(alignment: .leading) {
                Text(context.attributes.tripName).font(.headline).lineLimit(1)
                Text("\(context.state.notesCaptured) notes").font(.title3.bold())
            }
        default:
            VStack(alignment: .leading, spacing: 6) {
                HStack {
                    Text(context.attributes.tripName).font(.headline)
                    Spacer()
                    Text(context.attributes.startedAt, style: .timer).monospacedDigit()
                }
                Text("\(context.state.notesCaptured) notes captured")
                if let place = context.state.lastPlaceName {
                    Text("Last: \(place)").foregroundStyle(.secondary)
                }
                if context.isStale {
                    Text("Waiting for updates").font(.caption).foregroundStyle(.orange)
                }
            }
            .padding()
        }
    }
}
#endif

// FieldNotes/FieldTrip/FieldTripActivityController.swift
#if os(iOS)
import ActivityKit
import Foundation
import FieldNotesModel

@MainActor
final class FieldTripActivityController {
    private var activity: Activity<FieldTripAttributes>?

    func start(tripName: String, notebookID: UUID) throws {
        guard ActivityAuthorizationInfo().areActivitiesEnabled else { return }
        let attributes = FieldTripAttributes(tripName: tripName, notebookID: notebookID)
        let content = ActivityContent(state: FieldTripAttributes.ContentState(), staleDate: nil)
        let activity = try Activity.request(attributes: attributes, content: content, pushType: .token)
        self.activity = activity

        // The token arrives asynchronously and can change; forward every value to the provider.
        Task {
            for await token in activity.pushTokenUpdates {
                PushRegistration.shared.recordActivityToken(token, activityID: activity.id)
            }
        }
    }

    /// Called by NoteStore's capture path whenever a note is added during the trip.
    func noteCaptured(at placeName: String?) async {
        guard let activity else { return }
        var state = activity.content.state
        state.notesCaptured += 1
        state.lastPlaceName = placeName
        // Stale after 30 minutes without news, so the view can say "Waiting for updates".
        await activity.update(ActivityContent(state: state, staleDate: .now.addingTimeInterval(30 * 60)))
    }

    func end() async {
        guard let activity else { return }
        await activity.end(activity.content, dismissalPolicy: .after(.now.addingTimeInterval(15 * 60)))
        self.activity = nil
    }
}
#endif

// FieldTripActivityController.swift (continued)
#if os(iOS)
extension FieldTripActivityController {
    func schedule(tripName: String, notebookID: UUID, startingAt start: Date) throws {
        let attributes = FieldTripAttributes(tripName: tripName, notebookID: notebookID, startedAt: start)
        _ = try Activity.request(
            attributes: attributes,
            content: ActivityContent(state: FieldTripAttributes.ContentState(), staleDate: nil),
            pushType: .token,
            style: .standard,
            alertConfiguration: AlertConfiguration(
                title: "Field trip starting",
                body: "\(tripName) begins now. Captured notes will appear here.",
                sound: .default),
            start: start)
    }
}
#endif

{
  "aps": {
    "timestamp": 1790000000,
    "event": "update",
    "content-state": {
      "notesCaptured": 8,
      "lastPlaceName": "Heron Point"
    },
    "stale-date": 1790001800,
    "alert": {
      "title": "New note from Ana",
      "body": "Heron Point: two chicks visible"
    }
  }
}

// Started once at launch, for example from FieldNotesAppDelegate.
#if os(iOS)
import ActivityKit
import FieldNotesModel

@MainActor
func forwardPushToStartTokens() {
    Task {
        for await token in Activity<FieldTripAttributes>.pushToStartTokenUpdates {
            PushRegistration.shared.recordActivityToken(token, activityID: nil)
        }
    }
}
#endif

// FieldTripActivityController.swift (continued)
#if os(iOS)
extension FieldTripActivityController {
    /// `channelID` comes from the FieldNotes server, which created the channel with APNs.
    func join(groupTrip tripName: String, notebookID: UUID, channelID: String) throws {
        _ = try Activity.request(
            attributes: FieldTripAttributes(tripName: tripName, notebookID: notebookID),
            content: ActivityContent(state: FieldTripAttributes.ContentState(), staleDate: nil),
            pushType: .channel(channelID))
    }
}
#endif

curl --http2 \
  --header "authorization: bearer $AUTHENTICATION_TOKEN" \
  --header "apns-push-type: liveactivity" \
  --header "apns-channel-id: $CHANNEL_ID" \
  --header "apns-priority: 10" \
  --header "apns-expiration: 0" \
  --data '{"aps":{"timestamp":'$(date +%s)',"event":"update","content-state":{"notesCaptured":12,"lastPlaceName":"Dune crest"}}}' \
  https://api-broadcast.sandbox.push.apple.com/4/broadcasts/apps/com.example.fieldnotes

// Shared/EndFieldTripIntent.swift (member of FieldNotes and FieldNotesWidgets)
#if os(iOS)
import ActivityKit
import AppIntents
import FieldNotesModel

struct EndFieldTripIntent: LiveActivityIntent {
    static let title: LocalizedStringResource = "End Field Trip"

    @Parameter(title: "Activity ID")
    var activityID: String

    init() {}

    init(activityID: String) {
        self.activityID = activityID
    }

    func perform() async throws -> some IntentResult {
        for activity in Activity<FieldTripAttributes>.activities where activity.id == activityID {
            await activity.end(activity.content, dismissalPolicy: .immediate)
        }
        return .result()
    }
}
#endif