Navigation Component — ce este, NavHost și Navigation Graph

Autor: IT Sectr Publicat: 2026-02-22 Timp de citire: 7 min

Navigation Component — biblioteca Android Jetpack pentru implementarea navigării între ecranele aplicației. Componenta centralizează gestionarea stivei de fragmente, linkurile adânci și transmiterea argumentelor. Face parte din Jetpack din 2018 și este recomandat de Google pentru toate proiectele noi. Citiți mai multe în ghidul oficial Google.

Principalele puncte

  • Navigation Component — biblioteca Jetpack pentru navigare centralizată între ecranele Android
  • NavGraph — resursă XML care descrie toate ecranele și conexiunile dintre ele
  • NavHostFragment — container în layout-ul Activity care afișează ecranul curent de navigare
  • NavController — obiect de gestionare a navigării: navigate, popBackStack, navigateUp
  • Safe Args — plugin Gradle pentru transmiterea tip-securizată a argumentelor între ecrane

Ce este Navigation Component?

Navigation Component — biblioteca Android Jetpack (androidx.navigation) care oferă o API unificată pentru navigare. Include trei elemente cheie: Navigation Graph (graful de navigare), NavHostFragment (container pentru ecrane) și NavController (controler de tranziții). Componenta gestionează automat stiva de navigare și suportă deep links.

Înainte de Navigation Component, dezvoltatorii gestionau fragmentele manual prin FragmentManager. Acest lucru ducea la cod fragmentat: fiecare ecran avea propriile reguli de navigare, stările stivei de navigare diferau, iar deep links necesitau implementare separată. Navigation Component a unificat aceste scenarii. Conform Google (2026), biblioteca este instalată în 90% din noile proiecte Android.

Navigation Component se integrează cu alte biblioteci Jetpack: LiveData, ViewModel, Material Design. Suportă atât fragmente XML, cât și Jetpack Compose prin extensia navigation-compose. Lansarea stabilă — 2.8.x (2025), versiunea minimă Android — API 14.

NavGraph — resursă XML (res/navigation/nav_graph.xml) care definește toate ecranele aplicației și conexiunile dintre ele. Fiecare ecran este un nod (destination), care poate fi Fragment, Activity sau Composable. Conexiunile dintre noduri sunt action, care specifică direcția tranziției.

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

Atributul startDestination stabilește primul ecran afișat la pornire. Action definește destination-ul țintă și animațiile opționale. Argumentele (argument) descriu parametrii transmiși către ecran — tipul și valoarea implicită.

NavHostFragment — container plasat în layout-ul Activity care afișează ecranul curent de navigare. NavHostFragment comută automat fragmentele la apelarea NavController.navigate(). NavController — obiect care gestionează navigarea: tranziție, întoarcere, verificarea rutei curente.

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 leagă NavController de AppBar
        setupActionBarWithNavController(navController)
    }

    // Tranziție la ecranul de detalii
    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" — atribut important: interceptează butonul de sistem „Înapoi" și transmite controlul către NavController. NavigationUI — utilitar pentru conectarea NavController cu AppBar, BottomNavigationView, NavigationDrawer. setupActionBarWithNavController activează săgeata „Sus" pe ecranele imbricate.

Navigation Component suportă animații personalizate de tranziție, definite în action sau programatic. Animațiile sunt definite prin patru atribute: enterAnim (apariția ecranului nou), exitAnim (dispariția ecranului curent), popEnterAnim (apariția la întoarcere) și popExitAnim (dispariția la întoarcere).

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>

// Tranziție programatică cu animație
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)

Animațiile funcționează cu Fragment la nivel de FragmentTransaction. Pentru Jetpack Compose, animațiile se definesc prin NavOptionsCompat utilizând Compose Animation. Navigation Component nu impune restricții asupra tipului de animație — suportă translate, scale, alpha și combinațiile lor.

Safe Args: argumente tip-securizate

Safe Args — plugin Gradle pentru transmiterea tip-securizată a datelor între ecrane. Pluginul analizează NavGraph, generează clase Directions și Args cu câmpuri de tipuri specifice. La compilare se verifică conformitatea tipurilor — eroarea MissingArgumentException este depistată înainte de lansarea aplicației.

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

// Safe Args generează: DetailFragmentArgs, HomeFragmentDirections
// Utilizare în HomeFragment:
val action = HomeFragmentDirections
    .actionHomeToDetail(itemId = 42L)
findNavController().navigate(action)

// Utilizare în DetailFragment:
private val args: DetailFragmentArgs by navArgs()
// args.itemId are tipul Long, null nu poate fi transmis

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

navArgs() — delegat Kotlin pentru obținerea argumentelor în Fragment sau Activity. Pluginul suportă primitive, șiruri de caractere, Parcelable, Serializable, Enum și tablouri. Pentru obiecte complexe, utilizați transmiterea ID-ului cu încărcare din ViewModel sau bază de date.

Deep Link — link extern care deschide un ecran specific al aplicației. Navigation Component gestionează deep links prin atributul app:deepLink în NavGraph. Sistemul creează un PendingIntent care restaurează stiva de navigare până la ecranul țintă sau creează o stivă nouă dacă aplicația nu este pornită.

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>

// Crearea programatică a 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 suportă șabloane URI cu căi și parametri query, intent action și mime type. Placeholder-ul ({userId}) este asociat automat cu argumentul destination. Navigation Component gestionează și deep links implicite prin AndroidManifest — este suficient să adăugați intent-filter către Activity cu NavHostFragment.

Navigation Compose (androidx.navigation:navigation-compose) — extensia Navigation Component pentru Jetpack Compose. API păstrează conceptul de NavController și NavHost, dar ecranele sunt funcții Composable în loc de Fragment. NavHost primește o lambda composable pentru fiecare rută.

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 utilizează rute sub formă de șiruri de caractere în loc de id. Parametrii sunt transmiși prin șablonul de rută ("detail/{itemId}") și extrași din backStackEntry. rememberNavController() păstrează NavController la recompoziție. Pentru Type Safety în Compose, se recomandă modulul navigation-compose-type-safety (experimental).

Întrebări frecvente

Ce este NavHost în Navigation Component?

NavHost — container pentru afișarea ecranelor de navigare. Se implementează prin NavHostFragment în layout-ul XML. NavHost urmărește ecranul curent din NavGraph și gestionează tranzițiile. Fiecare Activity conține un singur NavHostFragment.

Cu ce este Safe Args mai bun decât Bundle?

Safe Args — plugin Gradle care generează clase de argumente tip-securizate. Bundle necesită specificarea manuală a cheilor și tipurilor, ceea ce duce la erori de execuție. Safe Args verifică tipurile la compilare și serializează automat datele.

Cum se transmit obiecte complexe prin Navigation Component?

Obiectele complexe se transmit prin ViewModel (partajat între ecrane) sau prin baza de date cu transmiterea ID-ului. Safe Args suportă doar primitive, șiruri de caractere și Parcelable. Google recomandă evitarea transmiterii obiectelor mari prin argumente de navigare.

Cum funcționează Deep Link în Navigation Component?

Deep Link se configurează în NavGraph prin atributul app:deepLink. Navigation Component gestionează automat linkurile primite, creează un PendingIntent prin NavDeepLinkBuilder și restaurează stiva de navigare până la ecranul țintă. Suportă URI, intent action și mime type.

Se poate utiliza Navigation Component cu Jetpack Compose?

Da. Navigation Compose (androidx.navigation:navigation-compose) oferă NavHost pentru Compose. API este similar cu versiunea XML, dar ecranele sunt funcții Composable. NavController se utilizează la fel în ambele versiuni. Google recomandă Navigation Compose pentru proiecte noi în Compose.

Rezumat

  • Navigation Component — biblioteca Android Jetpack pentru navigare centralizată cu NavController, NavHost și NavGraph
  • NavGraph — graf XML care descrie toate ecranele (destination) și conexiunile (action) dintre ele
  • NavHostFragment — container în layout-ul Activity care suportă atributul defaultNavHost pentru butonul „Înapoi"
  • Safe Args — plugin Gradle pentru transmiterea tip-securizată a argumentelor cu verificare la compilare
  • Deep Links suportă URI, intent action și mime type cu restaurarea automată a stivei de navigare
  • Navigation Compose — extensia pentru Jetpack Compose cu rute sub formă de șiruri și ecrane composable
  • Navigation Component este singurul mod de navigare recomandat de Google în proiectele Android noi

Vom dezvolta o aplicație mobilă la cheie

IT Sectr creează aplicații iOS și Android pentru startup-uri și afaceri din 2017. Vă vom consilia și vă vom propune cea mai bună soluție.

Discutați proiectul

Citiți și