Android
Navigation
Evolution

// Navigate to another screen — that's it
Intent intent = new Intent(this, DetailActivity.class);
intent.putExtra("product_id", productId);  // raw String key — no type safety
startActivity(intent);

// Reading the argument in DetailActivity
String productId = getIntent().getStringExtra("product_id");
// Null? Wrong key? Wrong type? Runtime crash. No compile-time check.

// For result — back in the old days
startActivityForResult(intent, REQUEST_CODE);   // deprecated in 2021

// Receive in the original activity
@Override
protected void onActivityResult(int reqCode, int resCode, Intent data) {
    if (reqCode == REQUEST_CODE && resCode == RESULT_OK) {
        String result = data.getStringExtra("result");  // magic string
    }
}

// Navigate to a detail screen
supportFragmentManager
    .beginTransaction()
    .setCustomAnimations(
        R.anim.slide_in_right, R.anim.slide_out_left,   // enter / exit
        R.anim.slide_in_left,  R.anim.slide_out_right   // popEnter / popExit
    )
    .replace(R.id.container, DetailFragment.newInstance(productId))
    .addToBackStack("detail")  // name for selective popping
    .commit()                    // async — or commitNow() for sync

// Passing arguments — still stringly-typed in this era
companion object {
    fun newInstance(id: String) = DetailFragment().also {
        it.arguments = bundleOf("product_id" to id)
    }
}

// Receiving arguments in the Fragment
val productId = requireArguments().getString("product_id")
    ?: error("Missing product_id argument")  // still runtime crash

// Pop back stack
parentFragmentManager.popBackStack()
// Or pop to a specific tag
parentFragmentManager.popBackStack("home", 0)

// Teams invented their own routers...
class Navigator(private val activity: AppCompatActivity) {

    fun goToDetail(productId: String) {
        activity.supportFragmentManager
            .beginTransaction()
            .replace(R.id.container, DetailFragment.newInstance(productId))
            .addToBackStack(null)
            .commit()
    }

    fun goToProfile(userId: String) { /* ... */ }
    fun goToCheckout(cartId: String) { /* ... */ }
    fun goToSettings() { /* ... */ }
    // ... 20 more methods growing forever, no tests
}
// Each team had a different version of this. Each had different bugs.

<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    app:startDestination="@id/homeFragment">

    <fragment
        android:id="@+id/homeFragment"
        android:name="com.app.HomeFragment">

        <action
            android:id="@+id/action_home_to_detail"
            app:destination="@id/detailFragment"
            app:enterAnim="@anim/slide_in_right"
            app:exitAnim="@anim/slide_out_left"/>
    </fragment>

    <fragment
        android:id="@+id/detailFragment"
        android:name="com.app.DetailFragment">

        <argument
            android:name="productId"
            app:argType="string" />       <!-- Safe Args generates type-safe class -->

        <deepLink
            app:uri="https://myapp.com/product/{productId}" />
    </fragment>

    <dialog android:id="@+id/confirmDialog" ... />
</navigation>

// Navigate with compile-time checked arguments
val action = HomeFragmentDirections.actionHomeToDetail(
    productId = "prod_123"   // generated function, typed parameter
)
findNavController().navigate(action)

// Read in DetailFragment — also type-safe
val args: DetailFragmentArgs by navArgs()
val productId: String = args.productId   // compile-time guaranteed non-null String

// Navigate to a bottom nav tab, clearing the stack
val options = navOptions {
    popUpTo(R.id.homeFragment) { inclusive = false }
    launchSingleTop = true
    restoreState = true
}
findNavController().navigate(R.id.feedFragment, null, options)

// NavController observes back stack as Flow
findNavController().addOnDestinationChangedListener { _, dest, _ ->
    binding.toolbar.title = dest.label
}

// NavGraph scoped ViewModel — shared across sub-flow
val checkoutVm: CheckoutViewModel by navGraphViewModels(R.id.checkout_graph)

// NavHost defines the entire graph as a Kotlin DSL
@Composable
fun AppNavHost(navController: NavHostController) {
    NavHost(navController, startDestination = "home") {

        composable("home") {
            HomeScreen(
                onProductClick = { id ->
                    navController.navigate("detail/$id")  // still stringly-typed
                }
            )
        }

        composable(
            route = "detail/{productId}",
            arguments = listOf(navArgument("productId") { type = NavType.StringType })
        ) { backStackEntry ->
            val productId = backStackEntry.arguments?.getString("productId")!!
            DetailScreen(productId = productId, onBack = { navController.popBackStack() })
        }

        composable("settings") { SettingsScreen() }

        navigation(startDestination = "cart", route = "checkout_flow") {
            composable("cart") { CartScreen() }
            composable("payment") { PaymentScreen() }
            composable("confirmation") { ConfirmationScreen() }
        }
    }
}

// Route definitions — plain Kotlin, fully serializable
@Serializable
object HomeRoute

@Serializable
data class DetailRoute(val productId: String)

@Serializable
object CheckoutGraph          // nested graph route

@Serializable
object CartRoute

// NavHost with type-safe destinations
@Composable
fun AppNavHost(navController: NavHostController) {
    NavHost(navController, startDestination = HomeRoute) {

        composable<HomeRoute> {
            HomeScreen(
                onProductClick = { id ->
                    navController.navigate(DetailRoute(productId = id))  // ← type-safe!
                }
            )
        }

        composable<DetailRoute> { backStackEntry ->
            val route: DetailRoute = backStackEntry.toRoute()   // no getString() needed
            DetailScreen(productId = route.productId)          // compile-time guaranteed
        }

        navigation<CheckoutGraph>(startDestination = CartRoute) {
            composable<CartRoute> { CartScreen() }
        }
    }
}

// Navigate — no strings, no magic, full IDE refactoring support
navController.navigate(DetailRoute(productId = "prod_42"))
navController.navigate(CheckoutGraph)
navController.popBackStack<HomeRoute>(inclusive = false)

// Custom NavType for non-primitive types
@Serializable
data class SearchRoute(
    val query: String,
    val filters: List<String> = emptyList(),   // supported via serialization
    val page: Int = 0
)

// Passing nested serializable types via custom NavType
@Serializable
data class ProfileFilter(val showPrivate: Boolean, val sortBy: String)

val ProfileFilterNavType = object : NavType<ProfileFilter>(isNullableAllowed = false) {
    override fun serializeAsValue(value: ProfileFilter) =
        Uri.encode(Json.encodeToString(value))
    override fun parseValue(value: String) =
        Json.decodeFromString(Uri.decode(value))
    override fun get(bundle: Bundle, key: String) =
        bundle.getString(key)?.let { parseValue(it) }
    override fun put(bundle: Bundle, key: String, value: ProfileFilter) =
        bundle.putString(key, serializeAsValue(value))
}