@rnmapbox/maps 10.0.0-beta.28

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

@@ -0,0 +1,264 @@
+package com.mapbox.rctmgl.components.styles.sources
+
+import android.content.Context
+import com.mapbox.maps.extension.style.sources.generated.GeoJsonSource
+import com.mapbox.rctmgl.utils.ImageEntry
+import android.graphics.drawable.BitmapDrawable
+import com.facebook.react.bridge.ReadableMap
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.mapbox.rctmgl.events.FeatureClickEvent
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.mapbox.bindgen.Value
+import com.mapbox.geojson.Feature
+import com.mapbox.rctmgl.events.AndroidCallbackEvent
+import com.mapbox.geojson.FeatureCollection
+import com.mapbox.maps.*
+import com.mapbox.maps.extension.style.expressions.generated.Expression
+import com.mapbox.rctmgl.utils.Logger
+import java.net.URL
+import java.util.ArrayList
+import java.util.HashMap
+
+class RCTMGLShapeSource(context: Context, private val mManager: RCTMGLShapeSourceManager) :
+    RCTSource<GeoJsonSource>(context) {
+    private var mURL: URL? = null
+    private var mShape: String? = null
+    private var mCluster: Boolean? = null
+    private var mClusterRadius: Long? = null
+    private var mClusterMaxZoom: Long? = null
+    private var mClusterProperties: HashMap<String, Any>? = null
+    private var mMaxZoom: Long? = null
+    private var mBuffer: Long? = null
+    private var mTolerance: Double? = null
+    private var mLineMetrics: Boolean? = null
+    private val mImages: List<Map.Entry<String, ImageEntry>>? = null
+    private val mNativeImages: List<Map.Entry<String, BitmapDrawable>>? = null
+    override fun addToMap(mapView: RCTMGLMapView) {
+        // Wait for style before adding the source to the map
+        mapView.getMapboxMap().getStyle {
+            val map = mapView.getMapboxMap()
+            super@RCTMGLShapeSource.addToMap(mapView)
+        }
+    }
+
+    override fun makeSource(): GeoJsonSource {
+        val builder = GeoJsonSource.Builder(iD.toString())
+        getOptions(builder)
+
+        builder.data(mShape ?: mURL.toString())
+
+        return builder.build()
+    }
+
+    fun setURL(url: URL) {
+        mURL = url
+        if (mSource != null && mMapView != null && !mMapView!!.isDestroyed) {
+            mSource!!.data(mURL.toString())
+        }
+    }
+
+    fun setShape(geoJSONStr: String) {
+        mShape = geoJSONStr
+        if (mSource != null && mMapView != null && !mMapView!!.isDestroyed) {
+            mSource!!.data(mShape!!)
+            val result = mMap!!.getStyle()!!
+                .setStyleSourceProperty(iD!!, "data", Value.valueOf(mShape!!))
+        }
+    }
+
+    fun setCluster(cluster: Boolean) {
+        mCluster = cluster
+    }
+
+    fun setClusterRadius(clusterRadius: Long) {
+        mClusterRadius = clusterRadius
+    }
+
+    fun setClusterMaxZoom(clusterMaxZoom: Long) {
+        mClusterMaxZoom = clusterMaxZoom
+    }
+
+    fun setClusterProperties(clusterProperties: HashMap<String, Any>) {
+        mClusterProperties = clusterProperties
+    }
+
+    fun setMaxZoom(maxZoom: Long) {
+        mMaxZoom = maxZoom
+    }
+
+    fun setBuffer(buffer: Long) {
+        mBuffer = buffer
+    }
+
+    fun setTolerance(tolerance: Double) {
+        mTolerance = tolerance
+    }
+
+    fun setLineMetrics(lineMetrics: Boolean) {
+        mLineMetrics = lineMetrics
+    }
+
+    override fun onPress(event: OnPressEvent?) {
+        mManager.handleEvent(FeatureClickEvent.makeShapeSourceEvent(this, event))
+    }
+
+    private fun getOptions(builder: GeoJsonSource.Builder) {
+        if (mCluster != null) {
+            builder.cluster(mCluster!!)
+        }
+        if (mClusterRadius != null) {
+            builder.clusterRadius(mClusterRadius!!)
+        }
+        if (mClusterMaxZoom != null) {
+            builder.clusterMaxZoom(mClusterMaxZoom!!)
+        }
+        if (mClusterProperties != null) {
+            builder.clusterProperties(mClusterProperties!!)
+        }
+        if (mMaxZoom != null) {
+            builder.maxzoom(mMaxZoom!!)
+        }
+        if (mBuffer != null) {
+            builder.buffer(mBuffer!!)
+        }
+        if (mTolerance != null) {
+            builder.tolerance(mTolerance!!)
+        }
+        if (mLineMetrics != null) {
+            builder.lineMetrics(mLineMetrics!!)
+        }
+    }
+
+    fun querySourceFeatures(
+        callbackID: String,
+        filter: Expression?
+    ) {
+        if (mSource == null) {
+            val payload: WritableMap = WritableNativeMap()
+            payload.putString("error", "source is not yet loaded")
+            val event = AndroidCallbackEvent(this, callbackID, payload)
+            mManager.handleEvent(event)
+            return
+        }
+        val _this = this
+        mMap!!.querySourceFeatures(
+            iD!!, SourceQueryOptions(
+                null,  // v10todo
+                filter!!
+            )
+        ) { features ->
+            if (features.isError) {
+                Logger.e("RCTMGLShapeSource", String.format("Error: %s", features.error))
+            } else {
+                val payload: WritableMap = WritableNativeMap()
+                val result: MutableList<Feature> = ArrayList(
+                    features.value!!.size
+                )
+                for (i in features.value!!) {
+                    result.add(i.feature)
+                }
+                payload.putString("data", FeatureCollection.fromFeatures(result).toJson())
+                val event = AndroidCallbackEvent(_this, callbackID, payload)
+                mManager.handleEvent(event)
+            }
+        }
+    }
+
+    private fun callbackSuccess(callbackID: String, payload: WritableMap) {
+        val event = AndroidCallbackEvent(this, callbackID, payload)
+        mManager.handleEvent(event)
+    }
+    private fun callbackError(callbackID: String, error: String, where: String) {
+        val payload: WritableMap = WritableNativeMap()
+        payload.putString("error", "$where: $error")
+        val event = AndroidCallbackEvent(this, callbackID, payload)
+        mManager.handleEvent(event)
+    }
+
+    fun getClusterExpansionZoom(callbackID: String, featureJSON: String) {
+        val feature = Feature.fromJson(featureJSON)
+
+        mMap!!.getGeoJsonClusterExpansionZoom(iD!!, feature, QueryFeatureExtensionCallback { features ->
+            if (features.isValue) {
+                val contents = features.value!!.value!!.contents
+                val payload: WritableMap = WritableNativeMap()
+
+                if (contents is Long) {
+                    val payload: WritableMap = WritableNativeMap()
+                    payload.putInt("data", contents.toInt())
+                    callbackSuccess(callbackID, payload)
+                    return@QueryFeatureExtensionCallback
+                } else {
+                    callbackError(
+                        callbackID,
+                        "Not a number: $contents",
+                        "getClusterExpansionZoom/getGeoJsonClusterExpansionZoom"
+                    )
+                    return@QueryFeatureExtensionCallback
+                }
+            } else {
+                callbackError(
+                    callbackID,
+                    features.error ?: "Unknown error",
+                    "getClusterExpansionZoom/getGeoJsonClusterExpansionZoom"
+                )
+                return@QueryFeatureExtensionCallback
+            }
+        })
+    }
+
+    fun getClusterLeaves(callbackID: String, featureJSON: String, number: Int, offset: Int) {
+        val feature = Feature.fromJson(featureJSON)
+
+        val _this = this
+        mMap!!.getGeoJsonClusterLeaves(iD!!, feature, number.toLong(), offset.toLong(), QueryFeatureExtensionCallback { features ->
+            if (features.isValue) {
+                val leaves = features.value!!
+                    .featureCollection
+                val payload: WritableMap = WritableNativeMap()
+                payload.putString(
+                    "data",
+                    FeatureCollection.fromFeatures(leaves!!).toJson()
+                )
+                callbackSuccess(callbackID, payload)
+            } else {
+                callbackError(
+                    callbackID,
+                    features.error ?: "Unknown error",
+                    "getClusterLeaves/getGeoJsonClusterLeaves"
+                )
+                return@QueryFeatureExtensionCallback
+            }
+        })
+    }
+
+    fun getClusterChildren(callbackID: String, featureJSON: String) {
+        val feature = Feature.fromJson(featureJSON)
+
+        val _this = this
+        mMap!!.getGeoJsonClusterChildren(iD!!, feature, QueryFeatureExtensionCallback { features ->
+            if (features.isValue) {
+                val children = features.value!!
+                    .featureCollection
+                val payload: WritableMap = WritableNativeMap()
+                payload.putString(
+                    "data",
+                    FeatureCollection.fromFeatures(children!!).toJson()
+                )
+                callbackSuccess(callbackID, payload)
+            }else {
+                callbackError(
+                    callbackID,
+                    features.error ?: "Unknown error",
+                    "getClusterLeaves/queryFeatureExtensions"
+                )
+                return@QueryFeatureExtensionCallback
+            }
+        })
+    }
+
+    /*companion object {
+        private val mImagePlaceholder: Bitmap? = null
+    }*/
+}

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

@@ -0,0 +1,198 @@
+package com.mapbox.rctmgl.components.styles.sources
+
+import android.util.Log
+import android.view.View
+import com.facebook.react.bridge.ReactApplicationContext
+import com.mapbox.rctmgl.components.AbstractEventEmitter
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.common.MapBuilder
+import com.mapbox.bindgen.Value
+import com.mapbox.maps.extension.style.expressions.generated.Expression
+import com.mapbox.rctmgl.events.constants.EventKeys
+import com.mapbox.rctmgl.utils.ExpressionParser
+import java.net.MalformedURLException
+import java.net.URL
+import java.util.ArrayList
+import java.util.HashMap
+
+
+class RCTMGLShapeSourceManager(private val mContext: ReactApplicationContext) :
+    AbstractEventEmitter<RCTMGLShapeSource>(
+        mContext
+    ) {
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    override fun createViewInstance(reactContext: ThemedReactContext): RCTMGLShapeSource {
+        return RCTMGLShapeSource(reactContext, this)
+    }
+
+    override fun getChildAt(source: RCTMGLShapeSource, childPosition: Int): View {
+        return source.getLayerAt(childPosition)
+    }
+
+    override fun getChildCount(source: RCTMGLShapeSource): Int {
+        return source.layerCount
+    }
+
+    override fun addView(source: RCTMGLShapeSource, childView: View, childPosition: Int) {
+        source.addLayer(childView, getChildCount(source))
+    }
+
+    override fun removeViewAt(source: RCTMGLShapeSource, childPosition: Int) {
+        source.removeLayer(childPosition)
+    }
+
+    @ReactProp(name = "id")
+    fun setId(source: RCTMGLShapeSource, id: String) {
+        source.iD = id
+    }
+
+    @ReactProp(name = "url")
+    fun setURL(source: RCTMGLShapeSource, urlStr: String) {
+        try {
+            source.setURL(URL(urlStr))
+        } catch (e: MalformedURLException) {
+            Log.w(LOG_TAG, e.localizedMessage ?: "Unknown URL error")
+        }
+    }
+
+    @ReactProp(name = "shape")
+    fun setGeometry(source: RCTMGLShapeSource, geoJSONStr: String) {
+        source.setShape(geoJSONStr)
+    }
+
+    @ReactProp(name = "cluster")
+    fun setCluster(source: RCTMGLShapeSource, cluster: Int) {
+        source.setCluster(cluster == 1)
+    }
+
+    @ReactProp(name = "clusterRadius")
+    fun setClusterRadius(source: RCTMGLShapeSource, radius: Int) {
+        source.setClusterRadius(radius.toLong())
+    }
+
+    @ReactProp(name = "clusterMaxZoomLevel")
+    fun setClusterMaxZoomLevel(source: RCTMGLShapeSource, clusterMaxZoom: Int) {
+        source.setClusterMaxZoom(clusterMaxZoom.toLong())
+    }
+
+    @ReactProp(name = "clusterProperties")
+    fun setClusterProperties(source: RCTMGLShapeSource, map: ReadableMap) {
+        val properties = HashMap<String, Any>()
+        val iterator = map.keySetIterator()
+        while (iterator.hasNextKey()) {
+            val name = iterator.nextKey()
+            val expressions = map.getArray(name)
+            val builder: MutableList<Value> = ArrayList()
+            for (iExp in 0 until expressions!!.size()) {
+                var argument: Expression
+                argument = when (expressions.getType(iExp)) {
+                    ReadableType.Array -> ExpressionParser.from(
+                        expressions.getArray(iExp)
+                    )!!
+                    ReadableType.Map -> ExpressionParser.from(
+                        expressions.getMap(iExp)
+                    )
+                    ReadableType.Boolean -> Expression.literal(expressions.getBoolean(iExp))
+                    ReadableType.Number -> Expression.literal(expressions.getDouble(iExp))
+                    else -> Expression.literal(expressions.getString(iExp))
+                }
+                builder.add(argument)
+            }
+            properties[name] = Value(builder)
+        }
+        source.setClusterProperties(properties)
+    }
+
+    @ReactProp(name = "maxZoomLevel")
+    fun setMaxZoomLevel(source: RCTMGLShapeSource, maxZoom: Int) {
+        source.setMaxZoom(maxZoom.toLong())
+    }
+
+    @ReactProp(name = "buffer")
+    fun setBuffer(source: RCTMGLShapeSource, buffer: Int) {
+        source.setBuffer(buffer.toLong())
+    }
+
+    @ReactProp(name = "tolerance")
+    fun setTolerance(source: RCTMGLShapeSource, tolerance: Double) {
+        source.setTolerance(tolerance)
+    }
+
+    @ReactProp(name = "lineMetrics")
+    fun setLineMetrics(source: RCTMGLShapeSource, lineMetrics: Boolean) {
+        source.setLineMetrics(lineMetrics)
+    }
+
+    @ReactProp(name = "hasPressListener")
+    fun setHasPressListener(source: RCTMGLShapeSource, hasPressListener: Boolean) {
+        source.setHasPressListener(hasPressListener)
+    }
+
+    @ReactProp(name = "hitbox")
+    fun setHitbox(source: RCTMGLShapeSource, map: ReadableMap) {
+        source.setHitbox(map)
+    }
+
+    override fun customEvents(): Map<String, String>? {
+        return MapBuilder.builder<String, String>()
+            .put(EventKeys.SHAPE_SOURCE_LAYER_CLICK, "onMapboxShapeSourcePress")
+            .put(EventKeys.MAP_ANDROID_CALLBACK, "onAndroidCallback")
+            .build()
+    }
+
+    override fun getCommandsMap(): Map<String, Int>? {
+        return MapBuilder.builder<String, Int>()
+            .put("features", METHOD_FEATURES)
+            .put("getClusterExpansionZoom", METHOD_GET_CLUSTER_EXPANSION_ZOOM)
+            .put("getClusterLeaves", METHOD_GET_CLUSTER_LEAVES)
+            .put("getClusterChildren", METHOD_GET_CLUSTER_CHILDREN)
+            .build()
+    }
+
+    override fun receiveCommand(source: RCTMGLShapeSource, commandID: Int, args: ReadableArray?) {
+        if (args == null) {
+            return
+        }
+
+        val callbackID = args.getString(0);
+
+        when (commandID) {
+            METHOD_FEATURES -> source.querySourceFeatures(
+                callbackID,
+                ExpressionParser.from(args.getArray(1))
+            )
+            METHOD_GET_CLUSTER_EXPANSION_ZOOM -> source.getClusterExpansionZoom(
+                callbackID,
+                args.getString(1)
+            )
+            METHOD_GET_CLUSTER_LEAVES -> source.getClusterLeaves(
+                callbackID,
+                args.getString(1),
+                args.getInt(2),
+                args.getInt(3)
+            )
+            METHOD_GET_CLUSTER_CHILDREN -> source.getClusterChildren(
+                callbackID,
+                args.getString(1)
+            )
+        }
+    }
+
+    companion object {
+        const val LOG_TAG = "RCTMGLShapeSourceManager"
+        const val REACT_CLASS = "RCTMGLShapeSource"
+
+        //region React Methods
+        const val METHOD_FEATURES = 103
+        const val METHOD_GET_CLUSTER_EXPANSION_ZOOM = 104
+        const val METHOD_GET_CLUSTER_LEAVES = 105
+        const val METHOD_GET_CLUSTER_CHILDREN = 106
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/sources/RCTMGLTileSource.java

@@ -0,0 +1,103 @@
+package com.mapbox.rctmgl.components.styles.sources;
+
+import android.content.Context;
+
+import com.mapbox.maps.extension.style.sources.Source;
+import com.mapbox.maps.extension.style.sources.TileSet;
+import com.mapbox.maps.extension.style.sources.generated.Scheme;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+
+@SuppressWarnings("unused")
+public abstract class RCTMGLTileSource<T extends Source> extends RCTSource<T> {
+    static final String TILE_SPEC_VERSION = "2.1.0";
+
+    private String mURL;
+    private Collection<String> mTileUrlTemplates = new ArrayList<>();
+    private String mAttribution;
+
+    private Integer mMinZoomLevel;
+    private Integer mMaxZoomLevel;
+
+    private boolean mIsTmsSource;
+
+    public RCTMGLTileSource(Context context) {
+        super(context);
+    }
+
+    public String getURL() {
+        return mURL;
+    }
+
+    public void setURL(String mURL) {
+        this.mURL = mURL;
+    }
+
+    public String getAttribution() {
+        return mAttribution;
+    }
+
+    public void setAttribution(String mAttribution) {
+        this.mAttribution = mAttribution;
+    }
+
+    public Integer getMinZoomLevel() {
+        return mMinZoomLevel;
+    }
+
+    public void setMinZoomLevel(Integer mMinZoomLevel) {
+        this.mMinZoomLevel = mMinZoomLevel;
+    }
+
+    public Integer getMaxZoomLevel() {
+        return mMaxZoomLevel;
+    }
+
+    public void setMaxZoomLevel(Integer mMaxZoomLevel) {
+        this.mMaxZoomLevel = mMaxZoomLevel;
+    }
+
+    public boolean getTMS() {
+        return mIsTmsSource;
+    }
+
+    public void setTMS(boolean mIsTmsSource) {
+        this.mIsTmsSource = mIsTmsSource;
+    }
+
+    public Collection<String> getTileUrlTemplates() {
+        return mTileUrlTemplates;
+    }
+
+    public void setTileUrlTemplates(Collection<String> tileUrlTemplates) {
+        this.mTileUrlTemplates = tileUrlTemplates;
+    }
+
+    public TileSet buildTileset() {
+        String[] tileUrlTemplates = mTileUrlTemplates.toArray(new String[mTileUrlTemplates.size()]);
+        TileSet.Builder builder = new TileSet.Builder(
+            TILE_SPEC_VERSION, Arrays.asList(tileUrlTemplates.clone()));
+
+        if (mMinZoomLevel != null) {
+            builder.minZoom((int) mMinZoomLevel.floatValue());
+        }
+
+        if (mMaxZoomLevel != null) {
+            builder.maxZoom((int) mMaxZoomLevel.floatValue());
+        }
+
+        if (mIsTmsSource) {
+            builder.scheme(Scheme.TMS);
+        }
+
+        if (mAttribution != null) {
+            builder.attribution(mAttribution);
+        }
+
+        TileSet tileSet = builder.build();
+
+        return tileSet;
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/sources/RCTMGLTileSourceManager.java

@@ -0,0 +1,80 @@
+package com.mapbox.rctmgl.components.styles.sources;
+
+import android.view.View;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.mapbox.rctmgl.components.AbstractEventEmitter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class RCTMGLTileSourceManager<T extends RCTMGLTileSource> extends AbstractEventEmitter<T> {
+
+    RCTMGLTileSourceManager(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+    }
+
+    @Override
+    public View getChildAt(T source, int childPosition) {
+        return source.getLayerAt(childPosition);
+    }
+
+    @Override
+    public int getChildCount(T source) {
+        return source.getLayerCount();
+    }
+
+    @Override
+    public void addView(T source, View childView, int childPosition) {
+        source.addLayer(childView, childPosition);
+    }
+
+    @Override
+    public void removeViewAt(T source, int childPosition) {
+        source.removeLayer(childPosition);
+    }
+
+    @ReactProp(name="id")
+    public void setID(T source, String id) {
+        source.setID(id);
+    }
+
+    @ReactProp(name="url")
+    public void setURL(T source, String url) {
+        source.setURL(url);
+    }
+
+    @ReactProp(name="tileUrlTemplates")
+    public void setTileUrlTemplates(T source, ReadableArray tileUrlTemplates) {
+        List<String> urls = new ArrayList<>();
+        for (int i = 0; i < tileUrlTemplates.size(); i++) {
+            if (tileUrlTemplates.getType(0) == ReadableType.String) {
+                urls.add(tileUrlTemplates.getString(i));
+            }
+        }
+        source.setTileUrlTemplates(urls);
+    }
+
+    @ReactProp(name="attribution")
+    public void setAttribution(T source, String attribution) {
+        source.setAttribution(attribution);
+    }
+
+    @ReactProp(name="minZoomLevel")
+    public void setMinZoomLevel(T source, int minZoomLevel) {
+        source.setMinZoomLevel(minZoomLevel);
+    }
+
+    @ReactProp(name="maxZoomLevel")
+    public void setMaxZoomLevel(T source, int maxZoomLevel) {
+        source.setMaxZoomLevel(maxZoomLevel);
+    }
+
+    @ReactProp(name="tms")
+    public void setTMS(T source, boolean tms) {
+        source.setTMS(tms);
+    }
+}