# Temporizador con Live Activity en Expo

By Tarik Pinarci (https://tarikpinarci.com). Published 2025-05-01. Canonical: https://tarikpinarci.com/es/blog/expo-live-activity-timer

# Cómo construir un temporizador con Live Activity en Expo

Las Live Activities de iOS cambian las reglas del juego: permiten que las apps muestren actualizaciones en tiempo real directamente en la pantalla de bloqueo o en la Dynamic Island. Como era de esperar, empecé a imaginar lo genial que sería tener un temporizador de entrenamiento ahí, manteniendo a los usuarios motivados sin que tengan que desbloquear el teléfono. Pero había una trampa: las Live Activities se construyen con las herramientas nativas de Apple, como Swift y ActivityKit. Fue entonces cuando descubrí una herramienta llamada [expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets), en lugar de escribir módulos enteros desde cero, y eso hizo el proceso mucho más fácil de lo que esperaba. En este artículo te cuento cómo construí una Live Activity basada en un temporizador para iOS, los pasos que seguí y lo que aprendí por el camino.

## Por qué me obsesioné con las Live Activities

Las Live Activities no son solo un truco vistoso: cambian las reglas del juego en cuanto a la implicación del usuario. Las [Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines/live-activities) de Apple las describen como una forma de ofrecer "información actual y fácil de consultar de un vistazo" para tareas que dependen del tiempo. Imagina una app de fitness que muestra tu tiempo de plancha en mitad del entrenamiento, una app de comida a domicilio que sigue el trayecto de tu pizza o una app de transporte que actualiza la hora de llegada de tu conductor, todo directamente en la pantalla de bloqueo o, en el iPhone 14 Pro y posteriores, en la Dynamic Island. Es como dar a los usuarios un pase VIP a las actualizaciones más importantes de tu app sin que tengan que desbloquear el teléfono.

Quería que los usuarios vieran su temporizador de entrenamiento avanzando durante una serie, manteniéndolos concentrados sin obligarlos a abrir la app. Es el tipo de acabado que hace que una app se sienta profesional, y me lancé de lleno. Pero no puedes manejar todo esto sin tocar ninguna capa nativa, así que sabía que me iba a tocar meterme en Swift y pelearme con Xcode. Entonces descubrí [expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets), un paquete que tiende un puente entre el mundo JavaScript de Expo y las funciones nativas de iOS. Enorme reconocimiento para [Evan Bacon](https://x.com/Baconbrix): esta herramienta tomó una tarea intimidante y la convirtió en un rompecabezas difícil pero resoluble.

## La visión general: Live Activities en una app de Expo

Las Live Activities son una fiesta exclusiva de iOS. Funcionan con ActivityKit, un framework basado en Swift, lo que significa que vas a escribir código nativo te guste o no. Para una app de Expo, esto es como intentar convencer a un pez de que trepe a un árbol: es posible, pero va a costar algo de esfuerzo. expo-apple-targets aparece como un guía experimentado, ofreciendo un marco para crear módulos nativos y extensiones de widget sin empezar desde cero. Está construido sobre el sistema de módulos de Expo ([Expo Modules API](https://docs.expo.dev/modules/module-api/)), que te permite escribir código nativo en Swift y exponerlo a JavaScript, con lo que todo el proceso se parece menos a una endodoncia.

## Configurar el proyecto

Empezar no fue precisamente un paseo, pero expo-apple-targets lo hizo manejable. Así es como arranqué:

- **Instalar expo-apple-targets**: un rápido npm install expo-apple-targets y ya estaba en marcha. El README del paquete es una mina de oro: te guía para añadir una extensión de widget en Xcode y actualizar app.json con el entitlement de Live Activity (com.apple.developer.activitykit).

- **Configurar el módulo nativo**: usé el sistema de módulos de Expo para crear un módulo en Swift que habla con ActivityKit. La [documentación de Expo Modules](https://docs.expo.dev/modules/module-api/) insiste en definir firmas de funciones y eventos claros, lo que me ayudó a exponer métodos como startActivity a JavaScript sin sudar.

- **Extensión de widget**: aquí entró SwiftUI, que me permitió diseñar el aspecto de la Live Activity para la pantalla de bloqueo y la Dynamic Island. expo-apple-targets proporciona una plantilla de widget, pero tuve que personalizarla para mostrar un temporizador en marcha y botones interactivos.

- **Intents**: permiten a los usuarios tocar botones en el widget para pausar o reanudar el temporizador. expo-apple-targets simplifica la configuración de los intents, pero aun así tuve que depurar algunos fallos para que las notificaciones fluyeran bien.

## ¿Un temporizador que se actualiza cada segundo?

![Un desarrollador implementa con entusiasmo una actualización del temporizador cada segundo, lo que provoca una sobrecarga caótica del sistema mientras el temporizador lo destroza todo. ([Generado por gpt-4o](https://openai.com/index/hello-gpt-4o/))](https://cdn-images-1.medium.com/max/2048/1*Nq1a3rqsEIBCgTsAWdvgNQ.png)_Un desarrollador implementa con entusiasmo una actualización del temporizador cada segundo, lo que provoca una sobrecarga caótica del sistema mientras el temporizador lo destroza todo. ([Generado por gpt-4o](https://openai.com/index/hello-gpt-4o/))_

Cuando abordé el temporizador por primera vez, mi cerebro dijo: "_Simplemente actualiza la Live Activity cada segundo con la hora actual_". Suena sencillo, ¿verdad? Pues no. Me topé con un [hilo de Reddit](https://www.reddit.com/r/iOSProgramming/comments/18n12wh/how_does_this_app_achieve_to_update_its_live/?rdt=52173) donde varios desarrolladores hablaban sobre la posibilidad de actualizar el temporizador de una Live Activity. El veredicto fue unánime: actualizar cada segundo es un desastre. Es como intentar mover una nave espacial con una rueda de hámster; se moverá, pero se quemará rápido. Las actualizaciones constantes machacan la CPU y agotan la batería, y tu app se vuelve lenta.

Ese hilo de Reddit me abrió los ojos. Encontré Text(timerInterval:) de SwiftUI en la [documentación de SwiftUI](<https://developer.apple.com/documentation/swiftui/text/init(timerinterval:pausetime:countsdown:showshours:)>) de Apple, y fue una revelación. Esta vista gestiona las actualizaciones del temporizador de forma nativa, avanzando sin necesidad de refrescar toda la Live Activity. Es como subcontratar lo aburrido a iOS para que tú te centres en lo divertido.

Así que descarté el plan de actualizar cada segundo y opté por un enfoque con startedAt/pausedAt. Por esto es la mejor opción:

- **Rendimiento**: en lugar de lanzar actualizaciones cada segundo, guardo la hora de inicio del temporizador (startedAt) y la hora de pausa (pausedAt, si está en pausa). El widget usa Text(timerInterval:) para mostrar un temporizador en vivo basado en startedAt y, cuando está en pausa, muestra un tiempo estático usando pausedAt. Esto reduce las llamadas a la API casi a cero.

- **Eficiencia de batería**: las actualizaciones frecuentes son un vampiro de batería. Dejar que SwiftUI se encargue del avance mantiene la app ligera y los teléfonos de los usuarios contentos.

- **Cumplimiento de la API**: las APIs de Live Activity de Apple no están pensadas para un bombardeo en tiempo real. La configuración con startedAt/pausedAt encaja con lo que iOS espera y reduce la probabilidad de que te limiten la frecuencia.

- **Simplicidad del código**: gestionar dos marcas de tiempo es mucho más fácil que hacer malabares con un flujo de actualizaciones. Mantiene el código limpio y mi nivel de estrés bajo control.

Este enfoque fue como encontrar un atajo secreto en un videojuego. El temporizador funciona con fluidez, se ve genial y no acapara recursos. El hilo de Reddit ([aquí está otra vez](https://www.reddit.com/r/iOSProgramming/comments/18n12wh/how_does_this_app_achieve_to_update_its_live/?rdt=52173)) merece una medalla por señalarme la dirección correcta.

## El corazón de la Live Activity

No voy a aburrirte con cada línea de código; centrémonos en los fragmentos clave que hacen funcionar este temporizador. Compartiré el código fuente completo en GitHub al final del artículo.

### El struct LiveActivityAttributes

Este struct es la columna vertebral de la Live Activity: define sus datos y cómo evolucionan.

```swift
    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
    }
```

Esto es como el ADN de la Live Activity. El LiveActivityAttributes exterior contiene lo estático, activityName (por ejemplo, "Workout") y activityIcon (por ejemplo, "RUNNING"), que se fijan cuando empieza la actividad. El ContentState interior es donde ocurre la acción: registra startedAt (cuándo empezó el temporizador) y pausedAt (cuándo se pausó, si es que se pausó). Los métodos auxiliares son los verdaderos protagonistas:

- getElapsedTimeInSeconds() calcula cuánto tiempo lleva en marcha el temporizador, deteniéndose en pausedAt si está en pausa o usando la hora actual si está activo. Así la lógica queda compacta y reutilizable.

- isRunning() es una comprobación simple: si pausedAt es null, el temporizador está en marcha. Es una forma limpia de evitar comprobaciones de estado desordenadas en otros sitios.

- getFormattedElapsedTime() convierte los segundos en una cadena bonita "MM:SS" o "HH:MM:SS" para el widget. Añadí soporte para horas al darme cuenta de que algunos usuarios podrían hacer entrenamientos larguísimos, como maratones.

- getFutureDate() fija una fecha a un año vista, que paso a Text(timerInterval:) para que el temporizador pueda correr indefinidamente sin preocuparme por una fecha de fin.

Me encanta cómo este struct mantiene todo organizado. Es como una mochila bien hecha: todo lo que necesitas y nada que no. La conformidad con Codable y Hashable facilita serializarlo para las actualizaciones y usarlo en SwiftUI, lo que me salvó la vida al sincronizar el estado entre el módulo y el widget.

### Iniciar la Live Activity

La función startActivity es donde empieza la magia: pone en marcha una nueva Live Activity.

```swift
    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 ""
    }
```

Esta función es la chispa que enciende el fuego. Está expuesta a JavaScript mediante el sistema de módulos de Expo, lo que permite que mi app de React Native la llame con un nombre y un icono. Esto es lo que hace:

- Comprueba que sea iOS 16.2 o posterior; las Live Activities no existen antes de esa versión.

- Llama a endAllActivities() para eliminar cualquier actividad existente. iOS permite varias Live Activities, pero yo quería una sola a la vez para evitar confusiones.

- Fija startedAt en la hora actual y limpia pausedAt, preparando el temporizador para arrancar.

- Verifica que las Live Activities estén activadas (los usuarios pueden desactivarlas en Ajustes, algo que me descolocó al principio).

- Construye un LiveActivityAttributes con el nombre y el icono proporcionados, y un ContentState con la hora de inicio.

- Solicita una nueva actividad mediante Activity.request, que me devuelve un objeto Activity con un ID único.

- Guarda el ID, lanza un evento de actualización a JavaScript y devuelve el ID para que la app pueda seguirlo.

### Pausar el temporizador

La pausa del temporizador la gestiona performPause, que actualiza el estado de la Live Activity.

```swift
    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
    }
```

Aquí es donde brilla el enfoque con startedAt/pausedAt. Cuando el usuario pausa el temporizador (ya sea desde la app o desde el widget), esta función:

- Comprueba que estamos en iOS 16.2 y que el temporizador no está ya en pausa (no se permite pausar dos veces).

- Obtiene el ID de la actividad y, si no se proporciona ninguno, recurre a currentActivityId.

- Encuentra la actividad con findActivityById, que busca entre las actividades activas.

- Fija pausedAt en la hora actual, congelando el temporizador.

- Crea un nuevo ContentState con el startedAt original y el nuevo pausedAt.

- Actualiza la actividad con activity.update, indicando al widget que muestre el tiempo en pausa.

- Envía un evento a JavaScript para mantener sincronizada la interfaz de la app.

La lógica aquí gira en torno a la precisión: cada comprobación (como pausedAt == nil) está ahí para evitar casos límite raros, como pausar una actividad que no existe. Me apoyé en la [documentación de Expo Modules](https://docs.expo.dev/modules/overview/) para el manejo de eventos, usando sendEvent para enviar actualizaciones a JavaScript. Las primeras versiones de esta función no validaban startedAt, lo que provocó que el temporizador se mostrara de formas extrañas. Lección aprendida: protege siempre tu estado.

## La vista de la pantalla de bloqueo

LockScreenLiveActivityView es lo que ven los usuarios cuando su teléfono está bloqueado, y tiene que verse impecable.

![Live Activity en la pantalla de bloqueo](https://cdn-images-1.medium.com/max/2000/1*IZ1ZSG7_99jfTMBJosePGQ.png)_Live Activity en la pantalla de bloqueo_

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

Este es el corazón visual de la Live Activity, y es donde SwiftUI saca músculo de verdad. La vista se divide en dos lados:

- **Lado izquierdo**: muestra el nombre de la actividad, el icono y el temporizador. Si el temporizador está en marcha, Text(timerInterval:) hace el trabajo pesado, contando hacia arriba desde startedAt hasta un año después (gracias a getFutureDate). Si está en pausa, muestra un tiempo estático de getFormattedElapsedTime. El modificador .monospacedDigit() mantiene los números nítidos, y ajusté la fuente para que fuera negrita y legible.

- **Lado derecho**: gestiona los botones. Cuando está en marcha, hay un botón azul de pausa. Cuando está en pausa, aparece una marca de verificación verde para abrir la app y un botón azul de reproducir para reanudar. Cada botón lanza un intent, que el módulo nativo captura y procesa.

## Explorando la [Dynamic Island](https://developer.apple.com/design/human-interface-guidelines/live-activities#The-Dynamic-Island)

![Vista de la Dynamic Island](https://cdn-images-1.medium.com/max/2000/1*iqy0d6FZe9UU0Tce7qCDug.png)_Vista de la Dynamic Island_

Este fragmento define cómo aparece la Live Activity en los tres modos de la Dynamic Island: expandido (vista completa), compacto (reducido) y mínimo (lo esencial).

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

- [\*\*Modo expandido](https://developer.apple.com/design/human-interface-guidelines/live-activities#Expanded-presentation)\*\*: se muestra al mantener pulsado y se divide en .leading y .trailing. El lado leading apila el icono (por ejemplo, una figura corriendo) y el nombre ("Workout") con un temporizador grande, estático cuando está en pausa (getFormattedElapsedTime) y en marcha cuando está activo (Text(timerInterval:)). El lado trailing tiene los botones: un botón azul de pausa cuando está en marcha, o una marca de verificación verde (abrir la app) y un botón azul de reproducir (reanudar) cuando está en pausa. Ajusté las fuentes y el padding para que encajaran en las curvas de la isla.

- [\*\*Modo compacto](https://developer.apple.com/design/human-interface-guidelines/live-activities#Compact-presentation)\*\*: cuando el espacio se reduce, compactLeading muestra un icono diminuto y el nombre recortado, mientras que compactTrailing muestra el temporizador (estático o en marcha). El .lineLimit(1) mantiene el nombre ordenado, y una fuente de 12 puntos garantiza la legibilidad.

- [\*\*Modo mínimo](https://developer.apple.com/design/human-interface-guidelines/live-activities#Minimal-presentation)\*\*: ultracompacto, es solo un icono de 12 puntos, como una mancuerna, para decir "el temporizador sigue aquí". Simple pero eficaz.

## La carpeta \_shared: por qué es tan importante

![Vista general de la carpeta _shared](https://cdn-images-1.medium.com/max/2000/1*OdZlqw2AXJeTakpTlghLDQ.png)_Vista general de la carpeta \_shared_

La carpeta \_shared de [expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets?tab=readme-ov-file#_shared) es un directorio de nivel superior pensado para enlazar el código esencial tanto al target principal de tu app como a los subtargets, como el widget de la Live Activity.

Las extensiones, como los widgets, se ejecutan en procesos separados y necesitan que ciertos archivos estén enlazados a su target además de al de la app principal. La carpeta \_shared garantiza que esos archivos se enlacen automáticamente a ambos, eliminando la configuración manual. Para mi temporizador, puse aquí el struct LiveActivityAttributes, lo que garantizaba que la app y el widget compartieran el mismo estado del temporizador (startedAt, pausedAt) sin problemas de sincronización.

## Abrir la app desde el widget de la Live Activity

CompleteIntent permite a los usuarios tocar un botón con una marca de verificación en el widget de la Live Activity para abrir la app, indicando que han terminado con el temporizador. Es una interacción simple pero crucial para cerrar un entrenamiento.

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

Cuando el usuario toca la marca de verificación verde, este intent se dispara y publica una notificación completeActivityFromWidget. El módulo nativo la captura, lanza el evento onWidgetCompleteActivity a JavaScript, e iOS abre la app gracias a [openAppWhenRun](https://developer.apple.com/documentation/appintents/openurlintent/openappwhenrun): true.

## Gestionar los toques del usuario con intents

PauseIntent es uno de los intents que hacen interactivo el widget.

![Intents de la Live Activity en la pantalla de bloqueo](https://cdn-images-1.medium.com/max/2000/1*k2nzvHgwgqj6tFESIFcmbw.png)_Intents de la Live Activity en la pantalla de bloqueo_

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

Este intent se activa cuando el usuario toca el botón de pausa en el widget. Es tremendamente simple pero potente:

- Publica una notificación (pauseTimerFromWidget) que el módulo nativo captura mediante setupNotificationObservers.

- Después, el módulo ejecuta performPause, actualizando el estado de la Live Activity y notificando a JavaScript.

Lo bonito aquí es cómo los intents crean un ciclo fluido: el usuario toca, el intent se dispara, el módulo actualiza y la app se mantiene sincronizada. expo-apple-targets hizo que configurar los intents fuera pan comido al proporcionar una plantilla, pero aun así tuve que depurar un caso en el que los toques no se registraban. Resultó que había escrito mal el nombre de una notificación. Un clásico. La [documentación de Expo Modules](https://docs.expo.dev/modules/overview/) me ayudó a entender cómo manejar los eventos disparados por acciones nativas, lo que fue clave para que esto funcionara.

## Eventos que hablan con JavaScript

![](https://cdn-images-1.medium.com/max/2000/1*F5GUBNYqWxbZbLU8-LZ0Ug.png)

Los eventos de la siguiente sección son la forma en que el módulo nativo mantiene la app de React Native sincronizada con el estado de la Live Activity, usando el sistema de eventos de Expo.

### onWidgetCompleteActivity

Este evento se dispara cuando el usuario toca la marca de verificación para completar la actividad, a través de CompleteIntent.

```swift
    @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 captura la notificación completeActivityFromWidget, calcula el tiempo transcurrido y envía el evento onWidgetCompleteActivity a JavaScript con el ID de la actividad y los segundos transcurridos. JavaScript puede entonces actualizar la interfaz de la app o registrar que el entrenamiento se completó.

### onLiveActivityUpdate

Este evento se dispara cada vez que cambia el estado del temporizador (por ejemplo, al pausar o reanudar).

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

Se llama después de los cambios de estado (como en performPause o performResume) y envía el evento onLiveActivityUpdate con el estado actual ("active" o "paused"), el tiempo transcurrido y el ID de la actividad. JavaScript lo escucha para mantener la interfaz del temporizador de la app sincronizada con el widget.

Ambos eventos crean un ciclo de retroalimentación estrecho entre el módulo nativo y JavaScript.

## Por qué todo esto importa

Esta Live Activity no es solo un temporizador: es una funcionalidad que hace que mi app se sienta como una ciudadana nativa de iOS. Por esto es importante:

- **Implicación del usuario**: mostrar un temporizador en la pantalla de bloqueo o en la Dynamic Island mantiene a los usuarios conectados con la app sin romper su ritmo. Es perfecto para entrenamientos, donde cada segundo cuenta.

- **Acabado nativo**: el diseño limpio del widget y sus botones interactivos hacen que la app parezca pertenecer a iOS, no un añadido multiplataforma de última hora.

- **Rendimiento**: el enfoque con startedAt/pausedAt, impulsado por Text(timerInterval:), garantiza que el temporizador funcione con fluidez sin agotar la batería ni chocar con los límites de la API.

expo-apple-targets y la [Expo Modules API](https://docs.expo.dev/modules/module-api/) fueron los héroes anónimos aquí, al ofrecer un marco sólido para conectar JavaScript y Swift. El énfasis de la documentación en definiciones de funciones limpias y en el manejo de eventos mantuvo mi código organizado y fácil de mantener.

## Reflexiones finales

Esta Live Activity añade una sensación fluida y nativa a la app, mostrando actualizaciones en tiempo real directamente en la pantalla de bloqueo y en la Dynamic Island. Gracias a expo-apple-targets, la Expo Modules API y las aportaciones de la comunidad (sí, hilos de Reddit incluidos), darle vida fue bastante sencillo. Las Live Activities son una forma potente de hacer que las apps se sientan más conectadas y dinámicas.

Aquí tienes el enlace de GitHub al repositorio con el código fuente completo 👉🏻 [https://github.com/tarikfp/expo-live-activity-timer](https://github.com/tarikfp/expo-live-activity-timer)

