lifecycleScope — apa itu, kaitan dengan Lifecycle dan bekerja di Android

Apa itu lifecycleScope di Android?

lifecycleScope — adalah properti ekstensi pada antarmuka LifecycleOwner (Activity, Fragment, Service) yang menyediakan CoroutineScope siap pakai yang terikat pada siklus hidup lengkap komponen. Saat LifecycleOwner mencapai status DESTROYED, lifecycleScope secara otomatis membatalkan semua korutin aktif.

// Di Fragment atau Activity
lifecycleScope.launch {
    delay(1000)
    showSnackbar("Halo!")
}

Tidak seperti viewModelScope, lifecycleScope dibatalkan pada setiap penghancuran LifecycleOwner — termasuk rotasi layar. Ini membuatnya ideal untuk operasi yang hanya perlu hidup selama layar tertentu terlihat.

Di mana lifecycleScope tersedia

lifecycleScope tersedia di mana pun ada LifecycleOwner:

• Activity — AppCompatActivity mewarisi LifecycleOwner
• Fragment — Fragment mewarisi LifecycleOwner
• LifecycleService — layanan dengan siklus hidup
• ProcessLifecycleOwner — siklus hidup seluruh aplikasi
• LifecycleOwner Kustom — objek apa pun yang mengimplementasikan LifecycleOwner

Bagaimana lifecycleScope bekerja: Lifecycle dan pembatalan otomatis

Mekanisme pembatalan otomatis lifecycleScope didasarkan pada langganan peristiwa Lifecycle. Saat Lifecycle turun di bawah CREATED ke DESTROYED, scope dibatalkan.

Status Lifecycle

Struktur internal lifecycleScope

lifecycleScope dibuat sebagai CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) dan disimpan di dalam Lifecycle. Saat Lifecycle beralih ke status DESTROYED, scope.cancel() dipanggil. Mekanisme ini diimplementasikan melalui LifecycleEventObserver, yang berlangganan peristiwa siklus hidup saat pertama kali mengakses scope.

Perilaku saat rotasi

Saat rotasi layar, Activity dihancurkan (onDestroy) dan dibuat ulang. lifecycleScope dibatalkan bersama Activity lama, dan instance scope baru dibuat untuk Activity baru. Ini adalah perbedaan mendasar dari viewModelScope, yang dipertahankan saat rotasi.

API lifecycleScope: launch, launchWhen dan repeatOnLifecycle

Pustaka lifecycle menyediakan beberapa cara untuk menjalankan korutin melalui lifecycleScope. Mari kita lihat evolusi API dari metode usang ke modern.

lifecycleScope.launch — peluncuran dasar

Cara paling sederhana — lifecycleScope.launch { ... }. Korutin segera dimulai dan dibatalkan saat DESTROYED. Namun, ia dapat mengeksekusi kode bahkan ketika UI tidak terlihat (misalnya, di latar belakang setelah onStop). Ini tidak selalu diinginkan.

Usang: launchWhenCreated / launchWhenStarted / launchWhenResumed

Metode ini menjeda eksekusi korutin saat Lifecycle turun di bawah status yang ditentukan dan melanjutkannya saat kembali. Namun, metode ini ditandai sebagai @Deprecated di lifecycle-runtime-ktx 2.6.0, karena:

• Tidak membatalkan korutin — hanya menjeda
• Menyebabkan akumulasi korutin yang menggantung dan memakan memori
• Menciptakan race condition saat pergantian status yang cepat

API modern: repeatOnLifecycle

repeatOnLifecycle — cara yang direkomendasikan Google untuk menjalankan korutin yang disinkronkan dengan siklus hidup. Ini membatalkan dan memulai ulang korutin setiap kali Lifecycle mencapai status yang ditentukan.

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.uiState.collect { state ->
            updateUI(state)
        }
    }
}

Korutin yang diteruskan ke repeatOnLifecycle dimulai saat Lifecycle mencapai STARTED dan dibatalkan saat turun di bawah STARTED. Saat kembali ke STARTED, korutin dimulai ulang dari awal. Ini aman dan efisien — tidak ada korutin yang menggantung dalam jeda.

flowWithLifecycle — untuk Flow

Untuk mengumpulkan data dari Flow dengan mempertimbangkan siklus hidup, ada operator flowWithLifecycle. Operator ini secara otomatis menghentikan dan melanjutkan pengumpulan saat status Lifecycle berubah:

viewModel.uiState
    .flowWithLifecycle(lifecycle, Lifecycle.State.STARTED)
    .onEach { state -> updateUI(state) }
    .launchIn(lifecycleScope)

Operator flowWithLifecycle — cara paling ringkas untuk berlangganan Flow dengan aman di lapisan UI.

Contoh penggunaan lifecycleScope

Mari kita lihat tiga skenario nyata penggunaan lifecycleScope di aplikasi Android dalam Kotlin.

Contoh 1: Berlangganan pembaruan lokasi hanya saat layar terlihat

class MapFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                locationProvider.observeLocation().collect { loc ->
                    updateMapMarker(loc)
                }
            }
        }
    }
}

Korutin dimulai saat fragmen menjadi terlihat (STARTED) dan dibatalkan saat meninggalkan layar (STOPPED). Jika pengguna beralih ke aplikasi lain, pembaruan lokasi tidak menghabiskan baterai.

Contoh 2: Menjalankan animasi saat fragmen dimulai

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.RESUMED) {
        animateFadeIn(titleView)
        delay(200)
        animateSlideUp(contentView)
    }
}

Animasi dimulai hanya saat fragmen di latar depan (RESUMED). Jika pengguna meminimalkan aplikasi selama animasi, korutin dibatalkan, dan saat kembali animasi dimulai ulang.

Contoh 3: Sinkronisasi data periodik di layar yang terlihat

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        while (isActive) {
            syncData()
            delay(30_000L)
        }
    }
}

Data disinkronkan setiap 30 detik, tetapi hanya saat layar terlihat. isActive memeriksa apakah korutin tidak dibatalkan, memastikan keluar yang aman dari loop saat meninggalkan layar.

lifecycleScope vs viewModelScope: skenario penerapan

Kedua scope terikat pada siklus hidup, tetapi pada aspek yang berbeda. Memahami perbedaannya sangat penting untuk arsitektur aplikasi Android yang benar.

Perbedaan utama

viewModelScope terikat pada ViewModel, yang bertahan dari rotasi layar. lifecycleScope terikat pada LifecycleOwner (Activity/Fragment), yang saat rotasi dihancurkan dan dibuat ulang. Ini menentukan skenario penerapannya.

Kapan menggunakan lifecycleScope

• Berlangganan peristiwa sistem (lokasi, sensor, kamera)
• Animasi dan efek UI yang terikat pada layar tertentu
• Memuat data secara bertahap dengan mempertimbangkan visibilitas layar
• Operasi yang harus berhenti saat meninggalkan layar

Kapan menggunakan viewModelScope

• Memuat data dari Repository
• Logika bisnis yang harus bertahan dari rotasi
• Caching dan pemrosesan data
• Operasi apa pun yang hasilnya diperlukan setelah rotasi

Penggunaan gabungan

Dalam praktiknya, kombinasi kedua scope sering ditemui: viewModelScope memuat data dan mengelola status, lifecycleScope berlangganan Flow dari ViewModel dengan mempertimbangkan siklus hidup layar. Pemisahan tanggung jawab ini dianggap sebagai best practice dalam pengembangan Android modern.

Kesalahan umum saat bekerja dengan lifecycleScope

Mari kita lihat empat kesalahan paling umum yang dilakukan pengembang saat menggunakan lifecycleScope.

Kesalahan 1: Menggunakan lifecycleScope alih-alih viewModelScope untuk memuat data

Jika Anda memulai pemuatan data di lifecycleScope.launch, saat rotasi layar korutin akan dibatalkan dan data harus dimuat ulang. Gunakan viewModelScope untuk operasi berumur panjang. lifecycleScope — hanya untuk tugas terkait UI.

Kesalahan 2: Mengumpulkan Flow tanpa repeatOnLifecycle

Panggilan langsung viewModel.someFlow.collect { ... } di dalam lifecycleScope.launch terus mengumpulkan data bahkan saat layar tidak terlihat. Ini dapat menyebabkan pembaruan UI di latar belakang dan overhead yang tidak perlu. Selalu gunakan repeatOnLifecycle atau flowWithLifecycle.

Kesalahan 3: Lupa pembatalan saat meninggalkan layar

Meskipun lifecycleScope dibatalkan saat DESTROYED, kode setelah titik jeda (suspend) mungkin tidak dijalankan saat pembatalan mendadak. Jangan mengandalkan eksekusi kode setelah panggilan suspend, kecuali jika Anda menggunakan NonCancellable.

Kesalahan 4: Menggunakan launchWhenStarted usang alih-alih repeatOnLifecycle

launchWhenStarted dan analognya tidak membatalkan korutin, hanya menjedanya. Jika layar sering beralih antara latar depan dan latar belakang, korutin mengakumulasi panggilan yang ditunda. Beralihlah ke repeatOnLifecycle — ini adalah satu-satunya cara yang benar untuk sinkronisasi dengan Lifecycle.