@rnmapbox/maps 10.0.0-beta.28

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/RCTMGLStyleValue.kt

@@ -0,0 +1,223 @@
+package com.mapbox.rctmgl.components.styles
+
+import com.facebook.react.bridge.*
+import com.mapbox.bindgen.Value
+import com.mapbox.maps.extension.style.types.StyleTransition.Builder
+import com.mapbox.rctmgl.utils.ImageEntry
+import com.mapbox.maps.extension.style.types.StyleTransition
+import com.mapbox.rctmgl.components.styles.RCTMGLStyleFactory
+import com.mapbox.maps.extension.style.expressions.generated.Expression
+import com.mapbox.maps.extension.style.light.LightPosition
+import com.mapbox.rctmgl.utils.ExpressionParser
+import java.util.ArrayList
+
+class RCTMGLStyleValue(config: ReadableMap) {
+    val type: String?
+    private var isExpression = false
+    private var mExpression: Expression? = null
+    private val mPayload: ReadableMap?
+    var imageURI: String? = ""
+    private var isAddImage = false
+    var imageScale = ImageEntry.defaultScale
+    private fun isTokenizedValue(value: String): Boolean {
+        return value.startsWith("{") && value.endsWith("}")
+    }
+
+    val isFunction: Boolean
+        get() = type == "function"
+
+    fun getInt(key: String?): Int {
+        return mPayload!!.getInt(key!!)
+    }
+
+    fun getIntExpression(key: String?): Expression {
+        return Expression.literal(mPayload!!.getInt(key!!).toLong())
+    }
+
+    fun getString(key: String?): String? {
+        return mPayload!!.getString(key!!)
+    }
+
+    fun getEnumName(): String {
+        return mPayload!!.getString("value")!!.toUpperCase().replace("-", "_")
+    }
+
+    fun getDouble(key: String?): Double {
+        return mPayload!!.getDouble(key!!)
+    }
+
+    fun getFloat(key: String?): Float {
+        return getDouble(key).toFloat()
+    }
+
+    fun getDynamic(key: String?): Dynamic {
+        return mPayload!!.getDynamic(key!!)
+    }
+
+    fun getArray(key: String?): ReadableArray? {
+        return mPayload!!.getArray(key!!)
+    }
+
+    fun getBoolean(key: String?): Boolean {
+        return mPayload!!.getBoolean(key!!)
+    }
+
+    /*
+    public Float[] getFloatArray(String key) {
+        ReadableArray arr = getArray(key);
+
+        Float[] floatArr = new Float[arr.size()];
+        for (int i = 0; i < arr.size(); i++) {
+            ReadableMap item = arr.getMap(i);
+            floatArr[i] = (float) item.getDouble("value");
+        }
+
+        return floatArr;
+    }
+    */
+    fun getFloatArray(key: String?): List<Double> {
+        val arr = getArray(key)
+        val result = ArrayList<Double>(arr!!.size())
+        for (i in 0 until arr.size()) {
+            val item = arr.getMap(i)
+            result.add(item.getDouble("value"))
+        }
+        return result
+    }
+
+    /*
+    public String[] getStringArray(String key) {
+        ReadableArray arr = getArray(key);
+
+        String[] stringArr = new String[arr.size()];
+        for (int i = 0; i < arr.size(); i++) {
+            ReadableMap item = arr.getMap(i);
+            stringArr[i] = item.getString("value");
+        }
+
+        return stringArr;
+    } */
+    fun getStringArray(key: String?): List<String?> {
+        val arr = getArray(key)
+        val result = ArrayList<String?>(arr!!.size())
+        for (i in 0 until arr.size()) {
+            val item = arr.getMap(i)
+            result.add(item.getString("value"))
+        }
+        return result
+    }
+
+    val map: ReadableMap?
+        get() {
+            if ("hashmap" == mPayload!!.getString("type")) {
+                val keyValues = mPayload.getArray("value")
+                val result = WritableNativeMap()
+                for (i in 0 until keyValues!!.size()) {
+                    val keyValue = keyValues.getArray(i)
+                    val stringKey = keyValue.getMap(0).getString("value")
+                    val value = WritableNativeMap()
+                    value.merge(keyValue.getMap(1))
+                    result.putMap(stringKey!!, value)
+                }
+                return result
+            }
+            return null
+        }
+
+    fun getMap(_key: String?): ReadableMap? {
+        return map
+    }
+
+    fun getExpression(): Expression? {
+        return mExpression
+    }
+
+    fun getLightPosition(): LightPosition {
+        return LightPosition.fromList(getFloatArray("value"))
+    }
+
+    fun isExpression(): Boolean {
+        return isExpression
+    }
+
+    fun shouldAddImage(): Boolean {
+        return isAddImage
+    }
+
+    val isImageStringValue: Boolean
+        get() = "string" == mPayload!!.getString("type")
+
+    fun getImageStringValue(): String? {
+        return mPayload!!.getString("value")
+    }
+
+    val transition: StyleTransition?
+        get() {
+            if (type != "transition") {
+                return null
+            }
+            val config = getMap(RCTMGLStyleFactory.VALUE_KEY)
+            var enablePlacementTransitions = true
+            if (config!!.hasKey("enablePlacementTransitions")) {
+                enablePlacementTransitions =
+                    config.getMap("enablePlacementTransitions")!!.getBoolean("value")
+            }
+            var duration = 300
+            val delay = 0
+            if (config.hasKey("duration") && ReadableType.Map == config.getType("duration")) {
+                duration = config.getMap("duration")!!.getInt("value")
+            }
+            if (config.hasKey("delay") && ReadableType.Map == config.getType("delay")) {
+                duration = config.getMap("delay")!!.getInt("value")
+            }
+            return Builder().duration(duration.toLong()).delay(delay.toLong()).build()
+        }
+
+    companion object {
+        const val InterpolationModeExponential = 100
+        const val InterpolationModeInterval = 101
+        const val InterpolationModeCategorical = 102
+        const val InterpolationModeIdentity = 103
+    }
+
+    init {
+        type = config.getString("styletype")
+        mPayload = config.getMap("stylevalue")
+        isAddImage = false
+        if ("image" == type) {
+            imageScale = ImageEntry.defaultScale
+            if ("hashmap" == mPayload!!.getString("type")) {
+                val map = map
+                imageURI = map!!.getMap("uri")!!.getString("value")
+                if (map.getMap("scale") != null) {
+                    imageScale = map.getMap("scale")!!.getDouble("value")
+                }
+            } else if ("string" == mPayload.getString("type")) {
+                val value = mPayload.getString("value")
+                if (value!!.contains("://")) {
+                    imageURI = value
+                } else {
+                    imageURI = null
+                    isExpression = true
+                    mExpression = Expression.literal(value)
+                }
+            } else {
+                imageURI = null
+            }
+            isAddImage = imageURI != null
+        }
+        if (!isAddImage) {
+            val dynamic = mPayload!!.getDynamic("value")
+            if (dynamic.type == ReadableType.Array) {
+                val array = dynamic.asArray()
+                if (array.size() > 0 && mPayload.getString("type") == "array") {
+                    val map = array.getMap(0)
+                    if (map != null && map.getString("type") == "string") {
+                        isExpression = true
+                        mExpression = ExpressionParser.fromTyped(mPayload)
+                    }
+                }
+            }
+        }
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/layers/RCTLayer.kt

@@ -0,0 +1,274 @@
+package com.mapbox.rctmgl.components.styles.layers
+
+import android.content.Context
+import com.mapbox.maps.extension.style.layers.Layer
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.mapbox.maps.Style
+import com.mapbox.maps.MapView
+import com.mapbox.rctmgl.components.styles.sources.AbstractSourceConsumer
+import com.facebook.react.bridge.ReadableMap
+import com.mapbox.maps.MapboxMap
+import com.facebook.react.bridge.ReadableArray
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView.FoundLayerCallback
+import com.facebook.common.logging.FLog
+import com.mapbox.maps.extension.style.expressions.dsl.generated.literal
+import com.mapbox.maps.extension.style.expressions.generated.Expression
+import com.mapbox.maps.extension.style.layers.*
+import com.mapbox.maps.extension.style.layers.properties.generated.Visibility
+import com.mapbox.rctmgl.components.styles.layers.RCTLayer
+import com.mapbox.rctmgl.modules.RCTMGLLogging
+import com.mapbox.rctmgl.utils.ExpressionParser
+import java.lang.ClassCastException
+import com.mapbox.rctmgl.utils.Logger
+
+
+// import com.mapbox.rctmgl.utils.ExpressionParser;
+abstract class RCTLayer<T : Layer?>(protected var mContext: Context) : AbstractSourceConsumer(
+    mContext
+) {
+    override var iD: String? = null
+    @JvmField
+    protected var mSourceID: String? = null
+    protected var mAboveLayerID: String? = null
+    protected var mBelowLayerID: String? = null
+    protected var mLayerIndex: Int? = null
+    protected var mVisible = false
+    protected var mMinZoomLevel: Double? = null
+    protected var mMaxZoomLevel: Double? = null
+    @JvmField
+    protected var mReactStyle: ReadableMap? = null
+    protected var mFilter: Expression? = null
+    @JvmField
+    protected var mMap: MapboxMap? = null
+    @JvmField
+    protected var mLayer: T? = null
+    protected var mMapView: RCTMGLMapView? = null
+    protected var mHadFilter = false
+
+    fun setSourceID(sourceID: String?) {
+        mSourceID = sourceID
+    }
+
+    fun setAboveLayerID(aboveLayerID: String) {
+        if (mAboveLayerID != null && mAboveLayerID == aboveLayerID) {
+            return
+        }
+        mAboveLayerID = aboveLayerID
+        if (mLayer != null) {
+            removeFromMap(mMapView!!)
+            addAbove(mAboveLayerID)
+        }
+    }
+
+    fun setBelowLayerID(belowLayerID: String) {
+        if (mBelowLayerID != null && mBelowLayerID == belowLayerID) {
+            return
+        }
+        mBelowLayerID = belowLayerID
+        if (mLayer != null) {
+            removeFromMap(mMapView!!)
+            addBelow(mBelowLayerID)
+        }
+    }
+
+    fun setLayerIndex(layerIndex: Int) {
+        if (mLayerIndex != null && mLayerIndex == layerIndex) {
+            return
+        }
+        mLayerIndex = layerIndex
+        if (mLayer != null) {
+            removeFromMap(mMapView!!)
+            addAtIndex(mLayerIndex!!)
+        }
+    }
+
+    fun setVisible(visible: Boolean) {
+        mVisible = visible
+        if (mLayer != null) {
+            mLayer!!.visibility(if (mVisible) Visibility.VISIBLE else Visibility.NONE)
+        }
+    }
+
+    fun setMinZoomLevel(minZoomLevel: Double) {
+        mMinZoomLevel = minZoomLevel
+        if (mLayer != null) {
+            mLayer!!.minZoom(minZoomLevel.toFloat().toDouble())
+        }
+    }
+
+    fun setMaxZoomLevel(maxZoomLevel: Double) {
+        mMaxZoomLevel = maxZoomLevel
+        if (mLayer != null) {
+            mLayer!!.maxZoom(maxZoomLevel.toFloat().toDouble())
+        }
+    }
+
+    fun setReactStyle(reactStyle: ReadableMap?) {
+        mReactStyle = reactStyle
+        if (mLayer != null) {
+            addStyles()
+        }
+    }
+
+    fun setFilter(readableFilterArray: ReadableArray?) {
+        val filterExpression = ExpressionParser.from(readableFilterArray)
+        mFilter = filterExpression
+        if (mLayer != null) {
+            if (mFilter != null) {
+                mHadFilter = true
+                updateFilter(mFilter)
+            } else if (mHadFilter) {
+                updateFilter(literal(true))
+            }
+        }
+    }
+
+    fun add() {
+        if (!hasInitialized()) {
+            return
+        }
+        if (style == null) return
+
+        /* V10TODO
+        String userBackgroundID = LocationComponentConstants.BACKGROUND_LAYER;
+        Layer userLocationBackgroundLayer = getStyle().getLayer(userBackgroundID);
+
+        // place below user location layer
+        if (userLocationBackgroundLayer != null) {
+            getStyle().addLayerBelow(mLayer, userBackgroundID);
+            mMapView.layerAdded(mLayer);
+            return;
+        } */
+
+        Logger.logged("RCTLayer.add") {
+            style!!.addLayer(mLayer!!);
+            mMapView!!.layerAdded(mLayer!!)
+        }
+    }
+
+    fun addAbove(aboveLayerID: String?) {
+        mMapView!!.waitForLayer(aboveLayerID!!, object : FoundLayerCallback {
+            override fun found(layer: Layer?) {
+                if (!hasInitialized()) {
+                    return
+                }
+                if (style == null) return
+                style!!.addLayerAbove(mLayer!!, aboveLayerID)
+                mMapView!!.layerAdded(mLayer!!)
+            }
+        })
+    }
+
+    fun addBelow(belowLayerID: String?) {
+        mMapView!!.waitForLayer(belowLayerID!!, object : FoundLayerCallback {
+            override fun found(layer: Layer?) {
+                if (!hasInitialized()) {
+                    return
+                }
+                if (style == null) return
+                style!!.addLayerBelow(mLayer!!, belowLayerID)
+                mMapView!!.layerAdded(mLayer!!)
+            }
+        })
+    }
+
+    fun addAtIndex(index: Int) {
+        var index = index
+        if (!hasInitialized()) {
+            return
+        }
+        if (style == null) return
+        val layerSize = style!!.styleLayers.size
+        if (index >= layerSize) {
+            FLog.e(
+                LOG_TAG,
+                "Layer index is greater than number of layers on map. Layer inserted at end of layer stack."
+            )
+            index = layerSize - 1
+        }
+        style!!.addLayerAt(mLayer!!, index)
+        mMapView!!.layerAdded(mLayer!!)
+    }
+
+    protected fun insertLayer() {
+        if (style == null) return
+        if (style!!.getLayer(iD!!) != null) {
+            return  // prevent adding a layer twice
+        }
+        if (mAboveLayerID != null) {
+            addAbove(mAboveLayerID)
+        } else if (mBelowLayerID != null) {
+            addBelow(mBelowLayerID)
+        } else if (mLayerIndex != null) {
+            addAtIndex(mLayerIndex!!)
+        } else {
+            add()
+        }
+        setZoomBounds()
+    }
+
+    protected fun setZoomBounds() {
+        if (mMaxZoomLevel != null) {
+            mLayer!!.maxZoom(mMaxZoomLevel!!.toFloat().toDouble())
+        }
+        if (mMinZoomLevel != null) {
+            mLayer!!.minZoom(mMinZoomLevel!!.toFloat().toDouble())
+        }
+    }
+
+    protected open fun updateFilter(expression: Expression?) {
+        // override if you want to update the filter
+    }
+
+    private fun getLayerAs(style: Style?, id: String?): T? {
+        val result = style!!.getLayer(iD!!)
+        return try {
+            result as T?
+        } catch (exception: ClassCastException) {
+            null
+        }
+    }
+
+    override fun addToMap(mapView: RCTMGLMapView) {
+        mMap = mapView.getMapboxMap()
+        mMapView = mapView
+        if (style == null) return
+        val existingLayer = getLayerAs(style, iD)
+        if (existingLayer != null) {
+            mLayer = existingLayer
+        } else {
+            mLayer = makeLayer()
+            insertLayer()
+        }
+        addStyles()
+        if (mFilter != null) {
+            mHadFilter = true
+            updateFilter(mFilter)
+        }
+    }
+
+    override fun removeFromMap(mapView: RCTMGLMapView) {
+        if (style != null) {
+            style!!.removeStyleLayer(mLayer!!.layerId)
+        }
+    }
+
+    // v10TOOD: adding anything seems to make getStyle null
+    //        return mMap.getStyle();
+    private val style: Style?
+        private get() =// v10TOOD: adding anything seems to make getStyle null
+            if (mMap == null) {
+                null
+            } else mMapView!!.savedStyle
+
+    //        return mMap.getStyle();
+    abstract fun makeLayer(): T
+    abstract fun addStyles()
+    private fun hasInitialized(): Boolean {
+        return mMap != null && mLayer != null
+    }
+
+    companion object {
+        const val LOG_TAG = "RCTLayer"
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/layers/RCTMGLBackgroundLayer.java

@@ -0,0 +1,23 @@
+package com.mapbox.rctmgl.components.styles.layers;
+
+import android.content.Context;
+
+import com.mapbox.maps.extension.style.layers.generated.BackgroundLayer;
+import com.mapbox.rctmgl.components.styles.RCTMGLStyle;
+import com.mapbox.rctmgl.components.styles.RCTMGLStyleFactory;
+
+public class RCTMGLBackgroundLayer extends RCTLayer<BackgroundLayer> {
+    public RCTMGLBackgroundLayer(Context context) {
+        super(context);
+    }
+
+    @Override
+    public BackgroundLayer makeLayer() {
+        return new BackgroundLayer(getID());
+    }
+
+    @Override
+    public void addStyles() {
+        RCTMGLStyleFactory.setBackgroundLayerStyle(mLayer, new RCTMGLStyle(getContext(), mReactStyle, mMap));
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/layers/RCTMGLBackgroundLayerManager.java

@@ -0,0 +1,60 @@
+package com.mapbox.rctmgl.components.styles.layers;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+public class RCTMGLBackgroundLayerManager extends ViewGroupManager<RCTMGLBackgroundLayer> {
+    public static final String REACT_CLASS = "RCTMGLBackgroundLayer";
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    protected RCTMGLBackgroundLayer createViewInstance(ThemedReactContext reactContext) {
+        return new RCTMGLBackgroundLayer(reactContext);
+    }
+
+    @ReactProp(name="id")
+    public void setId(RCTMGLBackgroundLayer layer, String id) {
+        layer.setID(id);
+    }
+
+    @ReactProp(name="sourceID")
+    public void setSourceID(RCTMGLBackgroundLayer layer, String sourceID) {
+        layer.setSourceID(sourceID);
+    }
+
+    @ReactProp(name="aboveLayerID")
+    public void setAboveLayerID(RCTMGLBackgroundLayer layer, String aboveLayerID) {
+        layer.setAboveLayerID(aboveLayerID);
+    }
+
+    @ReactProp(name="belowLayerID")
+    public void setBelowLayerID(RCTMGLBackgroundLayer layer, String belowLayerID) {
+        layer.setBelowLayerID(belowLayerID);
+    }
+
+    @ReactProp(name="layerIndex")
+    public void setLayerIndex(RCTMGLBackgroundLayer layer, int layerIndex){
+        layer.setLayerIndex(layerIndex);
+    }
+
+    @ReactProp(name="minZoomLevel")
+    public void setMinZoomLevel(RCTMGLBackgroundLayer layer, double minZoomLevel) {
+        layer.setMinZoomLevel(minZoomLevel);
+    }
+
+    @ReactProp(name="maxZoomLevel")
+    public void setMaxZoomLevel(RCTMGLBackgroundLayer layer, double maxZoomLevel) {
+        layer.setMaxZoomLevel(maxZoomLevel);
+    }
+
+    @ReactProp(name="reactStyle")
+    public void setReactStyle(RCTMGLBackgroundLayer layer, ReadableMap style) {
+        layer.setReactStyle(style);
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/layers/RCTMGLCircleLayer.java

@@ -0,0 +1,53 @@
+package com.mapbox.rctmgl.components.styles.layers;
+
+import android.content.Context;
+
+import com.mapbox.maps.extension.style.expressions.generated.Expression;
+import com.mapbox.maps.extension.style.layers.generated.CircleLayer;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView;
+import com.mapbox.rctmgl.components.styles.RCTMGLStyle;
+import com.mapbox.rctmgl.components.styles.RCTMGLStyleFactory;
+import com.mapbox.rctmgl.utils.Logger;
+
+public class RCTMGLCircleLayer extends RCTLayer<CircleLayer> {
+    private String mSourceLayerID;
+
+    public RCTMGLCircleLayer(Context context) {
+        super(context);
+    }
+
+    @Override
+    protected void updateFilter(Expression expression) {
+        mLayer.filter(expression);
+    }
+
+    @Override
+    public void addToMap(RCTMGLMapView mapView) {
+        super.addToMap(mapView);
+    }
+
+    @Override
+    public CircleLayer makeLayer() {
+        CircleLayer layer = new CircleLayer(getID(), mSourceID);
+
+        if (mSourceLayerID != null) {
+            layer.sourceLayer(mSourceLayerID);
+
+        }
+
+        return layer;
+    }
+
+    @Override
+    public void addStyles() {
+        RCTMGLStyleFactory.setCircleLayerStyle(mLayer, new RCTMGLStyle(getContext(), mReactStyle, mMap));
+    }
+
+    public void setSourceLayerID(String sourceLayerID) {
+        mSourceLayerID = sourceLayerID;
+
+        if (mLayer != null) {
+            mLayer.sourceLayer(sourceLayerID);
+        }
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/layers/RCTMGLCircleLayerManager.java

@@ -0,0 +1,73 @@
+package com.mapbox.rctmgl.components.styles.layers;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+import java.util.ArrayList;
+
+public class RCTMGLCircleLayerManager extends ViewGroupManager<RCTMGLCircleLayer> {
+    public static final String REACT_CLASS = "RCTMGLCircleLayer";
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    protected RCTMGLCircleLayer createViewInstance(ThemedReactContext reactContext) {
+        return new RCTMGLCircleLayer(reactContext);
+    }
+
+    @ReactProp(name="id")
+    public void setId(RCTMGLCircleLayer layer, String id) {
+        layer.setID(id);
+    }
+
+    @ReactProp(name="sourceID")
+    public void setSourceID(RCTMGLCircleLayer layer, String sourceID) {
+        layer.setSourceID(sourceID);
+    }
+
+    @ReactProp(name="aboveLayerID")
+    public void setAboveLayerID(RCTMGLCircleLayer layer, String aboveLayerID) {
+        layer.setAboveLayerID(aboveLayerID);
+    }
+
+    @ReactProp(name="belowLayerID")
+    public void setBelowLayerID(RCTMGLCircleLayer layer, String belowLayerID) {
+        layer.setBelowLayerID(belowLayerID);
+    }
+
+    @ReactProp(name="layerIndex")
+    public void setLayerIndex(RCTMGLCircleLayer layer, int layerIndex){
+        layer.setLayerIndex(layerIndex);
+    }
+
+    @ReactProp(name="minZoomLevel")
+    public void setMinZoomLevel(RCTMGLCircleLayer layer, double minZoomLevel) {
+        layer.setMinZoomLevel(minZoomLevel);
+    }
+
+    @ReactProp(name="maxZoomLevel")
+    public void setMaxZoomLevel(RCTMGLCircleLayer layer, double maxZoomLevel) {
+        layer.setMaxZoomLevel(maxZoomLevel);
+    }
+
+    @ReactProp(name="reactStyle")
+    public void setReactStyle(RCTMGLCircleLayer layer, ReadableMap style) {
+        layer.setReactStyle(style);
+    }
+
+    @ReactProp(name="sourceLayerID")
+    public void setSourceLayerId(RCTMGLCircleLayer layer, String sourceLayerID) {
+        layer.setSourceLayerID(sourceLayerID);
+    }
+
+    @ReactProp(name="filter")
+    public void setFilter(RCTMGLCircleLayer layer, ReadableArray filterList) {
+        layer.setFilter(filterList);
+    }
+}