@Composable
fun SampleNavGraph(
  // ...
) {
  NavHost(
    // ...
  ) {
    composable(route = /** Route 1 */) { entry ->
      // ...
      navController.navigate(/** Route 2 */)
    }
    composable(route = /** Route 2 */) { entry ->
      // ...
    }
  }
}

import androidx.core.os.bundleOf
import androidx.navigation.NavController
import androidx.navigation.NavOptions
import androidx.navigation.Navigator
import logcat.LogPriority.WARN
import logcat.logcat

fun NavController.navigateAndArgument(
  route: String,
  args: List<Pair<String, Any>>? = null,
  navOptions: NavOptions? = null,
  navigatorExtras: Navigator.Extras? = null,
) {
  // ⓵ navigate 호출하면, route의 NavBackStackEntry가 backQueue에 추가됨
  navigate(route, navOptions, navigatorExtras)

  if (args == null || args.isEmpty()) {
    return
  }

  // ⓶ backQueue.lastOrNull()의 결과로 route의 NavBackStackEntry가 반환
  val bundle = backQueue.lastOrNull()?.arguments
  if (bundle != null) {
    // ⓷ Bundle 타입의 arguments가 Null이 아니면, 전달하려는 데이터를 추가한다.
    bundle.putAll(bundleOf(*args.toTypedArray()))
  } else {
    logcat(WARN) {
      "The last argument of NavBackStackEntry is null."
    }
  }
}

public open class NavController {
  // ...
  /**
   * Retrieve the current back stack.
   *
   * @return The current back stack.
   * @hide
   */
  @get:RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
  public open val backQueue: ArrayDeque<NavBackStackEntry> = ArrayDeque()
  // ...
}

public class NavBackStackEntry private constructor(
  // ...
  /**
   * The arguments used for this entry
   * @return The arguments used when this entry was created
   */
  public val arguments: Bundle? = null,
)

NavHost(
  navController = navController,
  startDestination = "First",
  modifier = modifier
) {
  composable(route = "First") { entry ->
    entry.print(navController)
    SampleUi(
      title = "First",
      onClick = {
        navController.navigate("Second?test=abcd")
      }
    )
  }
  composable(route = "Second?test={test}",
    arguments = listOf(
      navArgument("test") { type = NavType.StringType }
    )
  ) { entry ->
    entry.print(navController)
    SampleUi(title = "Second")
  }
}

@Composable
private fun NavBackStackEntry.print(navController: NavController) {
  val parentId = destination.parent!!.id
  val parentEntry = remember {
    navController.getBackStackEntry(parentId)
  }
  // 동일한 ViewModelStoreOwner를 사용하도록 처리
  val viewModelStoreOwner: ViewModelStoreOwner = parentEntry
  
  val test1: SampleViewModel = viewModel(viewModelStoreOwner)
  val test2: SampleViewModel = hiltViewModel(viewModelStoreOwner)
  logcat(tag = "logger") {
    "${destination.route} : ViewModelStoreOwner=${viewModelStoreOwner.hashCode()}, vm1=${test1.hashCode()}, vm2=${test2.hashCode()}"
  }
}

// 출력 결과
// First : ViewModelStoreOwner=-218587067, vm1=10245372, vm2=10245372
// Second?test={test} : ViewModelStoreOwner=-218587067, vm1=10245372, vm2=10245372

import android.os.Parcelable
import kotlinx.parcelize.Parcelize
import kotlinx.serialization.Serializable

@Serializable
data class SampleSerializableModel(
  val value: String
): java.io.Serializable

@Serializable
@Parcelize
data class SampleParcelableModel(
  val value: String
): Parcelable

import android.os.Bundle
import android.os.Parcelable
import androidx.navigation.NavType
import kotlinx.serialization.decodeFromString
import kotlinx.serialization.json.Json
import java.io.Serializable

inline fun <reified T : Serializable> createSerializableNavType(
  isNullableAllowed: Boolean = false
): NavType<T> {
  return object : NavType<T>(isNullableAllowed) {
    override val name: String
      get() = "SupportSerializable"

    override fun put(bundle: Bundle, key: String, value: T) {
      bundle.putSerializable(key, value) // Bundle에 Serializable 타입으로 추가
    }

    override fun get(bundle: Bundle, key: String): T? {
      return bundle.getSerializable(key) as? T // Bundle에서 Serializable 타입으로 꺼낸다
    }

    override fun parseValue(value: String): T {
      return Json.decodeFromString(value) // String 전달된 Parsing 방법을 정의
    }
  }
}

inline fun <reified T : Parcelable> createParcelableNavType(
  isNullableAllowed: Boolean = false
): NavType<T> {
  return object : NavType<T>(isNullableAllowed) {
    override val name: String
      get() = "SupportParcelable"

    override fun put(bundle: Bundle, key: String, value: T) {
      bundle.putParcelable(key, value) // Bundle에 Parcelable 타입으로 추가
    }

    override fun get(bundle: Bundle, key: String): T? {
      return bundle.getParcelable(key) // Bundle에서 Parcelable 타입으로 꺼낸다
    }

    override fun parseValue(value: String): T {
      return Json.decodeFromString(value) // String 전달된 Parsing 방법을 정의
    }
  }
}

// Navigation 스펙대로 route 및 arguments를 정의
composable(route = "Third?key1={test_serialize}&key2={test_parcelable}",
  arguments = listOf(
    navArgument("test_serialize") {
      // Serializable NavType을 정의
      type = createSerializableNavType<SampleSerializableModel>()
    },
    navArgument("test_parcelable") {
      // Parcelable NavType을 정의
      type = createParcelableNavType<SampleParcelableModel>()
    }
  )
) { entry ->
  val arguments = requireNotNull(entry.arguments)

  // NavController#navigate로 전달된 정보와 Custom NavType으로
  val sample1 = arguments.getSerializable("test_serialize") as SampleSerializableModel
  val sample2 = arguments.getParcelable<SampleParcelableModel>("test_parcelable")!!

  logcat(tag = "logger") {
    "Third : Serializable=${sample1}, Parcelable=${sample2}"
  }
  // (예) Third : Serializable=SampleSerializableModel(value=abcd), Parcelable=SampleParcelableModel(value=efgh) 가 출력
}

import android.net.Uri
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json

val sample1 = Json.encodeToString(SampleSerializableModel("abcd"))
val sample2 = Json.encodeToString(SampleParcelableModel("efgh"))
navController.navigate(
  "Third?key1=${Uri.encode(sample1)}&key2=${Uri.encode(sample2)}"
)