Live Activities w iOS zmieniają zasady gry: pozwalają aplikacjom pokazywać aktualizacje na żywo prosto na ekranie blokady albo w Dynamic Island. Oczywiście od razu zacząłem wyobrażać sobie, jak fajnie byłoby mieć tam działający timer treningowy, który motywuje użytkowników, nawet gdy nie odblokowują telefonu. Był jednak haczyk: Live Activities buduje się natywnymi narzędziami Apple, takimi jak Swift i ActivityKit. Wtedy trafiłem na narzędzie expo-apple-targets, dzięki któremu nie musiałem pisać całych modułów od zera, i cały proces okazał się dużo prostszy, niż się spodziewałem. W tym artykule pokażę, jak zbudowałem Live Activity z timerem dla iOS, jakie kroki wykonałem i czego się po drodze nauczyłem.
Dlaczego Live Activities mnie wciągnęły
Live Activities to nie tylko fajny bajer, one naprawdę zmieniają zaangażowanie użytkowników. Apple w Human Interface Guidelines opisuje je jako sposób na dostarczanie „aktualnych informacji, które można ogarnąć jednym spojrzeniem” przy zadaniach, w których liczy się czas. Wyobraź sobie aplikację fitness, która w trakcie treningu pokazuje czas twojej deski, aplikację do zamawiania jedzenia, która śledzi drogę twojej pizzy, albo aplikację przewozową, która aktualizuje przewidywany czas przyjazdu kierowcy, wszystko prosto na ekranie blokady albo, na iPhonie 14 Pro i nowszych, w Dynamic Island. To trochę jak danie użytkownikom przepustki VIP do najważniejszych aktualizacji twojej aplikacji bez konieczności odblokowywania telefonu.
Chciałem, żeby użytkownicy widzieli, jak ich timer treningowy odlicza czas w trakcie serii, i żeby mogli się skupić bez otwierania aplikacji. To ten rodzaj dopracowania, przez który aplikacja wydaje się profesjonalna, więc wszedłem w to w całości. Nie da się jednak tego wszystkiego ogarnąć bez dotykania warstwy natywnej, więc wiedziałem, że czeka mnie Swift i zmagania z Xcode. Wtedy odkryłem expo-apple-targets, paczkę, która łączy javascriptowy świat Expo z natywnymi funkcjami iOS. Ogromne podziękowania dla Evan Bacon, to narzędzie zamieniło przytłaczające zadanie w wymagającą, ale wykonalną łamigłówkę.
Szerszy obraz: Live Activities w aplikacji Expo
Live Activities to impreza wyłącznie dla iOS. Napędza je ActivityKit, framework oparty na Swifcie, co oznacza, że piszesz kod natywny, czy ci się to podoba, czy nie. W aplikacji Expo to trochę jak przekonywanie ryby, żeby wspięła się na drzewo: da się, ale będzie to wymagało wysiłku. expo-apple-targets wkracza jak doświadczony przewodnik i daje framework do tworzenia natywnych modułów i rozszerzeń widgetów bez zaczynania od zera. Jest zbudowany na systemie modułów Expo (Expo Modules API), który pozwala pisać kod natywny w Swifcie i wystawiać go do JavaScriptu, dzięki czemu cały proces mniej przypomina leczenie kanałowe.
Konfiguracja projektu
Start nie był bułką z masłem, ale expo-apple-targets sprawiło, że dało się to ogarnąć. Oto jak zacząłem:
-
Instalacja expo-apple-targets: Szybkie npm install expo-apple-targets i ruszyłem. README paczki to kopalnia wiedzy: prowadzi przez dodanie rozszerzenia widgetu w Xcode i aktualizację app.json o entitlement dla Live Activity (com.apple.developer.activitykit).
-
Konfiguracja modułu natywnego: Użyłem systemu modułów Expo, żeby stworzyć moduł w Swifcie, który rozmawia z ActivityKit. Dokumentacja Expo Modules kładzie nacisk na jasne sygnatury funkcji i eventy, co pomogło mi bez wysiłku wystawić do JavaScriptu metody takie jak startActivity.
-
Rozszerzenie widgetu: Tu do gry wszedł SwiftUI, w którym zaprojektowałem wygląd Live Activity na ekranie blokady i w Dynamic Island. expo-apple-targets daje szablon widgetu, ale musiałem go dostosować, żeby pokazywał tykający timer i interaktywne przyciski.
-
Intenty: Pozwalają użytkownikom stuknąć przycisk na widgecie, żeby zatrzymać albo wznowić timer. expo-apple-targets upraszcza konfigurację intentów, ale i tak musiałem zdebugować kilka wpadek, zanim powiadomienia zaczęły płynąć jak trzeba.
Timer aktualizowany co sekundę?
Programista z entuzjazmem wdraża aktualizację timera co sekundę, co prowadzi do chaotycznego przeciążenia systemu, gdy timer sieje spustoszenie. (Wygenerowane przez gpt-4o)
Kiedy pierwszy raz zabrałem się za timer, mój mózg podpowiedział: „Po prostu aktualizuj Live Activity co sekundę aktualnym czasem”. Brzmi prosto, prawda? Nic z tych rzeczy. Trafiłem na wątek na Reddicie, w którym deweloperzy dyskutowali o możliwości aktualizowania timera w Live Activity. Werdykt był jednogłośny: aktualizowanie co sekundę to katastrofa. To jak próba napędzania statku kosmicznego kołowrotkiem dla chomika: ruszy, ale szybko się wypali. Ciągłe aktualizacje obciążają CPU i drenują baterię, przez co aplikacja zaczyna się ślimaczyć.
Ten wątek na Reddicie był dla mnie pobudką. W dokumentacji SwiftUI Apple znalazłem Text(timerInterval:) i to było objawienie. Ten widok natywnie obsługuje aktualizacje timera i tyka sam, bez potrzeby odświeżania całej Live Activity. To jak oddanie nudnej roboty iOS, żebyś mógł się skupić na przyjemniejszych rzeczach.
Porzuciłem więc plan z aktualizacją co sekundę i wybrałem podejście startedAt/pausedAt. Oto dlaczego wygrywa:
-
Wydajność: Zamiast odpalać aktualizacje co sekundę, zapisuję czas startu timera (startedAt) i czas pauzy (pausedAt, jeśli jest zatrzymany). Widget używa Text(timerInterval:), żeby pokazać żywy timer na podstawie startedAt, a po zatrzymaniu wyświetla statyczny czas wyliczony z pausedAt. To zbija liczbę wywołań API prawie do zera.
-
Oszczędność baterii: Częste aktualizacje wysysają baterię jak wampir. Zostawienie tykania SwiftUI sprawia, że aplikacja jest lekka, a telefony użytkowników są zadowolone.
-
Zgodność z API: API Live Activity od Apple nie są stworzone do spamowania w czasie rzeczywistym. Układ startedAt/pausedAt dobrze współgra z oczekiwaniami iOS i zmniejsza ryzyko rate limitingu.
-
Prostota kodu: Zarządzanie dwoma znacznikami czasu jest dużo łatwiejsze niż żonglowanie strumieniem aktualizacji. Kod zostaje czysty, a mój poziom stresu pod kontrolą.
To podejście było jak znalezienie sekretnego skrótu w grze. Timer działa płynnie, dobrze wygląda i nie zżera zasobów. Ten wątek na Reddicie (oto on jeszcze raz) zasługuje na medal za to, że skierował mnie we właściwą stronę.
Serce Live Activity
Nie będę cię zanudzał każdą linijką kodu, skupmy się na kluczowych fragmentach, dzięki którym ten timer tyka. Pełny kod źródłowy udostępnię na GitHubie na końcu artykułu.
Struktura LiveActivityAttributes
Ta struktura to kręgosłup Live Activity: definiuje jej dane i sposób, w jaki się zmieniają.
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
}
To coś w rodzaju DNA Live Activity. Zewnętrzne LiveActivityAttributes trzyma rzeczy statyczne: activityName (np. „Workout”) i activityIcon (np. „RUNNING”), ustawiane przy starcie aktywności. Wewnętrzny ContentState to miejsce, gdzie dzieje się akcja: śledzi startedAt (kiedy timer wystartował) i pausedAt (kiedy został zatrzymany, jeśli w ogóle). Prawdziwymi MVP są metody pomocnicze:
-
getElapsedTimeInSeconds() liczy, jak długo działa timer: zatrzymuje się na pausedAt, jeśli jest pauza, albo używa bieżącego czasu, jeśli timer jest aktywny. Dzięki temu logika jest zwarta i nadaje się do ponownego użycia.
-
isRunning() to prosty test: jeśli pausedAt jest null, timer działa. To czysty sposób na uniknięcie bałaganu ze sprawdzaniem stanu w innych miejscach.
-
getFormattedElapsedTime() zamienia sekundy na ładny string „MM:SS” albo „HH:MM:SS” dla widgetu. Obsługę godzin dodałem, gdy zdałem sobie sprawę, że niektórzy użytkownicy mogą robić ultradługie treningi, na przykład maratony.
-
getFutureDate() ustawia datę rok do przodu, którą przekazuję do Text(timerInterval:), żeby timer mógł działać bez końca i żebym nie musiał się martwić datą zakończenia.
Uwielbiam to, jak ta struktura trzyma wszystko w porządku. Jest jak dobrze spakowany plecak: wszystko, czego potrzebujesz, nic, czego nie potrzebujesz. Zgodność z Codable i Hashable ułatwia serializację przy aktualizacjach i użycie w SwiftUI, co uratowało mi skórę przy synchronizacji stanu między modułem a widgetem.
Uruchamianie Live Activity
Funkcja startActivity to miejsce, w którym zaczyna się magia: uruchamia nową 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 ""
}
Ta funkcja to iskra, która rozpala ogień. Jest wystawiona do JavaScriptu przez system modułów Expo, więc moja aplikacja React Native może ją wywołać z nazwą i ikoną. Oto co robi:
-
Sprawdza, czy działa iOS 16.2 lub nowszy, bo wcześniej Live Activities nie istnieją.
-
Wywołuje endAllActivities(), żeby wyczyścić istniejące aktywności. iOS pozwala na wiele Live Activities naraz, ale chciałem mieć jedną, żeby uniknąć zamieszania.
-
Ustawia startedAt na bieżący czas i czyści pausedAt, przygotowując timer do działania.
-
Sprawdza, czy Live Activities są włączone (użytkownicy mogą je wyłączyć w Ustawieniach, co na początku mnie zaskoczyło).
-
Buduje LiveActivityAttributes z podaną nazwą i ikoną oraz ContentState z czasem startu.
-
Prosi o nową aktywność przez Activity.request, co daje mi obiekt Activity z unikalnym ID.
-
Zapisuje ID, wysyła event aktualizacji do JavaScriptu i zwraca ID, żeby aplikacja mogła ją śledzić.
Pauzowanie timera
Pauzowanie timera obsługuje performPause, która aktualizuje stan Live Activity.
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
}
Tu podejście startedAt/pausedAt naprawdę błyszczy. Kiedy użytkownik zatrzymuje timer (z aplikacji albo z widgetu), ta funkcja:
-
Sprawdza, czy działamy na iOS 16.2 i czy timer nie jest już zatrzymany (żadnego podwójnego pauzowania).
-
Pobiera ID aktywności, a jeśli żadne nie zostało podane, używa currentActivityId.
-
Znajduje aktywność za pomocą findActivityById, która przeszukuje aktywne aktywności.
-
Ustawia pausedAt na bieżący czas, zamrażając timer.
-
Tworzy nowy ContentState z oryginalnym startedAt i nowym pausedAt.
-
Aktualizuje aktywność przez activity.update, mówiąc widgetowi, żeby pokazał czas pauzy.
-
Wysyła event do JavaScriptu, żeby UI aplikacji pozostał zsynchronizowany.
Cała logika opiera się tu na precyzji: każdy warunek (np. pausedAt == nil) jest po to, żeby zapobiec dziwnym przypadkom brzegowym, takim jak pauzowanie nieistniejącej aktywności. Przy obsłudze eventów opierałem się na dokumentacji Expo Modules i używałem sendEvent, żeby wypychać aktualizacje do JavaScriptu. Wczesne wersje tej funkcji nie walidowały startedAt, co prowadziło do dziwnie wyświetlanych timerów. Lekcja odrobiona: zawsze pilnuj swojego stanu.
Widok na ekranie blokady
LockScreenLiveActivityView to to, co użytkownicy widzą, gdy telefon jest zablokowany, i musi to wyglądać dobrze.
Live Activity na ekranie blokady
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)
}
}
}
To wizualne serce Live Activity i tu SwiftUI naprawdę pokazuje, co potrafi. Widok jest podzielony na dwie strony:
-
Lewa strona: Pokazuje nazwę aktywności, ikonę i timer. Jeśli timer działa, całą robotę wykonuje Text(timerInterval:), licząc w górę od startedAt do daty rok do przodu (dzięki getFutureDate). Po zatrzymaniu wyświetla statyczny czas z getFormattedElapsedTime. Modyfikator .monospacedDigit() utrzymuje cyfry wyraźne, a font podrasowałem, żeby był pogrubiony i czytelny.
-
Prawa strona: Obsługuje przyciski. Gdy timer działa, jest niebieski przycisk pauzy. Po zatrzymaniu pojawia się zielony znaczek „ptaszek”, który otwiera aplikację, i niebieski przycisk play, który wznawia timer. Każdy przycisk odpala intent, który moduł natywny przechwytuje i przetwarza.
Zagłębiamy się w Dynamic Island
Widok Dynamic Island
Ten fragment definiuje, jak Live Activity wygląda w trzech trybach Dynamic Island: rozwiniętym (pełny widok), kompaktowym (ściśniętym) i minimalnym (absolutne minimum).
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)
}
}
-
**Tryb rozwinięty**: Pokazuje się po długim przytrzymaniu i dzieli się na .leading i .trailing. Strona leading układa ikonę (np. biegnącą postać) i nazwę („Workout”) nad dużym timerem: statycznym przy pauzie (getFormattedElapsedTime) i tykającym, gdy jest aktywny (Text(timerInterval:)). Strona trailing ma przyciski: niebieski przycisk pauzy, gdy timer działa, albo zielony „ptaszek” (otwórz aplikację) i niebieski play (wznów) przy pauzie. Podrasowałem fonty i padding, żeby pasowały do krzywizn wyspy.
-
**Tryb kompaktowy**: Gdy brakuje miejsca, compactLeading pokazuje malutką ikonę i skróconą nazwę, a compactTrailing wyświetla timer (statyczny albo tykający). .lineLimit(1) utrzymuje nazwę w ryzach, a font 12 punktów zapewnia czytelność.
-
**Tryb minimalny**: Ultraciasny, to tylko ikona 12 punktów, na przykład hantla, która mówi „timer wciąż tu jest”. Prosto, ale skutecznie.
Folder _shared: dlaczego to ważne
Przegląd folderu _shared
Folder _shared w expo-apple-targets to katalog najwyższego poziomu, który służy do linkowania kluczowego kodu zarówno do głównego targetu aplikacji, jak i do subtargetów, takich jak widget Live Activity.
Rozszerzenia, takie jak widgety, działają w osobnych procesach i wymagają, żeby konkretne pliki były zlinkowane zarówno do ich targetu, jak i do targetu głównej aplikacji. Folder _shared sprawia, że te pliki są automatycznie linkowane do obu, bez ręcznej konfiguracji. W przypadku mojego timera umieściłem tam strukturę LiveActivityAttributes, co gwarantowało, że aplikacja i widget dzielą ten sam stan timera (startedAt, pausedAt) bez problemów z synchronizacją.
Uruchamianie aplikacji z widgetu Live Activity
CompleteIntent pozwala użytkownikom stuknąć przycisk z „ptaszkiem” na widgecie Live Activity, żeby otworzyć aplikację i dać znać, że skończyli z timerem. To prosta, ale kluczowa interakcja przy kończeniu treningu.
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()
}
}
Kiedy użytkownik stuknie zielony „ptaszek”, ten intent się odpala i wysyła powiadomienie completeActivityFromWidget. Moduł natywny je przechwytuje, wywołuje event onWidgetCompleteActivity w JavaScripcie, a iOS otwiera aplikację dzięki openAppWhenRun: true.
Obsługa stuknięć użytkownika za pomocą intentów
PauseIntent to jeden z intentów, które sprawiają, że widget jest interaktywny.
Intenty Live Activity na ekranie blokady
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()
}
}
Ten intent odpala się, gdy użytkownik stuknie przycisk pauzy na widgecie. Jest banalnie prosty, ale skuteczny:
-
Wysyła powiadomienie (pauseTimerFromWidget), które moduł natywny przechwytuje przez setupNotificationObservers.
-
Moduł uruchamia wtedy performPause, aktualizując stan Live Activity i powiadamiając JavaScript.
Piękno polega na tym, jak intenty tworzą płynną pętlę: użytkownik stuka → intent się odpala → moduł aktualizuje → aplikacja pozostaje zsynchronizowana. expo-apple-targets bardzo ułatwiło konfigurację intentów, bo dało szablon, ale i tak musiałem zdebugować przypadek, w którym stuknięcia nie były rejestrowane. Okazało się, że zrobiłem literówkę w nazwie powiadomienia. Klasyka. Dokumentacja Expo Modules pomogła mi zrozumieć, jak obsługiwać eventy wywoływane przez natywne akcje, i to było kluczowe, żeby to zadziałało.
Eventy, które rozmawiają z JavaScriptem

Eventy z tej sekcji to sposób, w jaki moduł natywny utrzymuje aplikację React Native w zgodzie ze stanem Live Activity, korzystając z systemu eventów Expo.
onWidgetCompleteActivity
Ten event odpala się, gdy użytkownik stuknie „ptaszek”, żeby zakończyć aktywność. Wywołuje go 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)
])
}
completeIntentHandler przechwytuje powiadomienie completeActivityFromWidget, liczy upływający czas i wysyła event onWidgetCompleteActivity do JavaScriptu z ID aktywności i liczbą sekund, które upłynęły. JavaScript może wtedy zaktualizować UI aplikacji albo zapisać zakończenie treningu
onLiveActivityUpdate
Ten event odpala się za każdym razem, gdy zmienia się stan timera (np. pauza, wznowienie).
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
])
}
Wywoływany po zmianach stanu (np. w performPause albo performResume), wysyła event onLiveActivityUpdate z bieżącym stanem („active” albo „paused”), upływającym czasem i ID aktywności. JavaScript nasłuchuje go, żeby UI timera w aplikacji był zsynchronizowany z widgetem.
Oba eventy tworzą ścisłą pętlę zwrotną między modułem natywnym a JavaScriptem.
Dlaczego to wszystko ma znaczenie
Ta Live Activity to nie tylko timer, to funkcja, dzięki której moja aplikacja czuje się jak pełnoprawny obywatel iOS. Oto dlaczego to ważne:
-
Zaangażowanie użytkowników: Timer na ekranie blokady albo w Dynamic Island utrzymuje kontakt użytkownika z aplikacją bez wybijania go z rytmu. To idealne rozwiązanie na treningi, gdzie liczy się każda sekunda.
-
Natywne dopracowanie: Czysty design widgetu i interaktywne przyciski sprawiają, że aplikacja wygląda, jakby należała do iOS, a nie jak cross-platformowa myśl dodana na końcu.
-
Wydajność: Podejście startedAt/pausedAt, oparte na Text(timerInterval:), sprawia, że timer działa płynnie, nie drenuje baterii i nie wpada w limity API.
expo-apple-targets i Expo Modules API były tu cichymi bohaterami, bo dały solidny framework do łączenia JavaScriptu ze Swiftem. Nacisk dokumentacji na czyste definicje funkcji i obsługę eventów pomógł mi utrzymać kod uporządkowany i łatwy w utrzymaniu.
Ostatnie przemyślenia
Ta Live Activity dodaje aplikacji płynny, natywny charakter i pokazuje aktualizacje na żywo prosto na ekranie blokady i w Dynamic Island. Dzięki expo-apple-targets, Expo Modules API i wskazówkom społeczności (tak, wątki na Reddicie też się liczą) wdrożenie tego okazało się całkiem proste. Live Activities to mocny sposób na to, żeby aplikacje były bardziej połączone z użytkownikiem i dynamiczne
Oto link do repozytorium na GitHubie z pełnym kodem źródłowym 👉🏻 https://github.com/tarikfp/expo-live-activity-timer