Showing Live Progress in the Dynamic Island from a Rork Max Swift App

Launch a Minimal Live Activity

With the attributes in place, start the Activity from the app. Calling it from the view-model layer that Rork Max generated is the natural fit.

func startTimerActivity(name: String, minutes: Int) throws {
    guard ActivityAuthorizationInfo().areActivitiesEnabled else {
        throw ActivityError.notAuthorized
    }
 
    let attributes = TimerAttributes(taskName: name)
    let end = Date().addingTimeInterval(Double(minutes) * 60)
    let state = TimerAttributes.ContentState(endDate: end, isPaused: false)
 
    let activity = try Activity.request(
        attributes: attributes,
        content: .init(state: state, staleDate: end.addingTimeInterval(60)),
        pushType: nil
    )
    print("started activity: \(activity.id)")
}

Passing a staleDate lets the system mark the presentation as outdated once the end time passes. I set it one minute after the end so the display does not vanish at the exact zero-second mark.

Split the Three Dynamic Island Presentations

This is the core. In the Widget Extension you write an ActivityConfiguration and fill in compact, minimal, and expanded inside the dynamicIsland closure.

struct TimerLiveActivity: Widget {
    var body: some WidgetConfiguration {
        ActivityConfiguration(for: TimerAttributes.self) { context in
            // Lock screen / banner
            LockScreenView(context: context)
                .padding()
        } dynamicIsland: { context in
            DynamicIsland {
                DynamicIslandExpandedRegion(.leading) {
                    Label(context.attributes.taskName, systemImage: "timer")
                }
                DynamicIslandExpandedRegion(.trailing) {
                    Text(timerInterval: Date()...context.state.endDate)
                        .monospacedDigit()
                        .frame(maxWidth: 64)
                }
            } compactLeading: {
                Image(systemName: "timer")
            } compactTrailing: {
                Text(timerInterval: Date()...context.state.endDate)
                    .monospacedDigit()
                    .frame(maxWidth: 44)
            } minimal: {
                Image(systemName: "timer")
            }
        }
    }
}

I fix the width of compactTrailing to stop the layout from jittering as the digit count changes. Pairing monospacedDigit() with frame(maxWidth:) keeps the island width stable even when it grows from 59 to 60. That behavior is hard to notice without a device.

Using Text(timerInterval:) lets the system advance the countdown without you sending an update every second. Hand continuous values like remaining time to that mechanism; it pays off as update-budget savings.

The Reality of State and Remote Updates

Update explicit "milestone" changes like pause and resume yourself.

func pause(_ activity: Activity<TimerAttributes>) async {
    var s = activity.content.state
    s.isPaused = true
    await activity.update(.init(state: s, staleDate: nil))
}

Local updates are enough for that, but to reflect a server-side event (a delivery status change) you need push updates. Take the token from pushType: .token, send it to your own backend, and post to APNs with the apns-push-type: liveactivity header. Leave it as alert and nothing arrives, so check that first.

Pitfalls I Hit in Production

Even in a tiny app, several limits only showed up once it shipped. Here they are roughly in the order they bit me.

1. A Live Activity auto-ends after at most eight hours. Long timers need a separate restart path afterward.
2. Updates have a frequency budget; calling update every second gets throttled. Hand continuous values to Text(timerInterval:) and keep explicit updates to milestones.
3. Push updates require apns-push-type: liveactivity. I burned hours with it stuck on alert.
4. The simulator does not match the device for the Dynamic Island. Treat a real device as mandatory for verification.
5. Forget to set staleDate and a finished presentation lingers.
6. End with activity.end(...) and a dismissalPolicy: .immediate for instant removal, .after(date) to leave a tail.
7. Without NSSupportsLiveActivities set to YES in Info.plist it will not start at all. Freshly generated plists often lack it, so add it by hand.

In numbers, narrowing explicit updates to milestones cut my updates-per-hour by roughly 90% by feel, and the system throttling warnings disappeared.

What to Write Yourself, What to Delegate

In my own workflow I design the state model (ActivityAttributes) and the update logic myself, and I let Rork Max handle the initial lock-screen layout and color matching. The reason is simple: get the state design wrong and both surfaces break together, and fixing it later is expensive. Visual tweaks, by contrast, iterate fast between generation and hand edits, so they are worth drafting with AI.

The Dynamic Island is one of the few places to deliver value during the time the app is not open. Unlike ad revenue from AdMob, this works on the satisfaction of the experience itself. Just having the remaining time on the island softened the tone of my reviews. Small as it is, getting your first one shipped is well worth it.

I hope this helps with your implementation.