@rnmapbox/maps 10.0.15 → 10.1.0-beta.11

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

@@ -0,0 +1,74 @@
+package com.rnmapbox.rnmbx.components
+
+import android.app.Activity
+import android.view.ViewGroup
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.rnmapbox.rnmbx.events.IEvent
+
+/**
+ * Created by nickitaliano on 8/23/17.
+ */
+abstract class AbstractEventEmitter<T : ViewGroup?>(reactApplicationContext: ReactApplicationContext) :
+    ViewGroupManager<T>() {
+    private val mRateLimitedEvents: MutableMap<String, Long>
+    private var mEventDispatcher: EventDispatcher? = null
+    private val mRCTAppContext: ReactApplicationContext
+
+    init {
+        mRateLimitedEvents = HashMap()
+        mRCTAppContext = reactApplicationContext
+    }
+
+    val activity : Activity?
+        get() = mRCTAppContext.currentActivity
+
+    fun handleEvent(event: IEvent) {
+        val eventCacheKey = getEventCacheKey(event)
+
+        // fail safe to protect bridge from being spammed
+        if (shouldDropEvent(eventCacheKey, event)) {
+            return
+        }
+        mRateLimitedEvents[eventCacheKey] = System.currentTimeMillis()
+        mEventDispatcher!!.dispatchEvent(
+            AbstractEvent(
+                event.iD,
+                event.key,
+                event.canCoalesce(),
+                event.toJSON()
+            )
+        )
+    }
+
+    override fun addEventEmitters(context: ThemedReactContext, view: T) {
+        mEventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(context, view!!.id)
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? {
+        val events = customEvents() ?: return null
+        val exportedEvents: MutableMap<String, Any> = HashMap()
+        for ((key, value) in events) {
+            exportedEvents[key] = MapBuilder.of("registrationName", value)
+        }
+        return exportedEvents
+    }
+
+    abstract fun customEvents(): Map<String, String>?
+    private fun shouldDropEvent(cacheKey: String, event: IEvent): Boolean {
+        val lastEventTimestamp = mRateLimitedEvents[cacheKey]
+        return lastEventTimestamp != null && event.timestamp - lastEventTimestamp <= BRIDGE_TIMEOUT_MS
+    }
+
+    private fun getEventCacheKey(event: IEvent): String {
+        return String.format("%s-%s", event.key, event.type)
+    }
+
+    companion object {
+        private const val BRIDGE_TIMEOUT_MS = 10.0
+    }
+}

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

@@ -0,0 +1,40 @@
+package com.rnmapbox.rnmbx.components
+
+import android.content.Context
+import com.facebook.react.views.view.ReactViewGroup
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+
+enum class RemovalReason {
+    VIEW_REMOVAL,
+    STYLE_CHANGE,
+    ON_DESTROY,
+    REORDER
+}
+
+abstract class AbstractMapFeature(context: Context?) : ReactViewGroup(context) {
+    protected var mMapView: RNMBXMapView? = null;
+    private var mWithMapViewCallbacks: Array<((RNMBXMapView) -> Unit)>? = null;
+
+    open fun addToMap(mapView: RNMBXMapView) {
+        mMapView = mapView;
+        mWithMapViewCallbacks?.forEach { it(mapView) }
+        mWithMapViewCallbacks = null;
+    }
+
+    // return false if you don not want to remove this feature based on reason
+    open fun removeFromMap(mapView: RNMBXMapView,reason: RemovalReason) : Boolean {
+        mMapView = null;
+        return true;
+    }
+
+    internal fun withMapView(callback: (mapView: RNMBXMapView) -> Unit) {
+        val mapView = mMapView;
+        if (mapView == null) {
+            val callbacks = mWithMapViewCallbacks ?: arrayOf();
+            callbacks.plus(callback)
+            mWithMapViewCallbacks = callbacks
+        } else {
+            callback(mapView)
+        }
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXCallout.kt

@@ -0,0 +1,6 @@
+package com.rnmapbox.rnmbx.components.annotation
+
+import android.content.Context
+import com.facebook.react.views.view.ReactViewGroup
+
+class RNMBXCallout(context: Context?) : ReactViewGroup(context)

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXCalloutManager.java

@@ -0,0 +1,18 @@
+package com.rnmapbox.rnmbx.components.annotation;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+
+public class RNMBXCalloutManager extends ViewGroupManager<RNMBXCallout> {
+    public static final String REACT_CLASS = "RNMBXCallout";
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    protected RNMBXCallout createViewInstance(ThemedReactContext reactContext) {
+        return new RNMBXCallout(reactContext);
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXMarkerView.kt

@@ -0,0 +1,201 @@
+package com.rnmapbox.rnmbx.components.annotation
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import com.mapbox.geojson.Point
+import com.mapbox.maps.ViewAnnotationAnchor
+import com.mapbox.maps.ViewAnnotationOptions
+import com.mapbox.maps.viewannotation.viewAnnotationOptions
+import com.rnmapbox.rnmbx.components.AbstractMapFeature
+import com.rnmapbox.rnmbx.components.RemovalReason
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.rnmapbox.rnmbx.utils.Logger
+import java.util.Vector
+
+private data class Vec2(val dx: Double, val dy: Double)
+
+class RNMBXMarkerView(context: Context?, private val mManager: RNMBXMarkerViewManager):
+    AbstractMapFeature(context),
+    View.OnLayoutChangeListener
+{
+    // region Instance variables
+    private var mView: View? = null
+    private var didAddToMap = false
+
+    private var mCoordinate: Point? = null
+    private var mAnchor: Vec2 = Vec2(0.5, 0.5)
+    private var mAllowOverlap = false
+    private var mIsSelected = false
+
+    fun setCoordinate(point: Point?) {
+        mCoordinate = point
+        update()
+    }
+
+    fun setAnchor(x: Float, y: Float) {
+        mAnchor = Vec2(x.toDouble(), y.toDouble())
+        update()
+    }
+
+    fun setAllowOverlap(allowOverlap: Boolean) {
+        mAllowOverlap = allowOverlap
+        update()
+    }
+
+    fun setIsSelected(isSelected: Boolean) {
+        mIsSelected = isSelected
+        update()
+    }
+
+    // endregion
+
+    // region View methods
+
+    override fun addView(childView: View, childPosition: Int) {
+        mView = childView
+        // Note: Do not call this method on `super`. The view is added manually.
+    }
+
+    override fun onLayoutChange(
+        v: View,
+        left: Int, top: Int, right: Int, bottom: Int,
+        oldLeft: Int, oldTop: Int, oldRight: Int, oldBottom: Int
+    ) {
+        addOrUpdate()
+    }
+
+    // endregion
+
+    // region AbstractMapFeature methods
+
+    override fun addToMap(mapView: RNMBXMapView) {
+        super.addToMap(mapView)
+        add()
+    }
+
+    override fun removeFromMap(mapView: RNMBXMapView, reason: RemovalReason): Boolean {
+        super.removeFromMap(mapView, reason)
+        remove(mapView)
+        return true
+    }
+
+    // endregion
+
+    // region Create, update, and remove methods
+
+    private fun addOrUpdate() {
+        if (didAddToMap) {
+            update()
+        } else {
+            add()
+        }
+    }
+
+    private fun add() {
+        if (didAddToMap) {
+            return
+        }
+
+        if (mView == null || mCoordinate == null) {
+            return
+        }
+        val view = mView!!
+
+        view.addOnLayoutChangeListener(this)
+
+        if (view.layoutParams == null && !view.isAttachedToWindow) {
+            mMapView?.offscreenAnnotationViewContainer?.addView(view)
+            mMapView?.offscreenAnnotationViewContainer?.removeView(view)
+        }
+
+        val options = getOptions()
+
+        val annotation = mMapView?.viewAnnotationManager?.addViewAnnotation(
+            view,
+            options
+        )
+        didAddToMap = true
+    }
+
+    fun update() {
+        if (!didAddToMap) {
+            return
+        }
+
+        if (mView == null || mCoordinate == null) {
+            return
+        }
+        val view = mView!!
+
+        val options = getOptions()
+
+        val annotation = mMapView?.viewAnnotationManager?.updateViewAnnotation(
+            view,
+            options
+        )
+    }
+
+    private fun remove(mapView: RNMBXMapView) {
+        this.removeOnLayoutChangeListener(this)
+
+        mView?.let { view ->
+            val parent = view.parent
+            if (parent is ViewGroup) {
+                parent.endViewTransition(view) // https://github.com/mapbox/mapbox-maps-android/issues/1723
+            }
+            val removed = mapView.viewAnnotationManager?.removeViewAnnotation(view)
+            if (removed == false) {
+                Logger.w("RNMBXMarkerView", "Unable to remove view")
+            }
+            didAddToMap = false
+        }
+    }
+
+    // endregion
+
+    // region Helper functions
+
+    private fun getOptions(): ViewAnnotationOptions {
+        val view = mView!!
+        val width = view.width
+        val height = view.height
+        val coordinate = mCoordinate
+
+        val offset = getOffset()
+
+        val options = viewAnnotationOptions {
+            geometry(coordinate)
+            width(width)
+            height(height)
+            allowOverlap(mAllowOverlap)
+            offsetX(offset.dx.toInt())
+            offsetY(offset.dy.toInt())
+            selected(mIsSelected)
+        }
+        return options
+    }
+
+    private fun getOffset(): Vec2 {
+        if (mView == null) {
+            return Vec2(0.0, 0.0)
+        }
+        val view = mView!!
+
+        val width = view.width
+        val height = view.height
+
+        // Create a modified offset, normalized from 0..1 to -1..1 and scaled to
+        // the view size.
+        val offsetX = (mAnchor.dx * 2 - 1) * (width / 2) * -1
+        val offsetY = (mAnchor.dy * 2 - 1) * (height / 2)
+
+        return Vec2(offsetX, offsetY)
+    }
+
+    // endregion
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXMarkerViewManager.kt

@@ -0,0 +1,78 @@
+package com.rnmapbox.rnmbx.components.annotation
+
+import android.view.View
+import android.widget.FrameLayout
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils.toPointGeometry
+import com.facebook.react.bridge.ReactApplicationContext
+import com.rnmapbox.rnmbx.components.AbstractEventEmitter
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+import com.mapbox.maps.ScreenCoordinate
+import com.mapbox.maps.viewannotation.OnViewAnnotationUpdatedListener
+import com.mapbox.maps.viewannotation.ViewAnnotationManager
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+
+class RNMBXMarkerViewManager(reactApplicationContext: ReactApplicationContext) :
+    AbstractEventEmitter<RNMBXMarkerView?>(reactApplicationContext) {
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    @ReactProp(name = "coordinate")
+    fun setCoordinate(markerView: RNMBXMarkerView, geoJSONStr: String?) {
+        markerView.setCoordinate(toPointGeometry(geoJSONStr))
+    }
+
+    @ReactProp(name = "anchor")
+    fun setAnchor(markerView: RNMBXMarkerView, map: ReadableMap) {
+        markerView.setAnchor(map.getDouble("x").toFloat(), map.getDouble("y").toFloat())
+    }
+
+    @ReactProp(name = "allowOverlap")
+    fun setAllowOverlap(markerView: RNMBXMarkerView, allowOverlap: Boolean) {
+        markerView.setAllowOverlap(allowOverlap)
+    }
+
+    @ReactProp(name = "isSelected")
+    fun setIsSelected(markerView: RNMBXMarkerView, isSelected: Boolean) {
+        markerView.setIsSelected(isSelected)
+    }
+
+    override fun createViewInstance(reactContext: ThemedReactContext): RNMBXMarkerView {
+        return RNMBXMarkerView(reactContext, this)
+    }
+
+    override fun customEvents(): Map<String, String>? {
+        return MapBuilder.builder<String, String>()
+            .build()
+    }
+
+    companion object {
+        const val REACT_CLASS = "RNMBXMarkerView"
+
+        fun markerViewContainerSizeFixer(mapView: RNMBXMapView, viewAnnotationManager: ViewAnnotationManager) {
+            // see https://github.com/rnmapbox/maps/issues/2376
+            viewAnnotationManager.addOnViewAnnotationUpdatedListener(object :
+                OnViewAnnotationUpdatedListener {
+                override fun onViewAnnotationVisibilityUpdated(view: View, visible: Boolean) {
+                    val parent = view.parent
+                    if (parent is FrameLayout) {
+                        if ((parent.width == 0 && parent.height == 0) && (mapView.width != 0 || mapView.height != 0)) {
+                            parent.layout(0,0,mapView.width, mapView.height)
+                        }
+                    }
+                }
+
+                override fun onViewAnnotationPositionUpdated(
+                    view: View,
+                    leftTopCoordinate: ScreenCoordinate,
+                    width: Int,
+                    height: Int
+                ) {
+                }
+            })
+        }
+    }
+}