Блог

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

1 травня 2025 р. 12 хв читання

Як додати Live Activities у застосунок на Expo. Інтерактивні віджети й оновлення в реальному часі на екрані блокування iOS і в Dynamic Island.

Таймер у Live Activity на Expo
ExpoiOSLive ActivitiesВіджетиReact Native

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)Розробник із ентузіазмом робить оновлення таймера щосекунди, і таймер доводить систему до хаотичного перевантаження. (Згенеровано gpt-4o)

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

Та гілка на Reddit мене протверезила. Я знайшов Text(timerInterval:) у документації SwiftUI від Apple, і це стало відкриттям. Цей view оновлює таймер нативно і тікає сам, не потребуючи оновлювати всю 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, щоб інтерфейс застосунку лишався синхронним.

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

View для екрана блокування

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 по-справжньому показує силу. View поділене на дві частини:

  • Ліва частина: показує назву активності, іконку і таймер. Якщо таймер іде, усю важку роботу виконує 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:)). У правій частині кнопки: синя кнопка паузи, коли таймер іде, або зелена галочка (відкрити застосунок) і синя кнопка відтворення (продовжити) на паузі. Шрифти та відступи я підлаштував під вигини острова.

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

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

Папка _shared: чому це важливо

Огляд папки _sharedОгляд папки _shared

Папка _shared в expo-apple-targets це директорія верхнього рівня, яка підключає важливий код і до основного target застосунку, і до підтаргетів, як-от віджета 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. Нативний модуль його перехоплює, запускає в JavaScript подію onWidgetCompleteActivity, а 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 може оновити інтерфейс застосунку або записати завершення тренування

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 слухає її, щоб інтерфейс таймера в застосунку був синхронним із віджетом.

Обидві події створюють щільний зворотний зв'язок між нативним модулем і JavaScript.

Чому це все важливо

Ця Live Activity не просто таймер, це функція, завдяки якій мій застосунок почувається повноправним громадянином iOS. Ось чому це важливо:

  • Залученість користувачів: таймер на екрані блокування або в Dynamic Island тримає користувачів на зв'язку із застосунком і не збиває їх з ритму. Це ідеально для тренувань, де кожна секунда на рахунку.

  • Нативна шліфовка: чистий дизайн віджета й інтерактивні кнопки створюють відчуття, що застосунок належить 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