Blog

Live Activity-timer in Expo

1 mei 2025 12 min leestijd

Live Activities implementeren in Expo-apps. Leer hoe je interactieve widgets en realtime updates maakt voor het toegangsscherm en het Dynamic Island van iOS.

Live Activity-timer in Expo
ExpoiOSLive ActivitiesWidgetsReact Native

Een Live Activity-timer bouwen in Expo

Live Activities op iOS veranderen alles: ze laten apps realtime updates tonen, direct op het toegangsscherm of in het Dynamic Island. Ik begon me natuurlijk meteen voor te stellen hoe gaaf het zou zijn om daar een workouttimer te laten lopen, die gebruikers gemotiveerd houdt zonder dat ze hun telefoon hoeven te ontgrendelen. Maar er zat een addertje onder het gras: Live Activities worden gebouwd met de native tools van Apple, zoals Swift en ActivityKit. Toen ontdekte ik een tool genaamd expo-apple-targets, waarmee ik niet hele modules vanaf nul hoefde te schrijven, en dat maakte het proces veel makkelijker dan ik had verwacht. In dit artikel laat ik je zien hoe ik een Live Activity met een timer voor iOS heb gebouwd, welke stappen ik zette en wat ik onderweg heb geleerd.

Waarom ik geobsedeerd raakte door Live Activities

Live Activities zijn niet zomaar een leuk trucje, ze veranderen echt hoe betrokken gebruikers zijn. De Human Interface Guidelines van Apple beschrijven ze als een manier om “actuele informatie die je in één oogopslag ziet” te tonen bij tijdgevoelige taken. Stel je een fitnessapp voor die midden in je workout je planktijd laat zien, een bezorgapp die de route van je pizza volgt of een taxiapp die de verwachte aankomsttijd van je chauffeur bijwerkt, allemaal direct op het toegangsscherm of, op de iPhone 14 Pro en nieuwer, in het Dynamic Island. Het is alsof je gebruikers een VIP-pas geeft voor de belangrijkste updates van je app, zonder dat ze hun telefoon hoeven te ontgrendelen.

Ik wilde dat gebruikers hun workouttimer tijdens een set zagen oplopen, zodat ze gefocust bleven zonder de app te hoeven openen. Het is het soort afwerking waardoor een app professioneel aanvoelt, en ik ging er volledig voor. Maar je kunt dit niet allemaal regelen zonder de native laag aan te raken, dus ik wist dat ik in Swift zou duiken en met Xcode zou moeten worstelen. Toen ontdekte ik expo-apple-targets, een package dat de kloof overbrugt tussen de JavaScript-wereld van Expo en de native features van iOS. Een groot compliment voor Evan Bacon: deze tool maakte van een ontmoedigende klus een uitdagende, maar haalbare puzzel.

Het grote plaatje: Live Activities in een Expo-app

Live Activities zijn een feestje dat alleen op iOS plaatsvindt. Ze draaien op ActivityKit, een framework in Swift, wat betekent dat je native code schrijft of je dat nu leuk vindt of niet. Voor een Expo-app is dat alsof je een vis probeert over te halen om in een boom te klimmen: het kan, maar het kost moeite. expo-apple-targets springt bij als een ervaren gids en geeft je een framework om native modules en widget-extensies te maken zonder vanaf nul te beginnen. Het is gebouwd op het modulesysteem van Expo (Expo Modules API), waarmee je native code in Swift schrijft en die aan JavaScript beschikbaar stelt. Daardoor voelt het hele proces een stuk minder als een wortelkanaalbehandeling.

Het project opzetten

Beginnen was niet bepaald een wandeling in het park, maar met expo-apple-targets was het te doen. Zo ben ik van start gegaan:

  • expo-apple-targets installeren: Een snelle npm install expo-apple-targets en ik kon aan de slag. De README van het package is een goudmijn: hij leidt je door het toevoegen van een widget-extensie in Xcode en het bijwerken van app.json met de Live Activity-entitlement (com.apple.developer.activitykit).

  • Native module opzetten: Ik gebruikte het modulesysteem van Expo om een Swift-module te maken die met ActivityKit praat. De documentatie van Expo Modules legt de nadruk op duidelijke functiesignaturen en events, en dat hielp me om methods zoals startActivity zonder moeite aan JavaScript beschikbaar te stellen.

  • Widget-extensie: Hier kwam SwiftUI in beeld, waarmee ik het uiterlijk van de Live Activity voor het toegangsscherm en het Dynamic Island kon ontwerpen. expo-apple-targets levert een widgettemplate, maar ik moest die aanpassen om een lopende timer en interactieve knoppen te tonen.

  • Intents: Hiermee kunnen gebruikers op knoppen in de widget tikken om de timer te pauzeren of te hervatten. expo-apple-targets maakt het opzetten van intents eenvoudiger, maar ik moest toch nog een paar mislukte aanroepen debuggen voordat de notificaties goed doorkwamen.

Een timer die elke seconde wordt bijgewerkt?

Een developer implementeert enthousiast een timer die elke seconde wordt bijgewerkt, wat leidt tot een chaotische overbelasting van het systeem terwijl de timer alles overhoop haalt. (Gegenereerd door gpt-4o)Een developer implementeert enthousiast een timer die elke seconde wordt bijgewerkt, wat leidt tot een chaotische overbelasting van het systeem terwijl de timer alles overhoop haalt. (Gegenereerd door gpt-4o)

Toen ik voor het eerst met de timer aan de slag ging, zei mijn brein: “Werk de Live Activity gewoon elke seconde bij met de huidige tijd.” Klinkt simpel, toch? Mis. Ik stuitte op een Reddit-thread waarin devs bespraken hoe je de timer van een Live Activity kunt bijwerken. Het oordeel was unaniem: elke seconde bijwerken is een ramp. Het is alsof je een ruimteschip probeert aan te drijven met een hamsterwiel; het beweegt wel, maar het is snel uitgeput. Constante updates belasten de CPU zwaar en trekken de batterij leeg, waardoor je app traag wordt.

Die Reddit-thread was een wake-upcall. Ik vond Text(timerInterval:) van SwiftUI in de SwiftUI-documentatie van Apple, en dat was een openbaring. Deze view regelt timerupdates native en blijft doortikken zonder dat de hele Live Activity ververst hoeft te worden. Het is alsof je het saaie werk uitbesteedt aan iOS, zodat jij je op de leuke delen kunt richten.

Dus liet ik het plan om elke seconde bij te werken varen en koos ik voor een aanpak met startedAt en pausedAt. Daarom is dit een winnaar:

  • Prestaties: In plaats van elke seconde updates af te vuren, sla ik de starttijd van de timer op (startedAt) en de pauzetijd (pausedAt, als hij gepauzeerd is). De widget gebruikt Text(timerInterval:) om een lopende timer te tonen op basis van startedAt, en bij een pauze toont hij een vaste tijd op basis van pausedAt. Dat brengt het aantal API-aanroepen terug tot bijna nul.

  • Zuinig met de batterij: Frequente updates zijn een batterijvampier. Door SwiftUI het tikken te laten regelen, blijft de app licht en blijven de telefoons van gebruikers blij.

  • Binnen de regels van de API: De Live Activity-API's van Apple zijn niet gemaakt voor realtime spam. De opzet met startedAt en pausedAt sluit netjes aan bij wat iOS verwacht, waardoor de kans op rate limiting kleiner wordt.

  • Eenvoudige code: Twee timestamps beheren is veel makkelijker dan jongleren met een stroom updates. Het houdt de code schoon en mijn stressniveau onder controle.

Deze aanpak voelde als het vinden van een geheime shortcut in een videogame. De timer loopt soepel, ziet er goed uit en slokt geen resources op. De Reddit-thread (hier is hij nog een keer) verdient een medaille omdat hij me de goede kant op wees.

Het hart van de Live Activity

Ik ga je niet vervelen met elke regel code; laten we ons richten op de belangrijkste snippets die deze timer laten tikken. Aan het eind van het artikel deel ik de volledige broncode op GitHub.

De struct LiveActivityAttributes

Deze struct is de ruggengraat van de Live Activity: hij bepaalt de data en hoe die zich ontwikkelt.

    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
    }

Dit is een soort DNA van de Live Activity. De buitenste LiveActivityAttributes bevat de vaste dingen: activityName (bijvoorbeeld “Workout”) en activityIcon (bijvoorbeeld “RUNNING”), die worden ingesteld als de activiteit start. De binnenste ContentState is waar het gebeurt: die houdt startedAt bij (wanneer de timer begon) en pausedAt (wanneer hij gepauzeerd is, als dat zo is). De helper methods zijn de echte MVP's:

  • getElapsedTimeInSeconds() berekent hoe lang de timer al loopt. Hij stopt bij pausedAt als de timer gepauzeerd is, of gebruikt de huidige tijd als hij actief is. Zo blijft de logica strak en herbruikbaar.

  • isRunning() is een simpele check: als pausedAt null is, loopt de timer. Het is een nette manier om rommelige state-checks elders te vermijden.

  • getFormattedElapsedTime() zet seconden om in een nette string als “MM:SS” of “HH:MM:SS” voor de widget. Ondersteuning voor uren voegde ik toe toen ik besefte dat sommige gebruikers misschien extreem lange workouts doen, zoals marathons.

  • getFutureDate() stelt een datum een jaar vooruit in, die ik aan Text(timerInterval:) meegeef, zodat de timer onbeperkt kan doorlopen zonder dat ik me zorgen hoef te maken over een einddatum.

Ik vind het mooi hoe deze struct alles georganiseerd houdt. Het is als een goed ingepakte rugzak: alles wat je nodig hebt, niets wat je niet nodig hebt. Doordat hij voldoet aan Codable en Hashable, is hij makkelijk te serialiseren voor updates en te gebruiken in SwiftUI. Dat was een redding bij het synchroniseren van de state tussen de module en de widget.

De Live Activity starten

In de functie startActivity begint de magie: die start een nieuwe 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 ""
    }

Deze functie is de vonk die het vuur aansteekt. Hij is via het modulesysteem van Expo beschikbaar voor JavaScript, zodat mijn React Native-app hem kan aanroepen met een naam en een icoon. Dit is wat hij doet:

  • Hij controleert of het iOS 16.2 of nieuwer is. Daarvoor bestaan Live Activities niet.

  • Hij roept endAllActivities() aan om bestaande activiteiten op te ruimen. iOS staat meerdere Live Activities toe, maar ik wilde er één tegelijk om verwarring te voorkomen.

  • Hij zet startedAt op de huidige tijd en maakt pausedAt leeg, zodat de timer klaar is om te lopen.

  • Hij controleert of Live Activities zijn ingeschakeld (gebruikers kunnen ze uitzetten in Instellingen, en daar ging ik in het begin flink de mist mee in).

  • Hij bouwt een LiveActivityAttributes met de opgegeven naam en het icoon, en een ContentState met de starttijd.

  • Hij vraagt een nieuwe activiteit aan via Activity.request, wat me een Activity-object met een uniek ID oplevert.

  • Hij slaat het ID op, stuurt een update-event naar JavaScript en geeft het ID terug, zodat de app het kan bijhouden.

De timer pauzeren

Het pauzeren van de timer gebeurt in performPause, dat de state van de Live Activity bijwerkt.

    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 komt de aanpak met startedAt en pausedAt echt tot zijn recht. Als de gebruiker de timer pauzeert (vanuit de app of de widget), doet deze functie het volgende:

  • Hij controleert of we op iOS 16.2 zitten en of de timer niet al gepauzeerd is (dubbel pauzeren mag niet).

  • Hij pakt het ID van de activiteit en valt terug op currentActivityId als er geen ID is meegegeven.

  • Hij zoekt de activiteit op met findActivityById, dat door de actieve activiteiten zoekt.

  • Hij zet pausedAt op de huidige tijd, waardoor de timer bevriest.

  • Hij maakt een nieuwe ContentState met de oorspronkelijke startedAt en de nieuwe pausedAt.

  • Hij werkt de activiteit bij met activity.update, zodat de widget de gepauzeerde tijd toont.

  • Hij stuurt een event naar JavaScript om de UI van de app synchroon te houden.

De logica draait hier helemaal om precisie: elke check (zoals pausedAt == nil) is er om vreemde edge cases te voorkomen, zoals het pauzeren van een activiteit die niet bestaat. Voor het afhandelen van events leunde ik op de documentatie van Expo Modules, waarbij ik sendEvent gebruikte om updates naar JavaScript te sturen. Eerdere versies van deze functie valideerden startedAt niet, wat tot vreemde timerweergaven leidde. Les geleerd: bewaak altijd je state.

De weergave op het toegangsscherm

De LockScreenLiveActivityView is wat gebruikers zien als hun telefoon vergrendeld is, en die moet er strak uitzien.

Live Activity op het toegangsschermLive Activity op het toegangsscherm

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

Dit is het visuele hart van de Live Activity, en hier laat SwiftUI echt zien wat het kan. De view is in twee kanten verdeeld:

  • Linkerkant: Toont de naam van de activiteit, het icoon en de timer. Als de timer loopt, doet Text(timerInterval:) het zware werk en telt hij op vanaf startedAt tot een jaar later (dankzij getFutureDate). Bij een pauze toont hij een vaste tijd uit getFormattedElapsedTime. De modifier .monospacedDigit() houdt de cijfers scherp, en ik heb het lettertype aangepast zodat het vet en goed leesbaar is.

  • Rechterkant: Regelt de knoppen. Als de timer loopt, is er een blauwe pauzeknop. Bij een pauze krijg je een groen vinkje om de app te openen en een blauwe afspeelknop om verder te gaan. Elke knop vuurt een intent af, die de native module opvangt en verwerkt.

Een duik in het Dynamic Island

Weergave in het Dynamic IslandWeergave in het Dynamic Island

Deze snippet bepaalt hoe de Live Activity verschijnt in de drie modi van het Dynamic Island: expanded (volledige weergave), compact (samengeperst) en minimal (het absolute 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)
      }
    }
  • **Expanded-modus**: Wordt getoond bij lang indrukken en is verdeeld in .leading en .trailing. De leading-kant stapelt het icoon (bijvoorbeeld een rennend figuurtje) en de naam (“Workout”) met een grote timer: vast bij een pauze (getFormattedElapsedTime), tikkend als hij actief is (Text(timerInterval:)). De trailing-kant heeft knoppen: een blauwe pauzeknop als de timer loopt, of een groen vinkje (app openen) en een blauwe afspeelknop (hervatten) bij een pauze. Ik heb lettertypen en padding aangepast zodat alles in de rondingen van het Island past.

  • **Compact-modus**: Als de ruimte krimpt, toont compactLeading een klein icoon en een afgekapte naam, terwijl compactTrailing de timer laat zien (vast of tikkend). De .lineLimit(1) houdt de naam netjes, en een lettergrootte van 12 punten zorgt dat het leesbaar blijft.

  • **Minimal-modus**: Supercompact: alleen een icoon van 12 punten, zoals een halter, om te laten zien dat de timer er nog is. Simpel maar effectief.

De map _shared: waarom die zo belangrijk is

Overzicht van de map _sharedOverzicht van de map _shared

De map _shared in expo-apple-targets is een map op het hoogste niveau die bedoeld is om essentiële code te koppelen aan zowel je hoofdtarget van de app als aan subtargets, zoals de Live Activity-widget.

Extensies zoals widgets draaien in aparte processen en vereisen dat bepaalde bestanden aan hun eigen target en aan dat van de hoofdapp gekoppeld zijn. De map _shared zorgt ervoor dat deze bestanden automatisch aan beide gekoppeld worden, zodat je niets handmatig hoeft te configureren. Voor mijn timer zette ik de struct LiveActivityAttributes hier neer, zodat de app en de widget gegarandeerd dezelfde timerstate (startedAt, pausedAt) deelden, zonder synchronisatieproblemen.

De app openen vanuit de Live Activity-widget

Met de CompleteIntent kunnen gebruikers op een vinkje in de Live Activity-widget tikken om de app te openen, als teken dat ze klaar zijn met de timer. Het is een simpele maar cruciale interactie om een workout af te ronden.

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

Als de gebruiker op het groene vinkje tikt, wordt deze intent afgevuurd en plaatst hij een notificatie completeActivityFromWidget. De native module vangt die op, stuurt het event onWidgetCompleteActivity naar JavaScript en iOS opent de app, dankzij openAppWhenRun: true.

Tikken van gebruikers afhandelen met intents

De PauseIntent is een van de intents die de widget interactief maken.

Intents van de Live Activity op het toegangsschermIntents van de Live Activity op het toegangsscherm

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

Deze intent wordt geactiveerd als de gebruiker op de pauzeknop in de widget tikt. Hij is heel simpel, maar krachtig:

  • Hij plaatst een notificatie (pauseTimerFromWidget) die de native module opvangt via setupNotificationObservers.

  • De module draait daarna performPause, werkt de state van de Live Activity bij en laat JavaScript dat weten.

Het mooie is hoe intents een naadloze cirkel vormen: gebruiker tikt → intent wordt afgevuurd → module werkt bij → app blijft synchroon. expo-apple-targets maakte het opzetten van intents een eitje door een template te leveren, maar ik moest toch nog een geval debuggen waarin tikken niet werden geregistreerd. Wat bleek: ik had de naam van een notificatie verkeerd gespeld. Klassiek. De documentatie van Expo Modules hielp me begrijpen hoe ik events kon afhandelen die door native acties worden geactiveerd, en dat was cruciaal om dit werkend te krijgen.

Events die met JavaScript praten

Met de events in de volgende sectie houdt de native module de React Native-app synchroon met de state van de Live Activity, via het eventsysteem van Expo.

onWidgetCompleteActivity

Dit event wordt afgevuurd als de gebruiker op het vinkje tikt om de activiteit af te ronden, geactiveerd door 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)
        ])
    }

De completeIntentHandler vangt de notificatie completeActivityFromWidget op, berekent de verstreken tijd en stuurt het event onWidgetCompleteActivity naar JavaScript, met het ID van de activiteit en het aantal verstreken seconden. JavaScript kan daarna de UI van de app bijwerken of de voltooide workout vastleggen

onLiveActivityUpdate

Dit event wordt afgevuurd zodra de state van de timer verandert (bijvoorbeeld bij pauzeren of hervatten).

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

Deze functie wordt aangeroepen na state-wijzigingen (zoals in performPause of performResume) en stuurt het event onLiveActivityUpdate met de huidige state (“active” of “paused”), de verstreken tijd en het ID van de activiteit. JavaScript luistert hiernaar om de timer-UI van de app synchroon te houden met de widget.

Beide events vormen een strakke feedbackcirkel tussen de native module en JavaScript.

Waarom dit allemaal belangrijk is

Deze Live Activity is niet zomaar een timer: het is een feature waardoor mijn app aanvoelt als een echte native iOS-app. Daarom is het zo belangrijk:

  • Betrokkenheid van gebruikers: Een timer op het toegangsscherm of in het Dynamic Island houdt gebruikers verbonden met de app zonder hun flow te onderbreken. Perfect voor workouts, waar elke seconde telt.

  • Native afwerking: Door het strakke ontwerp en de interactieve knoppen van de widget voelt de app alsof hij op iOS thuishoort, niet als een cross-platform bijzaak.

  • Prestaties: De aanpak met startedAt en pausedAt, aangedreven door Text(timerInterval:), zorgt ervoor dat de timer soepel loopt zonder de batterij leeg te trekken of tegen API-limieten aan te lopen.

expo-apple-targets en de Expo Modules API waren hier de onbezongen helden: ze boden een robuust framework om JavaScript en Swift met elkaar te verbinden. Doordat de documentatie de nadruk legt op nette functiedefinities en het afhandelen van events, bleef mijn code georganiseerd en goed te onderhouden.

Tot slot

Deze Live Activity geeft de app een soepel, native gevoel en toont realtime updates direct op het toegangsscherm en in het Dynamic Island. Dankzij expo-apple-targets, de Expo Modules API en inzichten uit de community (ja, Reddit-threads ook) was het vrij eenvoudig om dit tot leven te brengen. Live Activities zijn een krachtige manier om apps verbondener en dynamischer te laten aanvoelen

Hier is de GitHub-link naar de volledige broncode 👉🏻 https://github.com/tarikfp/expo-live-activity-timer