@rnmapbox/maps 10.2.7 → 10.2.9

package/android/build.gradle

@@ -1,5 +1,13 @@
 def defaultMapboxMapsImpl = "mapbox"
-def defaultMapboxMapsVersion = "11.15.2"
+
+def getDefaultMapboxMapsVersion() {
+    def packageJson = new groovy.json.JsonSlurper().parseText(
+        new File(projectDir.getPath(), "../package.json").text
+    )
+    return packageJson.mapbox.android
+}
+
+def defaultMapboxMapsVersion = getDefaultMapboxMapsVersion()
 
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback

package/android/src/main/java/com/rnmapbox/rnmbx/RNMBXPackage.kt

@@ -34,17 +34,20 @@ import com.rnmapbox.rnmbx.components.styles.layers.RNMBXHeatmapLayerManager
 import com.rnmapbox.rnmbx.components.styles.layers.RNMBXLineLayerManager
 import com.rnmapbox.rnmbx.components.styles.layers.RNMBXModelLayerManager
 import com.rnmapbox.rnmbx.components.styles.layers.RNMBXRasterLayerManager
+import com.rnmapbox.rnmbx.components.styles.layers.RNMBXRasterParticleLayerManager
 import com.rnmapbox.rnmbx.components.styles.layers.RNMBXSkyLayerManager
 import com.rnmapbox.rnmbx.components.styles.layers.RNMBXSymbolLayerManager
 import com.rnmapbox.rnmbx.components.styles.light.RNMBXLightManager
 import com.rnmapbox.rnmbx.components.styles.model.RNMBXModelsManager
 import com.rnmapbox.rnmbx.components.styles.sources.RNMBXImageSourceManager
+import com.rnmapbox.rnmbx.components.styles.sources.RNMBXRasterArraySourceManager
 import com.rnmapbox.rnmbx.components.styles.sources.RNMBXRasterDemSourceManager
 import com.rnmapbox.rnmbx.components.styles.sources.RNMBXRasterSourceManager
 import com.rnmapbox.rnmbx.components.styles.sources.RNMBXShapeSourceManager
 import com.rnmapbox.rnmbx.components.styles.sources.RNMBXShapeSourceModule
 import com.rnmapbox.rnmbx.components.styles.sources.RNMBXVectorSourceManager
 import com.rnmapbox.rnmbx.components.styles.terrain.RNMBXTerrainManager
+import com.rnmapbox.rnmbx.events.RNMBXCameraGestureObserverManager
 import com.rnmapbox.rnmbx.modules.RNMBXLocationModule
 import com.rnmapbox.rnmbx.modules.RNMBXLogging
 import com.rnmapbox.rnmbx.modules.RNMBXModule
@@ -123,6 +126,7 @@ class RNMBXPackage : TurboReactPackage() {
         managers.add(RNMBXMapViewManager(reactApplicationContext, getViewTagResolver(reactApplicationContext, "RNMBXMapViewManager")))
         managers.add(RNMBXStyleImportManager(reactApplicationContext))
         managers.add(RNMBXModelsManager(reactApplicationContext))
+        managers.add(RNMBXCameraGestureObserverManager(reactApplicationContext))
 
         // annotations
         managers.add(RNMBXMarkerViewManager(reactApplicationContext))
@@ -140,6 +144,9 @@ class RNMBXPackage : TurboReactPackage() {
             ))
         managers.add(RNMBXRasterDemSourceManager(reactApplicationContext))
         managers.add(RNMBXRasterSourceManager(reactApplicationContext))
+        if (RNMBXRasterArraySourceManager.isImplemented) {
+            managers.add(RNMBXRasterArraySourceManager(reactApplicationContext))
+        }
         managers.add(RNMBXImageSourceManager())
 
         // images
@@ -154,6 +161,9 @@ class RNMBXPackage : TurboReactPackage() {
         managers.add(RNMBXCircleLayerManager())
         managers.add(RNMBXSymbolLayerManager())
         managers.add(RNMBXRasterLayerManager())
+        if (RNMBXRasterParticleLayerManager.isImplemented) {
+            managers.add(RNMBXRasterParticleLayerManager())
+        }
         managers.add(RNMBXSkyLayerManager())
         managers.add(RNMBXTerrainManager())
         managers.add(RNMBXAtmosphereManager())

package/android/src/main/java/com/rnmapbox/rnmbx/components/location/RNMBXCustomLocationProvider.kt

@@ -87,6 +87,13 @@ class RNMBXCustomLocationProvider(context: Context) : AbstractMapFeature(context
         if (customLocationProvider == null) {
             customLocationProvider = object : LocationProvider {
                 override fun registerLocationConsumer(locationConsumer: LocationConsumer) {
+                    heading?.let {
+                        locationConsumer.onBearingUpdated(it)
+                    }
+                    coordinate?.let {
+                        val point = Point.fromLngLat(it.first, it.second)
+                        locationConsumer.onLocationUpdated(point)
+                    }
                     locationConsumers.add(locationConsumer)
                 }
 

package/android/src/main/java/com/rnmapbox/rnmbx/components/mapview/RNMBXMapView.kt

@@ -917,7 +917,13 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
             Logger.e("queryRenderedFeaturesAtPoint", "mapbox map is null")
             return
         }
-        val screenCoordinate = ScreenCoordinate(point.x.toDouble(), point.y.toDouble())
+        // JS sends point values in DIP (see getPointInView which divides by display density),
+        // but Mapbox core expects screen pixel coordinates. Convert back to px here.
+        val density: Float = getDisplayDensity()
+        val screenCoordinate = ScreenCoordinate(
+                (point.x * density).toDouble(),
+                (point.y * density).toDouble()
+        )
         val queryGeometry = RenderedQueryGeometry(screenCoordinate)
         val layers = layerIDs?.takeUnless { it.isEmpty() } ?: null;
         val queryOptions = RenderedQueryOptions(layers, filter)

package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleFactory.kt

@@ -13,6 +13,7 @@ import com.mapbox.maps.extension.style.layers.generated.SkyLayer
 // import com.mapbox.maps.extension.style.layers.generated.PropertyFactory
 // import com.mapbox.maps.extension.style.layers.generated.PropertyValue
 import com.mapbox.maps.extension.style.layers.generated.RasterLayer
+import com.mapbox.maps.extension.style.layers.generated.RasterParticleLayer
 import com.mapbox.maps.extension.style.layers.generated.SymbolLayer
 import com.mapbox.maps.extension.style.layers.generated.HeatmapLayer
 import com.mapbox.maps.extension.style.layers.generated.HillshadeLayer
@@ -704,6 +705,44 @@ object RNMBXStyleFactory {
         }
       }
     }
+    fun setRasterParticleLayerStyle(layer: RasterParticleLayer, style: RNMBXStyle ) {
+      val styleKeys = style.allStyleKeys
+
+      if (styleKeys.isEmpty()) {
+        return
+      }
+
+      for (styleKey in styleKeys) {
+        try {
+          val styleValue = style.getStyleValueForKey(styleKey)
+
+          when (styleKey) {
+              "visibility" ->
+                setVisibility(layer, styleValue)
+              "rasterParticleArrayBand" ->
+                setRasterParticleArrayBand(layer, styleValue)
+              "rasterParticleCount" ->
+                setRasterParticleCount(layer, styleValue)
+              "rasterParticleColor" ->
+                setRasterParticleColor(layer, styleValue)
+              "rasterParticleMaxSpeed" ->
+                setRasterParticleMaxSpeed(layer, styleValue)
+              "rasterParticleSpeedFactor" ->
+                setRasterParticleSpeedFactor(layer, styleValue)
+                "rasterParticleSpeedFactorTransition" ->
+                setRasterParticleSpeedFactorTransition(layer, styleValue)
+              "rasterParticleFadeOpacityFactor" ->
+                setRasterParticleFadeOpacityFactor(layer, styleValue)
+                "rasterParticleFadeOpacityFactorTransition" ->
+                setRasterParticleFadeOpacityFactorTransition(layer, styleValue)
+              "rasterParticleResetRateFactor" ->
+                setRasterParticleResetRateFactor(layer, styleValue)
+          }
+        } catch (e: MapboxStyleException) {
+          Logger.e(LOG_TAG, "Failed to update: $styleKey ${e.message}")
+        }
+      }
+    }
     fun setHillshadeLayerStyle(layer: HillshadeLayer, style: RNMBXStyle ) {
       val styleKeys = style.allStyleKeys
 
@@ -4354,6 +4393,147 @@ object RNMBXStyleFactory {
       }
     }
 
+    fun setVisibility(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+        layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
+    }
+
+    fun setRasterParticleArrayBand(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleArrayBand(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleArrayBand is null")
+        }
+      } else {
+          val value = styleValue.getString(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleArrayBand(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleArrayBand is null")
+          }
+      }
+    }
+
+    fun setRasterParticleCount(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleCount(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleCount is null")
+        }
+      } else {
+          val value = styleValue.getLong(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleCount(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleCount is null")
+          }
+      }
+    }
+
+    fun setRasterParticleColor(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleColor(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleColor is null")
+        }
+      } else {
+          layer.rasterParticleColor(styleValue.getIntExpression(VALUE_KEY))
+      }
+    }
+
+    fun setRasterParticleMaxSpeed(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleMaxSpeed(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleMaxSpeed is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleMaxSpeed(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleMaxSpeed is null")
+          }
+      }
+    }
+
+    fun setRasterParticleSpeedFactor(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleSpeedFactor(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleSpeedFactor is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleSpeedFactor(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleSpeedFactor is null")
+          }
+      }
+    }
+
+
+    fun setRasterParticleSpeedFactorTransition(layer: RasterParticleLayer, styleValue: RNMBXStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.rasterParticleSpeedFactorTransition(transition);
+      }
+    }
+
+    fun setRasterParticleFadeOpacityFactor(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleFadeOpacityFactor(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleFadeOpacityFactor is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleFadeOpacityFactor(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleFadeOpacityFactor is null")
+          }
+      }
+    }
+
+
+    fun setRasterParticleFadeOpacityFactorTransition(layer: RasterParticleLayer, styleValue: RNMBXStyleValue) {
+      val transition = styleValue.transition
+      if (transition != null) {
+        layer.rasterParticleFadeOpacityFactorTransition(transition);
+      }
+    }
+
+    fun setRasterParticleResetRateFactor(layer: RasterParticleLayer, styleValue: RNMBXStyleValue ) {
+      if (styleValue.isExpression()) {
+        val expression = styleValue.getExpression()
+        if (expression != null) {
+          layer.rasterParticleResetRateFactor(expression)
+        } else {
+          Logger.e("RNMBXRasterParticle", "Expression for rasterParticleResetRateFactor is null")
+        }
+      } else {
+          val value = styleValue.getDouble(VALUE_KEY)
+          if (value != null) {
+            layer.rasterParticleResetRateFactor(value)
+          } else {
+            Logger.e("RNMBXRasterParticle", "value for rasterParticleResetRateFactor is null")
+          }
+      }
+    }
+
     fun setVisibility(layer: HillshadeLayer, styleValue: RNMBXStyleValue ) {
         layer.visibility(Visibility.valueOf(styleValue.getEnumName()));
     }

package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleValue.kt

@@ -33,6 +33,10 @@ class RNMBXStyleValue(key: String?, config: ReadableMap) {
         return mPayload!!.getInt(key!!)
     }
 
+    fun getLong(key: String?): Long {
+        return mPayload!!.getInt(key!!).toLong()
+    }
+
     fun getIntExpression(key: String?): Expression {
         return Expression.literal(mPayload!!.getInt(key!!).toLong())
     }

package/android/src/main/java/com/rnmapbox/rnmbx/events/MapSteadyEvent.kt

@@ -0,0 +1,50 @@
+package com.rnmapbox.rnmbx.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * Direct event for CameraGestureObserver -> onMapSteady
+ * JS registrationName: onMapSteady
+ * Native event name (key): topOnMapSteady
+ */
+class MapSteadyEvent(
+    view: View?,
+    private val reason: String,
+    private val idleDurationMs: Double?,
+    private val lastGestureType: String?
+) : AbstractEvent(view, "mapSteady") {
+    override val key: String
+        get() = "topOnMapSteady"
+
+    override val payload: WritableMap
+        get() = Arguments.createMap().apply {
+            putString("reason", reason)
+            if (idleDurationMs != null) {
+                putDouble("idleDurationMs", idleDurationMs)
+            } else {
+                putNull("idleDurationMs")
+            }
+            if (lastGestureType != null) {
+                putString("lastGestureType", lastGestureType)
+            } else {
+                putNull("lastGestureType")
+            }
+            putDouble("timestamp", System.currentTimeMillis().toDouble())
+        }
+
+    override fun canCoalesce(): Boolean {
+        // Do not coalesce - each steady/timeout event is significant
+        return false
+    }
+
+    companion object {
+        fun make(
+            view: View,
+            reason: String,
+            idleDurationMs: Double?,
+            lastGestureType: String?
+        ): MapSteadyEvent = MapSteadyEvent(view, reason, idleDurationMs, lastGestureType)
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/events/RNMBXCameraGestureObserver.kt

@@ -0,0 +1,296 @@
+package com.rnmapbox.rnmbx.events
+
+import android.animation.ValueAnimator
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.mapbox.android.gestures.MoveGestureDetector
+import com.mapbox.android.gestures.RotateGestureDetector
+import com.mapbox.android.gestures.ShoveGestureDetector
+import com.mapbox.android.gestures.StandardScaleGestureDetector
+import com.mapbox.maps.plugin.animation.CameraAnimationsLifecycleListener
+import com.mapbox.maps.plugin.animation.CameraAnimatorType
+import com.mapbox.maps.plugin.gestures.OnMoveListener
+import com.mapbox.maps.plugin.gestures.OnRotateListener
+import com.mapbox.maps.plugin.gestures.OnScaleListener
+import com.mapbox.maps.plugin.gestures.OnShoveListener
+import com.rnmapbox.rnmbx.components.AbstractMapFeature
+import com.rnmapbox.rnmbx.components.RemovalReason
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+
+class RNMBXCameraGestureObserver(
+    private val mContext: Context,
+    private val mManager: RNMBXCameraGestureObserverManager
+) : AbstractMapFeature(mContext) {
+
+    var hasOnMapSteady: Boolean = false
+    var quietPeriodMs: Double? = null
+    var maxIntervalMs: Double? = null
+
+    override var requiresStyleLoad: Boolean = false
+
+    private val handler = Handler(Looper.getMainLooper())
+    private var activeAnimations: Int = 0
+    private var isGestureActive: Boolean = false
+    private var lastGestureType: String? = null
+    private var lastTransitionEndedAtMs: Double? = null
+    private var quietRunnable: Runnable? = null
+    private var timeoutRunnable: Runnable? = null
+    private var emittedForCurrentActivity: Boolean = false
+
+    private val quietMs: Double get() = quietPeriodMs ?: 200.0
+    private val maxMs: Double? get() = maxIntervalMs
+
+    private fun nowMs(): Double = System.currentTimeMillis().toDouble()
+    private fun timestamp(): Double = nowMs()
+
+    private val canEmitSteady: Boolean
+        get() = activeAnimations == 0 && !isGestureActive && lastTransitionEndedAtMs != null
+
+    private fun normalizeGestureType(type: String): String {
+        return when (type) {
+            "move" -> "pan"
+            "scale" -> "pinch"
+            "rotate" -> "rotate"
+            "shove" -> "pitch"
+            else -> type
+        }
+    }
+
+    private fun debugLog(message: String) {
+        Log.d(
+            LOG_TAG,
+            "$message; activeAnimations=$activeAnimations isGestureActive=$isGestureActive lastTransitionEnd=${lastTransitionEndedAtMs ?: -1}"
+        )
+    }
+
+    private fun scheduleTimer(delay: Double, task: Runnable): Runnable {
+        handler.removeCallbacks(task)
+        if (delay > 0) {
+            handler.postDelayed(task, delay.toLong())
+        }
+        return task
+    }
+
+    private fun cancelQuietTimer() {
+        quietRunnable?.let { handler.removeCallbacks(it) }
+        quietRunnable = null
+    }
+
+    private fun cancelTimeoutTimer() {
+        timeoutRunnable?.let { handler.removeCallbacks(it) }
+        timeoutRunnable = null
+    }
+
+    private fun scheduleQuietCheck() {
+        val delay = quietMs
+        if (delay <= 0) {
+            cancelQuietTimer()
+            maybeEmitSteady()
+            return
+        }
+        debugLog("scheduleQuietCheck in ${delay.toInt()}ms")
+        val runnable = Runnable {
+            debugLog("quiet timer fired")
+            maybeEmitSteady()
+        }
+        quietRunnable = scheduleTimer(delay, runnable)
+    }
+
+    private fun scheduleTimeout() {
+        val delay = maxMs ?: return
+        val runnable = Runnable {
+            emitTimeout()
+        }
+        timeoutRunnable = scheduleTimer(delay, runnable)
+    }
+
+    private fun markActivity(gestureType: String? = null) {
+        if (gestureType != null) lastGestureType = gestureType
+        emittedForCurrentActivity = false
+        scheduleQuietCheck()
+        scheduleTimeout()
+    }
+
+    private fun maybeEmitSteady() {
+        if (!canEmitSteady) return
+        val lastEnd = lastTransitionEndedAtMs ?: return
+        val sinceEnd = nowMs() - lastEnd
+        if (sinceEnd < quietMs) return
+        emitSteady(sinceEnd)
+    }
+
+    private fun emitSteady(idleDurationMs: Double) {
+        if (emittedForCurrentActivity) return
+        cancelQuietTimer()
+        cancelTimeoutTimer()
+        val gesture = lastGestureType
+        debugLog("EMIT steady idleDurationMs=$idleDurationMs lastGestureType=$gesture")
+        mManager.handleEvent(
+            MapSteadyEvent.make(this, "steady", idleDurationMs, gesture)
+        )
+        lastGestureType = null
+        emittedForCurrentActivity = true
+    }
+
+    private fun emitTimeout() {
+        cancelQuietTimer()
+        debugLog("EMIT timeout lastGestureType=$lastGestureType")
+        mManager.handleEvent(
+            MapSteadyEvent.make(this, "timeout", null, lastGestureType)
+        )
+        scheduleTimeout()
+    }
+
+    override fun addToMap(mapView: RNMBXMapView) {
+        super.addToMap(mapView)
+
+        if (!hasOnMapSteady) return
+
+        mapView.getMapAsync { mapboxMap ->
+            // Camera animations lifecycle
+            mapboxMap.cameraAnimationsPlugin {
+                this.addCameraAnimationsLifecycleListener(object : CameraAnimationsLifecycleListener {
+                    override fun onAnimatorStarting(
+                        type: CameraAnimatorType,
+                        animator: ValueAnimator,
+                        owner: String?
+                    ) {
+                        if (owner != "Maps-Gestures") return
+                        activeAnimations++
+                        lastTransitionEndedAtMs = null
+                        markActivity()
+                        debugLog("camera animator started")
+                    }
+
+                    override fun onAnimatorEnding(
+                        type: CameraAnimatorType,
+                        animator: ValueAnimator,
+                        owner: String?
+                    ) {
+                        if (owner != "Maps-Gestures") return
+                        handleAnimatorEnd()
+                    }
+
+                    override fun onAnimatorCancelling(
+                        type: CameraAnimatorType,
+                        animator: ValueAnimator,
+                        owner: String?
+                    ) {
+                        if (owner != "Maps-Gestures") return
+                        handleAnimatorEnd()
+                    }
+
+                    override fun onAnimatorInterrupting(
+                        type: CameraAnimatorType,
+                        runningAnimator: ValueAnimator,
+                        runningAnimatorOwner: String?,
+                        newAnimator: ValueAnimator,
+                        newAnimatorOwner: String?
+                    ) {
+                        // Interruptions are handled by the ending/starting callbacks
+                    }
+                })
+            }
+
+            // Gesture listeners
+            mapboxMap.gesturesPlugin {
+                this.addOnMoveListener(object : OnMoveListener {
+                    override fun onMoveBegin(detector: MoveGestureDetector) {
+                        handleGestureBegin("move")
+                    }
+
+                    override fun onMove(detector: MoveGestureDetector): Boolean {
+                        return false
+                    }
+
+                    override fun onMoveEnd(detector: MoveGestureDetector) {
+                        handleGestureEnd("move")
+                    }
+                })
+
+                this.addOnScaleListener(object : OnScaleListener {
+                    override fun onScaleBegin(detector: StandardScaleGestureDetector) {
+                        handleGestureBegin("scale")
+                    }
+
+                    override fun onScale(detector: StandardScaleGestureDetector) {
+                    }
+
+                    override fun onScaleEnd(detector: StandardScaleGestureDetector) {
+                        handleGestureEnd("scale")
+                    }
+                })
+
+                this.addOnRotateListener(object : OnRotateListener {
+                    override fun onRotateBegin(detector: RotateGestureDetector) {
+                        handleGestureBegin("rotate")
+                    }
+
+                    override fun onRotate(detector: RotateGestureDetector) {
+                    }
+
+                    override fun onRotateEnd(detector: RotateGestureDetector) {
+                        handleGestureEnd("rotate")
+                    }
+                })
+
+                this.addOnShoveListener(object : OnShoveListener {
+                    override fun onShoveBegin(detector: ShoveGestureDetector) {
+                        handleGestureBegin("shove")
+                    }
+
+                    override fun onShove(detector: ShoveGestureDetector) {
+                    }
+
+                    override fun onShoveEnd(detector: ShoveGestureDetector) {
+                        handleGestureEnd("shove")
+                    }
+                })
+            }
+
+            debugLog("addToMap and subscribed to gestures")
+        }
+    }
+
+    override fun removeFromMap(mapView: RNMBXMapView, reason: RemovalReason): Boolean {
+        debugLog("removeFromMap and unsubscribed from gestures")
+        cancelQuietTimer()
+        cancelTimeoutTimer()
+        return super.removeFromMap(mapView, reason)
+    }
+
+    private fun handleAnimatorEnd() {
+        activeAnimations--
+        if (activeAnimations < 0) {
+            Log.w(LOG_TAG, "WARNING: activeAnimations went negative, resetting to 0")
+            activeAnimations = 0
+        }
+        lastTransitionEndedAtMs = nowMs()
+        scheduleQuietCheck()
+        debugLog("camera animator ended")
+    }
+
+    private fun handleGestureBegin(type: String) {
+        isGestureActive = true
+        lastGestureType = normalizeGestureType(type)
+        lastTransitionEndedAtMs = null
+        markActivity(lastGestureType)
+        debugLog("gesture didBegin type=$lastGestureType")
+    }
+
+    private fun handleGestureEnd(type: String) {
+        lastGestureType = normalizeGestureType(type)
+        // On Android, gesture end callbacks fire AFTER animations complete
+        // So we can mark the gesture as inactive and transition as ended
+        isGestureActive = false
+        lastTransitionEndedAtMs = nowMs()
+        markActivity(lastGestureType)
+        debugLog("gesture didEnd type=$lastGestureType -> isGestureActive=$isGestureActive")
+    }
+
+    companion object {
+        const val LOG_TAG = "RNMBXCameraGestureObserver"
+    }
+}