It would be great if

RouterContract.Events.BackstackChanged

would also pass the old backstack or inform about what exactly has changed. This would enable us to do things like

saveableStateHolder.removeState(it.originalDestinationUrl)

Because right now it doesn’t look like the router manages saveable state for us, right? So I did something like this:

routerState.renderCurrentDestination(
   route = { screen ->
      val saveableStateProviderKey = remember(key1 = screen) {
         routerState.currentDestinationOrNotFound!!.originalDestinationUrl // seems to be the only way to get hold of the original destination URL
      }
      saveableStateHolder.SaveableStateProvider(key = saveableStateProviderKey) {
         when(screen) {
            Screen.Pastes -> {
               ...
            }
            Screen.Login -> {
               ...
            }
         }
      }
   },
   notFound = {
      ...
   }
)

Having a better way to determine what changed from each Navigation event is something that I have thought about, but haven’t really come to a good solution yet. The main problem is that I would either need to 1. perform a diff on the old and new backstacks to determine what changed (which would be difficult to get right) 2. ask the user to include the “type of change” with each navigation request like

router.trySend(GoToDestination("/newRoute", NavigationDirection.Forward))

(which is cumbersome and adds extra boilerplate) 3. just ask the user to figure this out for themselves. #3 is the option I’ve opted for thus far. And to that point, if you need to compare the previous vs current backstacks on each change, it’s not difficult for you to do that yourself. An earlier version actually did include both the previous and current backstacks in the

BackstackChanged

event, but ultimately decided that it wasn’t all that useful on its own and pulled it out.

I agree it isn’t an easy problem and going with 3 makes sense. Storing the backstack as a variable will likely work, but it means duplicating state which I personally would like to avoid. To support Compose SaveableState the code I’ve posted above would essentially be enough for starters. But I obviously need to clear the state once the according destination disappears from the backstack, therefore my question.

Yeah, duplicating the state isn’t a great solution, but I think you could use Flow operators to help somewhat. For example, something like this might work:

fun <T: Any> Flow<T>.zipWithNext(): Flow<Pair<T?, T>> = flow {
    var prev: T? = null
    collect { value ->
        emit(prev to value)
        prev = value
    }
}

val zippedFlow: Flow<Pair<Backstack<Screen>?, Backstack<Screen>>> = remember(router) {
    router.observeStates().zipWithNext()
}
val value: Pair<Backstack<Screen>?, Backstack<Screen>>? by zippedFlow.collectAsState(initial = null)

if(value != null) {
    val (oldBackstack, currentBackstack) = value!!
    currentBackstack.renderCurrentDestination(
        route = { screen ->
            LaunchedEffect(key1 = screen) {
                // clear the values from the old backstack
            }

            when(screen) {
                Screen.Pastes -> {
                    PastesScreen.Content(router)
                }
                Screen.Login -> {
                    LoginScreen.Content(router)
                }
            }
        },
        notFound = {
            // TODO add "not found" screen
        }
    )
}

Yes, that looks like a reasonable approach. Thanks for the snippet! 🙏