Navigation Component — co to je, NavHost a Navigation Graph

Autor: IT Sectr Publikováno: 2026-02-22 Doba čtení: 7 min

Navigation Component — knihovna Android Jetpack pro implementaci navigace mezi obrazovkami aplikace. Komponent centralizuje správu zásobníku fragmentů, hlubokých odkazů a předávání argumentů. Je součástí Jetpack od roku 2018 a je doporučen společností Google pro všechny nové projekty. Více informací naleznete v oficiálním průvodci Google.

Hlavní body

  • Navigation Component — knihovna Jetpack pro centralizovanou navigaci mezi obrazovkami Android
  • NavGraph — XML zdroj popisující všechny obrazovky a vazby mezi nimi
  • NavHostFragment — kontejner v layoutu Activity zobrazující aktuální navigační obrazovku
  • NavController — objekt správy navigace: navigate, popBackStack, navigateUp
  • Safe Args — plugin Gradle pro typově bezpečné předávání argumentů mezi obrazovkami

Co je Navigation Component?

Navigation Component — knihovna Android Jetpack (androidx.navigation) poskytující jednotné API pro navigaci. Zahrnuje tři klíčové prvky: Navigation Graph (navigační graf), NavHostFragment (kontejner pro obrazovky) a NavController (řadič přechodů). Komponent automaticky spravuje zásobník zpět a podporuje deep links.

Před Navigation Component vývojáři spravovali fragmenty ručně přes FragmentManager. To vedlo k roztříštěnému kódu: každá obrazovka měla vlastní pravidla navigace, stavy zásobníku zpět se lišily a deep links vyžadovaly samostatnou implementaci. Navigation Component tyto scénáře sjednotil. Podle Google (2026) je knihovna nainstalována v 90 % nových Android projektů.

Navigation Component se integruje s dalšími knihovnami Jetpack: LiveData, ViewModel, Material Design. Podporuje jak XML fragmenty, tak Jetpack Compose prostřednictvím rozšíření navigation-compose. Stabilní vydání — 2.8.x (2025), minimální verze Android — API 14.

NavGraph — XML zdroj (res/navigation/nav_graph.xml) definující všechny obrazovky aplikace a vazby mezi nimi. Každá obrazovka je uzel (destination), který může být Fragment, Activity nebo Composable. Vazby mezi uzly jsou action, které určují směr přechodu.

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="Domů"
        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="Podrobnosti"
        tools:layout="@layout/fragment_detail">
        <argument android:name="itemId"
            app:argType="integer"
            android:defaultValue="0" />
    </fragment>
</navigation>

Atribut startDestination nastavuje první obrazovku zobrazenou při spuštění. Action definuje cílový destination a volitelné animace. Argumenty (argument) popisují parametry předávané na obrazovku — typ a výchozí hodnotu.

NavHostFragment — kontejner umístěný v layoutu Activity zobrazující aktuální navigační obrazovku. NavHostFragment automaticky přepíná fragmenty při volání NavController.navigate(). NavController — objekt spravující navigaci: přechod, návrat, kontrola aktuální 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 propojuje NavController s AppBar
        setupActionBarWithNavController(navController)
    }

    // Přechod na obrazovku podrobností
    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" — důležitý atribut: zachycuje systémové tlačítko 'Zpět' a předává řízení NavController. NavigationUI — nástroj pro propojení NavController s AppBar, BottomNavigationView, NavigationDrawer. setupActionBarWithNavController aktivuje šipku 'Nahoru' na vnořených obrazovkách.

Navigation Component podporuje vlastní animace přechodů definované v action nebo programově. Animace jsou definovány čtyřmi atributy: enterAnim (objevení nové obrazovky), exitAnim (zmizení aktuální), popEnterAnim (objevení při návratu) a popExitAnim (zmizení při návratu).

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>

// Programový přechod s animací
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)

Animace pracují s Fragment na úrovni FragmentTransaction. Pro Jetpack Compose se animace nastavují přes NavOptionsCompat s použitím Compose Animation. Navigation Component neomezuje typ animace — podporuje translate, scale, alpha a jejich kombinace.

Safe Args: typově bezpečné argumenty

Safe Args — plugin Gradle pro typově bezpečný přenos dat mezi obrazovkami. Plugin analyzuje NavGraph, generuje třídy Directions a Args s konkrétními typy polí. Ve fázi kompilace se kontroluje shoda typů — chyba MissingArgumentException je odhalena před spuštěním aplikace.

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

// Safe Args generuje: DetailFragmentArgs, HomeFragmentDirections
// Použití v HomeFragment:
val action = HomeFragmentDirections
    .actionHomeToDetail(itemId = 42L)
findNavController().navigate(action)

// Použití v DetailFragment:
private val args: DetailFragmentArgs by navArgs()
// args.itemId má typ Long, null nelze předat

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

navArgs() — delegát Kotlin pro získání argumentů ve Fragment nebo Activity. Plugin podporuje primitivy, řetězce, Parcelable, Serializable, Enum a pole. Pro komplexní objekty použijte předávání ID s načtením z ViewModel nebo databáze.

Deep Link — externí odkaz otevírající konkrétní obrazovku aplikace. Navigation Component zpracovává deep links prostřednictvím atributu app:deepLink v NavGraph. Systém vytváří PendingIntent, který obnoví navigační zásobník do cílové obrazovky, nebo vytvoří nový zásobník, pokud aplikace není spuštěna.

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>

// Programové vytvoření 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 podporují šablony URI s cestami a query parametry, intent action a mime type. Placeholder ({userId}) je automaticky mapován na argument destination. Navigation Component také zpracovává implicitní deep links přes AndroidManifest — stačí přidat intent-filter k Activity s NavHostFragment.

Navigation Compose (androidx.navigation:navigation-compose) — rozšíření Navigation Component pro Jetpack Compose. API zachovává koncept NavController a NavHost, ale obrazovky jsou funkce Composable namísto Fragment. NavHost přijímá composable lambda pro každou trasu.

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 používá řetězcové trasy namísto id. Parametry se předávají přes šablonu trasy ("detail/{itemId}") a extrahují se z backStackEntry. rememberNavController() uchovává NavController při rekompozici. Pro Type Safety v Compose se doporučuje modul navigation-compose-type-safety (experimentální).

Často kladené otázky

Co je NavHost v Navigation Component?

NavHost — kontejner pro zobrazení navigačních obrazovek. Implementuje se přes NavHostFragment v XML layoutu. NavHost sleduje aktuální obrazovku v NavGraph a spravuje přechody. Každé Activity obsahuje jeden NavHostFragment.

Čím je Safe Args lepší než Bundle?

Safe Args — plugin Gradle generující typově bezpečné třídy argumentů. Bundle vyžaduje ruční zadávání klíčů a typů, což vede k chybám za běhu. Safe Args kontroluje typy při kompilaci a automaticky serializuje data.

Jak předat komplexní objekty přes Navigation Component?

Komplexní objekty se předávají přes ViewModel (sdílený mezi obrazovkami) nebo přes databázi s předáním ID. Safe Args podporuje pouze primitivy, řetězce a Parcelable. Google doporučuje vyhnout se předávání velkých objektů přes navigační argumenty.

Jak funguje Deep Link v Navigation Component?

Deep Link se konfiguruje v NavGraph přes atribut app:deepLink. Navigation Component automaticky zpracovává příchozí odkazy, vytváří PendingIntent přes NavDeepLinkBuilder a obnovuje navigační zásobník do cílové obrazovky. Podporuje URI, intent action a mime type.

Lze použít Navigation Component s Jetpack Compose?

Ano. Navigation Compose (androidx.navigation:navigation-compose) poskytuje NavHost pro Compose. API je podobné XML verzi, ale obrazovky jsou funkce Composable. NavController se používá stejně v obou verzích. Google doporučuje Navigation Compose pro nové projekty v Compose.

Shrnutí

  • Navigation Component — knihovna Android Jetpack pro centralizovanou navigaci s NavController, NavHost a NavGraph
  • NavGraph — XML graf popisující všechny obrazovky (destination) a vazby (action) mezi nimi
  • NavHostFragment — kontejner v layoutu Activity podporující atribut defaultNavHost pro tlačítko 'Zpět'
  • Safe Args — plugin Gradle pro typově bezpečné předávání argumentů s kontrolou typů při kompilaci
  • Deep Links podporují URI, intent action a mime type s automatickým obnovením navigačního zásobníku
  • Navigation Compose — rozšíření pro Jetpack Compose s řetězcovými trasami a composable obrazovkami
  • Navigation Component je jediný doporučený způsob navigace společností Google v nových Android projektech

Vyvineme mobilní aplikaci na klíč

IT Sectr vytváří aplikace pro iOS a Android pro startupy a podniky od roku 2017. Poradíme vám a navrhneme nejlepší řešení.

Prodiskutovat projekt

Přečtěte si také