Siklus Proses di Jetpack Compose   Bagian dari Android Jetpack.

Komponen berbasis siklus proses melakukan tindakan sebagai respons terhadap perubahan status siklus proses aktivitas host. Artefak androidx.lifecycle.compose menyediakan API khusus yang secara otomatis membersihkan resource saat resource keluar dari layar atau saat aplikasi masuk ke latar belakang.

API utama meliputi:

Integrasi ini menyediakan hook yang mudah untuk mengelola siklus proses dalam hierarki Compose. Dokumen ini menguraikan cara Anda dapat menggunakannya di aplikasi Anda.

Mengumpulkan status siklus proses dengan alur

Lifecycle mengekspos properti currentStateFlow yang menyediakan Lifecycle.State saat ini sebagai StateFlow Kotlin. Anda dapat mengumpulkan Flow ini sebagai State. Hal ini memungkinkan aplikasi Anda membaca perubahan di Siklus Proses selama komposisi.

val lifecycleOwner = LocalLifecycleOwner.current
val stateFlow = lifecycleOwner.lifecycle.currentStateFlow
…
val currentLifecycleState by stateFlow.collectAsState()

Contoh sebelumnya dapat diakses menggunakan modul lifecycle-common. Metode currentStateAsState() tersedia di modul lifecycle-runtime-compose, yang memungkinkan Anda membaca status Siklus Proses saat ini dengan mudah menggunakan satu baris. Contoh berikut menunjukkan hal tersebut:

val lifecycleOwner = LocalLifecycleOwner.current
val currentLifecycleState = lifecycleOwner.lifecycle.currentStateAsState()

Menjalankan kode pada peristiwa siklus proses

Daripada membuat class terpisah yang menerapkan DefaultLifecycleObserver dan menambahkannya secara manual ke siklus proses, Anda dapat mendeklarasikan logika siklus proses secara inline menggunakan efek tertentu. LifecycleEffects memungkinkan Anda menjalankan blok saat Lifecycle.Event tertentu terjadi langsung dalam komposisi.

LifecycleEventEffect

Gunakan LifecycleEventEffect untuk menjalankan blok kode saat peristiwa tertentu terjadi. Ini paling cocok untuk peristiwa sekali jalan seperti logging atau analisis, yang tidak memerlukan keberhasilan atau hasil langsung.

@Composable
fun AnalyticsTracker(screenName: String) {
    // Log an event when the app receives ON_RESUME (e.g. comes to foreground)
    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
        Analytics.logView(screenName)
    }
}

LifecycleStartEffect

Untuk operasi mulai/berhenti yang dipasangkan yang perlu dijalankan saat aplikasi dimulai (terlihat) dan dibersihkan saat aplikasi dihentikan (di latar belakang), gunakan LifecycleStartEffect.

Mirip dengan efek Compose lainnya (seperti LaunchedEffect), LifecycleStartEffect menerima kunci. Saat kunci berubah, blok akan dipicu untuk dijalankan lagi.

Saat peristiwa Lifecycle.Event.ON_STOP terjadi atau efek keluar dari komposisi, blok onStopOrDispose akan dieksekusi untuk membersihkan pekerjaan apa pun yang merupakan bagian dari blok awal.

@Composable
fun LocationMonitor(locationManager: LocationManager) {
    // Starts monitoring when ON_START is dispatched
    // Stops monitoring when ON_STOP is dispatched
    //   (or the composable leaves the screen)
    LifecycleStartEffect(locationManager) {
        val listener = LocationListener { location ->
            /* update UI */
        }
        locationManager.requestLocationUpdates(listener)
        // The cleanup block automatically runs on ON_STOP or on disposal
        onStopOrDispose {
            locationManager.removeUpdates(listener)
        }
    }
}

Untuk mengetahui informasi tentang jenis efek samping lainnya, lihat Efek samping di Compose.

LifecycleResumeEffect

LifecycleResumeEffect berfungsi dengan cara yang sama seperti LifecycleStartEffect, tetapi terikat pada peristiwa Lifecycle.Event.ON_RESUME. Composable ini juga menyediakan blok onPauseOrDispose yang melakukan pembersihan saat ON_PAUSE dikirim atau composable keluar dari layar.

API ini berguna untuk resource yang hanya perlu aktif saat pengguna berinteraksi dengan aplikasi—misalnya, kamera atau animasi.

@Composable
fun CameraPreview(cameraController: CameraController) {
    LifecycleResumeEffect(cameraController) {
        cameraController.startPreview()

        onPauseOrDispose {
            cameraController.stopPreview()
        }
    }
}

Mengakses LifecycleOwner

Di Compose, LifecycleOwner tersedia secara implisit melalui CompositionLocal bernama LocalLifecycleOwner. Secara default, host root hierarki komposisi Anda menyediakan pemilik ini.

val lifecycleOwner = LocalLifecycleOwner.current

Untuk banyak aplikasi, memeriksa pemilik default ini atau meneruskannya ke efek yang kompatibel dengan siklus proses sudah cukup. Namun, untuk navigasi kustom atau tata letak yang kompleks, Anda mungkin ingin membuat LifecycleOwner sendiri untuk mencakup status siklus proses ke bagian UI tertentu. Misalnya, library navigasi (seperti Navigation 3) melakukannya secara otomatis untuk memberikan siklus prosesnya sendiri pada setiap layar.

Membuat LifecycleOwner kustom

API rememberLifecycleOwner() memungkinkan Anda membuat dan mengingat LifecycleOwner kustom. Hal ini sangat berguna untuk komponen seperti HorizontalPager, di mana Anda hanya ingin halaman yang terlihat dan stabil menjadi RESUMED, sambil menetapkan maxState STARTED untuk halaman di luar layar yang berdekatan.

val pagerState = rememberPagerState(pageCount = { 10 })

HorizontalPager(state = pagerState) { pageNum ->
    val pageLifecycleOwner = rememberLifecycleOwner(
        maxState = if (pagerState.settledPage == pageNum) {
            Lifecycle.State.RESUMED
        } else {
            Lifecycle.State.STARTED
        }
    )

    CompositionLocalProvider(LocalLifecycleOwner provides pageLifecycleOwner) {
        // Your pages here. Their lifecycle-aware components respect the
        // custom maxState defined above.
    }
}

Untuk mengetahui informasi selengkapnya tentang CompositionLocal, lihat Data yang dicakup secara lokal dengan CompositionLocal.

Praktik terbaik untuk komponen berbasis siklus proses

  • Buatlah pengontrol UI yang seramping mungkin. Pengontrol UI tidak boleh mencoba memperoleh datanya sendiri; sebagai gantinya, gunakan ViewModel untuk tujuan tersebut, dan amati objek StateFlow untuk mencerminkan perubahan ke UI.
  • Cobalah untuk menulis UI berbasis data, yang tanggung jawab pengontrol UI-nya adalah memperbarui UI saat terjadi perubahan data, atau memberitahukan kembali tindakan pengguna ke ViewModel.
  • Tempatkan logika data Anda di class ViewModel. ViewModel harus berfungsi sebagai penghubung antara pengontrol UI dan seluruh aplikasi Anda. Namun, perlu diperhatikan, ViewModel tidak bertanggung jawab untuk mengambil data (misalnya, dari jaringan). Sebagai gantinya, ViewModel harus memanggil komponen yang sesuai untuk mengambil data, kemudian menyediakan kembali hasilnya ke pengontrol UI.
  • Gunakan coroutine Kotlin untuk mengelola tugas yang berjalan lama dan operasi lain yang berjalan secara asinkron.
  • Simpan logika mulai/berhenti di dalam composable yang benar-benar membutuhkannya. Dengan cara ini, logika akan otomatis dihapus jika elemen UI tertentu tersebut dihapus dari layar (misalnya, di dalam grafik navigasi atau saat visibilitas bersifat kondisional).
  • Gunakan collectAsStateWithLifecycle untuk data. Jangan memulai atau menghentikan pengumpulan Flow secara manual berdasarkan peristiwa siklus proses. Sebagai gantinya, gunakan collectAsStateWithLifecycle untuk mengonversi aliran menjadi status UI secara efisien. Hal ini menghemat baterai dan resource karena Flow dijeda saat aplikasi berada di latar belakang.

Untuk mengetahui informasi selengkapnya tentang Flow, lihat Jenis status lain yang didukung.

Kasus penggunaan komponen berbasis siklus proses

Komponen siklus proses dapat mempermudah Anda dalam mengelola siklus proses dalam berbagai kasus. Beberapa contohnya adalah:

  • Beralih antara update lokasi yang umum dan akurat. Gunakan LifecycleStartEffect untuk mengaktifkan update lokasi akurat saat aplikasi Anda terlihat (ON_START), dan secara otomatis menghapus pemroses atau beralih ke update lokasi umum saat aplikasi berada di latar belakang (ON_STOP).
  • Menghentikan atau memulai buffering video. Gunakan LifecycleResumeEffect untuk menunda pemutaran video sebenarnya hingga aplikasi sepenuhnya berada di latar depan dan interaktif (ON_RESUME), serta untuk memastikan pemutaran dijeda dan melepaskan resource saat aplikasi berada di latar belakang (ON_PAUSE).
  • Memulai dan menghentikan streaming jaringan. Gunakan collectAsStateWithLifecycle untuk mengamati aliran data berkelanjutan (seperti Flow Kotlin dari soket jaringan). Hal ini memberi Anda update live saat aplikasi berada di latar depan dan secara otomatis membatalkan pengumpulan saat aplikasi masuk ke latar belakang.
  • Menjeda dan melanjutkan tugas berat. Gunakan LifecycleResumeEffect untuk menangani penjedaan update visual berat saat aplikasi berada di latar belakang, dan melanjutkan update tersebut setelah aplikasi berada di latar depan.

Menangani peristiwa ON_STOP dengan aman

Compose dirancang untuk menangani peristiwa ON_STOP dengan aman.

  • Status aman: Anda dapat memperbarui MutableState (misalnya, dengan uiState.value = ...) kapan saja, bahkan saat aplikasi berada di latar belakang. Compose menunggu hingga aplikasi terlihat untuk merender perubahan.
  • Pembersihan otomatis: Dengan efek seperti LifecycleStartEffect, blok pembersihan (onStopOrDispose) Anda berjalan tepat saat siklus proses berpindah ke STOPPED. Hal ini mencegah Anda menahan resource berat (seperti kamera atau lokasi) saat aplikasi berada di latar belakang.

Untuk mengetahui informasi selengkapnya tentang MutableState, lihat Status dan Jetpack Compose.

Referensi lainnya

Untuk mempelajari lebih lanjut cara menangani siklus proses dengan komponen berbasis siklus proses, lihat referensi tambahan berikut.

Melihat konten