[Jetchat] Adds consistency with Owl's backhandler and uses rememberUp… (android#351)

Author: JoseAlcerreca

Jetchat/app/src/androidTest/java/com/example/compose/jetchat/ConversationTest.kt

@@ -66,7 +66,7 @@ class ConversationTest {
             // Launch the conversation screen
             composeTestRule.setContent {
                 Providers(
-                    AmbientBackPressedDispatcher provides newActivity,
+                    AmbientBackPressedDispatcher provides newActivity.onBackPressedDispatcher,
                     AmbientWindowInsets provides windowInsets
                 ) {
                     JetchatTheme(isDarkTheme = themeIsDark.collectAsState(false).value) {

Jetchat/app/src/androidTest/java/com/example/compose/jetchat/NavigationTest.kt

@@ -65,7 +65,7 @@ class NavigationTest {
         // Start the app
         composeTestRule.setContent {
             Providers(
-                AmbientBackPressedDispatcher provides activity,
+                AmbientBackPressedDispatcher provides activity.onBackPressedDispatcher,
                 AmbientWindowInsets provides windowInsets,
             ) {
                 JetchatTheme {

Jetchat/app/src/androidTest/java/com/example/compose/jetchat/UserInputTest.kt

@@ -65,7 +65,7 @@ class UserInputTest {
             // Launch the conversation screen
             composeTestRule.setContent {
                 Providers(
-                    AmbientBackPressedDispatcher provides activity,
+                    AmbientBackPressedDispatcher provides activity.onBackPressedDispatcher,
                     AmbientWindowInsets provides windowInsets,
                 ) {
                     JetchatTheme {

Jetchat/app/src/main/java/com/example/compose/jetchat/NavActivity.kt

@@ -29,7 +29,7 @@ import androidx.core.view.WindowCompat
 import androidx.navigation.findNavController
 import com.example.compose.jetchat.components.JetchatScaffold
 import com.example.compose.jetchat.conversation.AmbientBackPressedDispatcher
-import com.example.compose.jetchat.conversation.backPressHandler
+import com.example.compose.jetchat.conversation.BackPressHandler
 import com.example.compose.jetchat.databinding.ContentMainBinding
 import dev.chrisbanes.accompanist.insets.ProvideWindowInsets
 
@@ -50,7 +50,7 @@ class NavActivity : AppCompatActivity() {
             // Provide WindowInsets to our content. We don't want to consume them, so that
             // they keep being pass down the view hierarchy (since we're using fragments).
             ProvideWindowInsets(consumeWindowInsets = false) {
-                Providers(AmbientBackPressedDispatcher provides this) {
+                Providers(AmbientBackPressedDispatcher provides this.onBackPressedDispatcher) {
                     val scaffoldState = rememberScaffoldState()
 
                     val openDrawerEvent = viewModel.drawerShouldBeOpened.observeAsState()
@@ -62,11 +62,9 @@ class NavActivity : AppCompatActivity() {
                     }
 
                     // Intercepts back navigation when the drawer is open
-                    backPressHandler(
-                        enabled = scaffoldState.drawerState.isOpen,
-                        onBackPressed = { scaffoldState.drawerState.close() },
-                        highPriority = true
-                    )
+                    if (scaffoldState.drawerState.isOpen) {
+                        BackPressHandler { scaffoldState.drawerState.close() }
+                    }
 
                     JetchatScaffold(
                         scaffoldState,

Jetchat/app/src/main/java/com/example/compose/jetchat/conversation/BackHandler.kt

@@ -17,68 +17,55 @@
 package com.example.compose.jetchat.conversation
 
 import androidx.activity.OnBackPressedCallback
-import androidx.activity.OnBackPressedDispatcherOwner
+import androidx.activity.OnBackPressedDispatcher
 import androidx.compose.runtime.Ambient
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.onCommit
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.staticAmbientOf
 
 /**
- * This [Composable] can be used with a [AmbientBackPressedDispatcher] to intercept a back press (if
- * [enabled]).
+ * This [Composable] can be used with a [AmbientBackPressedDispatcher] to intercept a back press.
  *
  * @param onBackPressed (Event) What to do when back is intercepted
- * @param enabled (state) When to intercept the back navigation
- * @param highPriority (config) Used to make sure this is the first handler in the dispatcher
  *
  */
 @Composable
-fun backPressHandler(
-    onBackPressed: () -> Unit,
-    enabled: Boolean = true,
-    highPriority: Boolean = false
-) {
-    val dispatcher = AmbientBackPressedDispatcher.current.onBackPressedDispatcher
+fun BackPressHandler(onBackPressed: () -> Unit) {
+    // Safely update the current `onBack` lambda when a new one is provided
+    val currentOnBackPressed by rememberUpdatedState(onBackPressed)
 
-    // This callback is going to be remembered only if onBackPressed is referentially equal.
-    val backCallback = remember(onBackPressed) {
-        object : OnBackPressedCallback(enabled) {
+    // Remember in Composition a back callback that calls the `onBackPressed` lambda
+    val backCallback = remember {
+        object : OnBackPressedCallback(true) {
             override fun handleOnBackPressed() {
-                onBackPressed()
+                currentOnBackPressed()
             }
         }
     }
 
-    // Using onCommit guarantees that failed transactions don't incorrectly toggle the
-    // remembered callback.
-    onCommit(enabled, highPriority) {
-        if (enabled && highPriority) {
-            // Since the Navigation Component is also intercepting the back event, make sure
-            // that this is the first callback in the dispatcher.
-            backCallback.remove()
-            dispatcher.addCallback(backCallback)
-        }
-        backCallback.isEnabled = enabled
-    }
+    val backDispatcher = AmbientBackPressedDispatcher.current
 
-    onCommit(dispatcher, onBackPressed) {
-        // Whenever there's a new dispatcher set up the callback
-        dispatcher.addCallback(backCallback)
+    // Whenever there's a new dispatcher set up the callback
+    DisposableEffect(backDispatcher) {
+        backDispatcher.addCallback(backCallback)
+        // When the effect leaves the Composition, or there's a new dispatcher, remove the callback
         onDispose {
             backCallback.remove()
         }
     }
 }
 
 /**
- * This [Ambient] is used to provide an [OnBackPressedDispatcherOwner]:
+ * This [Ambient] is used to provide an [OnBackPressedDispatcher]:
  *
  * ```
- * Providers(AmbientBackPressedDispatcher provides requireActivity()) { }
+ * Providers(AmbientBackPressedDispatcher provides requireActivity().onBackPressedDispatcher) { }
  * ```
  *
- * and setting up the callbacks with [backPressHandler].
+ * and setting up the callbacks with [BackPressHandler].
  */
 val AmbientBackPressedDispatcher =
-    staticAmbientOf<OnBackPressedDispatcherOwner> { error("Ambient used without Provider") }
+    staticAmbientOf<OnBackPressedDispatcher> { error("No Back Dispatcher provided") }

Jetchat/app/src/main/java/com/example/compose/jetchat/conversation/ConversationFragment.kt

@@ -59,7 +59,7 @@ class ConversationFragment : Fragment() {
 
         setContent {
             Providers(
-                AmbientBackPressedDispatcher provides requireActivity(),
+                AmbientBackPressedDispatcher provides requireActivity().onBackPressedDispatcher,
                 AmbientWindowInsets provides windowInsets,
             ) {
                 JetchatTheme {

Jetchat/app/src/main/java/com/example/compose/jetchat/conversation/UserInput.kt

@@ -125,10 +125,11 @@ fun UserInput(
 ) {
     var currentInputSelector by savedInstanceState { InputSelector.NONE }
     val dismissKeyboard = { currentInputSelector = InputSelector.NONE }
-    backPressHandler(
-        enabled = currentInputSelector != InputSelector.NONE,
-        onBackPressed = dismissKeyboard
-    )
+
+    // Intercept back navigation if there's a InputSelector visible
+    if (currentInputSelector != InputSelector.NONE) {
+        BackPressHandler(onBackPressed = dismissKeyboard)
+    }
 
     var textState by remember { mutableStateOf(TextFieldValue()) }