Activity — was ist das, App-Bildschirm in Android und sein Lifecycle

Was ist Activity?

Activity — eine Schlüsselkomponente einer Android-Anwendung, die ein Fenster zur Benutzerinteraktion bereitstellt. Jede Activity verwaltet einen separaten Bildschirm: Aufgabenliste, Anmeldeformular, Fotobetrachter. Das Android-System erstellt eine Activity bei Anfrage und zerstört sie, wenn andere Anwendungen Speicher benötigen.

Activity erschien erstmals in Android 1.0 (2008) und bleibt der wichtigste Baustein der Benutzeroberfläche. Laut Google (2026) enthalten 98% der Apps im Google Play Store mindestens eine Activity. In der modernen Architektur empfiehlt Google eine Activity mit mehreren Fragments, jedoch bleibt die klassische Multi-Screen-Anwendung eine gängige Praxis.

Activity stack (Back Stack) — ein Aufgabenstapel, der den Navigationsverlauf speichert. Wenn der Benutzer "Zurück" drückt, wird die aktuelle Activity zerstört und die vorherige wiederhergestellt. Das System verwaltet den Stapel automatisch, aber der Entwickler kann das Verhalten durch launchMode und Intent-Flags steuern.

Activity-Lebenszyklus

Der Activity-Lebenszyklus ist eine Reihe von Zuständen und Callbacks, die ein Bildschirm von der Erstellung bis zur Zerstörung durchläuft. Das Verständnis des Lifecycle ist von entscheidender Bedeutung: falsche Zustandsverwaltung führt zu Speicherlecks, Datenverlust und App-Abstürzen.

Das Android-System ruft die Callbacks in einer strengen Reihenfolge auf. Der Entwickler überschreibt die erforderlichen Methoden, um Ressourcen zu initialisieren, Daten zu speichern und Speicher freizugeben. Jeder Callback hat ein entsprechendes Paar: onCreate ↔ onDestroy, onStart ↔ onStop, onResume ↔ onPause.

Activity-Zustände

Es gibt vier Zustände von Activity: Running (onResume aktiv), Paused (sichtbar aber ohne Fokus), Stopped (nicht sichtbar), Destroyed (zerstört). Das System kann eine Activity im Stopped-Zustand bei Speichermangel beenden — Daten müssen in onSaveInstanceState gespeichert werden.

Lebenszyklusmethoden: onCreate, onStart, onResume

Betrachten wir drei wichtige Methoden des Activity-Lebenszyklus mit einem Kotlin-Beispiel. onCreate — der Einstiegspunkt, wird einmal aufgerufen. Hier erfolgen das Layout-Binding per setContentView, die Initialisierung von RecyclerView, das Abonnieren von LiveData. onStart — die Activity wird für den Benutzer sichtbar. onResume — die Activity erhält Fokus und ist bereit für die Interaktion.

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val recyclerView = findViewById<RecyclerView>(R.id.rv_items)
        recyclerView.layoutManager = LinearLayoutManager(this)
        loadItems()
    }

    override fun onStart() {
        super.onStart()
        startLocationUpdates()
    }

    override fun onResume() {
        super.onResume()
        resumeVideoPlayer()
    }
}

Im Beispiel initialisiert onCreate RecyclerView und lädt Daten. onStart startet Geolokalisierungs-Updates — eine Ressource, die nur arbeiten sollte, wenn der Bildschirm sichtbar ist. onResume setzt das Video fort, das in onPause pausiert wurde. Diese Trennung verhindert unnötige Hintergrundarbeit.

Deklaration von Activity in AndroidManifest.xml

Jede Activity muss in der Datei AndroidManifest.xml deklariert werden. Ohne Registrierung findet das System den Bildschirm nicht und wirft eine ActivityNotFoundException. Im Manifest werden Klassenname, Thema, Ausrichtung, launchMode und Intent-Filter angegeben.

<application
    android:allowBackup="true"
    android:label="@string/app_name"
    android:theme="@style/Theme.MyApp">

    <activity
        android:name=".MainActivity"
        android:exported="true">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

    <activity
        android:name=".DetailActivity"
        android:parentActivityName=".MainActivity" />
</application>

Das exported-Flag bestimmt, ob andere Anwendungen die Activity starten können. Für den Hauptbildschirm exported=true, für interne Bildschirme — false. Das parentActivityName-Attribut aktiviert die Standard-Navigation "Nach oben" (Up Navigation).

Starten von Activity per Intent

Intent — ein Objekt, das eine auszuführende Aktion beschreibt. Im Kontext von Activity wird Intent verwendet, um einen anderen Bildschirm mit Datenübergabe zu starten. Intent kann explizit (eine bestimmte Klasse angeben) und implizit (eine Aktion angeben, das System wählt eine geeignete Komponente aus) sein.

// Expliziter Intent — Starten von DetailActivity mit Daten
val intent = Intent(this, DetailActivity::class.java).apply {
    putExtra("item_id", itemId)
    putExtra("item_name", itemName)
}
startActivity(intent)

// Daten in DetailActivity abrufen
val itemId = intent.getLongExtra("item_id", 0L)
val itemName = intent.getStringExtra("item_name") ?: ""

Um ein Ergebnis von einer gestarteten Activity zu erhalten, wird die Activity Result API verwendet, die das veraltete startActivityForResult ersetzt hat. Die neue API ist typsicher, deklarativ und funktioniert mit Jetpack Compose.

private val getResult = registerForActivityResult(
    ActivityResultContracts.StartActivityForResult()
) { result ->
    if (result.resultCode == Activity.RESULT_OK) {
        val data = result.data?.getStringExtra("result_key")
    }
}

fun openPicker() {
    val intent = Intent(this, PickerActivity::class.java)
    getResult.launch(intent)
}

Zustand bei Neuerstellung speichern

Bei Bildschirmdrehung oder Konfigurationsänderung erstellt Android die Activity neu — ruft nacheinander onDestroy und onCreate auf. Ohne Zustandsspeicherung verliert der Benutzer eingegebene Daten, Bildlaufposition und ausgewählte Elemente. Android bietet zwei Mechanismen zur Lösung dieses Problems: onSaveInstanceState und ViewModel.

onSaveInstanceState speichert einfache Daten im Bundle vor dem Aufruf von onDestroy. ViewModel von Jetpack übersteht die Neuerstellung der Activity und speichert Daten im Speicher, was für komplexe Objekte und Netzwerkanfragen effizienter ist.

class MainActivity : AppCompatActivity() {

    private val viewModel: MainViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // ViewModel speichert Daten automatisch
        viewModel.items.observe(this) { items ->
            updateAdapter(items)
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putInt("scroll_position", recyclerView.computeVerticalScrollOffset())
    }
}

Single Activity-Architektur und Jetpack

Der moderne Ansatz von Google ist die Single Activity-Architektur mit einer Activity und mehreren Fragments. Die App verwendet eine MainActivity, und die gesamte Navigation wird vom Navigation Component über NavHostFragment verwaltet. Vorteile: zentralisierte Navigation, gemeinsames ViewModel pro Bildschirm, korrekte Deep Links-Verarbeitung.

Jetpack Navigation Component automatisiert die Back-Stack-Verwaltung, Übergangsanimationen und Argumentübergabe. NavHostFragment wird im Activity-Layout platziert, und der Navigationsgraph (NavGraph) beschreibt alle Bildschirme und Verbindungen zwischen ihnen. Dieser Ansatz wird von Google für neue Projekte empfohlen und folgt den Material Design-Prinzipien.

class MainActivity : AppCompatActivity() {

    private val navController by lazy {
        findViewById<NavHostFragment>(R.id.nav_host_fragment)
            .navController
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Einrichten von NavigationUI für AppBar
        setupActionBarWithNavController(navController)
    }

    override fun onSupportNavigateUp() = 
        navController.navigateUp() || super.onSupportNavigateUp()
}