Einen Live-Activity-Timer in Expo bauen
Live Activities auf iOS sind ein echter Gamechanger: Mit ihnen können Apps Echtzeit-Updates direkt auf dem Sperrbildschirm oder in der Dynamic Island anzeigen. Natürlich habe ich mir sofort vorgestellt, wie cool ein Workout-Timer dort wäre, der Nutzer motiviert hält, ohne dass sie ihr Handy entsperren müssen. Aber es gab einen Haken: Live Activities werden mit Apples nativen Werkzeugen gebaut, also mit Swift und ActivityKit. Statt ganze Module von Grund auf zu schreiben, habe ich dann ein Tool namens expo-apple-targets entdeckt, das den Prozess viel einfacher gemacht hat, als ich erwartet hatte. In diesem Artikel zeige ich dir, wie ich eine timerbasierte Live Activity für iOS gebaut habe, welche Schritte ich gegangen bin und was ich dabei gelernt habe.
Warum ich von Live Activities besessen war
Live Activities sind nicht nur ein cooler Trick, sie verändern das Nutzerengagement grundlegend. Apples Human Interface Guidelines beschreiben sie als Möglichkeit, "aktuelle, auf einen Blick erfassbare Informationen" für zeitkritische Aufgaben zu liefern. Stell dir eine Fitness-App vor, die mitten im Workout deine Plank-Zeit zeigt, eine Lieferdienst-App, die den Weg deiner Pizza verfolgt, oder eine Fahrdienst-App, die die Ankunftszeit deines Fahrers aktualisiert, alles direkt auf dem Sperrbildschirm oder, ab dem iPhone 14 Pro, in der Dynamic Island. Es ist, als würdest du Nutzern einen VIP-Pass zu den wichtigsten Updates deiner App geben, ohne dass sie ihr Handy entsperren müssen.
Ich wollte, dass Nutzer sehen, wie ihr Workout-Timer während eines Satzes hochzählt, damit sie fokussiert bleiben, ohne die App öffnen zu müssen. Genau dieser Feinschliff lässt eine App professionell wirken, und ich war voll dabei. Aber das alles geht nicht, ohne die native Ebene anzufassen, also wusste ich, dass ich in Swift eintauchen und mit Xcode ringen würde. Dann habe ich expo-apple-targets entdeckt, ein Paket, das die Lücke zwischen der JavaScript-Welt von Expo und den nativen Features von iOS schließt. Großes Lob an Evan Bacon: Dieses Tool hat eine einschüchternde Aufgabe in ein herausforderndes, aber machbares Puzzle verwandelt.
Das große Ganze: Live Activities in einer Expo-App
Live Activities sind eine reine iOS-Party. Sie basieren auf ActivityKit, einem Swift-Framework, was bedeutet, dass du nativen Code schreibst, ob du willst oder nicht. Für eine Expo-App ist das, als würdest du einen Fisch überreden, auf einen Baum zu klettern: Es ist möglich, aber es kostet Mühe. expo-apple-targets springt hier wie ein erfahrener Bergführer ein und liefert ein Framework, um native Module und Widget Extensions zu erstellen, ohne bei null anzufangen. Es baut auf dem Modulsystem von Expo auf (Expo Modules API), mit dem du nativen Code in Swift schreiben und an JavaScript übergeben kannst. Dadurch fühlt sich der ganze Prozess weniger wie eine Wurzelbehandlung an.
Das Projekt aufsetzen
Der Einstieg war nicht gerade ein Spaziergang, aber expo-apple-targets hat ihn machbar gemacht. So habe ich angefangen:
-
expo-apple-targets installieren: Ein schnelles npm install expo-apple-targets, und es ging los. Die README des Pakets ist eine Goldgrube: Sie führt dich durch das Hinzufügen einer Widget Extension in Xcode und das Aktualisieren der app.json mit dem Live-Activity-Entitlement (com.apple.developer.activitykit).
-
Native Module einrichten: Ich habe das Modulsystem von Expo genutzt, um ein Swift-Modul zu erstellen, das mit ActivityKit spricht. Die Expo-Modules-Dokumentation legt Wert auf klare Funktionssignaturen und Events, was mir geholfen hat, Methoden wie startActivity ohne große Mühe an JavaScript zu übergeben.
-
Widget Extension: Hier kam SwiftUI ins Spiel, mit dem ich das Aussehen der Live Activity für den Sperrbildschirm und die Dynamic Island gestalten konnte. expo-apple-targets liefert ein Widget-Template, aber ich musste es anpassen, damit es einen laufenden Timer und interaktive Buttons zeigt.
-
Intents: Damit können Nutzer auf Buttons im Widget tippen, um den Timer zu pausieren oder fortzusetzen. expo-apple-targets vereinfacht das Einrichten von Intents, aber ich musste trotzdem ein paar Fehlzündungen debuggen, bis die Notifications richtig flossen.
Ein Timer, der jede Sekunde aktualisiert wird?
Ein Entwickler implementiert begeistert ein Timer-Update im Sekundentakt, was zu einer chaotischen Systemüberlastung führt, während der Timer alles verwüstet. (Generiert von gpt-4o)
Als ich mich zum ersten Mal an den Timer gemacht habe, sagte mein Gehirn: "Aktualisiere die Live Activity einfach jede Sekunde mit der aktuellen Zeit." Klingt einfach, oder? Falsch. Ich bin auf einen Reddit-Thread gestoßen, in dem Entwickler darüber diskutierten, wie man den Timer einer Live Activity aktualisieren kann. Das Urteil war einstimmig: Jede Sekunde zu aktualisieren ist eine Katastrophe. Das ist, als wolltest du ein Raumschiff mit einem Hamsterrad antreiben: Es bewegt sich, aber es brennt schnell aus. Ständige Updates belasten die CPU, leeren den Akku und machen deine App träge.
Dieser Reddit-Thread war ein Weckruf. In Apples SwiftUI-Dokumentation habe ich Text(timerInterval:) von SwiftUI gefunden, und das war eine Offenbarung. Diese View übernimmt Timer-Updates nativ und zählt weiter, ohne dass die gesamte Live Activity aktualisiert werden muss. Es ist, als würdest du den langweiligen Teil an iOS auslagern, damit du dich auf die spaßigen Teile konzentrieren kannst.
Also habe ich den Plan mit dem Update im Sekundentakt verworfen und mich für einen Ansatz mit startedAt/pausedAt entschieden. Darum ist er ein Gewinner:
-
Performance: Statt jede Sekunde Updates abzufeuern, speichere ich die Startzeit des Timers (startedAt) und die Pausenzeit (pausedAt, falls pausiert). Das Widget nutzt Text(timerInterval:), um auf Basis von startedAt einen laufenden Timer anzuzeigen, und im pausierten Zustand zeigt es mit pausedAt eine statische Zeit. Damit sinken die API-Aufrufe auf fast null.
-
Akkueffizienz: Häufige Updates sind ein Akku-Vampir. Wenn SwiftUI das Zählen übernimmt, bleibt die App schlank und die Handys der Nutzer bleiben glücklich.
-
API-Konformität: Apples Live-Activity-APIs sind nicht für Echtzeit-Spam gebaut. Das Setup mit startedAt/pausedAt passt zu den Erwartungen von iOS und verringert das Risiko eines Rate Limits.
-
Einfacher Code: Zwei Zeitstempel zu verwalten ist viel einfacher, als mit einem Strom von Updates zu jonglieren. Der Code bleibt sauber und mein Stresslevel im Rahmen.
Dieser Ansatz fühlte sich an, als hätte ich eine geheime Abkürzung in einem Videospiel gefunden. Der Timer läuft flüssig, sieht toll aus und frisst keine Ressourcen. Der Reddit-Thread (hier ist er noch einmal) verdient eine Medaille dafür, dass er mich in die richtige Richtung geschickt hat.
Das Herz der Live Activity
Ich werde dich nicht mit jeder Codezeile langweilen. Konzentrieren wir uns auf die wichtigsten Snippets, die diesen Timer zum Laufen bringen. Den vollständigen Quellcode teile ich am Ende des Artikels auf GitHub.
Das Struct LiveActivityAttributes
Dieses Struct ist das Rückgrat der Live Activity: Es definiert ihre Daten und wie sie sich verändern.
struct LiveActivityAttributes: ActivityAttributes {
public struct ContentState: Codable, Hashable {
var startedAt: Date
var pausedAt: Date?
func getElapsedTimeInSeconds() -> TimeInterval {
if let pausedAt = pausedAt {
return pausedAt.timeIntervalSince(startedAt)
} else {
return Date().timeIntervalSince(startedAt)
}
}
func isRunning() -> Bool {
return pausedAt == nil
}
func getFormattedElapsedTime() -> String {
let elapsed = getElapsedTimeInSeconds()
let totalSeconds = Int(elapsed)
let hours = totalSeconds / 3600
let minutes = (totalSeconds % 3600) / 60
let seconds = totalSeconds % 60
if hours > 0 {
return String(format: "%d:%02d:%02d", hours, minutes, seconds)
} else {
return String(format: "%d:%02d", minutes, seconds)
}
}
func getFutureDate() -> Date {
return Date().addingTimeInterval(365 * 24 * 60 * 60)
}
}
var activityName: String
var activityIcon: String
}
Das ist sozusagen die DNA der Live Activity. Das äußere LiveActivityAttributes enthält statische Dinge, nämlich activityName (z. B. "Workout") und activityIcon (z. B. "RUNNING"), die beim Start der Activity gesetzt werden. Im inneren ContentState passiert die eigentliche Action: Es verfolgt startedAt (wann der Timer gestartet wurde) und pausedAt (wann er pausiert wurde, falls überhaupt). Die Hilfsmethoden sind die eigentlichen MVPs:
-
getElapsedTimeInSeconds() berechnet, wie lange der Timer schon läuft. Ist er pausiert, stoppt die Rechnung bei pausedAt, ist er aktiv, wird die aktuelle Zeit verwendet. So bleibt die Logik kompakt und wiederverwendbar.
-
isRunning() ist ein einfacher Check: Wenn pausedAt null ist, läuft der Timer. Das ist ein sauberer Weg, unordentliche State-Checks an anderen Stellen zu vermeiden.
-
getFormattedElapsedTime() verwandelt Sekunden in einen hübschen String im Format "MM:SS" oder "HH:MM:SS" für das Widget. Die Unterstützung für Stunden habe ich ergänzt, nachdem mir klar wurde, dass manche Nutzer extrem lange Workouts wie Marathons machen könnten.
-
getFutureDate() setzt ein Datum ein Jahr in der Zukunft, das ich an Text(timerInterval:) übergebe, damit der Timer unbegrenzt laufen kann, ohne dass ich mir über ein Enddatum Gedanken machen muss.
Ich mag, wie dieses Struct alles organisiert hält. Es ist wie ein gut gepackter Rucksack: alles, was du brauchst, nichts, was du nicht brauchst. Durch die Konformität zu Codable und Hashable lässt es sich leicht für Updates serialisieren und in SwiftUI verwenden, was mir beim Synchronisieren des States zwischen Modul und Widget das Leben gerettet hat.
Die Live Activity starten
In der Funktion startActivity beginnt die Magie: Sie startet eine neue Live Activity.
AsyncFunction("startActivity") { (activityName: String, activityIcon: String) -> String in
if #available(iOS 16.2, *) {
await self.endAllActivities()
self.startedAt = Date()
self.pausedAt = nil
if !ActivityAuthorizationInfo().areActivitiesEnabled {
return ""
}
let attributes = LiveActivityAttributes(activityName: activityName, activityIcon: activityIcon)
let contentState = LiveActivityAttributes.ContentState(startedAt: self.startedAt!, pausedAt: nil)
do {
let activity = try Activity.request(attributes: attributes, content: .init(state: contentState, staleDate: nil), pushType: nil)
self.currentActivityId = activity.id
self.sendTimerUpdateEvent()
return activity.id
} catch {
throw error
}
}
return ""
}
Diese Funktion ist der Funke, der das Feuer entzündet. Sie wird über das Modulsystem von Expo an JavaScript übergeben, sodass meine React-Native-App sie mit einem Namen und einem Icon aufrufen kann. Das macht sie:
-
Sie prüft auf iOS 16.2 oder neuer, denn davor gibt es keine Live Activities.
-
Sie ruft endAllActivities() auf, um bestehende Activities zu entfernen. iOS erlaubt mehrere Live Activities, aber ich wollte immer nur eine gleichzeitig, um Verwirrung zu vermeiden.
-
Sie setzt startedAt auf die aktuelle Zeit und leert pausedAt, damit der Timer bereit zum Laufen ist.
-
Sie prüft, ob Live Activities aktiviert sind (Nutzer können sie in den Einstellungen deaktivieren, was mich anfangs ziemlich aus dem Konzept gebracht hat).
-
Sie baut ein LiveActivityAttributes mit dem übergebenen Namen und Icon und einen ContentState mit der Startzeit.
-
Sie fordert über Activity.request eine neue Activity an, was mir ein Activity-Objekt mit einer eindeutigen ID liefert.
-
Sie speichert die ID, schickt ein Update-Event an JavaScript und gibt die ID zurück, damit die App sie verfolgen kann.
Den Timer pausieren
Das Pausieren des Timers übernimmt performPause, das den State der Live Activity aktualisiert.
private func performPause(activityId: String?) async -> Bool {
guard #available(iOS 16.2, *), self.pausedAt == nil else {
return false
}
let targetId = activityId ?? self.currentActivityId
guard let targetId = targetId else {
return false
}
guard let activity = await self.findActivityById(targetId) else {
return false
}
guard let currentStartedAt = self.startedAt else {
return false
}
let now = Date()
self.pausedAt = now
let contentState = LiveActivityAttributes.ContentState(startedAt: currentStartedAt, pausedAt: self.pausedAt)
await activity.update(using: contentState)
self.sendTimerUpdateEvent()
return true
}
Hier glänzt der Ansatz mit startedAt/pausedAt. Wenn der Nutzer den Timer pausiert (entweder in der App oder im Widget), macht diese Funktion Folgendes:
-
Sie prüft, ob wir auf iOS 16.2 sind und der Timer nicht schon pausiert ist (doppeltes Pausieren ist nicht erlaubt).
-
Sie holt sich die Activity-ID und fällt auf currentActivityId zurück, wenn keine übergeben wurde.
-
Sie findet die Activity mit findActivityById, das die aktiven Activities durchsucht.
-
Sie setzt pausedAt auf die aktuelle Zeit und friert den Timer damit ein.
-
Sie erstellt einen neuen ContentState mit dem ursprünglichen startedAt und dem neuen pausedAt.
-
Sie aktualisiert die Activity mit activity.update und sagt dem Widget damit, dass es die pausierte Zeit anzeigen soll.
-
Sie schickt ein Event an JavaScript, damit die UI der App synchron bleibt.
Bei der Logik geht es hier um Präzision: Jeder Check (wie pausedAt == nil) soll seltsame Edge Cases verhindern, etwa das Pausieren einer Activity, die gar nicht existiert. Für das Event-Handling habe ich mich auf die Expo-Modules-Dokumentation gestützt und mit sendEvent Updates an JavaScript geschickt. Frühe Versionen dieser Funktion haben startedAt nicht validiert, was zu einigen merkwürdigen Timer-Anzeigen geführt hat. Lektion gelernt: Sichere deinen State immer ab.
Die Ansicht auf dem Sperrbildschirm
Die LockScreenLiveActivityView ist das, was Nutzer sehen, wenn ihr Handy gesperrt ist, und sie muss gut aussehen.
Live Activity auf dem Sperrbildschirm
struct LockScreenLiveActivityView: View {
let context: ActivityViewContext<LiveActivityAttributes>
var body: some View {
ZStack {
Color.black.opacity(0.8)
.clipShape(RoundedRectangle(cornerRadius: 16))
HStack(spacing: 16) {
VStack(alignment: .leading, spacing: 12) {
HStack(spacing: 8) {
ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
themeColor: .white,
size: 18)
Text(context.attributes.activityName)
.font(.headline)
.foregroundColor(.white)
}
VStack(alignment: .leading, spacing: 4) {
if !context.state.isRunning() {
Text(context.state.getFormattedElapsedTime())
.font(.system(size: 34, weight: .semibold, design: .rounded))
.foregroundColor(.white)
.fontWeight(.medium)
.monospacedDigit()
} else {
Text(timerInterval: context.state.startedAt...context.state.getFutureDate(),
pauseTime: nil,
countsDown: false,
showsHours: false)
.font(.system(size: 34, weight: .semibold, design: .rounded))
.foregroundColor(.white)
.fontWeight(.medium)
.monospacedDigit()
}
}
}
.frame(maxHeight: .infinity, alignment: .center)
Spacer()
VStack {
Spacer()
if context.state.isRunning() {
Button(intent: PauseIntent()) {
ZStack {
Circle()
.fill(Color(hex: "#007bff"))
.frame(width: 44, height: 44)
Image(systemName: "pause.fill")
.font(.system(size: 18, weight: .bold))
.foregroundColor(.white)
}
}
.buttonStyle(PlainButtonStyle())
} else {
HStack(spacing: 8) {
Button(intent: CompleteIntent()) {
ZStack {
Circle()
.fill(Color(hex: "#28a745"))
.frame(width: 44, height: 44)
Image(systemName: "checkmark")
.font(.system(size: 16, weight: .bold))
.foregroundColor(.white)
}
}
.buttonStyle(PlainButtonStyle())
Button(intent: ResumeIntent()) {
ZStack {
Circle()
.fill(Color(hex: "#007bff"))
.frame(width: 44, height: 44)
Image(systemName: "play.fill")
.font(.system(size: 18, weight: .bold))
.foregroundColor(.white)
}
}
.buttonStyle(PlainButtonStyle())
}
}
Spacer()
}
}
.padding(16)
}
}
}
Das ist das visuelle Herz der Live Activity, und hier zeigt SwiftUI richtig, was es kann. Die View ist in zwei Seiten aufgeteilt:
-
Linke Seite: Zeigt den Namen der Activity, das Icon und den Timer. Wenn der Timer läuft, übernimmt Text(timerInterval:) die schwere Arbeit und zählt von startedAt bis zu einem Zeitpunkt ein Jahr in der Zukunft hoch (dank getFutureDate). Im pausierten Zustand zeigt die View eine statische Zeit aus getFormattedElapsedTime. Der Modifier .monospacedDigit() hält die Ziffern sauber, und ich habe die Schrift angepasst, damit sie fett und gut lesbar ist.
-
Rechte Seite: Kümmert sich um die Buttons. Wenn der Timer läuft, gibt es einen blauen Pause-Button. Im pausierten Zustand gibt es einen grünen Haken, um die App zu öffnen, und einen blauen Play-Button zum Fortsetzen. Jeder Button löst einen Intent aus, den das native Modul abfängt und verarbeitet.
Ein Blick in die Dynamic Island
Ansicht in der Dynamic Island
Dieses Snippet legt fest, wie die Live Activity in den drei Modi der Dynamic Island erscheint: expanded (volle Ansicht), compact (zusammengedrückt) und minimal (das Nötigste).
dynamicIsland: { context in
DynamicIsland {
DynamicIslandExpandedRegion(.leading) {
VStack(alignment: .leading, spacing: 8) {
HStack(spacing: 8) {
ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
themeColor: .white,
size: 18)
Text(context.attributes.activityName)
.foregroundColor(.white)
.font(.system(size: 16, weight: .semibold))
}
if !context.state.isRunning() {
Text(context.state.getFormattedElapsedTime())
.font(.system(size: 32, weight: .bold, design: .rounded))
.foregroundColor(.white)
.fontWeight(.medium)
.monospacedDigit()
} else {
Text(timerInterval: context.state.startedAt...context.state.getFutureDate(),
pauseTime: nil,
countsDown: false,
showsHours: false)
.font(.system(size: 32, weight: .bold, design: .rounded))
.foregroundColor(.white)
.fontWeight(.medium)
.monospacedDigit()
}
}
.padding(.leading, 8)
}
DynamicIslandExpandedRegion(.trailing) {
VStack {
Spacer()
if context.state.isRunning() {
Button(intent: PauseIntent()) {
ZStack {
Circle()
.fill(Color(hex: "#007bff"))
.frame(width: 44, height: 44)
Image(systemName: "pause.fill")
.font(.system(size: 18, weight: .bold))
.foregroundColor(.white)
}
}
.buttonStyle(PlainButtonStyle())
.padding(.horizontal, 8)
} else {
HStack(spacing: 8) {
Button(intent: CompleteIntent()) {
ZStack {
Circle()
.fill(Color(hex: "#28a745"))
.frame(width: 44, height: 44)
Image(systemName: "checkmark")
.font(.system(size: 16, weight: .bold))
.foregroundColor(.white)
}
}
.buttonStyle(PlainButtonStyle())
Button(intent: ResumeIntent()) {
ZStack {
Circle()
.fill(Color(hex: "#007bff"))
.frame(width: 44, height: 44)
Image(systemName: "play.fill")
.font(.system(size: 18, weight: .bold))
.foregroundColor(.white)
}
}
.buttonStyle(PlainButtonStyle())
}
}
}
.frame(maxHeight: .infinity)
}
} compactLeading: {
HStack(spacing: 4) {
ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
themeColor: .white,
size: 16)
Text(context.attributes.activityName)
.foregroundColor(.white)
.font(.system(size: 12))
.lineLimit(1)
.truncationMode(.tail)
}
} compactTrailing: {
if !context.state.isRunning() {
Text(context.state.getFormattedElapsedTime())
.foregroundColor(.white)
.monospacedDigit()
.font(.system(size: 12, weight: .medium))
} else {
Text(timerInterval: context.state.startedAt...context.state.getFutureDate(),
pauseTime: nil,
countsDown: false,
showsHours: false)
.foregroundColor(.white)
.monospacedDigit()
.font(.system(size: 12, weight: .medium))
}
} minimal: {
ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
themeColor: .white,
size: 12)
}
}
-
**Expanded-Modus**: Wird bei langem Drücken angezeigt und ist in .leading und .trailing aufgeteilt. Die linke Seite stapelt das Icon (z. B. eine laufende Figur) und den Namen ("Workout") mit einem großen Timer, statisch im pausierten Zustand (getFormattedElapsedTime) und laufend im aktiven Zustand (Text(timerInterval:)). Die rechte Seite enthält die Buttons: einen blauen Pause-Button, wenn der Timer läuft, oder einen grünen Haken (App öffnen) und einen blauen Play-Button (fortsetzen), wenn er pausiert ist. Schriften und Padding habe ich angepasst, damit alles in die Rundungen der Island passt.
-
**Compact-Modus**: Wenn der Platz schrumpft, zeigt compactLeading ein winziges Icon und einen gekürzten Namen, während compactTrailing den Timer anzeigt (statisch oder laufend). Mit .lineLimit(1) bleibt der Name ordentlich, und eine Schriftgröße von 12 Punkt sorgt für Lesbarkeit.
-
**Minimal-Modus**: Extrem knapp, nur ein Icon mit 12 Punkt, zum Beispiel eine Hantel, das sagt: "Der Timer ist noch da." Einfach, aber wirkungsvoll.
Der Ordner _shared: Warum er so wichtig ist
Überblick über den Ordner _shared
Der Ordner _shared in expo-apple-targets ist ein Verzeichnis auf oberster Ebene, mit dem wichtiger Code sowohl mit dem Haupt-Target deiner App als auch mit Sub-Targets wie dem Live-Activity-Widget verknüpft wird.
Extensions wie Widgets laufen in eigenen Prozessen und brauchen bestimmte Dateien, die sowohl mit ihrem eigenen Target als auch mit dem der Haupt-App verknüpft sind. Der Ordner _shared sorgt dafür, dass diese Dateien automatisch mit beiden verknüpft werden, sodass keine manuelle Konfiguration nötig ist. Für meinen Timer habe ich das Struct LiveActivityAttributes hier abgelegt. So war garantiert, dass App und Widget denselben Timer-State (startedAt, pausedAt) ohne Synchronisierungsprobleme teilen.
Die App aus dem Live-Activity-Widget starten
Mit dem CompleteIntent können Nutzer im Live-Activity-Widget auf einen Haken tippen, um die App zu öffnen und zu signalisieren, dass sie mit dem Timer fertig sind. Eine einfache, aber entscheidende Interaktion, um ein Workout abzuschließen.
import AppIntents
import WidgetKit
@available(iOS 16.2, *)
struct CompleteIntent: AppIntent, LiveActivityIntent {
static var title: LocalizedStringResource = "Complete Exercise"
static var description: IntentDescription = "Opens the app to complete the exercise"
static var openAppWhenRun: Bool = true
init() {}
func perform() async throws -> some IntentResult {
NotificationCenter.default.post(name: Notification.Name("completeActivityFromWidget"), object: nil)
return .result()
}
}
Wenn der Nutzer auf den grünen Haken tippt, wird dieser Intent ausgelöst und postet eine Notification completeActivityFromWidget. Das native Modul fängt sie ab, löst das Event onWidgetCompleteActivity in JavaScript aus, und iOS öffnet die App, dank openAppWhenRun: true.
Taps der Nutzer mit Intents verarbeiten
Der PauseIntent ist einer der Intents, die das Widget interaktiv machen.
Intents der Live Activity auf dem Sperrbildschirm
import AppIntents
import WidgetKit
@available(iOS 16.2, *)
struct PauseIntent: AppIntent, LiveActivityIntent {
static var title: LocalizedStringResource = "Pause Timer"
static var description: IntentDescription = "Pauses the current timer."
init() {}
func perform() async throws -> some IntentResult {
NotificationCenter.default.post(name: Notification.Name("pauseTimerFromWidget"), object: nil)
return .result()
}
}
Dieser Intent wird ausgelöst, wenn der Nutzer im Widget auf den Pause-Button tippt. Er ist extrem einfach, aber mächtig:
-
Er postet eine Notification (pauseTimerFromWidget), die das native Modul über setupNotificationObservers abfängt.
-
Das Modul führt dann performPause aus, aktualisiert den State der Live Activity und benachrichtigt JavaScript.
Das Schöne daran ist, wie Intents einen nahtlosen Kreislauf bilden: Nutzer tippt → Intent wird ausgelöst → Modul aktualisiert → App bleibt synchron. expo-apple-targets hat das Einrichten von Intents mit einem Template zum Kinderspiel gemacht, aber ich musste trotzdem einen Fall debuggen, in dem Taps nicht ankamen. Wie sich herausstellte, hatte ich einen Notification-Namen falsch geschrieben. Klassiker. Die Expo-Modules-Dokumentation hat mir geholfen zu verstehen, wie man Events verarbeitet, die durch native Aktionen ausgelöst werden, und das war der Schlüssel, damit es funktioniert.
Events, die mit JavaScript sprechen

Mit den Events im folgenden Abschnitt hält das native Modul die React-Native-App mit dem State der Live Activity synchron, über das Event-System von Expo.
onWidgetCompleteActivity
Dieses Event wird ausgelöst, wenn der Nutzer auf den Haken tippt, um die Activity abzuschließen, ausgelöst durch CompleteIntent.
@objc func completeIntentHandler(_ notification: Notification) {
guard let currentId = self.currentActivityId, self.startedAt != nil else {
return
}
let elapsed = self.calculateElapsedTime()
sendEvent("onWidgetCompleteActivity", [
"activityId": currentId,
"elapsedTime": Int(elapsed)
])
}
Der completeIntentHandler fängt die Notification completeActivityFromWidget ab, berechnet die verstrichene Zeit und schickt das Event onWidgetCompleteActivity mit der Activity-ID und den verstrichenen Sekunden an JavaScript. JavaScript kann dann die UI der App aktualisieren oder den Abschluss des Workouts protokollieren.
onLiveActivityUpdate
Dieses Event wird ausgelöst, wann immer sich der State des Timers ändert (z. B. Pause, Fortsetzen).
private func sendTimerUpdateEvent() {
guard let currentId = self.currentActivityId else { return }
guard self.startedAt != nil else { return }
let state = self.pausedAt == nil ? "active" : "paused"
let elapsed = self.calculateElapsedTime()
sendEvent("onLiveActivityUpdate", [
"state": state,
"elapsedTime": Int(elapsed),
"activityId": currentId
])
}
Es wird nach State-Änderungen aufgerufen (etwa in performPause oder performResume) und schickt das Event onLiveActivityUpdate mit dem aktuellen State ("active" oder "paused"), der verstrichenen Zeit und der Activity-ID. JavaScript hört darauf, um die Timer-UI der App mit dem Widget synchron zu halten.
Beide Events schaffen eine enge Feedback-Schleife zwischen dem nativen Modul und JavaScript.
Warum das alles wichtig ist
Diese Live Activity ist nicht nur ein Timer, sie ist ein Feature, durch das sich meine App wie ein echter Bürger von iOS anfühlt. Darum ist das eine große Sache:
-
Nutzerengagement: Ein Timer auf dem Sperrbildschirm oder in der Dynamic Island hält Nutzer mit der App verbunden, ohne ihren Flow zu unterbrechen. Perfekt für Workouts, bei denen jede Sekunde zählt.
-
Nativer Feinschliff: Das saubere Design und die interaktiven Buttons des Widgets sorgen dafür, dass sich die App anfühlt, als gehöre sie auf iOS, und nicht wie ein nachträglich angeflanschtes Cross-Platform-Produkt.
-
Performance: Der Ansatz mit startedAt/pausedAt, angetrieben von Text(timerInterval:), sorgt dafür, dass der Timer flüssig läuft, ohne den Akku zu leeren oder an API-Limits zu stoßen.
expo-apple-targets und die Expo Modules API waren hier die heimlichen Helden und haben ein robustes Framework geliefert, um JavaScript und Swift zu verbinden. Der Fokus der Dokumentation auf saubere Funktionsdefinitionen und Event-Handling hat meinen Code organisiert und wartbar gehalten.
Fazit
Diese Live Activity verleiht der App ein flüssiges, natives Gefühl und zeigt Echtzeit-Updates direkt auf dem Sperrbildschirm und in der Dynamic Island. Dank expo-apple-targets, der Expo Modules API und Erkenntnissen aus der Community (ja, Reddit-Threads eingeschlossen) war die Umsetzung ziemlich geradlinig. Live Activities sind ein starkes Mittel, damit sich Apps vernetzter und dynamischer anfühlen.
Hier ist der GitHub-Link zum vollständigen Quell-Repo 👉🏻 https://github.com/tarikfp/expo-live-activity-timer