Navigation Component — Was ist das, NavHost und Navigation Graph

Was ist Navigation Component?

Navigation Component ist eine Android Jetpack-Bibliothek (androidx.navigation), die eine einheitliche API für die Navigation bereitstellt. Sie umfasst drei Schlüsselelemente: Navigation Graph (Navigationsgraph), NavHostFragment (Bildschirmcontainer) und NavController (Übergangssteuerung). Die Komponente verwaltet automatisch den Back-Stack und unterstützt Deep Links.

Vor Navigation Component verwalteten Entwickler Fragmente manuell über FragmentManager. Dies führte zu fragmentiertem Code: Jeder Bildschirm hatte seine eigenen Navigationsregeln, Back-Stack-Zustände variierten und Deep Links erforderten eine separate Implementierung. Navigation Component hat diese Szenarien vereinheitlicht. Laut Google (2026) ist die Bibliothek in 90% der neuen Android-Projekte installiert.

Navigation Component integriert sich mit anderen Jetpack-Bibliotheken: LiveData, ViewModel, Material Design. Es unterstützt sowohl XML-Fragmente als auch Jetpack Compose über die navigation-compose-Erweiterung. Stabile Version — 2.8.x (2025), minimale Android-Version — API 14.

NavGraph: Navigationsgraph in XML

NavGraph ist eine XML-Ressource (res/navigation/nav_graph.xml), die alle App-Bildschirme und Verbindungen zwischen ihnen definiert. Jeder Bildschirm ist ein Ziel (Destination), das ein Fragment, eine Activity oder ein Composable sein kann. Verbindungen zwischen Zielen sind Aktionen, die die Übergangsrichtung definieren.

<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    app:startDestination="@+id/homeFragment">

    <fragment
        android:id="@+id/homeFragment"
        android:name=".HomeFragment"
        android:label="Startseite"
        tools:layout="@layout/fragment_home">
        <action
            android:id="@+id/action_home_to_detail"
            app:destination="@+id/detailFragment"
            app:enterAnim="@anim/slide_in_right"
            app:exitAnim="@anim/slide_out_left"
            app:popEnterAnim="@anim/slide_in_left"
            app:popExitAnim="@anim/slide_out_right" />
    </fragment>

    <fragment
        android:id="@+id/detailFragment"
        android:name=".DetailFragment"
        android:label="Details"
        tools:layout="@layout/fragment_detail">
        <argument android:name="itemId"
            app:argType="integer"
            android:defaultValue="0" />
    </fragment>
</navigation>

Das Attribut startDestination legt den ersten Bildschirm fest, der beim Start angezeigt wird. Eine Aktion definiert das Ziel und optionale Animationen. Argumente beschreiben die an den Bildschirm übergebenen Parameter — Typ und Standardwert.

NavHost und NavController: Container und Steuerung

NavHostFragment ist ein Container, der im Activity-Layout platziert wird und den aktuellen Navigationsbildschirm anzeigt. NavHostFragment wechselt automatisch Fragmente, wenn NavController.navigate() aufgerufen wird. NavController ist das Objekt, das die Navigation verwaltet: Übergänge, Zurücknavigation und Überprüfung der aktuellen Route.

// Layout Activity: activity_main.xml
// <androidx.fragment.app.FragmentContainerView
//     android:id="@+id/nav_host_fragment"
//     android:name="androidx.navigation.fragment.NavHostFragment"
//     app:navGraph="@navigation/nav_graph"
//     app:defaultNavHost="true" />

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)

        // NavigationUI verbindet NavController mit AppBar
        setupActionBarWithNavController(navController)
    }

    // Zum Detailbildschirm navigieren
    fun openDetail(itemId: Long) {
        val bundle = Bundle().apply {
            putLong("itemId", itemId)
        }
        navController.navigate(R.id.action_home_to_detail, bundle)
    }

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

app:defaultNavHost="true" ist ein wichtiges Attribut: Es fängt die System-Zurück-Taste ab und übergibt die Kontrolle an NavController. NavigationUI ist ein Dienstprogramm zum Verknüpfen von NavController mit AppBar, BottomNavigationView, NavigationDrawer. setupActionBarWithNavController aktiviert den Zurück-Pfeil auf verschachtelten Bildschirmen.

Übergänge und Animationen zwischen Bildschirmen

Navigation Component unterstützt benutzerdefinierte Übergangsanimationen, die in Aktionen oder programmatisch festgelegt werden. Animationen werden durch vier Attribute definiert: enterAnim (Erscheinen des neuen Bildschirms), exitAnim (Verschwinden des aktuellen), popEnterAnim (Erscheinen beim Zurückkehren) und popExitAnim (Verschwinden beim Zurückkehren).

<?xml version="1.0" encoding="utf-8"?>
<set xmlns:android="http://schemas.android.com/apk/res/android">
    <translate
        android:fromXDelta="100%"
        android:toXDelta="0%"
        android:duration="300" />
</set>

// Programmatischer Übergang mit Animation
val navOptions = NavOptions.Builder()
    .setEnterAnim(R.anim.slide_in_right)
    .setExitAnim(R.anim.slide_out_left)
    .setPopEnterAnim(R.anim.slide_in_left)
    .setPopExitAnim(R.anim.slide_out_right)
    .build()

navController.navigate(R.id.detailFragment, args, navOptions)

Animationen arbeiten mit Fragment auf FragmentTransaction-Ebene. Für Jetpack Compose werden Animationen über NavOptionsCompat mit Compose Animation festgelegt. Navigation Component erzwingt keine Einschränkungen hinsichtlich des Animationstyps — translate, scale, alpha und deren Kombinationen werden unterstützt.

Safe Args: typsichere Argumente

Safe Args ist ein Gradle-Plugin für typsichere Datenübertragung zwischen Bildschirmen. Das Plugin analysiert NavGraph, generiert Directions- und Args-Klassen mit spezifischen Feldtypen. Die Typübereinstimmung wird zur Kompilierzeit geprüft — ein MissingArgumentException wird vor dem Ausführen der App erkannt.

// build.gradle (module)
plugins {
    id 'androidx.navigation.safeargs.kotlin'
}

// Safe Args generiert: DetailFragmentArgs, HomeFragmentDirections
// Verwendung in HomeFragment:
val action = HomeFragmentDirections
    .actionHomeToDetail(itemId = 42L)
findNavController().navigate(action)

// Verwendung in DetailFragment:
private val args: DetailFragmentArgs by navArgs()
// args.itemId ist vom Typ Long, null kann nicht übergeben werden

override fun onViewCreated(...) {
    super.onViewCreated(...)
    loadItem(args.itemId)
}

navArgs() ist ein Kotlin-Delegat zum Abrufen von Argumenten in einem Fragment oder Activity. Das Plugin unterstützt primitive Typen, Strings, Parcelable, Serializable, Enum und Arrays. Für komplexe Objekte übergeben Sie eine ID und laden aus ViewModel oder Datenbank.

Deep Links in Navigation Component

Deep Link ist ein externer Link, der einen bestimmten App-Bildschirm öffnet. Navigation Component verarbeitet Deep Links über das Attribut app:deepLink in NavGraph. Das System erstellt einen PendingIntent, der den Navigationsstack bis zum Zielbildschirm wiederherstellt, oder einen neuen Stack, wenn die App nicht läuft.

<fragment android:id="@+id/profileFragment"
    android:name=".ProfileFragment">
    <deepLink
        app:uri="https://example.com/profile/{userId}" />
    <argument
        android:name="userId"
        app:argType="string" />
</fragment>

// Programmatische Erstellung von Deep Link
val pendingIntent = NavDeepLinkBuilder(context)
    .setGraph(R.navigation.nav_graph)
    .setDestination(R.id.profileFragment)
    .setArguments(Bundle().apply {
        putString("userId", "user_123")
    })
    .createPendingIntent()

Deep Links unterstützen URI-Muster mit Pfaden und Abfrageparametern, intent action und MIME-Typ. Platzhalter ({userId}) werden automatisch den Zielargumenten zugeordnet. Navigation Component verarbeitet auch implizite Deep Links über AndroidManifest — fügen Sie einfach einen intent-filter zur Activity mit NavHostFragment hinzu.

Navigation Component mit Jetpack Compose

Navigation Compose (androidx.navigation:navigation-compose) ist eine Erweiterung von Navigation Component für Jetpack Compose. Die API bewahrt das Konzept von NavController und NavHost, aber die Bildschirme sind Composable-Funktionen statt Fragment. NavHost akzeptiert einen composable-Lambda für jede Route.

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MyAppTheme {
                val navController = rememberNavController()
                NavHost(
                    navController = navController,
                    startDestination = "home"
                ) {
                    composable("home") {
                        HomeScreen(
                            onItemClick = { id ->
                                navController.navigate("detail/$id")
                            }
                        )
                    }
                    composable(
                        route = "detail/{itemId}",
                        arguments = listOf(
                            navArgument("itemId") {
                                type = NavType.LongType
                            }
                        )
                    ) { backStackEntry ->
                        val itemId = backStackEntry
                            .arguments?.getLong("itemId") ?: 0L
                        DetailScreen(itemId = itemId)
                    }
                }
            }
        }
    }
}

Navigation Compose verwendet String-Routen anstelle von IDs. Parameter werden über Routenvorlagen ("detail/{itemId}") übergeben und aus backStackEntry extrahiert. rememberNavController() bewahrt NavController bei Neuzusammensetzungen. Für Typsicherheit in Compose wird das Modul navigation-compose-type-safety (experimentell) empfohlen.