Блог

Таймер Live Activity в Expo

1 мая 2025 г. 12 мин чтения

Реализация Live Activities в приложениях на Expo. Как создавать интерактивные виджеты и обновления в реальном времени для экрана блокировки iOS и Dynamic Island.

Таймер Live Activity в Expo
ExpoiOSLive ActivitiesВиджетыReact Native

Таймер на Live Activity в Expo

Live Activities в iOS сильно меняют дело: они позволяют приложениям показывать обновления в реальном времени прямо на экране блокировки или в Dynamic Island. Естественно, я сразу представил, как здорово было бы держать там таймер тренировки, который мотивирует пользователя, даже когда телефон не разблокирован. Но была загвоздка: Live Activities делаются нативными инструментами Apple, такими как Swift и ActivityKit. Тогда я и нашёл инструмент expo-apple-targets, который избавил меня от написания целых модулей с нуля и сделал процесс гораздо проще, чем я ожидал. В этой статье я расскажу, как построил Live Activity с таймером для iOS, какие шаги сделал и что узнал по пути.

Почему я так увлёкся Live Activities

Live Activities не просто красивый трюк, они серьёзно влияют на вовлечённость пользователей. В Human Interface Guidelines Apple описывает их как способ показывать «актуальную информацию, понятную с одного взгляда» для задач, где важно время. Представьте фитнес-приложение, которое показывает время вашей планки посреди тренировки, приложение доставки еды, отслеживающее путь вашей пиццы, или сервис такси, обновляющий время прибытия водителя, и всё это прямо на экране блокировки или, на iPhone 14 Pro и новее, в Dynamic Island. Это как VIP-пропуск к самым важным обновлениям вашего приложения, и пользователю даже не нужно разблокировать телефон.

Я хотел, чтобы пользователи видели, как идёт таймер тренировки во время подхода, и оставались сосредоточенными, не открывая приложение. Именно такая доработка делает приложение по-настоящему профессиональным, и я взялся за дело всерьёз. Но всё это невозможно сделать, не трогая нативный слой, так что я понимал, что придётся погрузиться в Swift и повоевать с Xcode. Тут я и нашёл expo-apple-targets, пакет, который соединяет мир JavaScript в Expo с нативными возможностями iOS. Огромное спасибо Evan Bacon: этот инструмент превратил пугающую задачу в сложную, но решаемую головоломку.

Общая картина: Live Activities в приложении на Expo

Live Activities работают только в iOS. Их основа ActivityKit, фреймворк на Swift, а значит, нативный код писать придётся, нравится вам это или нет. Для приложения на Expo это как уговорить рыбу залезть на дерево: возможно, но потребует усилий. expo-apple-targets выступает опытным проводником и даёт основу для создания нативных модулей и расширений виджетов без старта с нуля. Он построен на модульной системе Expo (Expo Modules API), которая позволяет писать нативный код на Swift и открывать его для JavaScript, так что весь процесс уже не похож на лечение зубного канала.

Настройка проекта

Начало было не совсем лёгкой прогулкой, но с expo-apple-targets всё оказалось решаемо. Вот с чего я начал:

  • Установка expo-apple-targets: быстрый npm install expo-apple-targets, и можно двигаться. README пакета настоящий кладезь: он проводит через добавление расширения виджета в Xcode и обновление app.json с entitlement для Live Activity (com.apple.developer.activitykit).

  • Настройка нативного модуля: с помощью модульной системы Expo я создал модуль на Swift, который общается с ActivityKit. В документации Expo Modules делается упор на чёткие сигнатуры функций и событий, и это помогло мне без особых усилий открыть для JavaScript такие методы, как startActivity.

  • Расширение виджета: здесь в дело вступил SwiftUI, с его помощью я спроектировал внешний вид Live Activity для экрана блокировки и Dynamic Island. expo-apple-targets даёт шаблон виджета, но мне пришлось доработать его, чтобы показывать идущий таймер и интерактивные кнопки.

  • Intents: они позволяют пользователям нажимать кнопки на виджете, чтобы поставить таймер на паузу или продолжить. expo-apple-targets упрощает настройку intents, но мне всё равно пришлось отладить несколько осечек, чтобы уведомления приходили правильно.

Таймер, который обновляется каждую секунду?

Разработчик с энтузиазмом реализует обновление таймера раз в секунду, и система захлёбывается от перегрузки, пока таймер сеет хаос. (Generated by gpt-4o)Разработчик с энтузиазмом реализует обновление таймера раз в секунду, и система захлёбывается от перегрузки, пока таймер сеет хаос. (Generated by gpt-4o)

Когда я впервые взялся за таймер, мозг подсказал: «Просто обновляй Live Activity каждую секунду текущим временем». Звучит просто, правда? Нет. Я наткнулся на ветку на Reddit, где разработчики обсуждали возможность обновлять таймер в Live Activity. Вердикт был единогласным: обновлять каждую секунду означает катастрофу. Это как пытаться запустить космический корабль на колесе для хомяка: он поедет, но быстро выдохнется. Постоянные обновления нагружают CPU и разряжают батарею, и приложение начинает тормозить.

Эта ветка на Reddit отрезвила меня. В документации SwiftUI от Apple я нашёл Text(timerInterval:), и это стало откровением. Это представление обновляет таймер нативно и тикает само, без необходимости перерисовывать всю Live Activity. Это как передать скучную работу iOS, чтобы самому заниматься интересными частями.

Так что я отказался от плана с обновлением каждую секунду и выбрал подход со startedAt/pausedAt. Вот почему он выигрывает:

  • Производительность: вместо обновлений каждую секунду я храню время старта таймера (startedAt) и время паузы (pausedAt, если таймер на паузе). Виджет использует Text(timerInterval:), чтобы показывать живой таймер на основе startedAt, а на паузе отображает статичное время по pausedAt. Это сокращает число вызовов API почти до нуля.

  • Экономия батареи: частые обновления высасывают батарею, как вампир. Если тиканьем занимается SwiftUI, приложение остаётся лёгким, а телефоны пользователей довольными.

  • Соответствие API: API Live Activity от Apple не рассчитаны на поток обновлений в реальном времени. Схема со startedAt/pausedAt соответствует ожиданиям iOS и снижает риск ограничения частоты запросов.

  • Простота кода: управлять двумя временными метками гораздо проще, чем жонглировать потоком обновлений. Код остаётся чистым, а уровень стресса под контролем.

Этот подход был похож на секретный короткий путь в видеоигре. Таймер работает плавно, выглядит отлично и не пожирает ресурсы. Ветка на Reddit (вот она ещё раз) заслуживает медали за то, что направила меня в нужную сторону.

Сердце Live Activity

Не буду утомлять вас каждой строчкой кода, сосредоточимся на ключевых фрагментах, благодаря которым этот таймер работает. Полный исходный код я выложу на GitHub, ссылка в конце статьи.

Структура LiveActivityAttributes

Эта структура составляет основу Live Activity: она определяет её данные и то, как они меняются.

    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
    }

Это что-то вроде ДНК Live Activity. Внешняя LiveActivityAttributes хранит статичные данные: activityName (например, «Workout») и activityIcon (например, «RUNNING»), которые задаются при старте активности. Внутренняя ContentState отвечает за динамику: она отслеживает startedAt (когда таймер запустился) и pausedAt (когда он поставлен на паузу, если вообще поставлен). Настоящие звёзды здесь вспомогательные методы:

  • getElapsedTimeInSeconds() вычисляет, сколько времени идёт таймер: останавливается на pausedAt, если таймер на паузе, или использует текущее время, если он активен. Так логика остаётся компактной и переиспользуемой.

  • isRunning() простая проверка: если pausedAt равен null, таймер идёт. Это аккуратный способ избежать запутанных проверок состояния в других местах.

  • getFormattedElapsedTime() превращает секунды в аккуратную строку «MM:SS» или «HH:MM:SS» для виджета. Поддержку часов я добавил, когда понял, что некоторые пользователи могут делать сверхдлинные тренировки, например марафоны.

  • getFutureDate() задаёт дату на год вперёд, и я передаю её в Text(timerInterval:), чтобы таймер мог идти бесконечно, не заботясь о дате окончания.

Мне нравится, как эта структура держит всё в порядке. Она как хорошо собранный рюкзак: всё нужное есть, ничего лишнего. Соответствие Codable и Hashable позволяет легко сериализовать её для обновлений и использовать в SwiftUI, и это меня очень выручило при синхронизации состояния между модулем и виджетом.

Запуск Live Activity

С функции startActivity начинается магия: она запускает новую 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 ""
    }

Эта функция и есть искра, из которой разгорается огонь. Она открыта для JavaScript через модульную систему Expo, и моё приложение на React Native вызывает её с названием и иконкой. Вот что она делает:

  • Проверяет, что версия iOS 16.2 или новее: до неё Live Activities не существует.

  • Вызывает endAllActivities(), чтобы убрать все существующие активности. iOS допускает несколько Live Activities, но я хотел держать одну за раз, чтобы не было путаницы.

  • Записывает в startedAt текущее время и очищает pausedAt, подготавливая таймер к запуску.

  • Проверяет, что Live Activities включены (пользователи могут отключить их в Настройках, и поначалу это сбило меня с толку).

  • Собирает LiveActivityAttributes с переданными названием и иконкой и ContentState со временем старта.

  • Запрашивает новую активность через Activity.request, который возвращает объект Activity с уникальным ID.

  • Сохраняет ID, отправляет событие обновления в JavaScript и возвращает ID, чтобы приложение могло его отслеживать.

Пауза таймера

Паузу обрабатывает performPause, которая обновляет состояние 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
    }

Здесь подход со startedAt/pausedAt раскрывается в полной мере. Когда пользователь ставит таймер на паузу (из приложения или из виджета), эта функция:

  • Проверяет, что мы на iOS 16.2 и таймер ещё не на паузе (двойная пауза запрещена).

  • Берёт ID активности, а если он не передан, использует currentActivityId.

  • Находит активность через findActivityById, которая ищет среди активных активностей.

  • Записывает в pausedAt текущее время, замораживая таймер.

  • Создаёт новый ContentState с исходным startedAt и новым pausedAt.

  • Обновляет активность через activity.update, сообщая виджету, что нужно показать время на паузе.

  • Отправляет событие в JavaScript, чтобы UI приложения оставался синхронизированным.

Вся логика здесь построена на точности: каждая проверка (например, pausedAt == nil) нужна, чтобы избежать странных пограничных случаев вроде паузы несуществующей активности. Для обработки событий я опирался на документацию Expo Modules и использовал sendEvent, чтобы отправлять обновления в JavaScript. Ранние версии этой функции не проверяли startedAt, и таймер иногда показывал странные значения. Урок усвоен: всегда защищайте своё состояние.

Представление на экране блокировки

LockScreenLiveActivityView пользователи видят, когда телефон заблокирован, поэтому выглядеть оно должно отлично.

Live Activity на экране блокировкиLive Activity на экране блокировки

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

Это визуальное сердце Live Activity, и здесь SwiftUI действительно показывает свою силу. Представление разделено на две части:

  • Левая часть: показывает название активности, иконку и таймер. Если таймер идёт, основную работу делает Text(timerInterval:), отсчитывая время от startedAt до даты через год (спасибо getFutureDate). На паузе отображается статичное время из getFormattedElapsedTime. Модификатор .monospacedDigit() сохраняет цифры чёткими, а шрифт я сделал жирным и читаемым.

  • Правая часть: отвечает за кнопки. Когда таймер идёт, показывается синяя кнопка паузы. На паузе появляется зелёная галочка для открытия приложения и синяя кнопка воспроизведения, чтобы продолжить. Каждая кнопка запускает intent, который нативный модуль перехватывает и обрабатывает.

Погружаемся в Dynamic Island

Представление в Dynamic IslandПредставление в Dynamic Island

Этот фрагмент определяет, как Live Activity выглядит в трёх режимах Dynamic Island: развёрнутом (полный вид), компактном (сжатом) и минимальном (самое необходимое).

    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)
      }
    }
  • **Развёрнутый режим**: показывается по долгому нажатию и разделён на .leading и .trailing. В левой части друг под другом идут иконка (например, бегущая фигура) и название («Workout») с крупным таймером: статичным на паузе (getFormattedElapsedTime) и тикающим в активном состоянии (Text(timerInterval:)). В правой части кнопки: синяя кнопка паузы, когда таймер идёт, или зелёная галочка (открыть приложение) и синяя кнопка воспроизведения (продолжить) на паузе. Шрифты и отступы я подогнал под изгибы Island.

  • **Компактный режим**: когда места мало, compactLeading показывает маленькую иконку и обрезанное название, а compactTrailing отображает таймер (статичный или тикающий). .lineLimit(1) держит название аккуратным, а шрифт в 12 пунктов обеспечивает читаемость.

  • **Минимальный режим**: предельно компактный, это просто иконка в 12 пунктов, например гантеля, которая говорит: «таймер всё ещё здесь». Просто, но эффективно.

Папка _shared: почему это важно

Обзор папки _sharedОбзор папки _shared

Папка _shared в expo-apple-targets это директория верхнего уровня, которая нужна, чтобы связывать важный код и с основным target приложения, и с дочерними targets, например с виджетом Live Activity.

Расширения, такие как виджеты, работают в отдельных процессах, и нужные файлы должны быть привязаны как к их target, так и к target основного приложения. Папка _shared гарантирует, что эти файлы автоматически привязываются к обоим, и ручная настройка не нужна. Для своего таймера я положил сюда структуру LiveActivityAttributes, чтобы приложение и виджет гарантированно делили одно и то же состояние таймера (startedAt, pausedAt) без проблем с синхронизацией.

Запуск приложения из виджета Live Activity

CompleteIntent позволяет пользователю нажать кнопку с галочкой на виджете Live Activity, чтобы открыть приложение и показать, что он закончил с таймером. Это простое, но важное взаимодействие для завершения тренировки.

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

Когда пользователь нажимает зелёную галочку, срабатывает этот intent и отправляет уведомление completeActivityFromWidget. Нативный модуль перехватывает его, запускает событие onWidgetCompleteActivity в JavaScript, и iOS открывает приложение благодаря openAppWhenRun: true.

Обработка нажатий через intents

PauseIntent один из intents, которые делают виджет интерактивным.

Intents в Live Activity на экране блокировкиIntents в Live Activity на экране блокировки

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

Этот intent срабатывает, когда пользователь нажимает кнопку паузы на виджете. Он предельно прост, но мощен:

  • Он отправляет уведомление (pauseTimerFromWidget), которое нативный модуль перехватывает через setupNotificationObservers.

  • Затем модуль выполняет performPause, обновляя состояние Live Activity и уведомляя JavaScript.

Красота здесь в том, что intents создают цельный цикл: пользователь нажимает, intent срабатывает, модуль обновляет состояние, приложение остаётся синхронизированным. expo-apple-targets дал шаблон, и настройка intents прошла легко, но мне всё равно пришлось отлаживать случай, когда нажатия не регистрировались. Оказалось, я опечатался в названии уведомления. Классика. Документация Expo Modules помогла понять, как обрабатывать события, вызванные нативными действиями, и это было ключом к тому, чтобы всё заработало.

События, которые общаются с JavaScript

События из этого раздела помогают нативному модулю держать приложение на React Native синхронизированным с состоянием Live Activity через систему событий Expo.

onWidgetCompleteActivity

Это событие срабатывает, когда пользователь нажимает галочку, чтобы завершить активность. Его вызывает CompleteIntent.

    @objc func completeIntentHandler(_ notification: Notification) {
        guard let currentId = self.currentActivityId, self.startedAt != nil else {
            return
        }

        let elapsed = self.calculateElapsedTime()

        sendEvent("onWidgetCompleteActivity", [
            "activityId": currentId,
            "elapsedTime": Int(elapsed)
        ])
    }

completeIntentHandler перехватывает уведомление completeActivityFromWidget, вычисляет прошедшее время и отправляет в JavaScript событие onWidgetCompleteActivity с ID активности и числом прошедших секунд. Дальше JavaScript может обновить UI приложения или записать завершение тренировки

onLiveActivityUpdate

Это событие срабатывает при каждом изменении состояния таймера (например, пауза или продолжение).

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

Оно вызывается после изменения состояния (например, в performPause или performResume) и отправляет событие onLiveActivityUpdate с текущим состоянием («active» или «paused»), прошедшим временем и ID активности. JavaScript слушает его, чтобы UI таймера в приложении оставался синхронизированным с виджетом.

Оба события создают плотную обратную связь между нативным модулем и JavaScript.

Почему всё это важно

Эта Live Activity не просто таймер, это функция, благодаря которой моё приложение ощущается как полноценный житель iOS. Вот почему это важно:

  • Вовлечённость пользователей: таймер на экране блокировки или в Dynamic Island сохраняет связь пользователя с приложением, не сбивая его с ритма. Это идеально подходит для тренировок, где важна каждая секунда.

  • Нативная доработка: чистый дизайн виджета и интерактивные кнопки делают приложение своим на iOS, а не кроссплатформенным приложением, где об iOS подумали в последнюю очередь.

  • Производительность: подход со startedAt/pausedAt на основе Text(timerInterval:) обеспечивает плавную работу таймера без разряда батареи и без упора в лимиты API.

expo-apple-targets и Expo Modules API стали здесь незаметными героями, дав надёжную основу для связи JavaScript и Swift. Упор документации на чистые определения функций и обработку событий помог сохранить мой код организованным и поддерживаемым.

Итоги

Эта Live Activity добавляет приложению плавности и нативного ощущения, показывая обновления в реальном времени прямо на экране блокировки и в Dynamic Island. Благодаря expo-apple-targets, Expo Modules API и опыту сообщества (да, включая ветки на Reddit) воплотить её в жизнь оказалось довольно просто. Live Activities дают мощный способ сделать приложения более связанными и живыми

Вот ссылка на GitHub с полным исходным кодом 👉🏻 https://github.com/tarikfp/expo-live-activity-timer