Nawigacja stanowi jeden z fundamentalnych elementów każdej aplikacji mobilnej. W ekosystemie Android, Jetpack Navigation Compose przeszedł znaczącą ewolucję, wprowadzając w 2026 roku pełne wsparcie dla nawigacji typu type-safe. Ten przewodnik przedstawia najnowsze podejścia do implementacji nawigacji w aplikacjach Compose oraz przygotowuje do rozmów rekrutacyjnych na stanowiska Android Developer.

Od wersji Navigation 2.8.0, Kotlin DSL dla nawigacji Compose obsługuje przekazywanie argumentów w sposób w pełni typowany, eliminując potrzebę ręcznego parsowania stringów i znacząco redukując błędy w czasie wykonywania.

Jetpack Navigation Compose umożliwia deklaratywne definiowanie grafu nawigacji bezpośrednio w kodzie Kotlin. W przeciwieństwie do tradycyjnego podejścia opartego na XML, cały graf nawigacji definiowany jest programowo, co zapewnia lepszą integrację z Compose i większą elastyczność.

Podstawowa konfiguracja wymaga zdefiniowania NavHost oraz poszczególnych destynacji:

kotlin

@Composable
fun AppNavigation() {
    val navController = rememberNavController()
    
    NavHost(
        navController = navController,
        startDestination = "home"
    ) {
        composable("home") {
            HomeScreen(
                onNavigateToDetails = { id ->
                    navController.navigate("details/$id")
                }
            )
        }
        composable(
            route = "details/{itemId}",
            arguments = listOf(
                navArgument("itemId") { type = NavType.StringType }
            )
        ) { backStackEntry ->
            val itemId = backStackEntry.arguments?.getString("itemId")
            DetailsScreen(itemId = itemId)
        }
    }
}

Powyższy przykład ilustruje tradycyjne podejście z argumentami opartymi na stringach. Choć funkcjonalne, wymaga ono ręcznego parsowania i jest podatne na błędy typograficzne.

Nawigacja Type-Safe z Kotlin Serialization

Wprowadzenie nawigacji typu type-safe eliminuje problemy związane z ręcznym zarządzaniem argumentami. Dzięki integracji z Kotlin Serialization, destynacje definiowane są jako klasy danych z pełnym wsparciem dla typów.

kotlin

@Serializable
object Home

@Serializable
data class Details(val itemId: String)

@Serializable
data class Profile(val userId: Int, val showSettings: Boolean = false)

@Composable
fun TypeSafeNavigation() {
    val navController = rememberNavController()
    
    NavHost(
        navController = navController,
        startDestination = Home
    ) {
        composable<Home> {
            HomeScreen(
                onNavigateToDetails = { id ->
                    navController.navigate(Details(itemId = id))
                }
            )
        }
        composable<Details> { backStackEntry ->
            val details: Details = backStackEntry.toRoute()
            DetailsScreen(itemId = details.itemId)
        }
        composable<Profile> { backStackEntry ->
            val profile: Profile = backStackEntry.toRoute()
            ProfileScreen(
                userId = profile.userId,
                showSettings = profile.showSettings
            )
        }
    }
}

Kluczowe zalety tego podejścia obejmują weryfikację typów w czasie kompilacji, automatyczną serializację argumentów oraz eliminację błędów związanych z nieprawidłowymi nazwami tras.

Zagnieżdżone Grafy Nawigacji

W większych aplikacjach organizacja nawigacji w zagnieżdżone grafy poprawia czytelność kodu i umożliwia modularyzację funkcjonalności. Każdy moduł aplikacji może definiować własny podgraf nawigacji.

kotlin

@Serializable
object AuthGraph

@Serializable
object Login

@Serializable
object Register

@Serializable
object ForgotPassword

fun NavGraphBuilder.authNavGraph(navController: NavController) {
    navigation<AuthGraph>(startDestination = Login) {
        composable<Login> {
            LoginScreen(
                onNavigateToRegister = {
                    navController.navigate(Register)
                },
                onNavigateToForgotPassword = {
                    navController.navigate(ForgotPassword)
                }
            )
        }
        composable<Register> {
            RegisterScreen(
                onRegistrationComplete = {
                    navController.popBackStack(Login, inclusive = true)
                    navController.navigate(Home)
                }
            )
        }
        composable<ForgotPassword> {
            ForgotPasswordScreen(
                onPasswordReset = {
                    navController.popBackStack()
                }
            )
        }
    }
}

Zagnieżdżone grafy umożliwiają enkapsulację logiki nawigacji specyficznej dla danego modułu, co jest szczególnie przydatne w architekturze wielomodułowej.

Obsługa Deep Links

Deep links pozwalają na bezpośrednie otwarcie konkretnego ekranu aplikacji z zewnętrznego źródła. Navigation Compose obsługuje deep links poprzez deklaratywną konfigurację.

kotlin

@Serializable
data class Product(
    val productId: String,
    val source: String? = null
)

NavHost(
    navController = navController,
    startDestination = Home
) {
    composable<Product>(
        deepLinks = listOf(
            navDeepLink<Product>(
                basePath = "https://example.com/product"
            )
        )
    ) { backStackEntry ->
        val product: Product = backStackEntry.toRoute()
        ProductScreen(
            productId = product.productId,
            source = product.source
        )
    }
}

Konfiguracja w AndroidManifest.xml pozostaje niezbędna dla obsługi deep links na poziomie systemu:

xml

<activity android:name=".MainActivity">
    <intent-filter>
        <action android:name="android.intent.action.VIEW" />
        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
        <data
            android:scheme="https"
            android:host="example.com"
            android:pathPrefix="/product" />
    </intent-filter>
</activity>

Zarządzanie Stanem Nawigacji

Efektywne zarządzanie stanem nawigacji wymaga zrozumienia cyklu życia NavBackStackEntry oraz mechanizmów zachowywania stanu. SavedStateHandle umożliwia przechowywanie danych przeżywających rekonfigurację.

kotlin

@HiltViewModel
class ProductViewModel @Inject constructor(
    savedStateHandle: SavedStateHandle
) : ViewModel() {
    
    private val productRoute: Product = savedStateHandle.toRoute()
    
    val productId: String = productRoute.productId
    
    private val _uiState = MutableStateFlow(ProductUiState())
    val uiState: StateFlow<ProductUiState> = _uiState.asStateFlow()
    
    init {
        loadProduct(productId)
    }
    
    private fun loadProduct(id: String) {
        viewModelScope.launch {
            _uiState.update { it.copy(isLoading = true) }
            // Fetch product data
        }
    }
}

Integracja z Hilt zapewnia automatyczne wstrzykiwanie SavedStateHandle do ViewModel, co umożliwia dostęp do argumentów nawigacji w sposób type-safe.

Animacje Przejść

Navigation Compose oferuje wsparcie dla niestandardowych animacji przejść między ekranami. Animacje definiowane są na poziomie poszczególnych destynacji lub globalnie dla całego NavHost.

kotlin

NavHost(
    navController = navController,
    startDestination = Home,
    enterTransition = {
        slideIntoContainer(
            towards = AnimatedContentTransitionScope.SlideDirection.Start,
            animationSpec = tween(300)
        )
    },
    exitTransition = {
        slideOutOfContainer(
            towards = AnimatedContentTransitionScope.SlideDirection.Start,
            animationSpec = tween(300)
        )
    },
    popEnterTransition = {
        slideIntoContainer(
            towards = AnimatedContentTransitionScope.SlideDirection.End,
            animationSpec = tween(300)
        )
    },
    popExitTransition = {
        slideOutOfContainer(
            towards = AnimatedContentTransitionScope.SlideDirection.End,
            animationSpec = tween(300)
        )
    }
) {
    // Destinations
}

Nawigacja Warunkowa i Guardy

Implementacja nawigacji warunkowej, na przykład sprawdzanie stanu autoryzacji przed dostępem do chronionych ekranów, wymaga odpowiedniej architektury.

kotlin

@Composable
fun AppNavigation(
    isAuthenticated: Boolean,
    onAuthRequired: () -> Unit
) {
    val navController = rememberNavController()
    
    LaunchedEffect(isAuthenticated) {
        if (!isAuthenticated) {
            navController.navigate(Login) {
                popUpTo(navController.graph.startDestinationId) {
                    inclusive = true
                }
            }
        }
    }
    
    NavHost(
        navController = navController,
        startDestination = if (isAuthenticated) Home else Login
    ) {
        composable<Home> {
            HomeScreen()
        }
        composable<Login> {
            LoginScreen(
                onLoginSuccess = {
                    navController.navigate(Home) {
                        popUpTo(Login) { inclusive = true }
                    }
                }
            )
        }
    }
}

Testowanie Nawigacji

Testowanie nawigacji w aplikacjach Compose wymaga odpowiedniego przygotowania środowiska testowego. Biblioteka navigation-testing dostarcza narzędzi do weryfikacji zachowania nawigacji.

kotlin

class NavigationTest {
    
    @get:Rule
    val composeTestRule = createComposeRule()
    
    private lateinit var navController: TestNavHostController
    
    @Before
    fun setup() {
        composeTestRule.setContent {
            navController = TestNavHostController(LocalContext.current)
            navController.navigatorProvider.addNavigator(
                ComposeNavigator()
            )
            AppNavigation(navController = navController)
        }
    }
    
    @Test
    fun navigateToDetails_displaysCorrectScreen() {
        composeTestRule.onNodeWithText("View Details").performClick()
        
        val currentRoute = navController.currentBackStackEntry?.toRoute<Details>()
        assertNotNull(currentRoute)
        assertEquals("expected-id", currentRoute?.itemId)
    }
}

Gotowy na rozmowy o Android?

Ćwicz z naszymi interaktywnymi symulatorami, flashcards i testami technicznymi.

Odkryj Android

Poniżej przedstawiono typowe pytania zadawane podczas rozmów rekrutacyjnych na stanowiska Android Developer dotyczące nawigacji w Compose.

Pytanie: Jakie są główne różnice między nawigacją opartą na stringach a nawigacją type-safe w Compose?

Nawigacja oparta na stringach wymaga ręcznego definiowania tras jako stringów i parsowania argumentów z NavBackStackEntry. Jest podatna na błędy typograficzne i nie oferuje weryfikacji typów w czasie kompilacji. Nawigacja type-safe wykorzystuje klasy danych z adnotacją @Serializable jako destynacje, zapewniając pełną weryfikację typów, automatyczną serializację i deserializację argumentów oraz eliminację błędów związanych z nieprawidłowymi nazwami tras.

Pytanie: Jak zaimplementować nawigację warunkową na podstawie stanu autoryzacji?

Nawigacja warunkowa implementowana jest poprzez obserwację stanu autoryzacji w LaunchedEffect lub przy użyciu derivedStateOf. Gdy stan autoryzacji zmienia się, nawController programowo nawiguje do odpowiedniej destynacji, wykorzystując popUpTo z inclusive = true do wyczyszczenia stosu nawigacji.

Pytanie: Wyjaśnij różnicę między popBackStack() a navigateUp().

Metoda popBackStack() bezwarunkowo usuwa bieżącą destynację ze stosu nawigacji. Metoda navigateUp() respektuje strukturę nawigacji zdefiniowaną przez deep links i grafy nadrzędne, potencjalnie nawigując do destynacji spoza bieżącego grafu, jeśli aplikacja została uruchomiona przez deep link.

Pytanie: Jak zachować stan ekranu podczas nawigacji w Compose?

Stan ekranu zachowywany jest poprzez użycie rememberSaveable dla prostych wartości, SavedStateHandle w ViewModel dla złożonych danych oraz poprawną konfigurację NavHost z odpowiednim zarządzaniem NavBackStackEntry. Dodatkowo, można wykorzystać mechanizm saveState i restoreState w NavOptions.

Pytanie: Jakie są najlepsze praktyki organizacji nawigacji w aplikacji wielomodułowej?

W architekturze wielomodułowej każdy moduł funkcjonalny definiuje własne destynacje jako publiczne klasy danych oraz funkcję rozszerzającą NavGraphBuilder dodającą podgraf nawigacji. Moduł app agreguje wszystkie podgrafy w głównym NavHost. Destynacje eksponowane są poprzez publiczne API modułu, podczas gdy implementacja ekranów pozostaje prywatna.

Podsumowanie

Jetpack Navigation Compose w 2026 roku oferuje dojrzały i kompletny zestaw narzędzi do implementacji nawigacji w aplikacjach Android. Wprowadzenie nawigacji typu type-safe znacząco podnosi bezpieczeństwo typów i redukuje błędy w czasie wykonywania. Zrozumienie zaawansowanych wzorców, takich jak zagnieżdżone grafy, deep links czy animacje przejść, stanowi kluczowy element przygotowania do rozmów rekrutacyjnych na stanowiska Android Developer.

Regularna praktyka implementacji różnych scenariuszy nawigacyjnych oraz dogłębne zrozumienie mechanizmów wewnętrznych biblioteki Navigation Compose przygotowuje do efektywnego rozwiązywania problemów zarówno w codziennej pracy, jak i podczas technicznych rozmów rekrutacyjnych.

Jetpack Navigation Compose w 2026: Nawigacja Type-Safe i Pytania Rekrutacyjne

Podstawy Jetpack Navigation Compose

Nawigacja Type-Safe z Kotlin Serialization

Zagnieżdżone Grafy Nawigacji

Obsługa Deep Links

Zarządzanie Stanem Nawigacji

Animacje Przejść

Nawigacja Warunkowa i Guardy

Testowanie Nawigacji

Gotowy na rozmowy o Android?

Pytania Rekrutacyjne: Jetpack Navigation Compose

Podsumowanie

Znajdziesz błąd w Android?

Powiązane artykuły

Jetpack Compose: Zaawansowane Animacje Krok po Kroku

20 najczesciej zadawanych pytan rekrutacyjnych z Jetpack Compose w 2026

Android WorkManager w 2026: Zadania w Tle, Ograniczenia i Pytania Rekrutacyjne