lifecycleScope — was es ist, Bindung an Lifecycle und Arbeiten in Android

Was ist lifecycleScope in Android?

lifecycleScope ist eine Erweiterungseigenschaft auf dem LifecycleOwner-Interface (Activity, Fragment, Service), die einen fertigen CoroutineScope bereitstellt, der an den vollständigen Lebenszyklus der Komponente gebunden ist. Wenn der LifecycleOwner den Zustand DESTROYED erreicht, bricht lifecycleScope automatisch alle aktiven Coroutinen ab.

// In Fragment or Activity
lifecycleScope.launch {
    delay(1000)
    showSnackbar("Hallo!")
}

Im Gegensatz zu viewModelScope wird lifecycleScope jedes Mal abgebrochen, wenn der LifecycleOwner zerstört wird — einschließlich Bildschirmrotation. Dies macht es ideal für Operationen, die nur leben sollten, solange ein bestimmter Bildschirm sichtbar ist.

Wo lifecycleScope verfügbar ist

lifecycleScope ist überall dort verfügbar, wo es einen LifecycleOwner gibt:

• Activity — AppCompatActivity erbt von LifecycleOwner
• Fragment — Fragment erbt von LifecycleOwner
• LifecycleService — ein Dienst mit Lebenszyklus
• ProcessLifecycleOwner — der Lebenszyklus der gesamten Anwendung
• Benutzerdefinierter LifecycleOwner — jedes Objekt, das LifecycleOwner implementiert

Wie lifecycleScope funktioniert: Lifecycle und automatischer Abbruch

Der automatische Abbruchmechanismus von lifecycleScope basiert auf dem Abonnieren von Lifecycle-Ereignissen. Wenn der Lifecycle unter CREATED auf DESTROYED fällt, wird der Scope abgebrochen.

Lifecycle-Zustände

Interne Struktur von lifecycleScope

lifecycleScope wird als CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) erstellt und innerhalb des Lifecycle gespeichert. Wenn der Lifecycle in den Zustand DESTROYED übergeht, wird scope.cancel() aufgerufen. Der Mechanismus wird über LifecycleEventObserver implementiert, der beim ersten Zugriff auf den Scope Lebenszyklus-Ereignisse abonniert.

Verhalten bei Rotation

Wenn der Bildschirm gedreht wird, wird die Activity zerstört (onDestroy) und neu erstellt. lifecycleScope wird zusammen mit der alten Activity abgebrochen, und eine neue Scope-Instanz wird für die neue Activity erstellt. Dies ist ein grundlegender Unterschied zu viewModelScope, das bei Rotation erhalten bleibt.

lifecycleScope API: launch, launchWhen und repeatOnLifecycle

Die lifecycle-Bibliothek bietet mehrere Möglichkeiten, Coroutinen über lifecycleScope zu starten. Betrachten wir die Entwicklung der API von veralteten Methoden zu modernen.

lifecycleScope.launch — Grundlegender Start

Der einfachste Weg ist lifecycleScope.launch { ... }. Die Coroutine startet sofort und wird bei DESTROYED abgebrochen. Sie kann jedoch Code ausführen, selbst wenn die UI nicht sichtbar ist (z. B. im Hintergrund nach onStop). Dies ist nicht immer wünschenswert.

Veraltet: launchWhenCreated / launchWhenStarted / launchWhenResumed

Diese Methoden pausierten die Ausführung der Coroutine, wenn der Lifecycle unter den angegebenen Zustand fiel, und setzten sie bei Rückkehr fort. Sie wurden jedoch in lifecycle-runtime-ktx 2.6.0 als @Deprecated markiert, weil:

• Sie die Coroutine nicht abbrachen — nur pausierten
• Sie zur Ansammlung von pausierten Coroutinen führten, die Speicher verbrauchen
• Sie Wettlaufsituationen bei schnellen Zustandswechseln erzeugten

Moderne API: repeatOnLifecycle

repeatOnLifecycle ist die von Google empfohlene Methode zum Starten von mit dem Lebenszyklus synchronisierten Coroutinen. Sie bricht die Coroutine ab und startet sie jedes Mal neu, wenn der Lifecycle den angegebenen Zustand erreicht.

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

Die an repeatOnLifecycle übergebene Coroutine startet, wenn der Lifecycle STARTED erreicht, und wird abgebrochen, wenn er unter STARTED fällt. Bei Rückkehr zu STARTED wird die Coroutine von Grund auf neu gestartet. Dies ist sicher und effizient — keine Coroutinen bleiben pausiert.

flowWithLifecycle — Für Flow

Zum Sammeln von Daten aus Flow mit Lebenszyklusbewusstsein gibt es den Operator flowWithLifecycle. Er stoppt und setzt die Sammlung automatisch fort, wenn sich der Lifecycle-Zustand ändert:

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

Der Operator flowWithLifecycle ist die prägnanteste Möglichkeit, einen Flow in der UI-Ebene sicher zu abonnieren.

Beispiele für die Verwendung von lifecycleScope

Betrachten wir drei reale Szenarien für die Verwendung von lifecycleScope in einer Android-Anwendung mit Kotlin.

Beispiel 1: Standortaktualisierungen nur abonnieren, wenn der Bildschirm sichtbar ist

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

Die Coroutine startet, wenn das Fragment sichtbar wird (STARTED), und wird abgebrochen, wenn es den Bildschirm verlässt (STOPPED). Wenn der Benutzer zu einer anderen App wechselt, verbrauchen Standortaktualisierungen keinen Akku.

Beispiel 2: Starten einer Animation beim Fragment-Start

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

Die Animation läuft nur, wenn das Fragment im Vordergrund ist (RESUMED). Wenn der Benutzer die App während der Animation minimiert, wird die Coroutine abgebrochen, und bei Rückkehr startet die Animation neu.

Beispiel 3: Periodische Datensynchronisation auf einem sichtbaren Bildschirm

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

Daten werden alle 30 Sekunden synchronisiert, aber nur wenn der Bildschirm sichtbar ist. isActive prüft, ob die Coroutine abgebrochen wurde, und bietet einen sicheren Ausweg aus der Schleife beim Verlassen des Bildschirms.

lifecycleScope vs viewModelScope: Anwendungsszenarien

Beide Scopes sind an den Lebenszyklus gebunden, jedoch an unterschiedliche Aspekte. Das Verständnis des Unterschieds ist entscheidend für eine korrekte Android-Anwendungsarchitektur.

Hauptunterschied

viewModelScope ist an das ViewModel gebunden, das eine Bildschirmrotation überlebt. lifecycleScope ist an den LifecycleOwner (Activity/Fragment) gebunden, der bei Rotation zerstört und neu erstellt wird. Dies bestimmt die Anwendungsszenarien.

Wann lifecycleScope verwenden

• Abonnieren von Systemereignissen (Standort, Sensoren, Kamera)
• Animationen und UI-Effekte, die an einen bestimmten Bildschirm gebunden sind
• Chunk-weises Laden von Daten basierend auf Bildschirmsichtbarkeit
• Operationen, die beim Verlassen des Bildschirms gestoppt werden sollen

Wann viewModelScope verwenden

• Laden von Daten aus einem Repository
• Geschäftslogik, die eine Rotation überleben soll
• Daten-Caching und -Verarbeitung
• Alle Operationen, deren Ergebnis nach der Rotation benötigt wird

Kombinierte Verwendung

In der Praxis ist eine Kombination beider Scopes üblich: viewModelScope lädt Daten und verwaltet den Zustand, während lifecycleScope den Flow aus dem ViewModel mit Lebenszyklusbewusstsein abonniert. Diese Trennung der Verantwortlichkeiten gilt in der modernen Android-Entwicklung als Best Practice.

Häufige Fehler bei der Arbeit mit lifecycleScope

Betrachten wir vier der häufigsten Fehler, die Entwickler bei der Verwendung von lifecycleScope machen.

Fehler 1: Verwenden von lifecycleScope statt viewModelScope zum Laden von Daten

Wenn Sie das Laden von Daten in lifecycleScope.launch starten, wird die Coroutine bei Bildschirmrotation abgebrochen, und die Daten müssen erneut geladen werden. Verwenden Sie viewModelScope für langlebige Operationen. lifecycleScope ist nur für UI-gebundene Aufgaben.

Fehler 2: Sammeln von Flow ohne repeatOnLifecycle

Der direkte Aufruf von viewModel.someFlow.collect { ... } innerhalb von lifecycleScope.launch sammelt weiterhin Daten, auch wenn der Bildschirm nicht sichtbar ist. Dies kann zu UI-Updates im Hintergrund und unnötigem Overhead führen. Verwenden Sie immer repeatOnLifecycle oder flowWithLifecycle.

Fehler 3: Vergessen des Abbruchs beim Verlassen des Bildschirms

Obwohl lifecycleScope bei DESTROYED abgebrochen wird, kann Code nach einem Suspend-Punkt bei plötzlichem Abbruch möglicherweise nicht ausgeführt werden. Verlassen Sie sich nicht auf die Ausführung von Post-Code nach einem Suspend-Aufruf, es sei denn, Sie verwenden NonCancellable.

Fehler 4: Verwenden des veralteten launchWhenStarted statt repeatOnLifecycle

launchWhenStarted und seine Gegenstücke brechen die Coroutine nicht ab, sondern pausieren sie nur. Wenn der Bildschirm mehrmals zwischen Vorder- und Hintergrund wechselt, sammelt die Coroutine verschobene Aufrufe an. Wechseln Sie zu repeatOnLifecycle — dies ist der einzig korrekte Weg, um mit dem Lifecycle zu synchronisieren.