Navigation Component — co to jest, NavHost i Navigation Graph

Autor: IT Sectr Opublikowano: 2026-02-22 Czas czytania: 7 min

Navigation Component — biblioteka Android Jetpack do implementacji nawigacji między ekranami aplikacji. Komponent centralizuje zarządzanie stosem fragmentów, głębokimi linkami i przekazywaniem argumentów. Wchodzi w skład Jetpack od 2018 roku i jest rekomendowany przez Google dla wszystkich nowych projektów. Więcej informacji znajdziesz w oficjalnym przewodniku Google.

Najważniejsze

  • Navigation Component — biblioteka Jetpack do scentralizowanej nawigacji między ekranami Android
  • NavGraph — zasób XML opisujący wszystkie ekrany i połączenia między nimi
  • NavHostFragment — kontener w layout Activity wyświetlający bieżący ekran nawigacji
  • NavController — obiekt zarządzania nawigacją: navigate, popBackStack, navigateUp
  • Safe Args — wtyczka Gradle do bezpiecznego typowo przekazywania argumentów między ekranami

Czym jest Navigation Component?

Navigation Component — biblioteka Android Jetpack (androidx.navigation) zapewniająca jednolity API do nawigacji. Zawiera trzy kluczowe elementy: Navigation Graph (graf nawigacji), NavHostFragment (kontener dla ekranów) i NavController (kontroler przejść). Komponent automatycznie zarządza back stack i obsługuje deep links.

Przed Navigation Component programiści zarządzali fragmentami ręcznie przez FragmentManager. Prowadziło to do fragmentarycznego kodu: każdy ekran miał własne reguły nawigacji, stany back stack różniły się, deep links wymagały osobnej implementacji. Navigation Component ujednolicił te scenariusze. Według Google (2026), biblioteka jest zainstalowana w 90% nowych projektów Android.

Navigation Component integruje się z innymi bibliotekami Jetpack: LiveData, ViewModel, Material Design. Obsługuje zarówno fragmenty XML, jak i Jetpack Compose przez rozszerzenie navigation-compose. Stabilne wydanie — 2.8.x (2025), minimalna wersja Android — API 14.

NavGraph — zasób XML (res/navigation/nav_graph.xml) definiujący wszystkie ekrany aplikacji i połączenia między nimi. Każdy ekran to węzeł (destination), który może być Fragment, Activity lub Composable. Połączenia między węzłami to action, które określają kierunek przejścia.

xml

<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="Główna"
        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="Szczegóły"
        tools:layout="@layout/fragment_detail">
        <argument android:name="itemId"
            app:argType="integer"
            android:defaultValue="0" />
    </fragment>
</navigation>

Atrybut startDestination określa pierwszy ekran wyświetlany przy starcie. Action definiuje docelowy destination i opcjonalne animacje. Argumenty (argument) opisują parametry przekazywane do ekranu — typ i wartość domyślną.

NavHostFragment — kontener umieszczany w layout Activity wyświetlający bieżący ekran nawigacji. NavHostFragment automatycznie przełącza fragmenty przy wywołaniu NavController.navigate(). NavController — obiekt zarządzający nawigacją: przejście, powrót, sprawdzenie bieżącej trasy.

kotlin
// 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 łączy NavController z AppBar
        setupActionBarWithNavController(navController)
    }

    // Przejście do ekranu szczegółów
    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" — ważny atrybut: przechwytuje systemowy przycisk „Wstecz” i przekazuje sterowanie do NavController. NavigationUI — narzędzie do łączenia NavController z AppBar, BottomNavigationView, NavigationDrawer. setupActionBarWithNavController włącza strzałkę „W górę" na zagnieżdżonych ekranach.

Navigation Component obsługuje niestandardowe animacje przejść określane w action lub programowo. Animacje definiowane są przez cztery atrybuty: enterAnim (pojawienie się nowego ekranu), exitAnim (zniknięcie bieżącego), popEnterAnim (pojawienie się przy powrocie) i popExitAnim (zniknięcie przy powrocie).

xml

<?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>

// Programowe przejście z animacją
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)

Animacje działają z Fragment na poziomie FragmentTransaction. Dla Jetpack Compose animacje określa się przez NavOptionsCompat z użyciem Compose Animation. Navigation Component nie nakłada ograniczeń na typ animacji — obsługuje translate, scale, alpha i ich kombinacje.

Safe Args: bezpieczne typowo argumenty

Safe Args — wtyczka Gradle do bezpiecznego typowo przesyłania danych między ekranami. Wtyczka analizuje NavGraph, generuje klasy Directions i Args z konkretnymi typami pól. Na etapie kompilacji sprawdzana jest zgodność typów — błąd MissingArgumentException jest wykrywany przed uruchomieniem aplikacji.

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

// Safe Args generuje: DetailFragmentArgs, HomeFragmentDirections
// Użycie w HomeFragment:
val action = HomeFragmentDirections
    .actionHomeToDetail(itemId = 42L)
findNavController().navigate(action)

// Użycie w DetailFragment:
private val args: DetailFragmentArgs by navArgs()
// args.itemId ma typ Long, null nie może być przekazany

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

navArgs() — delegat Kotlin do pobierania argumentów w Fragment lub Activity. Wtyczka obsługuje prymitywy, ciągi znaków, Parcelable, Serializable, Enum i tablice. Dla złożonych obiektów używaj przesyłania ID z ładowaniem z ViewModel lub bazy danych.

Deep Link — zewnętrzny link otwierający konkretny ekran aplikacji. Navigation Component obsługuje deep links przez atrybut app:deepLink w NavGraph. System tworzy PendingIntent, który przywraca stos nawigacji do docelowego ekranu lub tworzy nowy stos, jeśli aplikacja nie jest uruchomiona.

xml

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

// Programowe utworzenie 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 obsługują szablony URI ze ścieżkami i parametrami query, intent action i mime type. Placeholder ({userId}) jest automatycznie dopasowywany do argumentu destination. Navigation Component obsługuje również implicit deep links przez AndroidManifest — wystarczy dodać intent-filter do Activity z NavHostFragment.

Navigation Compose (androidx.navigation:navigation-compose) — rozszerzenie Navigation Component dla Jetpack Compose. API zachowuje koncepcję NavController i NavHost, ale ekrany to funkcje Composable zamiast Fragment. NavHost przyjmuje lambdę composable dla każdej trasy.

kotlin
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 używa tras tekstowych zamiast id. Parametry są przekazywane przez szablon route ("detail/{itemId}") i pobierane z backStackEntry. rememberNavController() zachowuje NavController przy rekompozycji. Dla Type Safety w Compose zaleca się moduł navigation-compose-type-safety (eksperymentalny).

Często zadawane pytania

Czym jest NavHost w Navigation Component?

NavHost — kontener do wyświetlania ekranów nawigacji. Implementowany przez NavHostFragment w layout XML. NavHost śledzi bieżący ekran w NavGraph i zarządza przejściami. Każde Activity zawiera jeden NavHostFragment.

Czym Safe Args jest lepsze od Bundle?

Safe Args — wtyczka Gradle generująca bezpieczne typowo klasy argumentów. Bundle wymaga ręcznego podawania kluczy i typów, co prowadzi do błędów wykonania. Safe Args sprawdza typy na etapie kompilacji i automatycznie serializuje dane.

Jak przekazywać złożone obiekty przez Navigation Component?

Złożone obiekty są przekazywane przez ViewModel (wspólny dla ekranów) lub przez bazę danych z przesyłaniem ID. Safe Args obsługuje tylko prymitywy, ciągi znaków i Parcelable. Google zaleca unikanie przesyłania dużych obiektów przez argumenty nawigacji.

Jak działa Deep Link w Navigation Component?

Deep Link jest konfigurowany w NavGraph przez atrybut app:deepLink. Navigation Component automatycznie obsługuje przychodzące linki, tworzy PendingIntent przez NavDeepLinkBuilder i przywraca stos nawigacji do docelowego ekranu. Obsługuje URI, intent action i mime type.

Czy można używać Navigation Component z Jetpack Compose?

Tak. Navigation Compose (androidx.navigation:navigation-compose) udostępnia NavHost dla Compose. API jest analogiczne do wersji XML, ale ekrany to funkcje Composable. NavController jest używany identycznie w obu wersjach. Google zaleca Navigation Compose dla nowych projektów w Compose.

Podsumowanie

  • Navigation Component — biblioteka Android Jetpack do scentralizowanej nawigacji z NavController, NavHost i NavGraph
  • NavGraph — graf XML opisujący wszystkie ekrany (destination) i połączenia (action) między nimi
  • NavHostFragment — kontener w layout Activity obsługujący atrybut defaultNavHost dla przycisku „Wstecz"
  • Safe Args — wtyczka Gradle do bezpiecznego typowo przekazywania argumentów z kontrolą typów na etapie kompilacji
  • Deep Links obsługują URI, intent action i mime type z automatycznym przywracaniem stosu nawigacji
  • Navigation Compose — rozszerzenie dla Jetpack Compose z trasami tekstowymi i ekranami composable
  • Navigation Component jest jedynym zalecanym przez Google sposobem nawigacji w nowych projektach Android

Opracujemy aplikację mobilną pod klucz

IT Sectr tworzy aplikacje na iOS i Androida dla startupów i firm od 2017 roku. Doradzimy Ci i zaproponujemy najlepsze rozwiązanie.

Omów projekt

Przeczytaj również