Android Academy · Pelajaran

ViewModel & LiveData

Pertahankan data saat terjadi perubahan konfigurasi dengan ViewModel. Sediakan aliran data reaktif menggunakan LiveData dan amati di Activity serta Fragment.

ViewModel & LiveData adalah pelajaran Android Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 6. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Android Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Android Academy mencakup 6 pelajaran total.

Masalah dengan Activity

Menyimpan data secara langsung di Activity memiliki dua masalah utama:

Saat pengguna memutar ponsel, Activity dihancurkan dan dibuat ulang — semua data Anda hilang
Jika Anda mengambil data dari jaringan dalam onCreate, data akan diambil ulang setiap kali layar diputar — tidak efisien

ViewModel mengatasi kedua masalah tersebut.

Apa Itu ViewModel?

ViewModel adalah Komponen Arsitektur Android yang:

Bertahan saat terjadi perubahan konfigurasi (rotasi, perubahan tema)
Menyimpan data terkait UI dan logika bisnis
Hanya dihancurkan saat pengguna meninggalkan layar secara permanen

Aturan praktis: jika data harus bertahan saat rotasi, simpan data tersebut di ViewModel.

Membuat ViewModel

Perluas ViewModel dan tambahkan ke dependensi Gradle:

// app/build.gradle:
// implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0'
// implementation 'androidx.lifecycle:lifecycle-livedata-ktx:2.7.0'

import androidx.lifecycle.ViewModel

class CounterViewModel : ViewModel() {

    var count = 0
        private set

    fun increment() {
        count++
    }

    fun reset() {
        count = 0
    }
}

Mendapatkan ViewModel di Activity

Gunakan ViewModelProvider (atau delegasi by viewModels()) untuk mendapatkan instans ViewModel:

import androidx.activity.viewModels

class CounterActivity : AppCompatActivity() {

    private lateinit var binding: ActivityCounterBinding
    // Android manages the ViewModel lifecycle — never instantiate it yourself
    private val viewModel: CounterViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityCounterBinding.inflate(layoutInflater)
        setContentView(binding.root)

        // This shows the count is preserved after rotation!
        binding.tvCount.text = viewModel.count.toString()

        binding.btnPlus.setOnClickListener {
            viewModel.increment()
            binding.tvCount.text = viewModel.count.toString()
        }
    }
}

Apa Itu LiveData?

LiveData adalah wadah data yang dapat diamati. UI mengamati nilai LiveData dan diperbarui secara otomatis saat nilainya berubah.

Menyadari siklus hidup — hanya memperbarui pengamat yang aktif (tidak terjadi kerusakan saat Activity berada di latar belakang)
Selalu terbaru — pengamat baru langsung mendapatkan nilai terbaru

LiveData di ViewModel

Gunakan MutableLiveData secara privat (ViewModel dapat menulis), lalu sediakan sebagai LiveData secara publik (UI hanya dapat mengamati):

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel

class CounterViewModel : ViewModel() {

    private val _count = MutableLiveData(0)
    val count: LiveData<Int> = _count  // read-only for the UI

    fun increment() {
        _count.value = (_count.value ?: 0) + 1
    }

    fun reset() {
        _count.value = 0
    }
}

Mengamati LiveData di Activity

Panggil .observe(lifecycleOwner) { value -> } untuk merespons perubahan:

class CounterActivity : AppCompatActivity() {

    private val viewModel: CounterViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ...

        // Automatically updates TextView whenever count changes
        viewModel.count.observe(this) { count ->
            binding.tvCount.text = count.toString()
        }

        binding.btnPlus.setOnClickListener { viewModel.increment() }
        binding.btnReset.setOnClickListener { viewModel.reset() }
    }
}

LiveData vs State Flow

LiveData adalah pendekatan klasik. Kode Kotlin modern sering menggunakan StateFlow dari Kotlin Coroutines sebagai gantinya:

StateFlow — berbasis coroutine, tanpa dependensi Android
Dikumpulkan dengan repeatOnLifecycle di Activity
Lebih baik untuk pengelolaan status yang kompleks

Keduanya bekerja dengan baik — LiveData lebih sederhana untuk memulai; Anda akan melihat StateFlow di aplikasi yang lebih besar.

ViewModel dengan Beberapa Pengamat

Beberapa komponen UI dapat mengamati LiveData yang sama. Misalnya, TextView dan status aktif Button dapat merespons nilai data yang sama di ViewModel — tanpa kode tambahan apa pun di ViewModel.

Dengan demikian, tanggung jawab terpisah dengan jelas: ViewModel menyimpan status, sedangkan UI hanya mengamati dan merender.

Pemeriksaan Singkat

Kapan ViewModel dihancurkan?

Ringkasan: ViewModel & LiveData

Sekarang Anda sudah mengetahui cara membuat UI yang menyadari siklus hidup:

ViewModel bertahan saat terjadi perubahan konfigurasi (rotasi)
Gunakan by viewModels() untuk mendapatkan ViewModel di Activity
Pola MutableLiveData (privat) / LiveData (publik)
Amati dengan .observe(this) { value -> updateUI(value) }
UI diperbarui secara otomatis — tidak diperlukan penyegaran manual

Berikutnya: simpan data secara permanen dengan basis data Room.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “ViewModel & LiveData” gratis?

Ya — teks lengkap “ViewModel & LiveData” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Android Academy, upgrade ke CoddyKit PRO. Kursus Android Academy mencakup 6 pelajaran total.

Apa yang akan aku pelajari di “ViewModel & LiveData”?

Pertahankan data saat terjadi perubahan konfigurasi dengan ViewModel. Sediakan aliran data reaktif menggunakan LiveData dan amati di Activity serta Fragment. Kamu berlatih Android Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Android Academy?

Tidak diperlukan pengalaman sebelumnya. Android Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 6.

Berapa lama pelajaran “ViewModel & LiveData” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Android Academy ini?

Ya. Setiap pelajaran Android Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Android Academy