Créer un timer Live Activity dans Expo
Les Live Activities sur iOS changent la donne : elles permettent aux applications d’afficher des mises à jour en temps réel directement sur l’écran verrouillé ou dans la Dynamic Island. Naturellement, j’ai commencé à imaginer à quel point ce serait génial d’y faire tourner un timer d’entraînement, pour garder les utilisateurs motivés sans même qu’ils déverrouillent leur téléphone. Mais il y avait un hic : les Live Activities sont construites avec les outils natifs d’Apple, comme Swift et ActivityKit. C’est là que j’ai découvert un outil appelé expo-apple-targets, qui m’a évité d’écrire des modules entiers à partir de zéro et a rendu le processus bien plus simple que prévu. Dans cet article, je vous explique comment j’ai construit une Live Activity basée sur un timer pour iOS, les étapes que j’ai suivies et ce que j’ai appris en chemin.
Pourquoi les Live Activities m’ont obsédé
Les Live Activities ne sont pas qu’un gadget sympa, elles changent la donne pour l’engagement des utilisateurs. Les Human Interface Guidelines d’Apple les décrivent comme un moyen de fournir des « informations actuelles, lisibles d’un coup d’œil » pour des tâches liées au temps. Imaginez une application de fitness qui affiche votre temps de gainage en pleine séance, une application de livraison qui suit le trajet de votre pizza, ou une application de VTC qui met à jour l’heure d’arrivée de votre chauffeur, le tout directement sur l’écran verrouillé ou, sur l’iPhone 14 Pro et les modèles suivants, dans la Dynamic Island. C’est comme offrir aux utilisateurs un pass VIP vers les mises à jour les plus importantes de votre application, sans qu’ils aient besoin de déverrouiller leur téléphone.
Je voulais que les utilisateurs voient le timer de leur entraînement défiler pendant une série, pour qu’ils restent concentrés sans être obligés d’ouvrir l’application. C’est le genre de finition qui donne à une application un côté pro, et j’étais à fond. Mais impossible de gérer tout ça sans toucher à la couche native, donc je savais que j’allais plonger dans Swift et me battre avec Xcode. C’est là que j’ai découvert expo-apple-targets, un package qui fait le lien entre le monde JavaScript d’Expo et les fonctionnalités natives d’iOS. Un grand bravo à Evan Bacon : cet outil a transformé une tâche intimidante en un puzzle exigeant mais faisable.
Vue d’ensemble : les Live Activities dans une application Expo
Les Live Activities sont une fête réservée à iOS. Elles reposent sur ActivityKit, un framework en Swift, ce qui veut dire que vous écrirez du code natif, que vous le vouliez ou non. Pour une application Expo, c’est un peu comme essayer de convaincre un poisson de grimper à un arbre : c’est possible, mais ça va demander des efforts. expo-apple-targets intervient comme un guide expérimenté, en fournissant un cadre pour créer des modules natifs et des extensions de widget sans partir de zéro. Il s’appuie sur le système de modules d’Expo (Expo Modules API), qui permet d’écrire du code natif en Swift et de l’exposer à JavaScript, ce qui rend le processus bien moins douloureux qu’un traitement de canal chez le dentiste.
Configurer le projet
Démarrer n’a pas vraiment été une promenade de santé, mais expo-apple-targets a rendu les choses gérables. Voici comment j’ai lancé le projet :
-
Installer expo-apple-targets : un rapide npm install expo-apple-targets et c’était parti. Le README du package est une mine d’or : il vous guide pour ajouter une extension de widget dans Xcode et mettre à jour app.json avec l’entitlement Live Activity (com.apple.developer.activitykit).
-
Configuration du module natif : j’ai utilisé le système de modules d’Expo pour créer un module Swift qui communique avec ActivityKit. La documentation des Expo Modules insiste sur la définition de signatures de fonctions et d’événements clairs, ce qui m’a aidé à exposer des méthodes comme startActivity à JavaScript sans transpirer.
-
Extension de widget : c’est là que SwiftUI entre en jeu, pour concevoir l’apparence de la Live Activity sur l’écran verrouillé et dans la Dynamic Island. expo-apple-targets fournit un template de widget, mais j’ai dû le personnaliser pour afficher un timer qui défile et des boutons interactifs.
-
Intents : ils permettent aux utilisateurs d’appuyer sur les boutons du widget pour mettre en pause ou relancer le timer. expo-apple-targets simplifie la configuration des intents, mais j’ai quand même dû déboguer quelques ratés pour que les notifications circulent correctement.
Un timer mis à jour chaque seconde ?
Un développeur enthousiaste implémente une mise à jour du timer chaque seconde, ce qui provoque une surcharge chaotique du système pendant que le timer sème le chaos. (Généré par gpt-4o)
Quand je me suis attaqué au timer, mon cerveau m’a dit : « Il suffit de mettre à jour la Live Activity chaque seconde avec l’heure actuelle. » Ça paraît simple, non ? Raté. Je suis tombé sur un fil Reddit où des développeurs discutaient de la possibilité de mettre à jour le timer d’une Live Activity. Le verdict était unanime : mettre à jour chaque seconde est une catastrophe. C’est comme essayer de propulser un vaisseau spatial avec une roue de hamster ; ça avancera, mais ça va vite griller. Des mises à jour constantes martèlent le CPU et vident la batterie, ce qui rend votre application poussive.
Ce fil Reddit a été un électrochoc. J’ai trouvé Text(timerInterval:) de SwiftUI dans la documentation SwiftUI d’Apple, et ça a été une révélation. Cette vue gère nativement les mises à jour du timer, elle défile toute seule sans qu’il soit nécessaire de rafraîchir toute la Live Activity. C’est comme confier les tâches ennuyeuses à iOS pour pouvoir se concentrer sur les parties amusantes.
J’ai donc abandonné l’idée d’une mise à jour par seconde et j’ai opté pour une approche startedAt/pausedAt. Voici pourquoi c’est gagnant :
-
Performance : au lieu d’envoyer des mises à jour chaque seconde, je stocke l’heure de démarrage du timer (startedAt) et l’heure de pause (pausedAt, s’il est en pause). Le widget utilise Text(timerInterval:) pour afficher un timer en direct basé sur startedAt, et en pause, il affiche un temps figé à partir de pausedAt. Les appels d’API tombent presque à zéro.
-
Efficacité énergétique : les mises à jour fréquentes sont de vrais vampires de batterie. Laisser SwiftUI gérer le défilement garde l’application légère et les téléphones des utilisateurs contents.
-
Respect des API : les API Live Activity d’Apple ne sont pas faites pour être bombardées en temps réel. La configuration startedAt/pausedAt respecte les attentes d’iOS et réduit le risque de rate limiting.
-
Simplicité du code : gérer deux timestamps est bien plus simple que jongler avec un flux de mises à jour. Le code reste propre et mon niveau de stress sous contrôle.
Cette approche m’a donné l’impression de trouver un raccourci secret dans un jeu vidéo. Le timer tourne de façon fluide, il est joli et il ne monopolise pas les ressources. Le fil Reddit (le revoici) mérite une médaille pour m’avoir mis sur la bonne voie.
Le cœur de la Live Activity
Je ne vais pas vous ennuyer avec chaque ligne de code, concentrons-nous sur les extraits clés qui font tourner ce timer. Je partagerai le code source complet sur GitHub à la fin de l’article.
La struct LiveActivityAttributes
Cette struct est la colonne vertébrale de la Live Activity : elle définit ses données et la façon dont elles évoluent.
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
}
C’est un peu l’ADN de la Live Activity. Le LiveActivityAttributes extérieur contient les données statiques, activityName (par exemple « Workout ») et activityIcon (par exemple « RUNNING »), définies au démarrage de l’activité. Le ContentState intérieur est là où tout se passe : il suit startedAt (le moment où le timer a démarré) et pausedAt (le moment où il a été mis en pause, le cas échéant). Les méthodes helper sont les vraies stars :
-
getElapsedTimeInSeconds() calcule depuis combien de temps le timer tourne, en s’arrêtant à pausedAt s’il est en pause, ou en utilisant l’heure actuelle s’il est actif. La logique reste ainsi compacte et réutilisable.
-
isRunning() est une simple vérification : si pausedAt vaut null, le timer tourne. C’est une façon propre d’éviter des vérifications d’état compliquées ailleurs.
-
getFormattedElapsedTime() transforme les secondes en une jolie chaîne « MM:SS » ou « HH:MM:SS » pour le widget. J’ai ajouté la gestion des heures après avoir réalisé que certains utilisateurs pourraient faire des entraînements très longs, comme des marathons.
-
getFutureDate() définit une date dans un an, que je passe à Text(timerInterval:) pour que le timer tourne indéfiniment sans avoir à se soucier d’une date de fin.
J’adore la façon dont cette struct garde tout bien organisé. C’est comme un sac à dos bien fait : tout ce dont vous avez besoin, rien de superflu. La conformité à Codable et Hashable facilite la sérialisation pour les mises à jour et l’utilisation dans SwiftUI, ce qui m’a sauvé la mise pour synchroniser l’état entre le module et le widget.
Démarrer la Live Activity
La fonction startActivity est le point de départ de la magie : elle lance une nouvelle 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 ""
}
Cette fonction est l’étincelle qui allume le feu. Elle est exposée à JavaScript via le système de modules d’Expo, ce qui permet à mon application React Native de l’appeler avec un nom et une icône. Voici ce qu’elle fait :
-
Elle vérifie qu’on est sur iOS 16.2 ou plus récent, car les Live Activities n’existent pas avant.
-
Elle appelle endAllActivities() pour supprimer les activités existantes. iOS autorise plusieurs Live Activities, mais je voulais une seule à la fois pour éviter toute confusion.
-
Elle définit startedAt à l’heure actuelle et vide pausedAt, pour préparer le timer à tourner.
-
Elle vérifie que les Live Activities sont activées (les utilisateurs peuvent les désactiver dans les Réglages, ce qui m’a dérouté au début).
-
Elle construit un LiveActivityAttributes avec le nom et l’icône fournis, ainsi qu’un ContentState avec l’heure de démarrage.
-
Elle demande une nouvelle activité via Activity.request, qui me renvoie un objet Activity avec un ID unique.
-
Elle stocke l’ID, envoie un événement de mise à jour à JavaScript et renvoie l’ID pour que l’application puisse le suivre.
Mettre le timer en pause
La mise en pause du timer est gérée par performPause, qui met à jour l’état de la 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
}
C’est ici que l’approche startedAt/pausedAt brille. Quand l’utilisateur met le timer en pause (depuis l’application ou le widget), cette fonction :
-
Vérifie qu’on est sur iOS 16.2 et que le timer n’est pas déjà en pause (pas de double pause).
-
Récupère l’ID de l’activité, en se rabattant sur currentActivityId si aucun n’est fourni.
-
Trouve l’activité avec findActivityById, qui parcourt les activités en cours.
-
Définit pausedAt à l’heure actuelle, ce qui fige le timer.
-
Crée un nouveau ContentState avec le startedAt d’origine et le nouveau pausedAt.
-
Met à jour l’activité avec activity.update, pour indiquer au widget d’afficher le temps en pause.
-
Envoie un événement à JavaScript pour garder l’interface de l’application synchronisée.
Ici, tout est question de précision : chaque vérification (comme pausedAt == nil) est là pour éviter des cas limites bizarres, comme mettre en pause une activité inexistante. Je me suis appuyé sur la documentation des Expo Modules pour la gestion des événements, en utilisant sendEvent pour envoyer les mises à jour à JavaScript. Les premières versions de cette fonction ne validaient pas startedAt, ce qui donnait des affichages de timer étranges. Leçon retenue : toujours protéger son état.
La vue de l’écran verrouillé
La LockScreenLiveActivityView est ce que voient les utilisateurs quand leur téléphone est verrouillé, et elle doit avoir fière allure.
Live Activity sur l’écran verrouillé
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)
}
}
}
C’est le cœur visuel de la Live Activity, et c’est là que SwiftUI montre vraiment ses muscles. La vue est divisée en deux côtés :
-
Côté gauche : affiche le nom de l’activité, l’icône et le timer. Si le timer tourne, Text(timerInterval:) fait le gros du travail, en comptant à partir de startedAt jusqu’à une date dans un an (grâce à getFutureDate). En pause, il affiche un temps figé fourni par getFormattedElapsedTime. Le modificateur .monospacedDigit() garde des chiffres nets, et j’ai ajusté la police pour qu’elle soit grasse et lisible.
-
Côté droit : gère les boutons. Quand le timer tourne, il y a un bouton pause bleu. En pause, vous avez une coche verte pour ouvrir l’application et un bouton lecture bleu pour reprendre. Chaque bouton déclenche un intent, que le module natif intercepte et traite.
Plongée dans la Dynamic Island
Vue dans la Dynamic Island
Cet extrait définit l’apparence de la Live Activity dans les trois modes de la Dynamic Island : étendu (vue complète), compact (resserré) et minimal (le strict 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)
}
}
-
**Mode étendu** : affiché lors d’un appui long, il est divisé en .leading et .trailing. Le côté leading empile l’icône (par exemple une silhouette qui court) et le nom (« Workout ») avec un grand timer, figé en pause (getFormattedElapsedTime) et défilant quand il est actif (Text(timerInterval:)). Le côté trailing contient les boutons : un bouton pause bleu quand le timer tourne, ou une coche verte (ouvrir l’application) et un bouton lecture bleu (reprendre) en pause. J’ai ajusté les polices et le padding pour épouser les courbes de l’Island.
-
**Mode compact** : quand l’espace se réduit, compactLeading affiche une petite icône et un nom tronqué, tandis que compactTrailing affiche le timer (figé ou défilant). Le .lineLimit(1) garde le nom propre, et une police de 12 points garantit la lisibilité.
-
**Mode minimal** : ultra serré, c’est juste une icône de 12 points, comme un haltère, pour dire « le timer est toujours là ». Simple mais efficace.
Le dossier _shared : pourquoi il est essentiel
Vue d’ensemble du dossier _shared
Le dossier _shared d’expo-apple-targets est un répertoire de premier niveau conçu pour lier du code essentiel à la fois à la target principale de votre application et aux sous-targets, comme le widget Live Activity.
Les extensions, comme les widgets, tournent dans des processus séparés et ont besoin que certains fichiers soient liés à leur propre target ainsi qu’à celle de l’application principale. Le dossier _shared garantit que ces fichiers sont automatiquement liés aux deux, sans configuration manuelle. Pour mon timer, j’y ai placé la struct LiveActivityAttributes, ce qui garantit que l’application et le widget partagent le même état du timer (startedAt, pausedAt) sans problème de synchronisation.
Lancer l’application depuis le widget Live Activity
Le CompleteIntent permet aux utilisateurs d’appuyer sur un bouton en forme de coche dans le widget Live Activity pour ouvrir l’application, en indiquant qu’ils en ont fini avec le timer. C’est une interaction simple mais cruciale pour conclure un entraînement.
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()
}
}
Quand l’utilisateur appuie sur la coche verte, cet intent se déclenche et publie une notification completeActivityFromWidget. Le module natif l’intercepte, déclenche l’événement onWidgetCompleteActivity côté JavaScript, et iOS ouvre l’application grâce à openAppWhenRun: true.
Gérer les appuis de l’utilisateur avec les intents
Le PauseIntent fait partie des intents qui rendent le widget interactif.
Intents de la Live Activity sur l’écran verrouillé
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()
}
}
Cet intent se déclenche quand l’utilisateur appuie sur le bouton pause du widget. C’est d’une simplicité désarmante, mais puissant :
-
Il publie une notification (pauseTimerFromWidget) que le module natif intercepte via setupNotificationObservers.
-
Le module exécute ensuite performPause, met à jour l’état de la Live Activity et prévient JavaScript.
Toute la beauté réside dans la boucle fluide que créent les intents : l’utilisateur appuie → l’intent se déclenche → le module met à jour → l’application reste synchronisée. expo-apple-targets a rendu la configuration des intents très facile en fournissant un template, mais j’ai quand même dû déboguer un cas où les appuis n’étaient pas pris en compte. En fait, j’avais mal orthographié le nom d’une notification. Un classique. La documentation des Expo Modules m’a aidé à comprendre comment gérer les événements déclenchés par des actions natives, ce qui a été essentiel pour que tout fonctionne.
Les événements qui communiquent avec JavaScript

Les événements de la section suivante permettent au module natif de garder l’application React Native synchronisée avec l’état de la Live Activity, grâce au système d’événements d’Expo.
onWidgetCompleteActivity
Cet événement se déclenche quand l’utilisateur appuie sur la coche pour terminer l’activité, via 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)
])
}
Le completeIntentHandler intercepte la notification completeActivityFromWidget, calcule le temps écoulé et envoie l’événement onWidgetCompleteActivity à JavaScript avec l’ID de l’activité et les secondes écoulées. JavaScript peut alors mettre à jour l’interface de l’application ou enregistrer la fin de l’entraînement
onLiveActivityUpdate
Cet événement se déclenche à chaque changement d’état du timer (par exemple pause ou reprise).
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
])
}
Appelé après les changements d’état (comme dans performPause ou performResume), il envoie l’événement onLiveActivityUpdate avec l’état actuel (« active » ou « paused »), le temps écoulé et l’ID de l’activité. JavaScript l’écoute pour garder l’interface du timer de l’application synchronisée avec le widget.
Ces deux événements créent une boucle de feedback étroite entre le module natif et JavaScript.
Pourquoi tout cela compte
Cette Live Activity n’est pas qu’un timer, c’est une fonctionnalité qui donne à mon application l’allure d’une vraie citoyenne d’iOS. Voici pourquoi c’est important :
-
Engagement des utilisateurs : afficher un timer sur l’écran verrouillé ou dans la Dynamic Island garde les utilisateurs connectés à l’application sans casser leur élan. C’est parfait pour les entraînements, où chaque seconde compte.
-
Finition native : le design épuré du widget et ses boutons interactifs donnent l’impression que l’application a sa place sur iOS, et non qu’elle est un portage multiplateforme fait à la va-vite.
-
Performance : l’approche startedAt/pausedAt, propulsée par Text(timerInterval:), garantit un timer fluide sans vider la batterie ni atteindre les limites des API.
expo-apple-targets et l’Expo Modules API ont été les héros discrets de ce projet, en fournissant un cadre solide pour faire le pont entre JavaScript et Swift. L’accent mis par la documentation sur des définitions de fonctions claires et la gestion des événements a gardé mon code organisé et maintenable.
Pour conclure
Cette Live Activity apporte une sensation fluide et native à l’application, avec des mises à jour en temps réel directement sur l’écran verrouillé et dans la Dynamic Island. Grâce à expo-apple-targets, à l’Expo Modules API et aux retours de la communauté (oui, fils Reddit compris), lui donner vie a été plutôt simple. Les Live Activities sont un moyen puissant de rendre les applications plus connectées et plus dynamiques
Voici le lien GitHub vers le repo complet 👉🏻 https://github.com/tarikfp/expo-live-activity-timer