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, але кілька осічок мені все одно довелося налагодити, щоб сповіщення ходили правильно.
Таймер, який оновлюється щосекунди?
Розробник із ентузіазмом робить оновлення таймера щосекунди, і таймер доводить систему до хаотичного перевантаження. (Згенеровано 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 на екрані блокування
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
Цей фрагмент визначає, як 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 в 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 на екрані блокування
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