Use CameraChangedCoalesced instead of CameraChanged event (#9061) (#9080)

GitOrigin-RevId: ab8581c210edf6c14b8bbfcd7b0d8296b41068dd

Author: jush

androidauto/src/main/java/com/mapbox/navigation/ui/androidauto/map/compass/CarCompassRenderer.kt

@@ -1,19 +1,21 @@
 package com.mapbox.navigation.ui.androidauto.map.compass
 
-import com.mapbox.maps.CameraChangedCallback
+import com.mapbox.common.Cancelable
+import com.mapbox.maps.CameraChangedCoalescedCallback
 import com.mapbox.maps.MapboxExperimental
 import com.mapbox.maps.MapboxMap
 import com.mapbox.maps.extension.androidauto.MapboxCarMapObserver
 import com.mapbox.maps.extension.androidauto.MapboxCarMapSurface
 import com.mapbox.maps.extension.androidauto.widgets.CompassWidget
 
-@OptIn(MapboxExperimental::class)
+@OptIn(MapboxExperimental::class, com.mapbox.annotation.MapboxExperimental::class)
 class CarCompassRenderer : MapboxCarMapObserver {
 
+    private var cameraChangedCancelable: Cancelable? = null
     private var mapboxMap: MapboxMap? = null
     private var compassWidget: CompassWidget? = null
-    private val onCameraChangeListener = CameraChangedCallback { _ ->
-        mapboxMap?.cameraState?.bearing?.toFloat()?.let { compassWidget?.setRotation(-it) }
+    private val onCameraChangeListener = CameraChangedCoalescedCallback { cameraEvent ->
+        cameraEvent.cameraState.bearing.toFloat().let { compassWidget?.setRotation(-it) }
     }
 
     override fun onAttached(mapboxCarMapSurface: MapboxCarMapSurface) {
@@ -22,12 +24,14 @@ class CarCompassRenderer : MapboxCarMapObserver {
         val mapboxMap = mapboxCarMapSurface.mapSurface.getMapboxMap().also { mapboxMap = it }
         this.compassWidget = compassWidget
         mapboxCarMapSurface.mapSurface.addWidget(compassWidget)
-        mapboxMap.subscribeCameraChanged(onCameraChangeListener)
+        cameraChangedCancelable = mapboxMap.subscribeCameraChangedCoalesced(onCameraChangeListener)
     }
 
     override fun onDetached(mapboxCarMapSurface: MapboxCarMapSurface) {
         compassWidget?.let { mapboxCarMapSurface.mapSurface.removeWidget(it) }
         compassWidget = null
+        cameraChangedCancelable?.cancel()
+        cameraChangedCancelable = null
         mapboxMap = null
     }
 }

ui-components/src/main/java/com/mapbox/navigation/ui/components/maps/internal/ui/CompassButtonComponent.kt

@@ -1,7 +1,8 @@
 package com.mapbox.navigation.ui.components.maps.internal.ui
 
+import com.mapbox.annotation.MapboxExperimental
 import com.mapbox.common.Cancelable
-import com.mapbox.maps.CameraChangedCallback
+import com.mapbox.maps.CameraChangedCoalescedCallback
 import com.mapbox.maps.CameraOptions
 import com.mapbox.maps.MapView
 import com.mapbox.maps.MapboxMap
@@ -16,24 +17,26 @@ class CompassButtonComponent(
 ) : UIComponent() {
 
     private val mapboxMap: MapboxMap? = mapView?.getMapboxMap()
-    private var onCameraChangeCallback: CameraChangedCallback? = null
+    private var onCameraChangeCallback: CameraChangedCoalescedCallback? = null
     private var cameraChangedSubscription: Cancelable? = null
 
+    @OptIn(MapboxExperimental::class)
     override fun onAttached(mapboxNavigation: MapboxNavigation) {
         super.onAttached(mapboxNavigation)
 
         if (mapboxMap != null) {
             compassButton.setOnClickListener {
                 mapboxMap.flyTo(CameraOptions.Builder().bearing(.0).build())
             }
-            onCameraChangeCallback = CameraChangedCallback {
-                compassButton.iconImage.rotation = -mapboxMap.cameraState.bearing.toFloat()
+            onCameraChangeCallback = CameraChangedCoalescedCallback {
+                compassButton.iconImage.rotation = -it.cameraState.bearing.toFloat()
             }.also {
-                cameraChangedSubscription = mapboxMap.subscribeCameraChanged(it)
+                cameraChangedSubscription = mapboxMap.subscribeCameraChangedCoalesced(it)
             }
         }
     }
 
+    @OptIn(MapboxExperimental::class)
     override fun onDetached(mapboxNavigation: MapboxNavigation) {
         super.onDetached(mapboxNavigation)
         compassButton.setOnClickListener(null)

ui-components/src/test/java/com/mapbox/navigation/ui/components/maps/internal/ui/CompassButtonComponentTest.kt

@@ -2,9 +2,12 @@ package com.mapbox.navigation.ui.components.maps.internal.ui
 
 import android.view.View
 import androidx.appcompat.widget.AppCompatImageView
+import com.mapbox.annotation.MapboxExperimental
 import com.mapbox.common.Cancelable
-import com.mapbox.maps.CameraChangedCallback
+import com.mapbox.maps.CameraChangedCoalesced
+import com.mapbox.maps.CameraChangedCoalescedCallback
 import com.mapbox.maps.CameraOptions
+import com.mapbox.maps.CameraState
 import com.mapbox.maps.MapView
 import com.mapbox.maps.MapboxMap
 import com.mapbox.maps.plugin.animation.flyTo
@@ -21,6 +24,7 @@ import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Test
 
+@OptIn(MapboxExperimental::class)
 class CompassButtonComponentTest {
 
     private val mapboxMap = mockk<MapboxMap>(relaxed = true)
@@ -61,17 +65,17 @@ class CompassButtonComponentTest {
         component.onAttached(mapboxNavigation)
 
         verify(exactly = 1) { compassButton.setOnClickListener(any()) }
-        verify(exactly = 1) { mapboxMap.subscribeCameraChanged(any()) }
+        verify(exactly = 1) { mapboxMap.subscribeCameraChangedCoalesced(any()) }
     }
 
     @Test
     fun `onDetached`() {
         val cameraChangedTask = mockk<Cancelable>(relaxed = true)
-        every { mapboxMap.subscribeCameraChanged(any()) } returns cameraChangedTask
-        val cameraCallbacks = mutableListOf<CameraChangedCallback>()
+        every { mapboxMap.subscribeCameraChangedCoalesced(any()) } returns cameraChangedTask
+        val cameraCallbacks = mutableListOf<CameraChangedCoalescedCallback>()
         component = CompassButtonComponent(compassButton, mapView)
         component.onAttached(mapboxNavigation)
-        verify(exactly = 1) { mapboxMap.subscribeCameraChanged(capture(cameraCallbacks)) }
+        verify(exactly = 1) { mapboxMap.subscribeCameraChangedCoalesced(capture(cameraCallbacks)) }
 
         component.onDetached(mapboxNavigation)
 
@@ -96,17 +100,16 @@ class CompassButtonComponentTest {
     @Test
     fun `camera state change rotates the image accordingly`() {
         val cameraChangedTask = mockk<Cancelable>()
-        every { mapboxMap.subscribeCameraChanged(any()) } returns cameraChangedTask
-        val cameraCallbacks = mutableListOf<CameraChangedCallback>()
+        every { mapboxMap.subscribeCameraChangedCoalesced(any()) } returns cameraChangedTask
+        val cameraCallbacks = mutableListOf<CameraChangedCoalescedCallback>()
         component = CompassButtonComponent(compassButton, mapView)
 
         component.onAttached(mapboxNavigation)
 
-        verify(exactly = 1) { mapboxMap.subscribeCameraChanged(capture(cameraCallbacks)) }
-        every { mapboxMap.cameraState } returns mockk {
-            every { bearing } returns 78.12
-        }
-        cameraCallbacks.first().run(mockk())
+        verify(exactly = 1) { mapboxMap.subscribeCameraChangedCoalesced(capture(cameraCallbacks)) }
+        val cameraState = mockk<CameraState>()
+        every { cameraState.bearing } returns 78.12
+        cameraCallbacks.first().run(CameraChangedCoalesced(cameraState, mockk()))
         verify { iconImage.rotation = -78.12f }
     }
 }

ui-maps/src/main/java/com/mapbox/navigation/ui/maps/camera/data/debugger/MapboxNavigationViewportDataSourceDebugger.kt

@@ -5,12 +5,13 @@ import android.graphics.Color
 import android.view.View
 import android.widget.FrameLayout
 import androidx.core.content.ContextCompat
+import com.mapbox.annotation.MapboxExperimental
 import com.mapbox.common.Cancelable
 import com.mapbox.geojson.Feature
 import com.mapbox.geojson.FeatureCollection
 import com.mapbox.geojson.LineString
 import com.mapbox.geojson.Point
-import com.mapbox.maps.CameraChangedCallback
+import com.mapbox.maps.CameraChangedCoalescedCallback
 import com.mapbox.maps.EdgeInsets
 import com.mapbox.maps.MapView
 import com.mapbox.maps.extension.style.layers.addLayer
@@ -83,7 +84,9 @@ class MapboxNavigationViewportDataSourceDebugger @JvmOverloads constructor(
                 mapView.addView(mapPaddingBorder)
                 mapView.addView(userPaddingBorder)
                 mapView.addView(cameraCenter)
-                cameraChangedSubscription = mapboxMap.subscribeCameraChanged(cameraChangeCallback)
+                cameraChangedSubscription = mapboxMap.subscribeCameraChangedCoalesced(
+                    cameraChangeCallback,
+                )
             } else {
                 mapView.removeView(cameraCenter)
                 mapView.removeView(userPaddingBorder)
@@ -92,8 +95,9 @@ class MapboxNavigationViewportDataSourceDebugger @JvmOverloads constructor(
                 mapboxMap.getStyle()?.removeStyleLayer(pointsLayerId)
                 mapboxMap.getStyle()?.removeStyleSource(pointsSourceId)
             }
-            updateMapCameraCenter()
-            updateMapPadding()
+            val initialCameraState = mapboxMap.cameraState
+            updateMapCameraCenter(initialCameraState.center)
+            updateMapPadding(initialCameraState.padding)
             updateUserPadding()
             updatePoints()
         }
@@ -143,23 +147,22 @@ class MapboxNavigationViewportDataSourceDebugger @JvmOverloads constructor(
         setBackgroundColor(Color.RED)
     }
 
-    private val cameraChangeCallback = CameraChangedCallback {
+    @OptIn(MapboxExperimental::class)
+    private val cameraChangeCallback = CameraChangedCoalescedCallback {
         mapView.post {
-            updateMapCameraCenter()
-            updateMapPadding()
+            updateMapCameraCenter(it.cameraState.center)
+            updateMapPadding(it.cameraState.padding)
         }
     }
     private var cameraChangedSubscription: Cancelable? = null
 
-    private fun updateMapCameraCenter() {
-        val center = mapboxMap.pixelForCoordinate(mapboxMap.cameraState.center)
+    private fun updateMapCameraCenter(cameraStateCenter: Point) {
+        val center = mapboxMap.pixelForCoordinate(cameraStateCenter)
         cameraCenter.x = center.x.toFloat() - cameraCenter.width / 2
         cameraCenter.y = center.y.toFloat() - cameraCenter.height / 2
     }
 
-    private fun updateMapPadding() {
-        val padding = mapboxMap.cameraState.padding
-
+    private fun updateMapPadding(padding: EdgeInsets) {
         val width = (mapView.width - padding.left - padding.right).toInt()
         val height = (mapView.height - padding.top - padding.bottom).toInt()
         val params = mapPaddingBorder.layoutParams

ui-maps/src/main/java/com/mapbox/navigation/ui/maps/camera/lifecycle/NavigationScaleGestureHandler.kt

@@ -6,9 +6,10 @@ import androidx.annotation.UiThread
 import com.mapbox.android.gestures.AndroidGesturesManager
 import com.mapbox.android.gestures.MoveGestureDetector
 import com.mapbox.android.gestures.RotateGestureDetector
+import com.mapbox.annotation.MapboxExperimental
 import com.mapbox.common.Cancelable
 import com.mapbox.geojson.Point
-import com.mapbox.maps.CameraChangedCallback
+import com.mapbox.maps.CameraChangedCoalescedCallback
 import com.mapbox.maps.MapboxMap
 import com.mapbox.maps.plugin.animation.CameraAnimationsLifecycleListener
 import com.mapbox.maps.plugin.animation.CameraAnimationsPlugin
@@ -263,7 +264,8 @@ class NavigationScaleGestureHandler(
             puckScreenPosition = point.also { adjustFocalPoint(it) }
         }
 
-    private val onCameraChangedCallback = CameraChangedCallback {
+    @OptIn(MapboxExperimental::class)
+    private val onCameraChangedCallback = CameraChangedCoalescedCallback {
         puckScreenPosition?.let { adjustFocalPoint(it) }
     }
     private var cameraChangedSubscription: Cancelable? = null
@@ -318,7 +320,10 @@ class NavigationScaleGestureHandler(
 
         userLocationIndicatorPositionProvider.addObserver(onIndicatorPositionChangedListener)
 
-        cameraChangedSubscription = mapboxMap.subscribeCameraChanged(onCameraChangedCallback)
+        @OptIn(MapboxExperimental::class)
+        cameraChangedSubscription = mapboxMap.subscribeCameraChangedCoalesced(
+            onCameraChangedCallback,
+        )
 
         navigationCamera.registerNavigationCameraStateChangeObserver(
             navigationCameraStateChangedObserver,

ui-maps/src/test/java/com/mapbox/navigation/ui/maps/camera/lifecycle/NavigationScaleGestureHandlerTest.kt

@@ -4,9 +4,10 @@ import android.content.Context
 import com.mapbox.android.gestures.AndroidGesturesManager
 import com.mapbox.android.gestures.MoveGestureDetector
 import com.mapbox.android.gestures.RotateGestureDetector
+import com.mapbox.annotation.MapboxExperimental
 import com.mapbox.common.Cancelable
 import com.mapbox.geojson.Point
-import com.mapbox.maps.CameraChangedCallback
+import com.mapbox.maps.CameraChangedCoalescedCallback
 import com.mapbox.maps.MapboxMap
 import com.mapbox.maps.ScreenCoordinate
 import com.mapbox.maps.plugin.animation.CameraAnimatorType
@@ -70,7 +71,9 @@ class NavigationScaleGestureHandlerTest {
     private val customGesturesInteractorSlot = slot<(AndroidGesturesManager) -> Unit>()
     private val onMoveListenerSlot = slot<OnMoveListener>()
     private val onIndicatorPositionChangedListenerSlot = slot<OnIndicatorPositionChangedListener>()
-    private val cameraChangedCallbackSlot = slot<CameraChangedCallback>()
+
+    @OptIn(MapboxExperimental::class)
+    private val cameraChangedCallbackSlot = slot<CameraChangedCoalescedCallback>()
     private val cameraChangedTask = mockk<Cancelable>(relaxed = true)
     private val navigationCameraStateChangedObserverSlot =
         slot<NavigationCameraStateChangedObserver>()
@@ -107,7 +110,8 @@ class NavigationScaleGestureHandlerTest {
             )
         } just Runs
         every {
-            mapboxMap.subscribeCameraChanged(capture(cameraChangedCallbackSlot))
+            @OptIn(MapboxExperimental::class)
+            mapboxMap.subscribeCameraChangedCoalesced(capture(cameraChangedCallbackSlot))
         } returns cameraChangedTask
         every {
             navigationCamera.registerNavigationCameraStateChangeObserver(