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 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.
<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.
// 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 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 — 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.
// 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.
<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.
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
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.
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.
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.
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.
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í
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í.
Přečtěte si také