Lebenszyklus in der mobilen Entwicklung: was ist das, welche Phasen und wie funktioniert es

Lebenszyklus der App (App Lifecycle)

Bevor wir uns dem Lebenszyklus einzelner Bildschirme widmen, ist es wichtig, den Lebenszyklus der gesamten App zu verstehen. In iOS durchläuft die App fünf Zustände: Not Running (nicht ausgeführt), Inactive (im Hintergrund, empfängt keine Ereignisse), Active (aktiv), Background (im Hintergrund, Code wird ausgeführt) und Suspended (im Hintergrund, Code pausiert). Diese Zustände werden im AppDelegate über die Methoden applicationDidFinishLaunching, applicationDidBecomeActive, applicationWillResignActive, applicationDidEnterBackground und applicationWillTerminate verwaltet.

In Android ist das Äquivalent der Application Lifecycle, der über das Interface Application.ActivityLifecycleCallbacks verfolgt wird. Allerdings konzentriert sich Android mehr auf den Lebenszyklus einer Activity — eines einzelnen App-Bildschirms. Dies liegt daran, dass eine Android-App aus mehreren Activities bestehen kann, jede mit ihrem eigenen Zyklus.

Der moderne Ansatz in Android ist die Verwendung von ProcessLifecycleOwner aus der lifecycle-process-Bibliothek. Er ermöglicht die Verfolgung des Zustands des gesamten Prozesses, ohne an eine bestimmte Activity gebunden zu sein. In iOS wird UISceneDelegate (seit iOS 13) oder AppDelegate zur Verfolgung des App-Zustands verwendet. SceneDelegate verwaltet mehrere Fenster (Multiwindow) auf dem iPad. Das Verständnis des App Lifecycle ist besonders wichtig für IT Sectr bei der Entwicklung von Apps mit Hintergrundsynchronisation, Streaming und VoIP-Anrufen.

Activity Lifecycle in Android

Activity ist die grundlegende Komponente einer Android-App, die einen Bildschirm darstellt. Die Activity hat einen klar definierten Lebenszyklus, der vom Betriebssystem als Reaktion auf Benutzeraktionen und Systemereignisse (Bildschirmdrehung, eingehender Anruf, Speichermangel) verwaltet wird.

Wichtig: onSaveInstanceState wird vor onStop aufgerufen, um den temporären Zustand zu speichern. Die Wiederherstellung erfolgt in onCreate über Bundle savedInstanceState oder über SavedStateHandle in der ViewModel. Ohne ordnungsgemäße Behandlung des Lebenszyklus verliert die App bei Bildschirmdrehung alle nicht gespeicherten Daten.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("draft", draftText)
    }
    override fun onDestroy() {
        super.onDestroy()
        // Отписка от всех подписок
    }
}

Activity Lifecycle in Jetpack Compose

In Jetpack Compose bleibt der Activity-Lebenszyklus unverändert, aber Compose bietet zusätzliche Werkzeuge: Lifecycle-bewusste Komposition über LifecycleOwner, LifecycleEventEffect und DisposableEffect für die automatische Bereinigung von Ressourcen bei der Zerstörung.

Fragment Lifecycle im Detail

Fragment in Android lebt innerhalb einer Activity und hat seinen eigenen Lebenszyklus, der sich teilweise mit dem der Activity überschneidet, aber neue Methoden hinzufügt. Fragmente können hinzugefügt, ersetzt und entfernt werden, ohne die Activity zu zerstören, was sie flexibler, aber auch komplexer macht.

Wichtige Methoden des Fragment Lifecycle: onAttach — Fragment an Activity angehängt (erster Aufruf); onCreate — Dateninitialisierung; onCreateView — View-Erstellung; onViewCreated — View erstellt, UI kann konfiguriert werden; onStart — Fragment sichtbar; onResume — Fragment im Fokus; onPause — Fragment verliert Fokus; onStop — Fragment nicht sichtbar; onDestroyView — View wird zerstört; onDestroy — Fragment wird zerstört; onDetach — Fragment von Activity getrennt.

Hauptunterschied zur Activity: onCreateView und onDestroyView können mehrmals aufgerufen werden (z.B. beim Wechseln von TabLayout), während onCreate einmal aufgerufen wird. Dementsprechend sollte die View-Initialisierung in onViewCreated erfolgen, nicht in onCreateView. View-bezogene Ressourcen (z.B. RecyclerView-Adapter) sollten in onDestroyView bereinigt werden.

ViewController Lifecycle in iOS

UIViewController ist die Basisklasse für die Verwaltung von Bildschirmen in iOS. Sein Lebenszyklus besteht aus einer Sequenz von Methoden, die UIKit automatisch aufruft. Das Verständnis dieses Zyklus ist entscheidend für die korrekte UI-Initialisierung, Datenverwaltung und Speicherbehandlung.

Wichtig: viewDidLoad wird nur einmal in der Lebensdauer eines View Controllers aufgerufen. Verwenden Sie viewWillAppear, um Daten bei jedem Erscheinen zu aktualisieren. Wenn Sie NotificationCenter in viewWillAppear abonnieren, melden Sie sich in viewDidDisappear ab, um Speicherlecks zu vermeiden.

SwiftUI Lifecycle

SwiftUI verwaltet den Lebenszyklus von Views durch View-Strukturen. Anstelle von Callback-Methoden verwendet SwiftUI die Modifikatoren onAppear und onDisappear. Für globale App-Zustände wird der App Lifecycle über die App- und Scene-Protokolle verwendet. SwiftUI verwaltet automatisch die Erstellung und Zerstörung von Views basierend auf dem Zustand, was die Entwicklung vereinfacht, aber ein Verständnis der View-Identität und -Lebensdauer erfordert.

struct ContentView: View {
    var body: some View {
        Text("Hello")
            .onAppear {
                print("View появилась")
            }
            .onDisappear {
                print("View исчезла")
            }
    }
}

LifecycleOwner und LifecycleObserver in Android

LifecycleOwner ist ein Interface aus Android Architecture Components, das ein Objekt markiert, das einen Lebenszyklus hat (Activity, Fragment). LifecycleObserver ist ein Interface, das es einem Objekt ermöglicht, Ereignisse des LifecycleOwner zu abonnieren. Zusammen bilden sie die Grundlage für reaktives Lifecycle-Management in der modernen Android-Entwicklung.

Anstatt Methoden explizit in onStart/onStop aufzurufen, wird die Verwendung von DefaultLifecycleObserver empfohlen (Ersatz für den veralteten LifecycleObserver mit @OnLifecycleEvent-Annotationen). Dieser Ansatz wird von Google für ViewModel und andere Komponenten gefördert, die auf den Lebenszyklus reagieren müssen, ohne direkte Referenzen auf Activity oder Fragment zu haben.

class MyObserver : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // Подписка на обновления
    }
    override fun onStop(owner: LifecycleOwner) {
        // Отписка
    }
}

Bei IT Sectr verwenden wir LifecycleOwner in allen Android-Projekten. Die ViewModel abonniert den LifecycleOwner der Activity über viewModelScope und lifecycleScope, was die automatische Kündigung von Coroutinen bei der Zerstörung der Activity garantiert. Dies verhindert Speicherlecks und macht den Code sauberer und sicherer.