@rnmapbox/maps 10.2.8 → 10.2.10-rc.2

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

@@ -47,6 +47,7 @@ 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
@@ -125,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))

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/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"
+    }
+}

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

@@ -0,0 +1,74 @@
+package com.rnmapbox.rnmbx.events
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNMBXCameraGestureObserverManagerDelegate
+import com.facebook.react.viewmanagers.RNMBXCameraGestureObserverManagerInterface
+import com.rnmapbox.rnmbx.components.AbstractEventEmitter
+import com.rnmapbox.rnmbx.rncompat.dynamic.getType
+import com.rnmapbox.rnmbx.utils.Logger
+
+@ReactModule(name = RNMBXCameraGestureObserverManager.REACT_CLASS)
+class RNMBXCameraGestureObserverManager(private val mContext: ReactApplicationContext) :
+    AbstractEventEmitter<RNMBXCameraGestureObserver>(mContext),
+    RNMBXCameraGestureObserverManagerInterface<RNMBXCameraGestureObserver> {
+
+    private val delegate: RNMBXCameraGestureObserverManagerDelegate<RNMBXCameraGestureObserver, RNMBXCameraGestureObserverManager> =
+        RNMBXCameraGestureObserverManagerDelegate(this)
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(reactContext: ThemedReactContext): RNMBXCameraGestureObserver =
+        RNMBXCameraGestureObserver(reactContext, this)
+
+    @ReactProp(name = "quietPeriodMs")
+    override fun setQuietPeriodMs(view: RNMBXCameraGestureObserver?, value: Dynamic?) {
+        value?.let {
+            when (it.getType()) {
+                ReadableType.Number -> view?.quietPeriodMs = it.asDouble()
+                ReadableType.Null -> view?.quietPeriodMs = null
+                else -> Logger.e(REACT_CLASS, "Expected Number or null for quietPeriodMs")
+            }
+        }
+    }
+
+    @ReactProp(name = "maxIntervalMs")
+    override fun setMaxIntervalMs(view: RNMBXCameraGestureObserver?, value: Dynamic?) {
+        value?.let {
+            when (it.getType()) {
+                ReadableType.Number -> view?.maxIntervalMs = it.asDouble()
+                ReadableType.Null -> view?.maxIntervalMs = null
+                else -> Logger.e(REACT_CLASS, "Expected Number or null for maxIntervalMs")
+            }
+        }
+    }
+
+    @ReactProp(name = "hasOnMapSteady")
+    override fun setHasOnMapSteady(view: RNMBXCameraGestureObserver?, value: Dynamic?) {
+        if (value?.getType()?.name == "Boolean") {
+            view?.hasOnMapSteady = value.asBoolean()
+        } else {
+            if (value == null) {
+                Logger.e(REACT_CLASS, "Expected Boolean value for hasOnMapSteady")
+            } else {
+                Logger.e(REACT_CLASS, "Expected Boolean value for hasOnMapSteady, got ${value.getType()?.name}")
+            }
+        }
+    }
+
+    override fun getDelegate(): ViewManagerDelegate<RNMBXCameraGestureObserver> = delegate
+
+    // Map the native event name to the JS registration name for direct events
+    override fun customEvents(): Map<String, String> = mapOf(
+        "topOnMapSteady" to "onMapSteady"
+    )
+
+    companion object {
+        const val REACT_CLASS = "RNMBXCameraGestureObserver"
+    }
+}

package/android/src/main/old-arch/com/facebook/react/viewmanagers/RNMBXCameraGestureObserverManagerDelegate.java

@@ -0,0 +1,39 @@
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* @generated by codegen project: GeneratePropsJavaDelegate.js
+*/
+
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.DynamicFromObject;
+import com.facebook.react.uimanager.BaseViewManager;
+import com.facebook.react.uimanager.BaseViewManagerDelegate;
+import com.facebook.react.uimanager.LayoutShadowNode;
+
+public class RNMBXCameraGestureObserverManagerDelegate<T extends View, U extends BaseViewManager<T, ? extends LayoutShadowNode> & RNMBXCameraGestureObserverManagerInterface<T>> extends BaseViewManagerDelegate<T, U> {
+  public RNMBXCameraGestureObserverManagerDelegate(U viewManager) {
+    super(viewManager);
+  }
+  @Override
+  public void setProperty(T view, String propName, @Nullable Object value) {
+    switch (propName) {
+      case "quietPeriodMs":
+        mViewManager.setQuietPeriodMs(view, new DynamicFromObject(value));
+        break;
+      case "maxIntervalMs":
+        mViewManager.setMaxIntervalMs(view, new DynamicFromObject(value));
+        break;
+      case "hasOnMapSteady":
+        mViewManager.setHasOnMapSteady(view, new DynamicFromObject(value));
+        break;
+      default:
+        super.setProperty(view, propName, value);
+    }
+  }
+}

package/android/src/main/old-arch/com/facebook/react/viewmanagers/RNMBXCameraGestureObserverManagerInterface.java

@@ -0,0 +1,18 @@
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* @generated by codegen project: GeneratePropsJavaInterface.js
+*/
+
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import com.facebook.react.bridge.Dynamic;
+public interface RNMBXCameraGestureObserverManagerInterface<T extends View> {
+  void setQuietPeriodMs(T view, Dynamic value);
+  void setMaxIntervalMs(T view, Dynamic value);
+  void setHasOnMapSteady(T view, Dynamic value);
+}