use OnBackPressedDispatcher for back press handling (#6483)

Author: Zayankovsky

CHANGELOG.md

@@ -8,6 +8,8 @@ Mapbox welcomes participation and contributions from everyone.
 - Improved precision of congestion visualization and independent leg styling transitions, especially for long routes. [#6476](https://github.com/mapbox/mapbox-navigation-android/pull/6476)
 - Fixed an issue with congestion visualization on the route line that occurred during route refreshes. [#6476](https://github.com/mapbox/mapbox-navigation-android/pull/6476)
 - Made `MapViewBinder#shouldLoadMapStyle` false by default. [#6485](https://github.com/mapbox/mapbox-navigation-android/pull/6485)
+- Fixed an issue that prevented any registered `OnBackPressedCallback`s to fire when `NavigationView` is attached. [#6483](https://github.com/mapbox/mapbox-navigation-android/pull/6483)
+- Removed `NavigationViewListener.onBackPressed()`. You can register your own [OnBackPressedCallback](https://developer.android.com/reference/androidx/activity/OnBackPressedCallback) to intercept any `NavigationView` BACK press events. [#6483](https://github.com/mapbox/mapbox-navigation-android/pull/6483)
 
 ## Mapbox Navigation SDK 2.9.0-beta.2 - 14 October, 2022
 ### Changelog

libnavui-dropin/api/current.txt

@@ -355,7 +355,6 @@ package com.mapbox.navigation.dropin.navigationview {
     method public void onActiveNavigation();
     method public void onArrival();
     method public void onAudioGuidanceStateChanged(boolean muted);
-    method public boolean onBackPressed();
     method public void onCameraPaddingChanged(com.mapbox.maps.EdgeInsets padding);
     method public void onDestinationChanged(com.mapbox.geojson.Point? destination);
     method public void onDestinationPreview();

libnavui-dropin/src/main/java/com/mapbox/navigation/dropin/NavigationView.kt

@@ -24,11 +24,11 @@ import com.mapbox.navigation.core.lifecycle.MapboxNavigationApp
 import com.mapbox.navigation.core.replay.MapboxReplayer
 import com.mapbox.navigation.dropin.actionbutton.ActionButtonsCoordinator
 import com.mapbox.navigation.dropin.analytics.AnalyticsComponent
-import com.mapbox.navigation.dropin.backpress.OnKeyListenerComponent
+import com.mapbox.navigation.dropin.backpress.BackPressedComponent
 import com.mapbox.navigation.dropin.databinding.MapboxNavigationViewLayoutBinding
 import com.mapbox.navigation.dropin.infopanel.InfoPanelCoordinator
 import com.mapbox.navigation.dropin.internal.extensions.navigationViewAccessToken
-import com.mapbox.navigation.dropin.internal.extensions.toComponentActivityRef
+import com.mapbox.navigation.dropin.internal.extensions.toComponentActivity
 import com.mapbox.navigation.dropin.internal.extensions.toViewModelStoreOwner
 import com.mapbox.navigation.dropin.maneuver.ManeuverCoordinator
 import com.mapbox.navigation.dropin.map.MapLayoutCoordinator
@@ -124,15 +124,16 @@ class NavigationView @JvmOverloads constructor(
 
         MapboxNavigationApp.attach(this)
 
+        val componentActivity = context.toComponentActivity()
         attachCreated(
             AnalyticsComponent(),
-            LocationPermissionComponent(context.toComponentActivityRef(), navigationContext.store),
+            LocationPermissionComponent(componentActivity, navigationContext.store),
             TripSessionComponent(lifecycle, navigationContext.store),
             MapLayoutCoordinator(navigationContext, binding),
-            OnKeyListenerComponent(
+            BackPressedComponent(
+                componentActivity.onBackPressedDispatcher,
                 navigationContext.store,
-                this,
-                navigationContext.listenerRegistry
+                lifecycleOwner = this,
             ),
             ScalebarPlaceholderCoordinator(navigationContext, binding.scalebarLayout),
             ManeuverCoordinator(navigationContext, binding.guidanceLayout),

libnavui-dropin/src/main/java/com/mapbox/navigation/dropin/backpress/BackPressedComponent.kt

@@ -0,0 +1,90 @@
+package com.mapbox.navigation.dropin.backpress
+
+import androidx.activity.OnBackPressedCallback
+import androidx.activity.OnBackPressedDispatcher
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.repeatOnLifecycle
+import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
+import com.mapbox.navigation.core.MapboxNavigation
+import com.mapbox.navigation.dropin.NavigationView
+import com.mapbox.navigation.ui.app.internal.Store
+import com.mapbox.navigation.ui.app.internal.destination.DestinationAction
+import com.mapbox.navigation.ui.app.internal.endNavigation
+import com.mapbox.navigation.ui.app.internal.extension.dispatch
+import com.mapbox.navigation.ui.app.internal.navigation.NavigationState
+import com.mapbox.navigation.ui.app.internal.navigation.NavigationStateAction
+import com.mapbox.navigation.ui.app.internal.routefetch.RoutePreviewAction
+import com.mapbox.navigation.ui.app.internal.routefetch.RoutesAction
+import com.mapbox.navigation.ui.base.lifecycle.UIComponent
+import com.mapbox.navigation.utils.internal.logE
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.launch
+
+/**
+ * Back pressed callback for the [NavigationView].
+ *
+ * On back pressed will update the navigation state.
+ *
+ * (FreeDrive) <- (DestinationPreview) <- (RoutePreview) <- (ActiveNavigation)
+ *             <- (Arrival)
+ */
+@ExperimentalPreviewMapboxNavigationAPI
+internal class BackPressedComponent(
+    onBackPressedDispatcher: OnBackPressedDispatcher,
+    private val store: Store,
+    private val lifecycleOwner: LifecycleOwner,
+) : UIComponent() {
+
+    private val onBackPressedCallback = object : OnBackPressedCallback(false) {
+
+        override fun handleOnBackPressed() {
+            when (store.state.value.navigation) {
+                NavigationState.FreeDrive -> {
+                    logE(
+                        msg = "The back pressed callback should be disabled in Free Drive state",
+                        category = "BackPressedComponent",
+                    )
+                }
+                NavigationState.DestinationPreview -> {
+                    store.dispatch(DestinationAction.SetDestination(null))
+                    store.dispatch(NavigationStateAction.Update(NavigationState.FreeDrive))
+                }
+                NavigationState.RoutePreview -> {
+                    store.dispatch(RoutePreviewAction.Ready(emptyList()))
+                    store.dispatch(NavigationStateAction.Update(NavigationState.DestinationPreview))
+                }
+                NavigationState.ActiveNavigation -> {
+                    store.dispatch(RoutesAction.SetRoutes(emptyList()))
+                    store.dispatch(NavigationStateAction.Update(NavigationState.RoutePreview))
+                }
+                NavigationState.Arrival -> {
+                    store.dispatch(endNavigation())
+                }
+            }
+        }
+    }
+
+    // Add the callback before onAttached so downstream developers can register higher priority
+    // back press callbacks. This means the component has to be registered via attachCreated.
+    init {
+        onBackPressedDispatcher.addCallback(onBackPressedCallback)
+    }
+
+    override fun onAttached(mapboxNavigation: MapboxNavigation) {
+        super.onAttached(mapboxNavigation)
+        coroutineScope.launch {
+            lifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                store.select { it.navigation != NavigationState.FreeDrive }
+                    .onCompletion { onBackPressedCallback.isEnabled = false }
+                    .collect { onBackPressedCallback.isEnabled = it }
+            }
+        }
+    }
+
+    override fun onDetached(mapboxNavigation: MapboxNavigation) {
+        super.onDetached(mapboxNavigation)
+        onBackPressedCallback.remove()
+    }
+}

libnavui-dropin/src/main/java/com/mapbox/navigation/dropin/backpress/OnKeyListenerComponent.kt

@@ -7,8 +7,6 @@ import android.content.Context
 import android.content.ContextWrapper
 import androidx.activity.ComponentActivity
 import androidx.lifecycle.ViewModelStoreOwner
-import com.mapbox.navigation.utils.internal.logW
-import java.lang.ref.WeakReference
 
 internal tailrec fun Context.recursiveUnwrap(): Context =
     if (this !is Activity && this is ContextWrapper) {
@@ -25,10 +23,10 @@ internal fun Context.toViewModelStoreOwner(): ViewModelStoreOwner {
     return viewModelStoreOwner
 }
 
-internal fun Context.toComponentActivityRef(): WeakReference<ComponentActivity>? {
+internal fun Context.toComponentActivity(): ComponentActivity {
     val componentActivity = this.recursiveUnwrap() as? ComponentActivity
-    if (componentActivity == null) {
-        logW("Unable to find ComponentActivity to request location permissions")
+    checkNotNull(componentActivity) {
+        "Please ensure that the hosting Context is a valid ComponentActivity"
     }
-    return componentActivity?.let { WeakReference(it) }
+    return componentActivity
 }

libnavui-dropin/src/main/java/com/mapbox/navigation/dropin/internal/extensions/ContextEx.kt

@@ -141,13 +141,6 @@ abstract class NavigationViewListener {
      */
     open fun onInfoPanelSlide(slideOffset: Float) = Unit
 
-    /**
-     * Called when hardware back button has been pressed.
-     *
-     * @return True if the listener has consumed the event, false otherwise.
-     */
-    open fun onBackPressed(): Boolean = false
-
     /**
      * Called when maneuver view has been expanded.
      */

libnavui-dropin/src/main/java/com/mapbox/navigation/dropin/navigationview/NavigationViewListener.kt

@@ -1,7 +1,5 @@
 package com.mapbox.navigation.dropin.navigationview
 
-import android.view.KeyEvent
-import android.view.View
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.mapbox.navigation.base.ExperimentalPreviewMapboxNavigationAPI
 import com.mapbox.navigation.dropin.infopanel.InfoPanelBehavior
@@ -27,7 +25,7 @@ internal class NavigationViewListenerRegistry(
     private val infoPanelSubscriber: InfoPanelBehavior,
     private val mapClickSubscriber: MapClickBehavior,
     private val coroutineScope: CoroutineScope
-) : View.OnKeyListener {
+) {
     private var listeners = mutableMapOf<NavigationViewListener, Job>()
 
     fun registerListener(listener: NavigationViewListener) {
@@ -39,19 +37,6 @@ internal class NavigationViewListenerRegistry(
         listeners.remove(listener)?.cancel()
     }
 
-    //region View.OnKeyListener
-
-    override fun onKey(v: View, keyCode: Int, event: KeyEvent): Boolean {
-        if (keyCode == KeyEvent.KEYCODE_BACK && event.action == KeyEvent.ACTION_UP) {
-            listeners.forEach { (listener, _) ->
-                if (listener.onBackPressed()) return true
-            }
-        }
-        return false
-    }
-
-    //endregion
-
     private fun connectListener(listener: NavigationViewListener): Job {
         return coroutineScope.launch {
             launch {

libnavui-dropin/src/main/java/com/mapbox/navigation/dropin/navigationview/NavigationViewListenerRegistry.kt

@@ -20,15 +20,17 @@ import java.lang.ref.WeakReference
 /**
  * Default experience for location permissions.
  *
- * @param componentActivityRef used for requesting location permissions
+ * @param componentActivity used for requesting location permissions
  * @param tripSessionStarterViewModel used to notify when location permissions are granted
  */
 @ExperimentalPreviewMapboxNavigationAPI
 internal class LocationPermissionComponent(
-    private val componentActivityRef: WeakReference<ComponentActivity>?,
+    componentActivity: ComponentActivity,
     private val store: Store
 ) : UIComponent() {
 
+    private val componentActivityRef = WeakReference(componentActivity)
+
     private val callback = ActivityResultCallback { permissions: Map<String, Boolean> ->
         val accessFineLocation = permissions[FINE_LOCATION_PERMISSIONS]
             ?: false
@@ -39,7 +41,7 @@ internal class LocationPermissionComponent(
     }
 
     private val launcher = try {
-        componentActivityRef?.get()?.registerForActivityResult(
+        componentActivityRef.get()?.registerForActivityResult(
             ActivityResultContracts.RequestMultiplePermissions(),
             callback
         )
@@ -82,7 +84,7 @@ internal class LocationPermissionComponent(
      */
     private fun notifyGrantedOnForegrounded(applicationContext: Context) {
         coroutineScope.launch {
-            componentActivityRef?.get()?.repeatOnLifecycle(Lifecycle.State.STARTED) {
+            componentActivityRef.get()?.repeatOnLifecycle(Lifecycle.State.STARTED) {
                 if (!store.state.value.tripSession.isLocationPermissionGranted) {
                     val isGranted = PermissionsManager.areLocationPermissionsGranted(
                         applicationContext