Android Academy · Lektion

ViewModel och LiveData

Överlev konfigurationsändringar med ViewModel. Exponera reaktiva dataströmmar med LiveData och observera dem i Activities och Fragments.

Lektion 1 av 611 steg

ViewModel och LiveData är en gratis lektion i Android Academy på CoddyKit. Detta är lektion 1 av 6. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Android Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Android Academy innehåller totalt 6 lektioner.

Problemet med Activities

Att lagra data direkt i en Activity har två stora problem:

När användaren roterar telefonen förstörs och återskapas Activity — all data går förlorad
Om du hämtar data från nätverket i onCreate hämtas den på nytt vid varje rotation — slöseri med resurser

ViewModel löser båda problemen.

Vad är ViewModel?

ViewModel är en Android Architecture Component som:

Överlever konfigurationsändringar (rotation, temabyte)
Innehåller användargränssnittsrelaterade data och affärslogik
Förstörs först när användaren lämnar skärmen permanent

En tumregel: om data ska överleva en rotation ska du placera den i en ViewModel.

Skapa en ViewModel

Ärv från ViewModel och lägg till den i dina Gradle-beroenden:

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

Hämta en ViewModel i Activity

Använd ViewModelProvider (eller delegaten by viewModels()) för att hämta en ViewModel-instans:

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

Vad är LiveData?

LiveData är en observerbar datahållare. Användargränssnittet observerar LiveData-värden och uppdateras automatiskt när värdet ändras.

Livscykelmedveten — uppdaterar endast aktiva observatörer (inga krascher när Activity körs i bakgrunden)
Alltid aktuell — nya observatörer får det senaste värdet direkt

LiveData i ViewModel

Använd MutableLiveData privat (ViewModel kan skriva) och exponera det som LiveData offentligt (användargränssnittet kan endast observera):

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

Observera LiveData i Activity

Anropa .observe(lifecycleOwner) { value -> } för att reagera på ändringar:

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 jämfört med State Flow

LiveData är det klassiska tillvägagångssättet. Modern Kotlin-kod använder ofta i stället StateFlow från Kotlin Coroutines:

StateFlow — coroutine-baserat, utan beroende av Android
Samlas in med repeatOnLifecycle i Activity
Bättre för komplex tillståndshantering

Båda fungerar bra — LiveData är enklare att komma igång med; StateFlow används ofta i större appar.

ViewModel med flera observatörer

Flera användargränssnittskomponenter kan observera samma LiveData. Till exempel kan både en TextView och en Buttons aktiveringsstatus reagera på samma datavärde i ViewModel — utan någon extra kod i ViewModel.

Detta separerar ansvarsområden på ett tydligt sätt: ViewModel innehåller tillståndet, medan användargränssnittet endast observerar och återger det.

Snabbtest

När förstörs en ViewModel?

Besvara frågan i den interaktiva lektionen

Sammanfattning: ViewModel och LiveData

Nu vet du hur du bygger användargränssnitt som tar hänsyn till livscykeln:

ViewModel överlever konfigurationsändringar (rotation)
Använd by viewModels() för att hämta en ViewModel i en Activity
Mönstret MutableLiveData (privat) / LiveData (offentligt)
Observera med .observe(this) { value -> updateUI(value) }
Användargränssnittet uppdateras automatiskt — ingen manuell uppdatering behövs

Nästa steg: lagra data permanent med Room-databasen.

Gratis att börja

Lär dig Kotlin med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 36
Lektioner: 152

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”ViewModel och LiveData” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Android Academy, inklusive ”ViewModel och LiveData”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Android Academy innehåller totalt 6 lektioner.

Vad lär jag mig i ”ViewModel och LiveData”?

Överlev konfigurationsändringar med ViewModel. Exponera reaktiva dataströmmar med LiveData och observera dem i Activities och Fragments. Ni övar på Android Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Android Academy?

Du behöver inga förkunskaper. Utbildningen i Android Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 6.

Hur lång tid tar lektionen ”ViewModel och LiveData”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Android Academy-lektionen?

Ja. Varje Android Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Android Academy