Blogg

Live Activity-timer i Expo

1 maj 2025 12 min läsning

Så implementerar du Live Activities i Expo-appar. Lär dig skapa interaktiva widgets och uppdateringar i realtid för låsskärmen och Dynamic Island i iOS.

Live Activity-timer i Expo
ExpoiOSLive ActivitiesWidgetsReact Native

Bygga en Live Activity-timer i Expo

Live Activities i iOS ändrar spelplanen. De låter appar visa uppdateringar i realtid direkt på låsskärmen eller i Dynamic Island. Självklart började jag föreställa mig hur coolt det skulle vara med en träningstimer som tickade där och höll användarna motiverade utan att de ens behövde låsa upp telefonen. Men det fanns en hake: Live Activities byggs med Apples nativa verktyg, som Swift och ActivityKit. Det var då jag upptäckte verktyget expo-apple-targets i stället för att skriva hela moduler från grunden, och det gjorde processen mycket enklare än jag hade väntat mig. I den här artikeln går jag igenom hur jag byggde en timerbaserad Live Activity för iOS, vilka steg jag tog och vad jag lärde mig på vägen.

Varför jag blev besatt av Live Activities

Live Activities är inte bara ett coolt trick, de ändrar spelplanen för hur engagerade användarna blir. Apples Human Interface Guidelines beskriver dem som ett sätt att leverera "aktuell information som går att läsa med en blick" för tidskänsliga uppgifter. Tänk dig en träningsapp som visar din plankningstid mitt i passet, en matleveransapp som följer pizzans resa eller en samåkningsapp som uppdaterar när föraren beräknas komma fram, allt direkt på låsskärmen eller, på iPhone 14 Pro och senare, i Dynamic Island. Det är som att ge användarna ett VIP-pass till appens viktigaste uppdateringar utan att de behöver låsa upp telefonen.

Jag ville att användarna skulle se träningstimern ticka under ett set och hålla fokus utan att behöva öppna appen. Det är den sortens finish som får en app att kännas proffsig, och jag var helt med på det. Men du kan inte hantera allt det här utan att röra något nativt lager, så jag visste att jag skulle behöva dyka ner i Swift och brottas med Xcode. Sedan upptäckte jag expo-apple-targets, ett paket som överbryggar klyftan mellan Expos JavaScript-värld och iOS nativa funktioner. Stort tack till Evan Bacon. Verktyget tog en avskräckande uppgift och fick den att kännas som ett utmanande men lösbart pussel.

Helheten: Live Activities i en Expo-app

Live Activities är en fest bara för iOS. De drivs av ActivityKit, ett Swift-baserat ramverk, vilket betyder att du skriver nativ kod vare sig du vill eller inte. För en Expo-app är det som att försöka övertala en fisk att klättra i ett träd. Det går, men det kommer att kräva en del ansträngning. expo-apple-targets kliver in som en erfaren guide och ger dig ett ramverk för att skapa native-moduler och widget-tillägg utan att börja från noll. Det bygger på Expos modulsystem (Expo Modules API), som låter dig skriva nativ kod i Swift och exponera den för JavaScript, så att hela processen känns mindre som en rotfyllning.

Sätta upp projektet

Att komma igång var inte direkt en promenad i parken, men expo-apple-targets gjorde det hanterbart. Så här drog jag igång:

  • Installera expo-apple-targets: Ett snabbt npm install expo-apple-targets fick mig igång. Paketets README är en guldgruva som guidar dig genom att lägga till ett widget-tillägg i Xcode och uppdatera app.json med entitlementet för Live Activity (com.apple.developer.activitykit).

  • Konfigurera native-modulen: Jag använde Expos modulsystem för att skapa en Swift-modul som pratar med ActivityKit. Dokumentationen för Expo Modules betonar tydliga funktionssignaturer och händelser, vilket hjälpte mig att exponera metoder som startActivity för JavaScript utan att svettas.

  • Widget-tillägg: Här kom SwiftUI in i bilden och lät mig designa hur Live Activityn ser ut på låsskärmen och i Dynamic Island. expo-apple-targets har en mall för widgets, men jag var tvungen att anpassa den för att visa en tickande timer och interaktiva knappar.

  • Intents: De låter användare trycka på knappar i widgeten för att pausa eller återuppta timern. expo-apple-targets förenklar konfigurationen av intents, men jag fick ändå felsöka några feltändningar för att få notiserna att flöda rätt.

En timer som uppdateras varje sekund?

En utvecklare implementerar ivrigt en timeruppdatering varje sekund, vilket leder till kaotisk överbelastning av systemet när timern härjar fritt. (Genererad av gpt-4o)En utvecklare implementerar ivrigt en timeruppdatering varje sekund, vilket leder till kaotisk överbelastning av systemet när timern härjar fritt. (Genererad av gpt-4o)

När jag först tog mig an timern sa min hjärna: "Uppdatera bara Live Activityn varje sekund med aktuell tid." Låter enkelt, eller hur? Fel. Jag snubblade över en Reddit-tråd där utvecklare diskuterade möjligheten att uppdatera timern i en Live Activity. Domen var enhällig: att uppdatera varje sekund är en katastrof. Det är som att försöka driva ett rymdskepp med ett hamsterhjul; det rör sig, men det brinner ut snabbt. Ständiga uppdateringar hamrar på CPU:n och tömmer batteriet, vilket gör appen seg.

Den Reddit-tråden var en väckarklocka. Jag hittade SwiftUI:s Text(timerInterval:) i Apples SwiftUI-dokumentation, och det var en uppenbarelse. Den här vyn hanterar timeruppdateringar nativt och tickar på utan att hela Live Activityn behöver uppdateras. Det är som att lägga ut det tråkiga på iOS så att du kan fokusera på de roliga delarna.

Så jag slopade planen med uppdateringar varje sekund och valde ett upplägg med startedAt/pausedAt. Därför är det en vinnare:

  • Prestanda: I stället för att skicka uppdateringar varje sekund sparar jag timerns starttid (startedAt) och paustid (pausedAt, om den är pausad). Widgeten använder Text(timerInterval:) för att visa en levande timer baserad på startedAt, och när den är pausad visar den en statisk tid utifrån pausedAt. Det kapar API-anropen till nästan noll.

  • Batterieffektivitet: Täta uppdateringar är en batterivampyr. När SwiftUI får sköta tickandet förblir appen slimmad och användarnas telefoner glada.

  • Följer API:et: Apples API:er för Live Activity är inte byggda för spam i realtid. Upplägget med startedAt/pausedAt spelar enligt iOS förväntningar och minskar risken för begränsningar av antalet anrop.

  • Enkel kod: Att hantera två tidsstämplar är mycket enklare än att jonglera en ström av uppdateringar. Det håller koden ren och min stressnivå i schack.

Det här upplägget kändes som att hitta en hemlig genväg i ett tv-spel. Timern går smidigt, ser bra ut och slukar inga resurser. Reddit-tråden (här är den igen) förtjänar en medalj för att den pekade mig i rätt riktning.

Hjärtat i Live Activityn

Jag tänker inte tråka ut dig med varenda kodrad. Vi fokuserar på de viktiga kodsnuttarna som får timern att ticka. Jag delar hela källkoden på GitHub i slutet av artikeln.

Structen LiveActivityAttributes

Den här structen är ryggraden i Live Activityn och definierar dess data och hur den förändras.

    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
    }

Det här är som Live Activityns DNA. Den yttre LiveActivityAttributes innehåller statiska saker, activityName (t.ex. "Workout") och activityIcon (t.ex. "RUNNING"), som sätts när aktiviteten startar. Den inre ContentState är där det händer, och den håller reda på startedAt (när timern startade) och pausedAt (när den pausades, om alls). Hjälpmetoderna är de verkliga MVP:erna:

  • getElapsedTimeInSeconds() räknar ut hur länge timern har gått, stannar vid pausedAt om den är pausad eller använder aktuell tid om den är aktiv. Det håller logiken tät och återanvändbar.

  • isRunning() är en enkel kontroll: om pausedAt är null är timern igång. Det är ett rent sätt att slippa röriga kontroller av state på andra ställen.

  • getFormattedElapsedTime() gör om sekunder till en snygg sträng i formatet "MM:SS" eller "HH:MM:SS" för widgeten. Jag lade till stöd för timmar när jag insåg att vissa användare kanske kör extremt långa pass, som maraton.

  • getFutureDate() sätter ett datum ett år framåt, som jag skickar till Text(timerInterval:) så att timern kan gå på obestämd tid utan att jag behöver bry mig om ett slutdatum.

Jag älskar hur den här structen håller ordning. Den är som en välpackad ryggsäck: allt du behöver, inget du inte behöver. Att den följer Codable och Hashable gör den lätt att serialisera för uppdateringar och använda i SwiftUI, vilket räddade mig när state skulle synkas mellan modulen och widgeten.

Starta Live Activityn

Funktionen startActivity är där magin börjar, och den startar en ny 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 ""
    }

Den här funktionen är gnistan som tänder elden. Den exponeras för JavaScript via Expos modulsystem, så att min React Native-app kan anropa den med ett namn och en ikon. Så här gör den:

  • Den kontrollerar att det är iOS 16.2 eller senare. Live Activities finns inte före det.

  • Den anropar endAllActivities() för att rensa bort befintliga aktiviteter. iOS tillåter flera Live Activities, men jag ville bara ha en åt gången för att undvika förvirring.

  • Den sätter startedAt till aktuell tid och rensar pausedAt, så att timern är redo att gå.

  • Den kontrollerar att Live Activities är aktiverade (användare kan stänga av dem i Inställningar, vilket ställde till det för mig i början).

  • Den bygger en LiveActivityAttributes med angivet namn och ikon, och en ContentState med starttiden.

  • Den begär en ny aktivitet via Activity.request, som ger mig ett Activity-objekt med ett unikt ID.

  • Den sparar ID:t, skickar en uppdateringshändelse till JavaScript och returnerar ID:t så att appen kan hålla koll på det.

Pausa timern

Att pausa timern sköts av performPause, som uppdaterar Live Activityns state.

    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
    }

Det är här upplägget med startedAt/pausedAt glänser. När användaren pausar timern (antingen från appen eller widgeten) gör funktionen följande:

  • Kontrollerar att vi kör iOS 16.2 och att timern inte redan är pausad (dubbelpausning är inte tillåten).

  • Hämtar aktivitetens ID och faller tillbaka på currentActivityId om inget anges.

  • Hittar aktiviteten med findActivityById, som söker bland aktiva aktiviteter.

  • Sätter pausedAt till aktuell tid, vilket fryser timern.

  • Skapar en ny ContentState med den ursprungliga startedAt och den nya pausedAt.

  • Uppdaterar aktiviteten med activity.update, så att widgeten visar den pausade tiden.

  • Skickar en händelse till JavaScript för att hålla appens UI i synk.

Logiken här handlar om precision. Varje kontroll (som pausedAt == nil) finns där för att förhindra konstiga kantfall, som att pausa en aktivitet som inte finns. Jag lutade mig mot dokumentationen för Expo Modules för händelsehanteringen och använde sendEvent för att skicka uppdateringar till JavaScript. Tidiga versioner av funktionen validerade inte startedAt, vilket ledde till en del skumma timervisningar. Läxan: skydda alltid ditt state.

Vyn på låsskärmen

LockScreenLiveActivityView är det användarna ser när telefonen är låst, och den måste se skarp ut.

Live Activity på låsskärmenLive Activity på låsskärmen

    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)
            }
        }
    }

Det här är det visuella hjärtat i Live Activityn, och det är här SwiftUI verkligen visar musklerna. Vyn är uppdelad i två sidor:

  • Vänster sida: Visar aktivitetens namn, ikon och timer. Om timern går gör Text(timerInterval:) grovjobbet och räknar uppåt från startedAt till ett år framåt (tack vare getFutureDate). Om den är pausad visas en statisk tid från getFormattedElapsedTime. Modifieraren .monospacedDigit() håller siffrorna skarpa, och jag justerade typsnittet så att det blev fetstilt och lättläst.

  • Höger sida: Hanterar knapparna. När timern går finns en blå pausknapp. När den är pausad får du en grön bock för att öppna appen och en blå play-knapp för att fortsätta. Varje knapp utlöser en intent, som native-modulen fångar upp och hanterar.

En titt in i Dynamic Island

Vy i Dynamic IslandVy i Dynamic Island

Den här kodsnutten definierar hur Live Activityn visas i Dynamic Islands tre lägen: expanderat (full vy), kompakt (ihoptryckt) och minimalt (bara det nödvändigaste).

    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)
      }
    }
  • **Expanderat läge**: Visas vid långt tryck och är uppdelat i .leading och .trailing. Den vänstra sidan staplar ikonen (t.ex. en springande figur) och namnet ("Workout") med en stor timer, statisk när den är pausad (getFormattedElapsedTime) och tickande när den är aktiv (Text(timerInterval:)). Den högra sidan har knappar: en blå pausknapp när timern går, eller en grön bock (öppna appen) och en blå play-knapp (fortsätt) när den är pausad. Jag justerade typsnitt och padding så att det passar Islands kurvor.

  • **Kompakt läge**: När utrymmet krymper visar compactLeading en pytteliten ikon och ett avkortat namn, medan compactTrailing visar timern (statisk eller tickande). .lineLimit(1) håller namnet prydligt, och ett typsnitt på 12 punkter ser till att det går att läsa.

  • **Minimalt läge**: Extremt trångt, så det är bara en ikon på 12 punkter, som en hantel, som säger "timern finns kvar". Enkelt men effektivt.

Mappen _shared: varför den är så viktig

översikt över mappen _sharedöversikt över mappen _shared

Mappen _shared i expo-apple-targets är en katalog på toppnivå som är till för att länka viktig kod till både appens huvudtarget och undertargets, som widgeten för Live Activityn.

Tillägg, som widgets, körs i separata processer och kräver att vissa filer länkas till deras target såväl som till huvudappens. Mappen _shared ser till att de här filerna automatiskt länkas till båda, så att ingen manuell konfiguration behövs. För min timer lade jag structen LiveActivityAttributes här, vilket garanterade att appen och widgeten delade samma timer-state (startedAt, pausedAt) utan synkproblem.

Starta appen från Live Activity-widgeten

CompleteIntent låter användare trycka på en bockknapp i Live Activity-widgeten för att öppna appen och signalera att de är klara med timern. Det är en enkel men avgörande interaktion för att avsluta ett träningspass.

    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()
        }
    }

När användaren trycker på den gröna bocken utlöses den här intenten, som postar notisen completeActivityFromWidget. Native-modulen fångar upp den, utlöser händelsen onWidgetCompleteActivity till JavaScript, och iOS öppnar appen tack vare openAppWhenRun: true.

Hantera användarens tryck med intents

PauseIntent är en av de intents som gör widgeten interaktiv.

Intents för Live Activity på låsskärmenIntents för Live Activity på låsskärmen

    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()
      }
    }

Den här intenten utlöses när användaren trycker på pausknappen i widgeten. Den är löjligt enkel men kraftfull:

  • Den postar en notis (pauseTimerFromWidget) som native-modulen fångar upp via setupNotificationObservers.

  • Modulen kör sedan performPause, som uppdaterar Live Activityns state och meddelar JavaScript.

Det fina här är hur intents skapar en sömlös loop: användaren trycker → intenten utlöses → modulen uppdaterar → appen förblir i synk. expo-apple-targets gjorde det busenkelt att sätta upp intents genom att erbjuda en mall, men jag fick ändå felsöka ett fall där trycken inte registrerades. Det visade sig att jag hade stavat fel på namnet på en notis. Klassiskt. Dokumentationen för Expo Modules hjälpte mig att förstå hur man hanterar händelser som utlöses av nativa handlingar, vilket var avgörande för att få det här att fungera.

Händelser som pratar med JavaScript

Händelserna i följande avsnitt är hur native-modulen håller React Native-appen i synk med Live Activityns state, med hjälp av Expos händelsesystem.

onWidgetCompleteActivity

Den här händelsen utlöses när användaren trycker på bocken för att avsluta aktiviteten, och den triggas av 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 fångar upp notisen completeActivityFromWidget, räknar ut förfluten tid och skickar händelsen onWidgetCompleteActivity till JavaScript med aktivitetens ID och antalet förflutna sekunder. JavaScript kan sedan uppdatera appens UI eller logga att passet är avslutat

onLiveActivityUpdate

Den här händelsen utlöses varje gång timerns state ändras (t.ex. paus eller återupptagning).

    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
        ])
    }

Den anropas efter ändringar av state (som i performPause eller performResume) och skickar händelsen onLiveActivityUpdate med aktuellt läge ("active" eller "paused"), förfluten tid och aktivitetens ID. JavaScript lyssnar efter den för att hålla appens timer-UI i synk med widgeten.

Båda händelserna skapar en tät återkopplingsloop mellan native-modulen och JavaScript.

Varför allt det här spelar roll

Den här Live Activityn är inte bara en timer, det är en funktion som får min app att kännas som en riktig iOS-medborgare. Därför är den viktig:

  • Engagemang: En timer på låsskärmen eller i Dynamic Island håller användarna kopplade till appen utan att bryta deras flow. Det är perfekt för träning, där varje sekund räknas.

  • Nativ finish: Widgetens rena design och interaktiva knappar får appen att kännas som att den hör hemma i iOS, inte som en plattformsoberoende eftertanke.

  • Prestanda: Upplägget med startedAt/pausedAt, drivet av Text(timerInterval:), ser till att timern går smidigt utan att tömma batteriet eller slå i API-gränser.

expo-apple-targets och Expo Modules API var de okända hjältarna här, med ett robust ramverk för att överbrygga JavaScript och Swift. Dokumentationens fokus på rena funktionsdefinitioner och händelsehantering höll min kod organiserad och lätt att underhålla.

Avslutande tankar

Den här Live Activityn ger appen en smidig, nativ känsla och visar uppdateringar i realtid direkt på låsskärmen och i Dynamic Island. Tack vare expo-apple-targets, Expo Modules API och insikter från communityn (ja, inklusive Reddit-trådar) var det ganska rakt på sak att få liv i den. Live Activities är ett kraftfullt sätt att få appar att kännas mer uppkopplade och dynamiska

Här är GitHub-länken till hela källkodsrepot 👉🏻 https://github.com/tarikfp/expo-live-activity-timer