lifecycleScope — vad det är, koppling till Lifecycle och arbete i Android

Vad är lifecycleScope i Android?

lifecycleScope — är en utökningsegenskap på gränssnittet LifecycleOwner (Activity, Fragment, Service) som tillhandahåller en färdig CoroutineScope kopplad till komponentens fulla livscykel. När LifecycleOwner når tillståndet DESTROYED annullerar lifecycleScope automatiskt alla aktiva korutiner.

// I Fragment eller Activity
lifecycleScope.launch {
    delay(1000)
    showSnackbar("Hej!")
}

Till skillnad från viewModelScope annulleras lifecycleScope vid varje förstöring av LifecycleOwner — inklusive skärmrotation. Detta gör den idealisk för operationer som bara ska leva så länge en specifik skärm är synlig.

Var är lifecycleScope tillgängligt

lifecycleScope är tillgängligt överallt där det finns en LifecycleOwner:

• Activity — AppCompatActivity ärver LifecycleOwner
• Fragment — Fragment ärver LifecycleOwner
• LifecycleService — tjänst med livscykel
• ProcessLifecycleOwner — hela applikationens livscykel
• Anpassad LifecycleOwner — alla objekt som implementerar LifecycleOwner

Hur lifecycleScope fungerar: Lifecycle och automatisk annullering

Mekanismen för automatisk annullering av lifecycleScope är baserad på prenumeration på Lifecycle-händelser. När Lifecycle sjunker under CREATED till DESTROYED annulleras scopen.

Lifecycle-tillstånd

Inre struktur av lifecycleScope

lifecycleScope skapas som CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) och lagras inuti Lifecycle. När Lifecycle övergår till tillståndet DESTROYED anropas scope.cancel(). Mekanismen implementeras via LifecycleEventObserver, som prenumererar på livscykelhändelser vid första åtkomst till scopen.

Beteende vid rotation

Vid skärmrotation förstörs Activity (onDestroy) och skapas på nytt. lifecycleScope annulleras tillsammans med den gamla Activity och en ny instans av scopen skapas för den nya Activity. Detta är en grundläggande skillnad från viewModelScope, som bevaras vid rotation.

lifecycleScope API: launch, launchWhen och repeatOnLifecycle

Lifecycle-biblioteket erbjuder flera sätt att starta korutiner via lifecycleScope. Låt oss titta på API-utvecklingen från föråldrade metoder till moderna.

lifecycleScope.launch — grundläggande start

Det enklaste sättet — lifecycleScope.launch { ... }. Korutinen startar omedelbart och annulleras vid DESTROYED. Den kan dock köra kod även när UI inte är synligt (t.ex. i bakgrunden efter onStop). Detta är inte alltid önskvärt.

Föråldrade: launchWhenCreated / launchWhenStarted / launchWhenResumed

Dessa metoder pausade korutinens exekvering när Lifecycle sjönk under det angivna tillståndet och återupptog vid återkomst. Men de markerades som @Deprecated i lifecycle-runtime-ktx 2.6.0, eftersom:

• De annullerade inte korutinen — bara pausade den
• De ledde till ackumulering av hängande korutiner som förbrukar minne
• De skapade race condition vid snabb växling av tillstånd

Modernt API: repeatOnLifecycle

repeatOnLifecycle — det av Google rekommenderade sättet att starta korutiner synkroniserade med livscykeln. Den annullerar och startar om korutinen varje gång Lifecycle når ett specificerat tillstånd.

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

Korutinen som skickas till repeatOnLifecycle startar när Lifecycle når STARTED och annulleras när den sjunker under STARTED. Vid återkomst till STARTED startas korutinen om från början. Detta är säkert och effektivt — inga korutiner hänger i paus.

flowWithLifecycle — för Flow

För insamling av data från Flow med hänsyn till livscykeln finns operatorn flowWithLifecycle. Den stoppar och återupptar automatiskt insamlingen när Lifecycle-tillståndet ändras:

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

Operatorn flowWithLifecycle — det mest koncisa sättet för säker prenumeration på Flow i UI-lagret.

Exempel på användning av lifecycleScope

Låt oss titta på tre verkliga scenarier för användning av lifecycleScope i en Android-app i Kotlin.

Exempel 1: Prenumeration på platsuppdateringar endast när skärmen är synlig

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

Korutinen startar när fragmentet blir synligt (STARTED) och annulleras när det lämnar skärmen (STOPPED). Om användaren växlar till en annan app förbrukar platsuppdateringarna inte batteri.

Exempel 2: Starta animering vid fragmentets start

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

Animeringen startar endast när fragmentet är i förgrunden (RESUMED). Om användaren minimerar appen under animeringen annulleras korutinen, och vid återkomst startas animeringen om.

Exempel 3: Periodisk datasynkronisering på synlig skärm

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

Data synkroniseras var 30:e sekund, men endast när skärmen är synlig. isActive kontrollerar om korutinen inte har annullerats, vilket säkerställer säker utträde ur loopen när skärmen lämnas.

lifecycleScope vs viewModelScope: användningsscenarier

Båda scoperna är kopplade till livscykeln, men till olika aspekter av den. Att förstå skillnaden är avgörande för korrekt arkitektur av Android-applikationer.

Viktig skillnad

viewModelScope är kopplad till ViewModel, som överlever skärmrotation. lifecycleScope är kopplad till LifecycleOwner (Activity/Fragment), som vid rotation förstörs och skapas på nytt. Detta bestämmer deras användningsscenarier.

När ska man använda lifecycleScope

• Prenumeration på systemhändelser (plats, sensorer, kamera)
• Animeringar och UI-effekter kopplade till en specifik skärm
• Bitvis dataladdning med hänsyn till skärmens synlighet
• Operationer som bör upphöra när skärmen lämnas

När ska man använda viewModelScope

• Dataladdning från Repository
• Affärslogik som måste överleva rotation
• Cachning och databearbetning
• Alla operationer vars resultat behövs efter rotation

Kombinerad användning

I praktiken är kombinationen av båda scoperna vanlig: viewModelScope laddar data och hanterar tillstånd, lifecycleScope prenumererar på Flow från ViewModel med hänsyn till skärmens livscykel. Denna ansvarsuppdelning anses vara best practice inom modern Android-utveckling.

Vanliga misstag vid arbete med lifecycleScope

Låt oss titta på fyra vanliga misstag som utvecklare gör vid användning av lifecycleScope.

Misstag 1: Användning av lifecycleScope istället för viewModelScope för dataladdning

Om du startar dataladdning i lifecycleScope.launch kommer korutinen att annulleras vid skärmrotation och data måste laddas om. Använd viewModelScope för långvariga operationer. lifecycleScope — endast för UI-relaterade uppgifter.

Misstag 2: Insamling av Flow utan repeatOnLifecycle

Direktanrop av viewModel.someFlow.collect { ... } inuti lifecycleScope.launch fortsätter att samla in data även när skärmen inte är synlig. Detta kan leda till UI-uppdateringar i bakgrunden och onödig overhead. Använd alltid repeatOnLifecycle eller flowWithLifecycle.

Misstag 3: Glömma annullering när skärmen lämnas

Även om lifecycleScope annulleras vid DESTROYED, kan koden efter en suspend-punkt kanske inte köras vid plötslig annullering. Lita inte på att kod körs efter ett suspend-anrop, om du inte använder NonCancellable.

Misstag 4: Användning av föråldrad launchWhenStarted istället för repeatOnLifecycle

launchWhenStarted och dess analoger annullerar inte korutinen, bara pausar den. Om skärmen växlar flera gånger mellan förgrund och bakgrund ackumulerar korutinen uppskjutna anrop. Byt till repeatOnLifecycle — det är det enda korrekta sättet att synkronisera med Lifecycle.