Android Academy · Lekcja

ViewModel i LiveData

Przetrwaj zmiany konfiguracji dzięki ViewModel. Udostępniaj reaktywne strumienie danych za pomocą LiveData i obserwuj je w Activities oraz Fragments.

ViewModel i LiveData to bezpłatna lekcja Android Academy na CoddyKit. To lekcja 1 z 6. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Android Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Android Academy zawiera 6 lekcji w sumie.

Problem z Activity

Bezpośrednie przechowywanie danych w Activity wiąże się z dwoma głównymi problemami:

Po obróceniu telefonu Activity zostaje zniszczone i utworzone ponownie — wszystkie dane zostają utracone
Jeśli dane z sieci są pobierane w onCreate, po każdym obrocie są pobierane ponownie — to niepotrzebne obciążenie

ViewModel rozwiązuje oba problemy.

Czym jest ViewModel?

ViewModel to komponent architektury Androida, który:

przetrwa zmiany konfiguracji (obrót ekranu, zmiana motywu)
przechowuje dane związane z interfejsem użytkownika i logikę biznesową
jest niszczony dopiero wtedy, gdy użytkownik na stałe opuszcza ekran

Zasada praktyczna: jeśli dane powinny przetrwać obrót ekranu, należy umieścić je w ViewModel.

Tworzenie ViewModel

Proszę rozszerzyć ViewModel i dodać go do zależności 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
    }
}

Pobieranie ViewModel w Activity

Proszę użyć ViewModelProvider (lub delegata by viewModels()), aby uzyskać instancję 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()
        }
    }
}

Czym jest LiveData?

LiveData to obserwowalny kontener danych. Interfejs użytkownika obserwuje wartości LiveData i automatycznie się aktualizuje, gdy wartość ulegnie zmianie.

Świadomość cyklu życia — aktualizuje tylko aktywnych obserwatorów (brak awarii, gdy Activity działa w tle)
Zawsze aktualne dane — nowi obserwatorzy natychmiast otrzymują najnowszą wartość

LiveData w ViewModel

Proszę używać prywatnie MutableLiveData (ViewModel może zapisywać dane), a publicznie udostępniać je jako LiveData (interfejs użytkownika może je tylko obserwować):

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

Obserwowanie LiveData w Activity

Proszę wywołać .observe(lifecycleOwner) { value -> }, aby reagować na zmiany:

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 a State Flow

LiveData to klasyczne podejście. We współczesnym kodzie Kotlin często zamiast niego używa się StateFlow z Kotlin Coroutines:

StateFlow — rozwiązanie oparte na korutynach, bez zależności od Androida
Zbieranie danych za pomocą repeatOnLifecycle w Activity
Lepsze rozwiązanie do złożonego zarządzania stanem

Oba rozwiązania działają dobrze — z LiveData łatwiej zacząć, natomiast StateFlow jest często spotykany w większych aplikacjach.

ViewModel z wieloma obserwatorami

Wiele komponentów interfejsu użytkownika może obserwować to samo LiveData. Na przykład zarówno TextView, jak i stan aktywności przycisku mogą reagować na tę samą wartość danych w ViewModel — bez dodawania jakiegokolwiek kodu w ViewModel.

Umożliwia to przejrzysty podział odpowiedzialności: ViewModel przechowuje stan, a interfejs użytkownika tylko go obserwuje i renderuje.

Szybkie sprawdzenie

Kiedy ViewModel jest niszczony?

Podsumowanie: ViewModel i LiveData

Potrafią już Państwo tworzyć interfejsy użytkownika świadome cyklu życia:

ViewModel przetrwa zmiany konfiguracji (obrót ekranu)
Proszę użyć by viewModels(), aby uzyskać ViewModel w Activity
Wzorzec MutableLiveData (prywatne) / LiveData (publiczne)
Obserwowanie za pomocą .observe(this) { value -> updateUI(value) }
Interfejs użytkownika aktualizuje się automatycznie — nie jest potrzebne ręczne odświeżanie

Następnie: trwałe przechowywanie danych za pomocą bazy Room.

Często zadawane pytania

Czy lekcja „ViewModel i LiveData” jest bezpłatna?

Tak — pełny tekst „ViewModel i LiveData” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Android Academy, przejdź na CoddyKit PRO. Kurs Android Academy zawiera 6 lekcji w sumie.

Co nauczysz się w „ViewModel i LiveData”?

Przetrwaj zmiany konfiguracji dzięki ViewModel. Udostępniaj reaktywne strumienie danych za pomocą LiveData i obserwuj je w Activities oraz Fragments. Ćwiczysz Android Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Android Academy?

Nie wymagamy żadnego doświadczenia. Android Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 6.

Ile czasu zajmuje lekcja „ViewModel i LiveData”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Android Academy?

Tak. Każda lekcja Android Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Android Academy