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 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.
<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.
// 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 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 — 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.
// 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.
<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.
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
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.
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.
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.
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.
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
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.
Przeczytaj również