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

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

Live Activities в iOS змінюють правила гри: вони дають застосункам показувати оновлення в реальному часі просто на екрані блокування або в Dynamic Island. Звісно, я одразу уявив, як круто було б мати там таймер тренування, який підтримує мотивацію і навіть не вимагає розблоковувати телефон. Але була заковика: Live Activities створюють нативними інструментами Apple, як-от Swift і ActivityKit. Саме тоді я знайшов інструмент [expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets), завдяки якому не довелося писати цілі модулі з нуля, і процес виявився значно простішим, ніж я очікував. У цій статті я покажу, як зробив Live Activity з таймером для iOS, які кроки пройшов і чого навчився дорогою.

## Чому я захопився Live Activities

Live Activities не просто гарний трюк, вони по-справжньому змінюють залученість користувачів. [Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines/live-activities) від Apple описують їх як спосіб показувати «актуальну інформацію, яку можна схопити поглядом» для задач, де важливий час. Уявіть фітнес-застосунок, що показує час планки посеред тренування, сервіс доставки, що відстежує шлях вашої піци, або таксі, що оновлює час прибуття водія, і все це просто на екрані блокування або, на iPhone 14 Pro і новіших, у Dynamic Island. Це наче VIP-перепустка до найважливіших оновлень застосунку, і телефон навіть не треба розблоковувати.

Я хотів, щоб користувачі бачили, як іде таймер тренування під час підходу, і залишалися зосередженими, не відкриваючи застосунок. Саме така шліфовка робить застосунок професійним, тож я взявся за це на повну. Але без нативного шару тут не обійтися, тож я знав, що доведеться зануритися в Swift і поборотися з Xcode. Тоді я відкрив [expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets), пакет, що з'єднує світ JavaScript в Expo з нативними можливостями iOS. Величезна подяка [Evan Bacon](https://x.com/Baconbrix): цей інструмент перетворив лячне завдання на складну, але цілком розв'язну головоломку.

## Загальна картина: Live Activities у застосунку на Expo

Live Activities працюють лише в iOS. В їхній основі ActivityKit, фреймворк на Swift, тож писати нативний код доведеться, хочете ви того чи ні. Для застосунку на Expo це схоже на спробу навчити рибу лазити по деревах: можливо, але зусиль знадобиться чимало. expo-apple-targets приходить на допомогу як досвідчений провідник і дає основу для нативних модулів і розширень віджетів, тож не треба починати з нуля. Він побудований на модульній системі Expo ([Expo Modules API](https://docs.expo.dev/modules/module-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](https://docs.expo.dev/modules/module-api/) наголошує на чітких сигнатурах функцій і подіях, і це допомогло мені без зайвих зусиль відкрити для JavaScript методи на кшталт startActivity.

- **Розширення віджета**: тут у гру вступив SwiftUI, у якому я спроєктував вигляд Live Activity для екрана блокування і Dynamic Island. expo-apple-targets дає шаблон віджета, але мені довелося доналаштувати його, щоб показувати таймер, що йде, та інтерактивні кнопки.

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

## Таймер, який оновлюється щосекунди?

![Розробник із ентузіазмом робить оновлення таймера щосекунди, і таймер доводить систему до хаотичного перевантаження. ([Generated by gpt-4o](https://openai.com/index/hello-gpt-4o/))](https://cdn-images-1.medium.com/max/2048/1*Nq1a3rqsEIBCgTsAWdvgNQ.png)_Розробник із ентузіазмом робить оновлення таймера щосекунди, і таймер доводить систему до хаотичного перевантаження. ([Згенеровано gpt-4o](https://openai.com/index/hello-gpt-4o/))_

Коли я вперше взявся за таймер, мозок підказав: «_Просто оновлюй Live Activity щосекунди поточним часом_». Звучить просто, правда? Ні. Я натрапив на [гілку на Reddit](https://www.reddit.com/r/iOSProgramming/comments/18n12wh/how_does_this_app_achieve_to_update_its_live/?rdt=52173), де розробники обговорювали, чи можна оновлювати таймер у Live Activity. Вердикт був одностайний: оновлювати щосекунди це катастрофа. Це як живити космічний корабель колесом для хом'яка: він рушить, але швидко вигорить. Постійні оновлення навантажують CPU, висаджують батарею і роблять застосунок повільним.

Та гілка на Reddit мене протверезила. Я знайшов Text(timerInterval:) у [документації SwiftUI](<https://developer.apple.com/documentation/swiftui/text/init(timerinterval:pausetime:countsdown:showshours:)>) від Apple, і це стало відкриттям. Цей view оновлює таймер нативно і тікає сам, не потребуючи оновлювати всю Live Activity. Це як віддати нудну роботу iOS, а самому зосередитися на цікавому.

Тож я відмовився від плану з оновленням щосекунди і обрав підхід зі startedAt/pausedAt. Ось чому він виграє:

- **Продуктивність**: замість оновлень щосекунди я зберігаю час старту таймера (startedAt) і час паузи (pausedAt, якщо таймер на паузі). Віджет використовує Text(timerInterval:), щоб показувати живий таймер на основі startedAt, а на паузі виводить статичний час із pausedAt. Це скорочує кількість викликів API майже до нуля.

- **Економія батареї**: часті оновлення це справжній вампір для батареї. Коли тікання бере на себе SwiftUI, застосунок лишається легким, а телефони користувачів задоволеними.

- **Відповідність API**: API Live Activity від Apple не створені для спаму в реальному часі. Підхід зі startedAt/pausedAt узгоджується з очікуваннями iOS і зменшує ризик обмеження частоти запитів.

- **Простота коду**: керувати двома мітками часу значно легше, ніж жонглювати потоком оновлень. Код лишається чистим, а мій рівень стресу під контролем.

Цей підхід був як таємний короткий шлях у відеогрі. Таймер іде плавно, виглядає чудово і не жере ресурси. Гілка на Reddit ([ось вона ще раз](https://www.reddit.com/r/iOSProgramming/comments/18n12wh/how_does_this_app_achieve_to_update_its_live/?rdt=52173)) заслуговує на медаль за те, що спрямувала мене в правильний бік.

## Серце Live Activity

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

### Структура LiveActivityAttributes

Ця структура є кістяком Live Activity: вона визначає її дані та те, як вони змінюються.

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

Це щось на кшталт ДНК 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.

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

Ця функція і є тією іскрою, від якої все спалахує. Вона відкрита для 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.

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

Саме тут підхід зі startedAt/pausedAt показує себе найкраще. Коли користувач ставить таймер на паузу (у застосунку або у віджеті), ця функція:

- Перевіряє, що ми на iOS 16.2 і таймер ще не на паузі (подвійна пауза заборонена).

- Бере ID активності, а якщо його не передали, використовує currentActivityId.

- Знаходить активність через findActivityById, яка шукає серед активних активностей.

- Встановлює pausedAt на поточний час і так заморожує таймер.

- Створює новий ContentState з початковим startedAt і новим pausedAt.

- Оновлює активність через activity.update, і віджет показує час паузи.

- Надсилає подію в JavaScript, щоб інтерфейс застосунку лишався синхронним.

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

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

LockScreenLiveActivityView це те, що користувачі бачать на заблокованому телефоні, тож воно має виглядати бездоганно.

![Live Activity на екрані блокування](https://cdn-images-1.medium.com/max/2000/1*IZ1ZSG7_99jfTMBJosePGQ.png)_Live Activity на екрані блокування_

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

Це візуальне серце Live Activity, і тут SwiftUI по-справжньому показує силу. View поділене на дві частини:

- **Ліва частина**: показує назву активності, іконку і таймер. Якщо таймер іде, усю важку роботу виконує Text(timerInterval:), рахуючи від startedAt до дати через рік (завдяки getFutureDate). На паузі вона показує статичний час із getFormattedElapsedTime. Модифікатор .monospacedDigit() тримає цифри чіткими, а шрифт я зробив жирним і добре читабельним.

- **Права частина**: відповідає за кнопки. Коли таймер іде, тут синя кнопка паузи. На паузі з'являються зелена галочка, яка відкриває застосунок, і синя кнопка відтворення, яка продовжує таймер. Кожна кнопка запускає intent, який нативний модуль перехоплює й обробляє.

## Занурюємося в [Dynamic Island](https://developer.apple.com/design/human-interface-guidelines/live-activities#The-Dynamic-Island)

![Вигляд у Dynamic Island](https://cdn-images-1.medium.com/max/2000/1*iqy0d6FZe9UU0Tce7qCDug.png)_Вигляд у Dynamic Island_

Цей фрагмент визначає, як Live Activity виглядає в трьох режимах Dynamic Island: розгорнутому (повний вигляд), компактному (стиснутому) і мінімальному (найпростішому).

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

- [\*\*Розгорнутий режим](https://developer.apple.com/design/human-interface-guidelines/live-activities#Expanded-presentation)\*\*: з'являється після довгого натискання і поділений на .leading і .trailing. Ліва частина складає разом іконку (наприклад, фігуру, що біжить) і назву («Workout») з великим таймером: статичним на паузі (getFormattedElapsedTime) і живим, коли він активний (Text(timerInterval:)). У правій частині кнопки: синя кнопка паузи, коли таймер іде, або зелена галочка (відкрити застосунок) і синя кнопка відтворення (продовжити) на паузі. Шрифти та відступи я підлаштував під вигини острова.

- [\*\*Компактний режим](https://developer.apple.com/design/human-interface-guidelines/live-activities#Compact-presentation)\*\*: коли місця менше, compactLeading показує маленьку іконку і скорочену назву, а compactTrailing виводить таймер (статичний або живий). .lineLimit(1) тримає назву охайною, а шрифт розміром 12 пунктів забезпечує читабельність.

- [\*\*Мінімальний режим](https://developer.apple.com/design/human-interface-guidelines/live-activities#Minimal-presentation)\*\*: зовсім тісно, тож тут лише іконка на 12 пунктів, наприклад гантель, яка каже «таймер досі тут». Просто, але ефективно.

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

![Огляд папки _shared](https://cdn-images-1.medium.com/max/2000/1*OdZlqw2AXJeTakpTlghLDQ.png)_Огляд папки \_shared_

Папка \_shared в [expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets?tab=readme-ov-file#_shared) це директорія верхнього рівня, яка підключає важливий код і до основного target застосунку, і до підтаргетів, як-от віджета Live Activity.

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

## Запуск застосунку з віджета Live Activity

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

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

Коли користувач натискає зелену галочку, спрацьовує цей intent і надсилає сповіщення completeActivityFromWidget. Нативний модуль його перехоплює, запускає в JavaScript подію onWidgetCompleteActivity, а iOS відкриває застосунок завдяки [openAppWhenRun](https://developer.apple.com/documentation/appintents/openurlintent/openappwhenrun): true.

## Обробка натискань через intents

PauseIntent один з intents, які роблять віджет інтерактивним.

![Intents у Live Activity на екрані блокування](https://cdn-images-1.medium.com/max/2000/1*k2nzvHgwgqj6tFESIFcmbw.png)_Intents у Live Activity на екрані блокування_

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

Цей intent спрацьовує, коли користувач натискає кнопку паузи у віджеті. Він дуже простий, але потужний:

- Надсилає сповіщення (pauseTimerFromWidget), яке нативний модуль перехоплює через setupNotificationObservers.

- Потім модуль виконує performPause, оновлює стан Live Activity і повідомляє JavaScript.

Краса тут у тому, як intents створюють безшовний цикл: користувач натискає → спрацьовує intent → модуль оновлюється → застосунок лишається синхронним. expo-apple-targets дав шаблон, тож налаштувати intents було легко, але мені все одно довелося розбиратися з випадком, коли натискання не реєструвалися. Виявилося, я помилився в назві сповіщення. Класика. [Документація Expo Modules](https://docs.expo.dev/modules/overview/) допомогла зрозуміти, як обробляти події, що їх запускають нативні дії, і це було ключем до того, щоб усе запрацювало.

## Події, що спілкуються з JavaScript

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

Події з цього розділу дозволяють нативному модулю тримати застосунок на React Native синхронним зі станом Live Activity через систему подій Expo.

### onWidgetCompleteActivity

Ця подія спрацьовує, коли користувач натискає галочку, щоб завершити активність, і її запускає 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 перехоплює сповіщення completeActivityFromWidget, рахує час, що минув, і надсилає в JavaScript подію onWidgetCompleteActivity з ID активності та кількістю секунд. Далі JavaScript може оновити інтерфейс застосунку або записати завершення тренування

### onLiveActivityUpdate

Ця подія спрацьовує щоразу, коли змінюється стан таймера (наприклад, пауза чи продовження).

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

Вона викликається після змін стану (як у 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](https://docs.expo.dev/modules/module-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](https://github.com/tarikfp/expo-live-activity-timer)

