Android navigation components with deep link: onNewIntent called multiple times

When an implicit deeplink is clicked the FLAG_ACTIVITY_NEW_TASK is set with intent. And as per the documentation the backstack will be recreated to be in a good state. See the documentation here Implicit deep link.

If you do not want this behavior and do not want to change the intent flags you can handle the deeplink yourself rather than passing it to Navigation components. So if you are using AdvancedNavigationSample you need to remove handledeeplink and use findNavController().navigate() to the direction.

Also remember to set the launch mode for launcher activity as singleTask to receive new intents on clicking deepink or notifications.

1. Replace NavController.handledeeplink() in sample with

fun BottomNavigationView.navigateDeeplink(
    navGraphIds: List<Int>,
    fragmentManager: FragmentManager,
    containerId: Int,
    uri: Uri
) {
    navGraphIds.forEachIndexed { index, navGraphId ->
        val fragmentTag = getFragmentTag(index)

        // Find or create the Navigation host fragment
        val navHostFragment = obtainNavHostFragment(
            fragmentManager,
            fragmentTag,
            navGraphId,
            containerId
        )
        // Handle deeplink
        val canHandleDeeplink = navHostFragment.navController.graph.hasDeepLink(uri)

        if (canHandleDeeplink) {
            if (selectedItemId != navHostFragment.navController.graph.id) {
                selectedItemId = navHostFragment.navController.graph.id
            }
            navHostFragment.lifecycleScope.launchWhenResumed {
                // Wait for fragment to restore state from backStack
                // otherwise navigate will be ignored
                // Ignoring navigate() call: FragmentManager has already saved its state
                navHostFragment.navController.navigateOnce(uri)
            }
        }
    }
}

2. Store intent.data in a variable and set it to null so that navigation component can not handle it. Also do the same in onHandleNewIntent
3. pass this deeplink to bottom navigation to handle. and if the app is already running you can directly navigate to destination using the above function.

The complete solution is implemented at this sample.

Pros:

1. You can directly handle the notification clicks the same way. Create a deeplink from the actions and pass it in intent.data in PendingIntent.
2. You can validate and change the deeplink according to your need. like if user is not logged it go directly to login activity or else move to specified destination.

When callback on onNewIntent arrive for the first time, just setup the flag intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK); and pass mutated intent to handleDeepLink(intent);

This flag eliminated the second arrive of onNewIntent callback due to reattaching to existing Activity (with full reconstruction of backstack trace to your desired deep link destination) instead of launching new Activity.

Details is in the source code of handleDeepLink method.

It feels weird, but it actually seems to work as intended. The documentation regarding the implicit deep links says:

When triggering an implicit deep link, the state of the back stack depends on whether the implicit Intent was launched with the Intent.FLAG_ACTIVITY_NEW_TASK flag:

If the flag is set, the task back stack is cleared and replaced with the deep link destination....

If the flag is not set, you remain on the task stack of the previous app where the implicit deep link was triggered.

In your case I believe when you tap a link the intent has the flag Intent.FLAG_ACTIVITY_NEW_TASK set, so the whole new stack is created. Currently the implementation just restarts the activity with the newly created stack to make sure the task state is consistent.

If you don't need this behavior, one possible workaround would be to clear the flag Intent.FLAG_ACTIVITY_NEW_TASK from the intent before navigation component has a chance to handle it.

I experienced a similar issue and I was following NavigationAdvancedSample where I had BottomNavigationView with multiple NavHostFragments. So posting my fix for those who has the same case.

More specifically, onCreate() of my MainActivity was getting called twice when app was launched via a notification deeplink.

I had following flags set for the intent:

private fun getPendingIntent(data: Uri?): PendingIntent {
    val intent = Intent(context, MainActivity::class.java)
    intent.action = Intent.ACTION_VIEW
    intent.data = data
    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_NEW_TASK)
    return PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_ONE_SHOT)
}

And I didn't have android:launchMode="singleTask" in the Manifest for the MainActivity, as it wasn't really helpful in my case.

I have fixed my problem first preventing navController.handleDeepLink(intent) to be called automatically on onCreate() of the MainActivity with following code (thanks to you):

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    val uri = intent.data
    intent.data = null
}

and then making the change in this PR in the NavigationExtensions file which basically replaces navController.handleDeepLink(intent) with navController.navigate(uri) which was causing the Activity to be created twice as you noted in your post.

So the code to setup Navigation with BottomNavigationView looks as follows in the MainActivity:

private fun setupBottomNavigation(uri: Uri?) {
    val navGraphIds =
        listOf(
            R.navigation.all_integrations,
            R.navigation.favourites,
            R.navigation.settings
        )

    currentNavController = bottomNavView.setupWithNavController(
        navGraphIds,
        supportFragmentManager,
        R.id.navHostContainer
    )

    uri?.let {
        bottomNavView.handleDeepLinks(
            navGraphIds,
            supportFragmentManager,
            R.id.navHostContainer,
            it
        )
    }
}