# Timer Live Activity di Expo

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

# Membangun Timer Live Activity di Expo

Live Activities di iOS benar-benar mengubah permainan: fitur ini memungkinkan aplikasi menampilkan pembaruan real-time langsung di Lock Screen atau Dynamic Island. Tentu saja, saya mulai membayangkan betapa kerennya punya timer latihan yang berjalan di sana, menjaga motivasi pengguna bahkan tanpa membuka kunci ponsel. Tapi ada masalah: Live Activities dibangun dengan tool native Apple, seperti Swift dan ActivityKit. Saat itulah saya menemukan tool bernama [expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets) sebagai pengganti menulis seluruh modul dari nol, dan prosesnya jadi jauh lebih mudah dari yang saya kira. Di artikel ini, saya akan mengajak kamu melihat bagaimana saya membangun Live Activity berbasis timer untuk iOS, langkah-langkah yang saya ambil, dan apa yang saya pelajari di sepanjang jalan.

## Kenapa Saya Terobsesi dengan Live Activities

Live Activities bukan sekadar trik keren, fitur ini mengubah cara aplikasi menjaga keterlibatan pengguna. [Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines/live-activities) dari Apple menggambarkannya sebagai cara untuk menyajikan “informasi terkini yang bisa dilihat sekilas” untuk tugas yang terikat waktu. Bayangkan aplikasi fitness yang menampilkan waktu plank kamu di tengah latihan, aplikasi pesan antar makanan yang melacak perjalanan pizza kamu, atau aplikasi ride sharing yang memperbarui perkiraan waktu tiba pengemudi, semuanya langsung di Lock Screen atau, di iPhone 14 Pro dan yang lebih baru, di Dynamic Island. Rasanya seperti memberi pengguna akses VIP ke pembaruan terpenting aplikasimu tanpa perlu membuka kunci ponsel.

Saya ingin pengguna melihat timer latihan mereka terus berjalan selama satu set, menjaga fokus mereka tanpa memaksa mereka membuka aplikasi. Ini jenis sentuhan akhir yang membuat aplikasi terasa profesional, dan saya sepenuhnya tertarik. Tapi kamu tidak bisa menangani semua ini tanpa menyentuh lapisan native, jadi saya tahu saya akan menyelam ke Swift dan bergulat dengan Xcode. Lalu saya menemukan [expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets), package yang menjembatani dunia JavaScript Expo dengan fitur native iOS. Salut besar untuk [Evan Bacon](https://x.com/Baconbrix): tool ini mengubah tugas yang menakutkan menjadi teka-teki yang menantang tapi bisa diselesaikan.

## Gambaran Besar: Live Activities di Aplikasi Expo

Live Activities adalah pesta khusus iOS. Fitur ini ditenagai ActivityKit, framework berbasis Swift, yang berarti kamu harus menulis kode native, suka atau tidak. Untuk aplikasi Expo, ini seperti membujuk ikan memanjat pohon: mungkin saja, tapi butuh usaha. expo-apple-targets hadir seperti pemandu berpengalaman, menyediakan kerangka untuk membuat native module dan widget extension tanpa memulai dari nol. Tool ini dibangun di atas sistem modul Expo ([Expo Modules API](https://docs.expo.dev/modules/module-api/)), yang memungkinkan kamu menulis kode native di Swift dan mengeksposnya ke JavaScript, sehingga seluruh prosesnya tidak terasa seperti perawatan saluran akar gigi.

## Menyiapkan Proyek

Memulainya tidak bisa dibilang gampang, tetapi expo-apple-targets membuatnya bisa ditangani. Begini cara saya memulai:

- **Menginstal expo-apple-targets**: Cukup npm install expo-apple-targets dan saya siap berangkat. README package ini adalah tambang emas, memandu kamu menambahkan widget extension di Xcode dan memperbarui app.json dengan entitlement Live Activity (com.apple.developer.activitykit).

- **Setup Native Module**: Saya memakai sistem modul Expo untuk membuat modul Swift yang berkomunikasi dengan ActivityKit. [Dokumentasi Expo Modules](https://docs.expo.dev/modules/module-api/) menekankan pentingnya mendefinisikan signature fungsi dan event dengan jelas, yang membantu saya mengekspos method seperti startActivity ke JavaScript tanpa kesulitan.

- **Widget Extension**: Di sinilah SwiftUI berperan, memungkinkan saya mendesain tampilan Live Activity untuk Lock Screen dan Dynamic Island. expo-apple-targets menyediakan template widget, tetapi saya harus mengustomisasinya untuk menampilkan timer yang berjalan dan tombol interaktif.

- **Intents**: Intent memungkinkan pengguna mengetuk tombol di widget untuk menjeda atau melanjutkan timer. expo-apple-targets menyederhanakan setup intent, tetapi saya tetap harus men-debug beberapa kegagalan agar notifikasinya mengalir dengan benar.

## Timer yang diperbarui setiap detik?

![Seorang developer dengan antusias menerapkan pembaruan timer setiap satu detik, yang berujung pada kekacauan sistem saat timer itu mengamuk. ([Dibuat oleh gpt-4o](https://openai.com/index/hello-gpt-4o/))](https://cdn-images-1.medium.com/max/2048/1*Nq1a3rqsEIBCgTsAWdvgNQ.png)_Seorang developer dengan antusias menerapkan pembaruan timer setiap satu detik, yang berujung pada kekacauan sistem saat timer itu mengamuk. ([Dibuat oleh gpt-4o](https://openai.com/index/hello-gpt-4o/))_

Saat pertama kali mengerjakan timer, otak saya berkata, “_Perbarui saja Live Activity setiap detik dengan waktu saat ini_.” Kedengarannya mudah, kan? Salah. Saya menemukan sebuah [thread Reddit](https://www.reddit.com/r/iOSProgramming/comments/18n12wh/how_does_this_app_achieve_to_update_its_live/?rdt=52173) tempat para developer membahas kemampuan memperbarui timer Live Activity. Kesimpulannya bulat: memperbarui setiap detik adalah bencana. Seperti mencoba menggerakkan pesawat luar angkasa dengan roda hamster; memang bergerak, tapi cepat habis. Pembaruan terus-menerus membebani CPU dan menguras baterai, sehingga aplikasimu jadi lamban.

Thread Reddit itu membuka mata saya. Saya menemukan Text(timerInterval:) dari SwiftUI di [dokumentasi SwiftUI](<https://developer.apple.com/documentation/swiftui/text/init(timerinterval:pausetime:countsdown:showshours:)>) milik Apple, dan itu benar-benar pencerahan. View ini menangani pembaruan timer secara native, terus berjalan tanpa perlu me-refresh seluruh Live Activity. Rasanya seperti menyerahkan pekerjaan membosankan ke iOS supaya kamu bisa fokus pada bagian yang seru.

Jadi, saya membuang rencana pembaruan setiap detik dan memilih pendekatan startedAt/pausedAt. Inilah alasan pendekatan ini unggul:

- **Performa**: Alih-alih mengirim pembaruan setiap detik, saya menyimpan waktu mulai timer (startedAt) dan waktu jeda (pausedAt, jika dijeda). Widget memakai Text(timerInterval:) untuk menampilkan timer yang berjalan berdasarkan startedAt, dan saat dijeda, widget menampilkan waktu statis dari pausedAt. Ini memangkas panggilan API hingga hampir nol.

- **Efisiensi Baterai**: Pembaruan yang sering adalah vampir baterai. Membiarkan SwiftUI menangani detak timer membuat aplikasi tetap ringan dan ponsel pengguna tetap aman.

- **Kepatuhan API**: API Live Activity dari Apple tidak dibuat untuk dibanjiri pembaruan real-time. Setup startedAt/pausedAt sesuai dengan harapan iOS, sehingga mengurangi kemungkinan terkena rate limit.

- **Kesederhanaan Kode**: Mengelola dua timestamp jauh lebih mudah daripada mengatur aliran pembaruan. Kodenya tetap bersih dan tingkat stres saya tetap terkendali.

Pendekatan ini terasa seperti menemukan jalan pintas rahasia di video game. Timer berjalan mulus, terlihat bagus, dan tidak memonopoli resource. Thread Reddit itu ([ini dia lagi](https://www.reddit.com/r/iOSProgramming/comments/18n12wh/how_does_this_app_achieve_to_update_its_live/?rdt=52173)) layak mendapat medali karena sudah menunjukkan arah yang benar.

## Jantung Live Activity

Saya tidak akan membuatmu bosan dengan setiap baris kode. Mari fokus pada potongan kunci yang membuat timer ini berdetak. Saya akan membagikan source code lengkapnya di GitHub di akhir artikel.

### Struct LiveActivityAttributes

Struct ini adalah tulang punggung Live Activity, yang mendefinisikan datanya dan bagaimana data itu berubah.

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

Ini seperti DNA dari Live Activity. LiveActivityAttributes di bagian luar menyimpan data statis, yaitu activityName (misalnya “Workout”) dan activityIcon (misalnya “RUNNING”) yang diatur saat aktivitas dimulai. ContentState di bagian dalam adalah tempat semua aksi terjadi, melacak startedAt (kapan timer mulai) dan pausedAt (kapan dijeda, jika memang dijeda). Method helper-nya adalah pemain terbaik yang sebenarnya:

- getElapsedTimeInSeconds() menghitung berapa lama timer sudah berjalan, berhenti di pausedAt jika dijeda, atau memakai waktu saat ini jika aktif. Ini menjaga logikanya tetap ringkas dan bisa dipakai ulang.

- isRunning() adalah pengecekan sederhana: jika pausedAt bernilai null, timer sedang berjalan. Ini cara yang rapi untuk menghindari pengecekan state yang berantakan di tempat lain.

- getFormattedElapsedTime() mengubah detik menjadi string “MM:SS” atau “HH:MM:SS” yang rapi untuk widget. Saya menambahkan dukungan jam setelah menyadari sebagian pengguna mungkin melakukan latihan yang sangat panjang seperti maraton.

- getFutureDate() mengatur tanggal satu tahun ke depan, yang saya berikan ke Text(timerInterval:) supaya timer bisa berjalan tanpa batas tanpa perlu memikirkan tanggal akhir.

Saya suka bagaimana struct ini menjaga semuanya tetap rapi. Seperti ransel yang dikemas dengan baik: semua yang kamu butuhkan ada, tidak ada yang tidak perlu. Kepatuhan pada Codable dan Hashable membuatnya mudah diserialisasi untuk pembaruan dan dipakai di SwiftUI, yang sangat menyelamatkan saat menyinkronkan state antara modul dan widget.

### Memulai Live Activity

Fungsi startActivity adalah tempat keajaiban dimulai, memulai Live Activity baru.

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

Fungsi ini adalah percikan yang menyalakan api. Fungsi ini diekspos ke JavaScript melalui sistem modul Expo, sehingga aplikasi React Native saya bisa memanggilnya dengan nama dan ikon. Inilah yang dilakukannya:

- Memeriksa apakah iOS 16.2 atau lebih baru, karena Live Activities tidak ada sebelum versi itu.

- Memanggil endAllActivities() untuk membersihkan aktivitas yang sudah ada. iOS mengizinkan beberapa Live Activity sekaligus, tetapi saya ingin hanya ada satu dalam satu waktu untuk menghindari kebingungan.

- Mengatur startedAt ke waktu saat ini dan mengosongkan pausedAt, menyiapkan timer untuk berjalan.

- Memverifikasi bahwa Live Activities diaktifkan (pengguna bisa menonaktifkannya di Settings, yang sempat membuat saya bingung di awal).

- Membuat LiveActivityAttributes dengan nama dan ikon yang diberikan, serta ContentState dengan waktu mulai.

- Meminta aktivitas baru lewat Activity.request, yang memberi saya objek Activity dengan ID unik.

- Menyimpan ID tersebut, mengirim event pembaruan ke JavaScript, dan mengembalikan ID supaya aplikasi bisa melacaknya.

### Menjeda Timer

Menjeda timer ditangani oleh performPause, yang memperbarui state 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
    }
```

Di sinilah pendekatan startedAt/pausedAt bersinar. Saat pengguna menjeda timer (baik dari aplikasi maupun widget), fungsi ini:

- Memastikan kita berada di iOS 16.2 dan timer belum dijeda (tidak boleh menjeda dua kali).

- Mengambil ID aktivitas, dan memakai currentActivityId jika tidak ada ID yang diberikan.

- Mencari aktivitas memakai findActivityById, yang menelusuri aktivitas yang sedang aktif.

- Mengatur pausedAt ke waktu saat ini, sehingga timer membeku.

- Membuat ContentState baru dengan startedAt yang asli dan pausedAt yang baru.

- Memperbarui aktivitas dengan activity.update, memberi tahu widget untuk menampilkan waktu yang dijeda.

- Mengirim event ke JavaScript supaya UI aplikasi tetap sinkron.

Logika di sini sepenuhnya soal ketelitian. Setiap pengecekan (seperti pausedAt == nil) ada untuk mencegah edge case yang aneh, seperti menjeda aktivitas yang tidak ada. Saya mengandalkan [dokumentasi Expo Modules](https://docs.expo.dev/modules/overview/) untuk penanganan event, memakai sendEvent untuk mengirim pembaruan ke JavaScript. Versi awal fungsi ini tidak memvalidasi startedAt, sehingga tampilan timer sempat aneh. Pelajarannya: selalu jaga state kamu.

## Tampilan Lock Screen

LockScreenLiveActivityView adalah yang dilihat pengguna saat ponsel mereka terkunci, dan tampilannya harus rapi.

![Live Activity di Lock Screen](https://cdn-images-1.medium.com/max/2000/1*IZ1ZSG7_99jfTMBJosePGQ.png)_Live Activity di Lock Screen_

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

Ini adalah jantung visual dari Live Activity, dan di sinilah SwiftUI benar-benar unjuk kemampuan. View-nya dibagi menjadi dua sisi:

- **Sisi Kiri**: Menampilkan nama aktivitas, ikon, dan timer. Jika timer berjalan, Text(timerInterval:) melakukan pekerjaan beratnya, menghitung naik dari startedAt sampai satu tahun ke depan (berkat getFutureDate). Jika dijeda, view menampilkan waktu statis dari getFormattedElapsedTime. Modifier .monospacedDigit() menjaga angka tetap tajam, dan saya menyesuaikan font agar tebal dan mudah dibaca.

- **Sisi Kanan**: Menangani tombol. Saat berjalan, ada tombol jeda berwarna biru. Saat dijeda, kamu mendapat tanda centang hijau untuk membuka aplikasi dan tombol play biru untuk melanjutkan. Setiap tombol memicu sebuah intent, yang ditangkap dan diproses oleh native module.

## Menyelami [Dynamic Island](https://developer.apple.com/design/human-interface-guidelines/live-activities#The-Dynamic-Island)

![Tampilan Dynamic Island](https://cdn-images-1.medium.com/max/2000/1*iqy0d6FZe9UU0Tce7qCDug.png)_Tampilan Dynamic Island_

Potongan ini mendefinisikan bagaimana Live Activity muncul di tiga mode Dynamic Island: expanded (tampilan penuh), compact (diperkecil), dan minimal (paling sederhana).

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

- [\*\*Mode Expanded](https://developer.apple.com/design/human-interface-guidelines/live-activities#Expanded-presentation)\*\*: Muncul saat ditekan lama, dan dibagi menjadi .leading dan .trailing. Sisi leading menumpuk ikon (misalnya figur orang berlari) dan nama (“Workout”) dengan timer besar: statis saat dijeda (getFormattedElapsedTime), berjalan saat aktif (Text(timerInterval:)). Sisi trailing berisi tombol: tombol jeda biru saat berjalan, atau centang hijau (buka aplikasi) dan play biru (lanjutkan) saat dijeda. Saya menyesuaikan font dan padding agar pas dengan lengkungan Island.

- [\*\*Mode Compact](https://developer.apple.com/design/human-interface-guidelines/live-activities#Compact-presentation)\*\*: Saat ruang menyempit, compactLeading menampilkan ikon kecil dan nama yang dipotong, sedangkan compactTrailing menampilkan timer (statis atau berjalan). .lineLimit(1) menjaga nama tetap rapi, dan font 12 point memastikan teks tetap terbaca.

- [\*\*Mode Minimal](https://developer.apple.com/design/human-interface-guidelines/live-activities#Minimal-presentation)\*\*: Sangat sempit, hanya berupa ikon 12 point, seperti dumbel, untuk mengatakan “timer masih ada di sini.” Sederhana tapi efektif.

## Folder \_shared: Kenapa Ini Penting

![Ringkasan folder _shared](https://cdn-images-1.medium.com/max/2000/1*OdZlqw2AXJeTakpTlghLDQ.png)_Ringkasan folder \_shared_

Folder \_shared di [expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets?tab=readme-ov-file#_shared) adalah direktori tingkat atas yang dirancang untuk menautkan kode penting ke target aplikasi utama sekaligus ke sub target, seperti widget Live Activity.

Extension, seperti widget, berjalan di proses terpisah dan membutuhkan file tertentu yang ditautkan ke target mereka sendiri maupun ke target aplikasi utama. Folder \_shared memastikan file-file ini otomatis ditautkan ke keduanya, sehingga tidak perlu konfigurasi manual. Untuk timer saya, saya menaruh struct LiveActivityAttributes di sini, sehingga aplikasi dan widget dijamin berbagi state timer yang sama (startedAt, pausedAt) tanpa masalah sinkronisasi.

## Membuka aplikasi dari Widget Live Activity

CompleteIntent memungkinkan pengguna mengetuk tombol centang di widget Live Activity untuk membuka aplikasi, sebagai tanda bahwa mereka sudah selesai dengan timer. Ini interaksi yang sederhana tapi krusial untuk menutup sesi latihan.

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

Saat pengguna mengetuk centang hijau, intent ini berjalan dan mengirim notifikasi completeActivityFromWidget. Native module menangkapnya, memicu event onWidgetCompleteActivity ke JavaScript, dan iOS membuka aplikasi, berkat [openAppWhenRun](https://developer.apple.com/documentation/appintents/openurlintent/openappwhenrun): true.

## Menangani Ketukan Pengguna dengan Intent

PauseIntent adalah salah satu intent yang membuat widget menjadi interaktif.

![Intent Live Activity di Lock Screen](https://cdn-images-1.medium.com/max/2000/1*k2nzvHgwgqj6tFESIFcmbw.png)_Intent Live Activity di Lock Screen_

```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 ini dipicu saat pengguna mengetuk tombol jeda di widget. Sangat sederhana tapi ampuh:

- Intent ini mengirim notifikasi (pauseTimerFromWidget) yang ditangkap native module melalui setupNotificationObservers.

- Modul kemudian menjalankan performPause, memperbarui state Live Activity dan memberi tahu JavaScript.

Keindahannya ada pada bagaimana intent menciptakan alur yang mulus: pengguna mengetuk → intent berjalan → modul memperbarui → aplikasi tetap sinkron. expo-apple-targets membuat setup intent jadi mudah dengan menyediakan template, tetapi saya tetap harus men-debug kasus ketika ketukan tidak terdaftar. Ternyata saya salah mengeja nama notifikasi. Klasik. [Dokumentasi Expo Modules](https://docs.expo.dev/modules/overview/) membantu saya memahami cara menangani event yang dipicu oleh aksi native, yang menjadi kunci agar semua ini berjalan.

## Event yang berkomunikasi dengan JavaScript

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

Event di bagian berikut adalah cara native module menjaga aplikasi React Native tetap sinkron dengan state Live Activity, memakai sistem event Expo.

### onWidgetCompleteActivity

Event ini berjalan saat pengguna mengetuk centang untuk menyelesaikan aktivitas, dipicu oleh 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 menangkap notifikasi completeActivityFromWidget, menghitung waktu yang sudah berlalu, lalu mengirim event onWidgetCompleteActivity ke JavaScript dengan ID aktivitas dan jumlah detik yang berlalu. JavaScript kemudian bisa memperbarui UI aplikasi atau mencatat bahwa latihan sudah selesai.

### onLiveActivityUpdate

Event ini berjalan setiap kali state timer berubah (misalnya jeda, lanjut).

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

Dipanggil setelah state berubah (seperti di performPause atau performResume), fungsi ini mengirim event onLiveActivityUpdate dengan state saat ini (“active” atau “paused”), waktu yang berlalu, dan ID aktivitas. JavaScript mendengarkan event ini untuk menjaga UI timer aplikasi tetap sinkron dengan widget.

Kedua event ini menciptakan feedback loop yang erat antara native module dan JavaScript.

## Kenapa Semua Ini Penting

Live Activity ini bukan sekadar timer, ini fitur yang membuat aplikasi saya terasa seperti warga asli iOS. Inilah alasannya:

- **Keterlibatan Pengguna**: Menampilkan timer di Lock Screen atau Dynamic Island membuat pengguna tetap terhubung dengan aplikasi tanpa memutus alur mereka. Sangat cocok untuk latihan, ketika setiap detik berharga.

- **Sentuhan Native**: Desain widget yang bersih dan tombol yang interaktif membuat aplikasi terasa memang milik iOS, bukan tambahan lintas platform yang dipikirkan belakangan.

- **Performa**: Pendekatan startedAt/pausedAt, yang ditenagai Text(timerInterval:), memastikan timer berjalan mulus tanpa menguras baterai atau menabrak batas API.

expo-apple-targets dan [Expo Modules API](https://docs.expo.dev/modules/module-api/) adalah pahlawan tanpa tanda jasa di sini, menyediakan kerangka yang kuat untuk menjembatani JavaScript dan Swift. Penekanan dokumentasinya pada definisi fungsi dan penanganan event yang bersih membuat kode saya tetap rapi dan mudah dipelihara.

## Penutup

Live Activity ini menambahkan nuansa native yang mulus ke aplikasi, menampilkan pembaruan real-time langsung di Lock Screen dan Dynamic Island. Berkat expo-apple-targets, Expo Modules API, dan wawasan dari komunitas (ya, termasuk thread Reddit), mewujudkannya ternyata cukup lugas. Live Activities adalah cara yang ampuh untuk membuat aplikasi terasa lebih terhubung dan dinamis.

Berikut tautan GitHub untuk repo source code lengkapnya 👉🏻 [https://github.com/tarikfp/expo-live-activity-timer](https://github.com/tarikfp/expo-live-activity-timer)

