Xây dựng bộ đếm giờ Live Activity trong Expo
Live Activities trên iOS là một thứ thay đổi cuộc chơi: chúng cho phép app hiển thị cập nhật theo thời gian thực ngay trên màn hình khóa hoặc Dynamic Island. Tất nhiên, tôi bắt đầu tưởng tượng sẽ tuyệt thế nào nếu có một bộ đếm giờ tập luyện chạy ở đó, giữ động lực cho người dùng mà họ thậm chí không cần mở khóa điện thoại. Nhưng có một vấn đề: Live Activities được xây dựng bằng công cụ native của Apple, như Swift và ActivityKit. Đó là lúc tôi phát hiện ra một công cụ tên là expo-apple-targets thay vì phải viết toàn bộ module từ đầu, và nó khiến quá trình này dễ hơn nhiều so với tôi nghĩ. Trong bài viết này, tôi sẽ hướng dẫn bạn cách tôi xây dựng một Live Activity dạng đếm giờ cho iOS, các bước tôi đã làm và những gì tôi học được trên đường đi.
Vì sao tôi mê Live Activities
Live Activities không chỉ là một mẹo hay ho, chúng thay đổi cuộc chơi về mức độ gắn kết của người dùng. Human Interface Guidelines của Apple mô tả chúng là cách để mang đến "thông tin hiện tại, xem nhanh trong một cái liếc" cho những việc nhạy cảm về thời gian. Hãy hình dung một app thể dục hiển thị thời gian plank giữa buổi tập, một app giao đồ ăn theo dõi hành trình chiếc pizza của bạn, hay một app gọi xe cập nhật thời gian tài xế đến, tất cả ngay trên màn hình khóa hoặc, trên iPhone 14 Pro trở lên, trong Dynamic Island. Nó giống như trao cho người dùng một tấm vé VIP để xem những cập nhật quan trọng nhất của app mà không cần mở khóa điện thoại.
Tôi muốn người dùng thấy bộ đếm giờ tập luyện chạy lên trong lúc tập một hiệp, giúp họ tập trung mà không buộc phải mở app. Đó là kiểu chăm chút khiến một app trông chuyên nghiệp, và tôi quyết làm tới cùng. Nhưng bạn không thể xử lý tất cả những điều này mà không đụng tới tầng native, nên tôi biết mình sẽ phải lao vào Swift và vật lộn với Xcode. Rồi tôi phát hiện ra expo-apple-targets, một package nối thế giới JavaScript của Expo với các tính năng native của iOS. Xin dành lời cảm ơn lớn cho Evan Bacon, công cụ này biến một nhiệm vụ đáng sợ thành một câu đố khó nhưng giải được.
Bức tranh tổng thể: Live Activities trong một app Expo
Live Activities là bữa tiệc chỉ dành cho iOS. Chúng được vận hành bởi ActivityKit, một framework dựa trên Swift, nghĩa là bạn sẽ phải viết code native dù muốn hay không. Với một app Expo, việc này giống như thuyết phục một con cá trèo cây: có thể làm được, nhưng sẽ tốn công. expo-apple-targets xuất hiện như một người dẫn đường lão luyện, cung cấp một khung để tạo native module và widget extension mà không phải bắt đầu từ con số không. Nó được xây trên hệ thống module của Expo (Expo Modules API), cho phép bạn viết code native bằng Swift và expose nó sang JavaScript, khiến cả quá trình bớt giống một ca chữa tủy răng.
Thiết lập dự án
Bắt đầu không hẳn là dễ như dạo chơi, nhưng expo-apple-targets giúp mọi thứ trong tầm kiểm soát. Đây là cách tôi khởi động:
-
Cài đặt expo-apple-targets: Một lệnh npm install expo-apple-targets nhanh gọn là đủ để bắt đầu. README của package là một mỏ vàng, hướng dẫn bạn thêm widget extension trong Xcode và cập nhật app.json với entitlement cho Live Activity (com.apple.developer.activitykit).
-
Thiết lập native module: Tôi dùng hệ thống module của Expo để tạo một Swift module giao tiếp với ActivityKit. Tài liệu Expo Modules nhấn mạnh việc định nghĩa rõ ràng chữ ký hàm và event, điều này giúp tôi expose các method như startActivity sang JavaScript mà không đổ mồ hôi.
-
Widget extension: Đây là chỗ SwiftUI vào cuộc, cho phép tôi thiết kế giao diện của Live Activity trên màn hình khóa và Dynamic Island. expo-apple-targets cung cấp sẵn một template widget, nhưng tôi phải tùy chỉnh để hiển thị bộ đếm giờ đang chạy và các nút tương tác.
-
Intent: Chúng cho phép người dùng chạm vào nút trên widget để tạm dừng hoặc tiếp tục bộ đếm giờ. expo-apple-targets giúp việc thiết lập intent đơn giản hơn, nhưng tôi vẫn phải debug vài lần bấm không ăn để notification chạy đúng.
Một bộ đếm giờ được cập nhật mỗi giây?
Một lập trình viên hào hứng cài đặt việc cập nhật bộ đếm giờ mỗi giây, khiến hệ thống quá tải hỗn loạn khi bộ đếm giờ tàn phá mọi thứ. (Tạo bởi gpt-4o)
Khi lần đầu xử lý bộ đếm giờ, đầu tôi bảo: "Cứ cập nhật Live Activity mỗi giây với thời gian hiện tại là xong." Nghe có vẻ đơn giản, đúng không? Sai. Tôi tình cờ thấy một thread trên Reddit nơi các dev bàn về khả năng cập nhật bộ đếm giờ của Live Activity. Kết luận là nhất trí: cập nhật mỗi giây là một thảm họa. Nó giống như cố chạy tàu vũ trụ bằng bánh xe chuột hamster; nó sẽ chạy, nhưng sẽ kiệt sức rất nhanh. Cập nhật liên tục làm CPU quá tải, ngốn pin và khiến app chậm chạp.
Thread Reddit đó là một hồi chuông cảnh tỉnh. Tôi tìm thấy Text(timerInterval:) của SwiftUI trong tài liệu SwiftUI của Apple, và đó là một phát hiện lớn. View này xử lý việc cập nhật bộ đếm giờ một cách native, tự chạy mà không cần làm mới toàn bộ Live Activity. Nó giống như giao việc nhàm chán cho iOS để bạn tập trung vào phần thú vị.
Vậy nên tôi bỏ kế hoạch cập nhật mỗi giây và chọn cách dùng startedAt/pausedAt. Đây là lý do nó thắng:
-
Hiệu năng: Thay vì bắn cập nhật mỗi giây, tôi lưu thời điểm bắt đầu (startedAt) và thời điểm tạm dừng (pausedAt, nếu đang dừng). Widget dùng Text(timerInterval:) để hiển thị bộ đếm giờ đang chạy dựa trên startedAt, còn khi tạm dừng, nó hiển thị một thời gian tĩnh dựa trên pausedAt. Cách này giảm số lần gọi API xuống gần bằng không.
-
Tiết kiệm pin: Cập nhật thường xuyên là một con ma cà rồng hút pin. Để SwiftUI lo phần đếm giúp app nhẹ nhàng và điện thoại người dùng vui vẻ.
-
Tuân thủ API: Các API Live Activity của Apple không được làm ra để bị spam theo thời gian thực. Cách dùng startedAt/pausedAt hợp với kỳ vọng của iOS, giảm khả năng bị giới hạn tần suất.
-
Code đơn giản: Quản lý hai mốc thời gian dễ hơn nhiều so với việc tung hứng một luồng cập nhật. Nó giữ code gọn gàng và mức căng thẳng của tôi trong tầm kiểm soát.
Cách tiếp cận này giống như tìm ra một lối tắt bí mật trong trò chơi điện tử. Bộ đếm giờ chạy mượt, trông đẹp và không chiếm tài nguyên. Thread Reddit đó (đây là nó lần nữa) xứng đáng nhận huy chương vì đã chỉ tôi đi đúng hướng.
Trái tim của Live Activity
Tôi sẽ không làm bạn chán bằng từng dòng code, hãy tập trung vào những đoạn chính giúp bộ đếm giờ này chạy. Tôi sẽ chia sẻ toàn bộ mã nguồn trên GitHub ở cuối bài.
Struct LiveActivityAttributes
Struct này là xương sống của Live Activity, định nghĩa dữ liệu của nó và cách nó thay đổi.
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
}
Đây giống như ADN của Live Activity. LiveActivityAttributes bên ngoài chứa những thứ tĩnh: activityName (ví dụ "Workout") và activityIcon (ví dụ "RUNNING"), được đặt khi activity bắt đầu. ContentState bên trong là nơi mọi thứ diễn ra, theo dõi startedAt (khi bộ đếm giờ bắt đầu) và pausedAt (khi nó tạm dừng, nếu có). Các method trợ giúp mới là những nhân vật chính thực sự:
-
getElapsedTimeInSeconds() tính bộ đếm giờ đã chạy bao lâu, dừng ở pausedAt nếu đang tạm dừng, hoặc dùng thời gian hiện tại nếu đang chạy. Điều này giữ logic chặt chẽ và dùng lại được.
-
isRunning() là một phép kiểm tra đơn giản: nếu pausedAt là null thì bộ đếm giờ đang chạy. Đó là một cách gọn gàng để tránh những phép kiểm tra state lộn xộn ở chỗ khác.
-
getFormattedElapsedTime() biến số giây thành một chuỗi đẹp dạng "MM:SS" hoặc "HH:MM:SS" cho widget. Tôi thêm hỗ trợ giờ sau khi nhận ra một số người dùng có thể tập cực lâu, như chạy marathon.
-
getFutureDate() đặt một ngày cách đây một năm về sau, mà tôi đưa vào Text(timerInterval:) để bộ đếm giờ chạy vô thời hạn mà không phải lo về ngày kết thúc.
Tôi thích cách struct này giữ mọi thứ ngăn nắp. Nó giống như một chiếc ba lô được xếp gọn: có mọi thứ bạn cần, không có thứ bạn không cần. Việc conform Codable và Hashable giúp dễ serialize để cập nhật và dùng trong SwiftUI, điều này đã cứu tôi khi đồng bộ state giữa module và widget.
Khởi động Live Activity
Hàm startActivity là nơi phép màu bắt đầu, khởi động một Live Activity mới.
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 ""
}
Hàm này là tia lửa châm ngòi. Nó được expose sang JavaScript qua hệ thống module của Expo, cho phép app React Native của tôi gọi nó với một cái tên và một icon. Đây là những gì nó làm:
-
Nó kiểm tra iOS 16.2 trở lên, vì trước phiên bản đó Live Activities chưa tồn tại.
-
Nó gọi endAllActivities() để dọn mọi activity đang có. iOS cho phép nhiều Live Activity cùng lúc, nhưng tôi muốn mỗi lần chỉ một để tránh nhầm lẫn.
-
Nó đặt startedAt bằng thời gian hiện tại và xóa pausedAt, chuẩn bị cho bộ đếm giờ chạy.
-
Nó xác minh rằng Live Activities đang được bật (người dùng có thể tắt chúng trong Cài đặt, điều này từng làm tôi bối rối lúc đầu).
-
Nó tạo một LiveActivityAttributes với tên và icon được truyền vào, cùng một ContentState với thời điểm bắt đầu.
-
Nó yêu cầu một activity mới qua Activity.request, trả về cho tôi một object Activity với ID duy nhất.
-
Nó lưu ID, bắn một event cập nhật sang JavaScript và trả về ID để app có thể theo dõi.
Tạm dừng bộ đếm giờ
Việc tạm dừng bộ đếm giờ được xử lý bởi performPause, hàm cập nhật state của 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
}
Đây là chỗ cách dùng startedAt/pausedAt tỏa sáng. Khi người dùng tạm dừng bộ đếm giờ (từ app hoặc từ widget), hàm này:
-
Kiểm tra rằng chúng ta đang ở iOS 16.2 và bộ đếm giờ chưa bị tạm dừng (không được tạm dừng hai lần).
-
Lấy ID của activity, dùng currentActivityId nếu không có ID nào được truyền vào.
-
Tìm activity bằng findActivityById, hàm tìm trong các activity đang hoạt động.
-
Đặt pausedAt bằng thời gian hiện tại, đóng băng bộ đếm giờ.
-
Tạo một ContentState mới với startedAt ban đầu và pausedAt mới.
-
Cập nhật activity bằng activity.update, báo cho widget hiển thị thời gian lúc tạm dừng.
-
Gửi một event sang JavaScript để giao diện của app luôn đồng bộ.
Logic ở đây xoay quanh sự chính xác: mỗi phép kiểm tra (như pausedAt == nil) đều có mặt để ngăn các trường hợp biên kỳ quặc, như tạm dừng một activity không tồn tại. Tôi dựa vào tài liệu Expo Modules để xử lý event, dùng sendEvent để đẩy cập nhật sang JavaScript. Các phiên bản đầu của hàm này không kiểm tra startedAt, dẫn đến vài kiểu hiển thị bộ đếm giờ kỳ cục. Bài học rút ra: luôn bảo vệ state của bạn.
Giao diện trên màn hình khóa
LockScreenLiveActivityView là thứ người dùng thấy khi điện thoại bị khóa, và nó phải trông thật gọn gàng.
Live Activity trên màn hình khóa
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)
}
}
}
Đây là trái tim về mặt hình ảnh của Live Activity, và là nơi SwiftUI thực sự thể hiện sức mạnh. View được chia làm hai bên:
-
Bên trái: Hiển thị tên activity, icon và bộ đếm giờ. Nếu bộ đếm giờ đang chạy, Text(timerInterval:) làm phần việc nặng, đếm lên từ startedAt đến một năm sau (nhờ getFutureDate). Nếu tạm dừng, nó hiển thị thời gian tĩnh từ getFormattedElapsedTime. Modifier .monospacedDigit() giữ các con số sắc nét, và tôi chỉnh font cho đậm và dễ đọc.
-
Bên phải: Xử lý các nút. Khi đang chạy, có một nút tạm dừng màu xanh dương. Khi tạm dừng, bạn có một dấu tích xanh lá để mở app và một nút play xanh dương để tiếp tục. Mỗi nút bắn một intent, được native module bắt và xử lý.
Khám phá Dynamic Island
Giao diện Dynamic Island
Đoạn code này định nghĩa cách Live Activity xuất hiện ở ba chế độ của Dynamic Island: expanded (đầy đủ), compact (thu gọn) và minimal (tối giản).
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)
}
}
-
**Chế độ Expanded**: Hiện ra khi nhấn giữ, được chia thành .leading và .trailing. Bên leading xếp chồng icon (ví dụ hình người đang chạy) và tên ("Workout") cùng một bộ đếm giờ lớn: tĩnh khi tạm dừng (getFormattedElapsedTime), chạy khi đang hoạt động (Text(timerInterval:)). Bên trailing có các nút: một nút tạm dừng xanh dương khi đang chạy, hoặc dấu tích xanh lá (mở app) và nút play xanh dương (tiếp tục) khi tạm dừng. Tôi chỉnh font và padding cho vừa với các đường cong của Island.
-
**Chế độ Compact**: Khi không gian bị thu hẹp, compactLeading hiển thị một icon nhỏ và tên bị cắt bớt, còn compactTrailing hiển thị bộ đếm giờ (tĩnh hoặc đang chạy). .lineLimit(1) giữ tên gọn gàng, và font 12 point đảm bảo dễ đọc.
-
**Chế độ Minimal**: Cực kỳ chật, chỉ là một icon 12 point, như quả tạ, để nói rằng "bộ đếm giờ vẫn ở đây". Đơn giản nhưng hiệu quả.
Thư mục _shared: vì sao nó quan trọng
Tổng quan thư mục _shared
Thư mục _shared trong expo-apple-targets là một thư mục cấp cao nhất được thiết kế để liên kết code thiết yếu tới cả target chính của app lẫn các sub-target, như widget Live Activity.
Các extension, chẳng hạn widget, chạy trong các process riêng và cần một số file cụ thể được liên kết tới target của chúng cũng như target của app chính. Thư mục _shared đảm bảo các file này được tự động liên kết tới cả hai, loại bỏ việc cấu hình thủ công. Với bộ đếm giờ của tôi, tôi đặt struct LiveActivityAttributes ở đây, đảm bảo app và widget dùng chung một state bộ đếm giờ (startedAt, pausedAt) mà không gặp vấn đề đồng bộ.
Mở app từ widget Live Activity
CompleteIntent cho phép người dùng chạm vào nút dấu tích trên widget Live Activity để mở app, báo hiệu họ đã xong với bộ đếm giờ. Đây là một tương tác đơn giản nhưng quan trọng để kết thúc buổi tập.
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()
}
}
Khi người dùng chạm vào dấu tích xanh lá, intent này được kích hoạt, gửi đi notification completeActivityFromWidget. Native module bắt được nó, kích hoạt event onWidgetCompleteActivity sang JavaScript, và iOS mở app, nhờ openAppWhenRun: true.
Xử lý thao tác chạm của người dùng bằng intent
PauseIntent là một trong những intent giúp widget có thể tương tác.
Các intent của Live Activity trên màn hình khóa
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 này được kích hoạt khi người dùng chạm vào nút tạm dừng trên widget. Nó cực kỳ đơn giản nhưng mạnh mẽ:
-
Nó gửi một notification (pauseTimerFromWidget) mà native module bắt được qua setupNotificationObservers.
-
Sau đó module chạy performPause, cập nhật state của Live Activity và thông báo cho JavaScript.
Cái hay ở đây là cách intent tạo ra một vòng lặp liền mạch: người dùng chạm → intent kích hoạt → module cập nhật → app luôn đồng bộ. expo-apple-targets khiến việc thiết lập intent trở nên dễ dàng nhờ có template, nhưng tôi vẫn phải debug một trường hợp thao tác chạm không được ghi nhận. Hóa ra tôi đã viết sai chính tả tên một notification. Kinh điển. Tài liệu Expo Modules giúp tôi hiểu cách xử lý các event được kích hoạt bởi hành động native, đó là chìa khóa để mọi thứ hoạt động.
Các event nói chuyện với JavaScript

Các event trong phần sau là cách native module giữ cho app React Native đồng bộ với state của Live Activity, bằng hệ thống event của Expo.
onWidgetCompleteActivity
Event này được kích hoạt khi người dùng chạm vào dấu tích để hoàn thành activity, do CompleteIntent khởi phát.
@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 bắt notification completeActivityFromWidget, tính thời gian đã trôi qua và gửi event onWidgetCompleteActivity sang JavaScript kèm ID của activity và số giây đã trôi qua. Sau đó JavaScript có thể cập nhật giao diện của app hoặc ghi lại việc hoàn thành buổi tập
onLiveActivityUpdate
Event này được kích hoạt mỗi khi state của bộ đếm giờ thay đổi (ví dụ tạm dừng, tiếp tục).
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
])
}
Được gọi sau khi state thay đổi (như trong performPause hoặc performResume), nó gửi event onLiveActivityUpdate với state hiện tại ("active" hoặc "paused"), thời gian đã trôi qua và ID của activity. JavaScript lắng nghe event này để giữ giao diện bộ đếm giờ trong app đồng bộ với widget.
Cả hai event tạo ra một vòng phản hồi chặt chẽ giữa native module và JavaScript.
Vì sao tất cả điều này quan trọng
Live Activity này không chỉ là một bộ đếm giờ, nó là một tính năng khiến app của tôi trông như một công dân iOS thực thụ. Đây là lý do nó quan trọng:
-
Gắn kết người dùng: Hiển thị bộ đếm giờ trên màn hình khóa hoặc Dynamic Island giữ người dùng kết nối với app mà không làm gián đoạn mạch của họ. Nó hoàn hảo cho việc tập luyện, nơi từng giây đều có giá trị.
-
Chăm chút kiểu native: Thiết kế gọn gàng và các nút tương tác của widget khiến app trông thuộc về iOS, chứ không phải thứ đa nền tảng làm cho có.
-
Hiệu năng: Cách dùng startedAt/pausedAt, nhờ Text(timerInterval:), đảm bảo bộ đếm giờ chạy mượt mà không ngốn pin hay chạm giới hạn API.
expo-apple-targets và Expo Modules API là những người hùng thầm lặng ở đây, cung cấp một khung vững chắc để nối JavaScript với Swift. Việc tài liệu nhấn mạnh định nghĩa hàm rõ ràng và xử lý event giúp code của tôi ngăn nắp và dễ bảo trì.
Suy nghĩ cuối cùng
Live Activity này mang lại cảm giác mượt mà, native cho app, hiển thị cập nhật theo thời gian thực ngay trên màn hình khóa và Dynamic Island. Nhờ expo-apple-targets, Expo Modules API và những chia sẻ từ cộng đồng (đúng vậy, kể cả các thread Reddit), việc hiện thực hóa nó khá đơn giản. Live Activities là một cách mạnh mẽ để khiến app có cảm giác kết nối và sống động hơn
Đây là link GitHub của repo mã nguồn đầy đủ 👉🏻 https://github.com/tarikfp/expo-live-activity-timer