viewModelScope: apa itu, keterkaitan dengan ViewModel dan kerja di Android

Apa itu viewModelScope di Android?

viewModelScope — adalah properti ekstensi (extension property) pada antarmuka ViewModel, ditambahkan di pustaka lifecycle-viewmodel-ktx (sejak versi 2.1.0). Ini menyediakan CoroutineScope siap pakai yang terikat pada siklus hidup ViewModel.

// Struktur internal (disederhanakan)
val ViewModel.viewModelScope: CoroutineScope
    get() {
        val scope = this.getTag(JOB_KEY)
        if (scope != null) return scope
        return CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
            .also { setTag(JOB_KEY, it) }
    }

Scope dibuat secara malas (lazy) saat akses pertama dan di-cache melalui setTag. SupervisorJob digunakan, yang berarti pengecualian di satu coroutine anak tidak membatalkan yang lain. Dispatcher default adalah Dispatchers.Main.immediate, yang mengeksekusi kode di thread utama tanpa dispatch tambahan jika panggilan sudah di Main.

Bagaimana viewModelScope menerima notifikasi pembersihan

Ketika ViewModel meninggalkan siklus hidup (Activity selesai atau Fragment dihapus), sistem memanggil clear(), yang memicu onCleared(). Dalam callback ini, viewModelScope membatalkan Job-nya, yang secara rekursif mengakhiri semua coroutine aktif. Mekanismenya diimplementasikan melalui antarmuka Closeable, di mana Job scope didaftarkan sebagai sumber daya untuk penutupan otomatis.

Cara kerja viewModelScope: keterkaitan dengan siklus hidup ViewModel

Mekanisme pengikatan viewModelScope ke siklus hidup ViewModel didasarkan pada penandaan dan callback onCleared. Mari kita lihat langkah demi langkah cara kerjanya.

Langkah 1: Pembuatan scope saat akses pertama

Ketika ViewModel menjalankan viewModelScope.launch { ... }, getter memeriksa apakah ada scope yang disimpan di bawah tag JOB_KEY. Jika scope belum dibuat — instance baru CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) dibuat. Scope disimpan di dalam ViewModel melalui peta tag internal.

Langkah 2: Siklus hidup coroutine

Semua coroutine yang dijalankan melalui viewModelScope.launch atau viewModelScope.async menjadi anak dari SupervisorJob scope. Mereka berjalan di thread utama (jika tidak ada dispatcher lain yang ditentukan melalui withContext). Selama ViewModel hidup — coroutine bisa aktif, ditangguhkan, atau selesai.

Langkah 3: Pembatalan saat onCleared

Ketika sistem menghancurkan ViewModel, ViewModel.clear() dipanggil. Di dalam clear() terjadi hal berikut:

• Pemanggilan onCleared() untuk logika pengguna
• Penutupan semua sumber daya Closeable yang didaftarkan melalui addCloseable
• Job viewModelScope beralih ke status Cancelled
• Semua coroutine anak dibatalkan secara rekursif
• Pembebasan referensi ke scope untuk garbage collector

Ketahanan terhadap rotasi layar

Saat rotasi layar, Activity dibuat ulang, tetapi ViewModel dipertahankan (berkat ViewModelStoreOwner). Ini berarti viewModelScope tetap aktif, dan coroutine terus berjalan tanpa gangguan. Setelah pembuatan ulang Activity, ViewModel yang sama (dan scope yang sama) digunakan kembali — pemuatan data tidak dimulai dari awal.

viewModelScope dalam arsitektur MVVM

MVVM (Model-View-ViewModel) — adalah arsitektur yang direkomendasikan Google untuk aplikasi Android. viewModelScope menempati posisi sentral di dalamnya sebagai pelaksana operasi asinkron.

Peran viewModelScope dalam lapisan arsitektur

ViewModel melalui viewModelScope menjalankan coroutine, di dalamnya memanggil fungsi suspend Repository. Hasilnya diubah menjadi StateFlow, yang diamati oleh lapisan UI. Skema ini memastikan pemisahan tanggung jawab yang jelas dan kemampuan pengujian setiap lapisan secara independen.

Mengapa viewModelScope di ViewModel, bukan di Fragment

Jika coroutine dijalankan dari Fragment, saat rotasi layar mereka akan dibatalkan bersamaan dengan penghancuran Fragment. ViewModel bertahan dari rotasi, sehingga coroutine yang dijalankan dalam scope-nya terus berlangsung. Ini adalah keunggulan utama viewModelScope dibandingkan lifecycleScope saat memuat data.

Contoh penggunaan viewModelScope

Mari kita lihat tiga skenario praktis penggunaan viewModelScope dalam aplikasi Android dengan Kotlin.

Contoh 1: Memuat data saat pembuatan ViewModel

class ProfileViewModel(
    private val repo: ProfileRepository
) : ViewModel() {

    private val _profile = MutableStateFlow<Profile?>(null)
    val profile: StateFlow<Profile?> = _profile

    init {
        loadProfile()
    }

    private fun loadProfile() {
        viewModelScope.launch {
            val result = repo.getProfile()
            _profile.value = result
        }
    }
}

Di blok init, pemuatan profil segera dimulai. Coroutine berjalan di thread utama (secara default). Repositori menggunakan withContext(Dispatchers.IO) untuk permintaan jaringan di dalam fungsi suspend-nya, sehingga ViewModel tidak perlu memikirkan perpindahan thread.

Contoh 2: Penanganan kesalahan melalui sealed class

sealed class UiState {
    object Loading : UiState()
    data class Success(val data: List<Item>) : UiState()
    data class Error(val message: String) : UiState()
}

fun fetchItems() {
    _state.value = UiState.Loading
    viewModelScope.launch {
        try {
            val items = repo.getItems()
            _state.value = UiState.Success(items)
        } catch (e: Exception) {
            _state.value = UiState.Error(e.message ?: "Unknown error")
        }
    }
}

Status UI dijelaskan melalui sealed class UiState. ViewModel memperbarui state pada setiap perubahan. Fragment berlangganan ke StateFlow dan hanya bereaksi terhadap status saat ini, mengabaikan panggilan usang pada rotasi berulang.

Contoh 3: Pembatalan coroutine sebelumnya saat permintaan baru

private var searchJob: Job? = null

fun search(query: String) {
    searchJob?.cancel()
    searchJob = viewModelScope.launch {
        delay(300)
        val results = repo.search(query)
        _searchResults.value = results
    }
}

Pada setiap permintaan pencarian baru, coroutine sebelumnya dibatalkan. delay(300) mengimplementasikan debounce — pencarian dilakukan hanya setelah jeda 300 ms dalam input. Ini mengurangi beban server dan mencegah hasil usang.

viewModelScope vs lifecycleScope: kapan memilih apa

Kedua scope disediakan oleh pustaka AndroidX Lifecycle, tetapi terikat pada siklus hidup yang berbeda. Pilihan di antara mereka tergantung pada jenis tugas.

Perbandingan scope

Rekomendasi Google

Google merekomendasikan penggunaan viewModelScope untuk semua tugas yang terkait dengan pemuatan dan pemrosesan data. lifecycleScope harus diterapkan untuk operasi yang terikat pada momen tertentu dari kehidupan UI — misalnya, memulai animasi saat pertama kali layar muncul atau berlangganan pembaruan Location yang harus berhenti saat meninggalkan layar.

Kesalahan umum saat bekerja dengan viewModelScope

Bahkan di API Android yang terdokumentasi dengan baik, pengembang membuat kesalahan karakteristik. Mari kita lihat empat masalah paling umum.

Kesalahan 1: Memperbarui UI setelah pembatalan scope

Kesalahan paling berbahaya — mencoba memperbarui StateFlow atau LiveData setelah ViewModel dibersihkan. Meskipun viewModelScope dibatalkan saat onCleared(), coroutine dapat mengeksekusi kode hingga saat pembatalan yang sebenarnya. Gunakan isActive untuk pemeriksaan atau andalkan penyelesaian blok catch.

Kesalahan 2: Menjalankan coroutine tanpa mempertimbangkan SupervisorJob

viewModelScope secara internal menggunakan SupervisorJob, yang mengisolasi kesalahan antar coroutine. Tetapi jika Anda menjalankan coroutine dengan Job() sendiri di dalam viewModelScope.launch, coroutine tersebut menjadi anak dari SupervisorJob, tetapi tidak akan dilindungi dari pembatalan saat terjadi kesalahan di coroutine lain.

Kesalahan 3: Terlalu banyak coroutine dalam satu scope

Meskipun viewModelScope tidak memiliki batasan ketat, ribuan coroutine aktif dapat memperlambat sistem. Untuk daftar data yang panjang, gunakan Flow dengan collectLatest daripada membuat coroutine terpisah untuk setiap elemen.

Kesalahan 4: Menggunakan GlobalScope alih-alih viewModelScope

Jika Anda secara tidak sengaja mengimpor GlobalScope alih-alih viewModelScope, coroutine tidak akan dibatalkan saat pembersihan ViewModel. Ini menyebabkan kebocoran memori dan potensi crash. Selalu periksa bahwa coroutine dijalankan melalui viewModelScope, terutama di fragment turunan.