Integrate the new camera changed coalesced into platform code (#3562)

PR #3525 introduced a new event: camera changed coalesced.

We do not currently expose the new event fully. It is annotated with
`@RestrictTo(Scope.LIBRARY_GROUP_PREFIX)` and also `MapboxExperimental`.
We might expose it later on in 11.13.0-beta.1.

This PR substitutes the previous use of `cameraChanged` event in
scalebar and `MapCamera` plugins.

Previously, with `cameraChanged` event, we were running unnecessary code
in those cases where the camera state changed internally but it was not
the one being rendered in the map. That was clearly visible when doing
an animation (for example `flyTo`) where each animator calls
`setCamera`. Every `setCamera` results in `cameraChanged` event. The new
`cameraChangedCoalesced` will only be triggered once, once all the
`setCamera` are done and the new camera options to be rendered is known.

https://mapbox.atlassian.net/browse/MAPSAND-2116

cc @mapbox/sdk-ci

GitOrigin-RevId: 394adbb4e8c7d40c37ab2326ed1538042955508c

Author: jush

CHANGELOG.md

@@ -7,6 +7,8 @@ Mapbox welcomes participation and contributions from everyone.
 * Expose `RenderThreadStatsRecorder` as experimental API. 
 * Expose an experimental API to define a non-rectangular screen culling shape(`MapboxMap.get/setScreenCullingShape`)
 
+## Bug fixes 🐞
+* Fix registering camera change listener every time `mapView.scalebar.enabled` is called with value `true` and it was already enabled.
 
 # 11.12.0-rc.1
 ## Features ✨ and improvements 🏁

app/src/androidTest/java/com/mapbox/maps/testapp/observable/ObservableEventsTest.kt

@@ -5,6 +5,7 @@ import androidx.core.content.ContextCompat
 import androidx.core.graphics.drawable.toBitmap
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.LargeTest
+import com.mapbox.annotation.MapboxExperimental
 import com.mapbox.bindgen.DataRef
 import com.mapbox.common.Cancelable
 import com.mapbox.geojson.Point
@@ -18,6 +19,7 @@ import com.mapbox.maps.testapp.BaseMapTest
 import com.mapbox.maps.testapp.R
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -517,36 +519,110 @@ class ObservableEventsTest : BaseMapTest() {
     }
   }
 
+  @OptIn(MapboxExperimental::class)
   @Test
   @UiThread
   fun subscribeCameraChangedEvent() {
-    val latch = CountDownLatch(1)
+    var latch = CountDownLatch(2)
+    val targetCameraOptions2 = cameraOptions {
+        center(Point.fromLngLat(1.0, 2.0))
+        zoom(16.0)
+        bearing(18.0)
+        pitch(85.0)
+        anchor(ScreenCoordinate(1.0, 2.0))
+        padding(EdgeInsets(1.0, 2.0, 3.0, 4.0))
+      }
 
+    val cameraChangedResults = mutableListOf<CameraChanged>()
     val listener = CameraChangedCallback {
-      val actualCameraOption = it.cameraState.toCameraOptions()
-      assertNotNull(it.timestamp.time)
-      assertEquals(targetCameraOptions.center!!.longitude(), actualCameraOption.center!!.longitude(), EPS)
-      assertEquals(targetCameraOptions.center!!.latitude(), actualCameraOption.center!!.latitude(), EPS)
-      assertEquals(targetCameraOptions.zoom, actualCameraOption.zoom)
+      cameraChangedResults.add(it)
       latch.countDown()
     }
 
-    rule.scenario.onActivity { activity ->
-      activity.runOnUiThread {
-        mapboxMap.apply {
-          cancelable = subscribeCameraChanged(listener)
-          setCamera(targetCameraOptions)
+    val coalescedLatch = CountDownLatch(1)
+    val cameraChangedCoalescedResults = mutableListOf<CameraChangedCoalesced>()
+    val listenerCoalesced = CameraChangedCoalescedCallback {
+      cameraChangedCoalescedResults.add(it)
+      coalescedLatch.countDown()
+    }
+
+    var cancelableCoalesced: Cancelable? = null
+
+    try {
+      rule.scenario.onActivity { activity ->
+        activity.runOnUiThread {
+          mapboxMap.apply {
+            cancelable = subscribeCameraChanged(listener)
+            cancelableCoalesced = subscribeCameraChangedCoalesced(listenerCoalesced)
+            setCamera(targetCameraOptions)
+            setCamera(targetCameraOptions2)
+          }
         }
       }
-    }
-    loadTestStyle()
-    if (!latch.await(20000, TimeUnit.MILLISECONDS)) {
-      throw TimeoutException()
-    }
+      loadTestStyle()
+
+      // For normal camera changed events we should get 2 events (same as `setCamera` calls)
+      assertTrue(latch.await(20_000, TimeUnit.MILLISECONDS))
+      assertEquals(2, cameraChangedResults.size)
+      assertNotNull(cameraChangedResults[0].timestamp.time)
+      with(cameraChangedResults[0].cameraState) {
+        assertEquals(targetCameraOptions.center!!.longitude(), center.longitude(), EPS)
+        assertEquals(targetCameraOptions.center!!.latitude(), center.latitude(), EPS)
+        assertEquals(targetCameraOptions.zoom, zoom)
+      }
+      with(cameraChangedResults[1].cameraState) {
+        assertEquals(targetCameraOptions2.center!!.longitude(), center.longitude(), EPS)
+        assertEquals(targetCameraOptions2.center!!.latitude(), center.latitude(), EPS)
+        assertEquals(targetCameraOptions2.zoom, zoom)
+        assertEquals(targetCameraOptions2.bearing, bearing)
+        assertEquals(targetCameraOptions2.pitch, pitch)
+        assertEquals(targetCameraOptions2.anchor, ScreenCoordinate(1.0, 2.0))
+        assertEquals(targetCameraOptions2.padding, EdgeInsets(1.0, 2.0, 3.0, 4.0))
+      }
 
-    rule.scenario.onActivity { activity ->
-      activity.runOnUiThread {
-        cancelable.cancel()
+      // We should only get one coalesced event instead of 2 like the normal camera changed event
+      assertEquals(1, cameraChangedCoalescedResults.size)
+      assertNotNull(cameraChangedCoalescedResults[0].timestamp.time)
+      with(cameraChangedCoalescedResults[0].cameraState) {
+        assertEquals(targetCameraOptions2.center!!.longitude(), center.longitude(), EPS)
+        assertEquals(targetCameraOptions2.center!!.latitude(), center.latitude(), EPS)
+        assertEquals(targetCameraOptions2.zoom, zoom)
+        assertEquals(targetCameraOptions2.bearing, bearing)
+        assertEquals(targetCameraOptions2.pitch, pitch)
+        assertEquals(targetCameraOptions2.anchor, ScreenCoordinate(1.0, 2.0))
+        assertEquals(targetCameraOptions2.padding, EdgeInsets(1.0, 2.0, 3.0, 4.0))
+      }
+
+      latch = CountDownLatch(1)
+      rule.scenario.onActivity { activity ->
+        activity.runOnUiThread {
+          mapboxMap.apply {
+            setCamera(targetCameraOptions2)
+          }
+        }
+      }
+      assertTrue(latch.await(20_000, TimeUnit.MILLISECONDS))
+      assertEquals(3, cameraChangedResults.size)
+      assertNotNull(cameraChangedResults[2].timestamp.time)
+      with(cameraChangedResults[2].cameraState) {
+        assertEquals(targetCameraOptions2.center!!.longitude(), center.longitude(), EPS)
+        assertEquals(targetCameraOptions2.center!!.latitude(), center.latitude(), EPS)
+        assertEquals(targetCameraOptions2.zoom, zoom)
+        assertEquals(targetCameraOptions2.bearing, bearing)
+        assertEquals(targetCameraOptions2.pitch, pitch)
+        assertEquals(targetCameraOptions2.anchor, ScreenCoordinate(1.0, 2.0))
+        assertEquals(targetCameraOptions2.padding, EdgeInsets(1.0, 2.0, 3.0, 4.0))
+      }
+
+      // The camera changed coalesced event should not be called again because we pushed the same
+      // camera than last time.
+      assertEquals(1, cameraChangedCoalescedResults.size)
+    } finally {
+      rule.scenario.onActivity { activity ->
+        activity.runOnUiThread {
+          cancelable.cancel()
+          cancelableCoalesced?.cancel()
+        }
       }
     }
   }

app/src/main/java/com/mapbox/maps/testapp/examples/DebugModeActivity.kt

@@ -148,6 +148,7 @@ class DebugModeActivity : AppCompatActivity() {
     }
   }
 
+  @OptIn(com.mapbox.annotation.MapboxExperimental::class)
   private fun registerListeners(mapboxMap: MapboxMap) {
     mapboxMap.subscribeStyleLoaded {
       logI(TAG, "StyleLoadedCallback: $it")
@@ -173,6 +174,9 @@ class DebugModeActivity : AppCompatActivity() {
     mapboxMap.subscribeCameraChanged {
       logI(TAG, "CameraChangedCallback: $it")
     }
+    mapboxMap.subscribeCameraChangedCoalesced {
+      logI(TAG, "CameraChangedCoalescedCallback: $it")
+    }
     mapboxMap.subscribeRenderFrameStarted {
       logI(TAG, "RenderFrameStartedCallback: $it")
     }

app/src/main/java/com/mapbox/maps/testapp/examples/InsetMapActivity.kt

@@ -3,10 +3,14 @@ package com.mapbox.maps.testapp.examples
 import android.graphics.Color
 import android.os.Bundle
 import androidx.appcompat.app.AppCompatActivity
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
 import com.mapbox.geojson.Feature
 import com.mapbox.geojson.LineString
 import com.mapbox.geojson.Point
 import com.mapbox.maps.*
+import com.mapbox.maps.coroutine.cameraChangedEvents
 import com.mapbox.maps.dsl.cameraOptions
 import com.mapbox.maps.extension.style.layers.addLayer
 import com.mapbox.maps.extension.style.layers.generated.lineLayer
@@ -26,12 +30,13 @@ import com.mapbox.maps.plugin.scalebar.scalebar
 import com.mapbox.maps.testapp.R
 import com.mapbox.maps.testapp.databinding.ActivityInsetMapBinding
 import com.mapbox.maps.testapp.examples.fragment.MapFragment
+import kotlinx.coroutines.launch
 
 /**
  * Example demonstrating displaying two maps: main map and small map with lower zoom
  * in bottom-right corner with optional bounds showing what area is covered by main map.
  */
-class InsetMapActivity : AppCompatActivity(), CameraChangedCallback {
+class InsetMapActivity : AppCompatActivity() {
 
   private lateinit var mainMapboxMap: MapboxMap
   private var insetMapboxMap: MapboxMap? = null
@@ -44,7 +49,17 @@ class InsetMapActivity : AppCompatActivity(), CameraChangedCallback {
     mainMapboxMap.setCamera(MAIN_MAP_CAMERA_POSITION)
     mainMapboxMap.loadStyle(
       style = STYLE_URL
-    ) { mainMapboxMap.subscribeCameraChanged(this@InsetMapActivity) }
+    )
+
+    lifecycleScope.launch {
+      // repeatOnLifecycle launches the block in a new coroutine every time the
+      // lifecycle is in the STARTED state (or above) and cancels it when it's STOPPED.
+      repeatOnLifecycle(Lifecycle.State.STARTED) {
+        mainMapboxMap.cameraChangedEvents.collect {
+          updateInsetMapCamera(it.cameraState)
+        }
+      }
+    }
 
     var insetMapFragment: MapFragment? =
       supportFragmentManager.findFragmentByTag(INSET_FRAGMENT_TAG) as? MapFragment
@@ -76,10 +91,7 @@ class InsetMapActivity : AppCompatActivity(), CameraChangedCallback {
         loadStyle(
           style = STYLE_URL
         ) { style ->
-          val source = geoJsonSource(BOUNDS_LINE_LAYER_SOURCE_ID) {
-            feature(Feature.fromGeometry(LineString.fromLngLats(getRectanglePoints())))
-          }
-          style.addSource(source)
+          style.addSource(geoJsonSource(BOUNDS_LINE_LAYER_SOURCE_ID) {})
           // The layer properties for our line. This is where we make the line dotted, set the color, etc.
           val layer = lineLayer(BOUNDS_LINE_LAYER_LAYER_ID, BOUNDS_LINE_LAYER_SOURCE_ID) {
             lineCap(LineCap.ROUND)
@@ -89,7 +101,7 @@ class InsetMapActivity : AppCompatActivity(), CameraChangedCallback {
             visibility(Visibility.VISIBLE)
           }
           style.addLayer(layer)
-          updateInsetMapLineLayerBounds(style)
+          updateInsetMapLineLayerBounds(style, mainMapboxMap.cameraState)
         }
       }
       insetMapFragment.getMapView().apply {
@@ -106,27 +118,29 @@ class InsetMapActivity : AppCompatActivity(), CameraChangedCallback {
     }
   }
 
-  override fun run(cameraChanged: CameraChanged) {
-    val mainCameraPosition = mainMapboxMap.cameraState
+  private fun updateInsetMapCamera(mainCameraPosition: CameraState) {
     val insetCameraPosition = CameraOptions.Builder()
       .zoom(mainCameraPosition.zoom.minus(ZOOM_DISTANCE_BETWEEN_MAIN_AND_INSET_MAPS))
       .pitch(mainCameraPosition.pitch)
       .bearing(mainCameraPosition.bearing)
       .center(mainCameraPosition.center)
       .build()
     insetMapboxMap?.setCamera(insetCameraPosition)
-    insetMapboxMap?.getStyle { style -> updateInsetMapLineLayerBounds(style) }
+    insetMapboxMap?.getStyle { style -> updateInsetMapLineLayerBounds(style, mainCameraPosition) }
   }
 
-  private fun updateInsetMapLineLayerBounds(fullyLoadedStyle: Style) {
+  private fun updateInsetMapLineLayerBounds(
+    fullyLoadedStyle: Style,
+    mainMapCameraState: CameraState
+  ) {
     (fullyLoadedStyle.getSource(BOUNDS_LINE_LAYER_SOURCE_ID) as? GeoJsonSource)?.apply {
-      feature(Feature.fromGeometry(LineString.fromLngLats(getRectanglePoints())))
+      feature(Feature.fromGeometry(LineString.fromLngLats(getRectanglePoints(mainMapCameraState))))
     }
   }
 
-  private fun getRectanglePoints(): List<Point> {
+  private fun getRectanglePoints(mainMapCameraState: CameraState): List<Point> {
     val bounds = mainMapboxMap.coordinateBoundsForCamera(
-      mainMapboxMap.cameraState.toCameraOptions()
+      mainMapCameraState.toCameraOptions()
     )
     return listOf(
       Point.fromLngLat(bounds.northeast.longitude(), bounds.northeast.latitude()),

app/src/main/java/com/mapbox/maps/testapp/examples/markersandcallouts/viewannotation/DynamicViewAnnotationActivity.kt

@@ -5,7 +5,6 @@ import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.Paint
 import android.graphics.Rect
-import android.graphics.drawable.BitmapDrawable
 import android.graphics.drawable.Drawable
 import android.os.Bundle
 import android.view.View
@@ -15,6 +14,7 @@ import androidx.annotation.UiThread
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.content.ContextCompat.getColor
 import androidx.core.content.ContextCompat.getDrawable
+import androidx.core.graphics.drawable.toDrawable
 import androidx.lifecycle.lifecycleScope
 import com.mapbox.geojson.Feature
 import com.mapbox.geojson.FeatureCollection
@@ -288,13 +288,13 @@ class DynamicViewAnnotationActivity : AppCompatActivity() {
     val paddingView = PaddingView(context)
     addView(paddingView)
     mapboxMap.subscribeCameraChanged {
-      mapboxMap.cameraState.padding.let {
+      it.cameraState.padding.let { padding ->
         paddingView.updateRect(
           Rect(
-            /* left = */ it.left.toInt(),
-            /* top = */ it.top.toInt(),
-            /* right = */ width - it.right.toInt(),
-            /* bottom = */ height - it.bottom.toInt()
+            /* left = */ padding.left.toInt(),
+            /* top = */ padding.top.toInt(),
+            /* right = */ width - padding.right.toInt(),
+            /* bottom = */ height - padding.bottom.toInt()
           )
         )
       }
@@ -497,15 +497,12 @@ class DynamicViewAnnotationActivity : AppCompatActivity() {
       }
     }
 
-    return BitmapDrawable(
-      resources,
-      BitmapUtils.drawableToBitmap(
-        getDrawable(this, R.drawable.bg_dva_eta)!!,
-        flipX = flipX,
-        flipY = flipY,
-        tint = tint,
-      )
-    )
+    return BitmapUtils.drawableToBitmap(
+      getDrawable(this, R.drawable.bg_dva_eta)!!,
+      flipX = flipX,
+      flipY = flipY,
+      tint = tint,
+    ).toDrawable(resources)
   }
 
   private companion object {

extension-compose/api/Release/metalava.txt

@@ -41,6 +41,7 @@ package com.mapbox.maps.extension.compose {
   @androidx.compose.runtime.Stable public final class MapState {
     ctor public MapState();
     method @com.mapbox.maps.MapboxExperimental public kotlinx.coroutines.flow.Flow<com.mapbox.maps.GenericEvent> genericEvents(String eventName);
+    method @RestrictTo(androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP_PREFIX) public kotlinx.coroutines.flow.Flow<com.mapbox.maps.CameraChangedCoalesced> getCameraChangedCoalescedEvents();
     method public kotlinx.coroutines.flow.Flow<com.mapbox.maps.CameraChanged> getCameraChangedEvents();
     method @com.mapbox.maps.MapboxExperimental public suspend <FS extends com.mapbox.maps.interactions.FeatureState> Object? getFeatureState(com.mapbox.maps.interactions.FeaturesetFeature<FS> featuresetFeature, kotlin.coroutines.Continuation<? super FS>);
     method public com.mapbox.maps.plugin.gestures.generated.GesturesSettings getGesturesSettings();
@@ -67,6 +68,7 @@ package com.mapbox.maps.extension.compose {
     method @com.mapbox.maps.MapboxExperimental public suspend Object? resetFeatureStates(com.mapbox.maps.interactions.TypedFeaturesetDescriptor<?,?> descriptor, kotlin.coroutines.Continuation<? super com.mapbox.bindgen.Expected<java.lang.String,com.mapbox.bindgen.None>>);
     method @com.mapbox.maps.MapboxExperimental public suspend <FS extends com.mapbox.maps.interactions.FeatureState> Object? setFeatureState(com.mapbox.maps.interactions.FeaturesetFeature<FS> featuresetFeature, FS state, kotlin.coroutines.Continuation<? super com.mapbox.bindgen.Expected<java.lang.String,com.mapbox.bindgen.None>>);
     method public void setGesturesSettings(com.mapbox.maps.plugin.gestures.generated.GesturesSettings);
+    property @RestrictTo(androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP_PREFIX) public final kotlinx.coroutines.flow.Flow<com.mapbox.maps.CameraChangedCoalesced> cameraChangedCoalescedEvents;
     property public final kotlinx.coroutines.flow.Flow<com.mapbox.maps.CameraChanged> cameraChangedEvents;
     property public final com.mapbox.maps.plugin.gestures.generated.GesturesSettings gesturesSettings;
     property public final kotlinx.coroutines.flow.Flow<com.mapbox.maps.MapIdle> mapIdleEvents;

extension-compose/api/extension-compose.api

@@ -63,6 +63,7 @@ public final class com/mapbox/maps/extension/compose/MapState {
 	public static final field Companion Lcom/mapbox/maps/extension/compose/MapState$Companion;
 	public fun <init> ()V
 	public final fun genericEvents (Ljava/lang/String;)Lkotlinx/coroutines/flow/Flow;
+	public final fun getCameraChangedCoalescedEvents ()Lkotlinx/coroutines/flow/Flow;
 	public final fun getCameraChangedEvents ()Lkotlinx/coroutines/flow/Flow;
 	public final fun getFeatureState (Lcom/mapbox/maps/interactions/FeaturesetFeature;Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 	public final fun getGesturesSettings ()Lcom/mapbox/maps/plugin/gestures/generated/GesturesSettings;