BackPress handling in Android Fragments, The old and the new! + Compose

Demonstrating the old way of implementing this and the new one-liner!

How hard it was to handle BackPress in fragments before!

One of the nice things that recently was introduced in the Android world in devSummit19 was the new way of handling back presses in the fragments which always was a bit of pain to implement. Previously if a fragment let’s say a SearchFragment needed to respond to back press events and close the SearchView, we had to go through all the steps as below:

2024 Update, Scroll all the way down for Jetpack Compose implementation!

The old:

1-We should’ve had an interface as:

Interface that every fragment willing to intercept backPressed() event needs to implement

2- All the fragments willing to intercept the BackPress event had to implement the interface above which caused them having the onBackPressed() function call. Now the fragment can respond to BackPress events and do something and based on if the event was consumed or not they can return true or false.

The fragment:

Fragment that needs to handle backPressed() event

The method:

Logic to handle when backPress is clicked in SearchFragment

3-Now it’s the time to connect the dots and override the Activity’s OnBackPressed() function to implement the logic, We needed to get the current fragment from “fragmentManager” and examine if it was of type BackPressHandler and if so we should’ve executed the onBackPressed() function on that particular fragment and checked the response, If it was returning false, meaning that they were not interested in consuming the event then the next move was to call super.onBackPressed() or do specific logic in the activity, but if it returned true then it means that the fragment has consumed the event and we should skip executing the logic in Activity’s onBackPressed(), Let’s see how it is done in Action:

Structure of MainActivity’s onBackPressed() function

and If you’re wondering what’s inside getTopFragment extension function:

Kotlin function extension to get the fragment on top

The new:

As you can see it was a lot of work just for a simple thing to do, Now with the new way of doing this we only need to add the code below on the Fragment’s onCreate() method:

Demonstration of the recent method of backpress handling in fragments

From now on all the back press events will be captured by handleOnBackPressed() method and your fragments will have the opportunity to react to Back Press events. but what about the times that we’re not sure that we need to consume the back press event? The times that we just need to check some condition and if they apply then do some action? In those cases we can set the isEnabled variable to false and call the onBackPressed() method on activity again manually:

Well, it’s much easier to achieve this by registering OnBackPressedCallback instances for handling the ComponentActivity.onBackPressed() callback via composition.

Jetpack Compose:

It’s 2024 and we need to talk about JC right? It’s much easier to handle back presses in jetpack compose, first we need to import the line below:

import androidx.activity.compose.BackHandler

Then wherever in a composable that we need to override the back press we can have the following block

BackHandler {
    //Handle back press here
}

which we can have our back handling logic inside that block, we still have the same functionality as the fragment world to enable and disable this override based on our logic, an implementation could look like this:

val isDrawerClosed by remember(drawerState.currentValue) {
    mutableStateOf(drawerState.currentValue == DrawerValue.Closed)
}
BackHandler(enabled = isDrawerClosed) {
    drawerState.setValue(DrawerValue.Open)
}

In the code above we are interested in reacting to back presses only if the drawer is opened, and we’d like to close it and if it’s closed we simply don’t care about it. The enabling and disabling gives other Composables and fragments the chance to override and also listen to this event.

The entire code is available on Github:

LloydBlv/BackPressHandle

Are you using Gson in your projects as well? Then maybe it’s time to migrate away from it 🚀🚀🚀:

Goodbye Gson, Hello Moshi

Great job on making it to the end of this article! 💪

• Follow my YouTube channel for video tutorials and tips on Android development
• If you need help with your Android project, Book a 1:1 or a Pair-Programming meeting with me, 100% free! book a time here 🚀

If you like this article please can you do me a little favour and hit the 👏clap button as many times! I really appreciate your kindness x❤️👊

Read more: https://developer.android.com/reference/androidx/activity/OnBackPressedDispatcher