@rnmapbox/maps 10.0.12 → 10.0.13-rc.0

package/android/{rctmgl/src → src}/main/java-mapboxgl/common/com/mapbox/rctmgl/components/styles/layers/RCTMGLHeatmapLayerManager.java

@@ -1,77 +1,77 @@
-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;
-
-/**
- * Created by dhee9000 on 6/8/2019
- */
-
-public class RCTMGLHeatmapLayerManager extends ViewGroupManager<RCTMGLHeatmapLayer>{
-    public static final String REACT_CLASS = "RCTMGLHeatmapLayer";
-
-    @Override
-    public String getName() {
-        return REACT_CLASS;
-    }
-
-    @Override
-    protected RCTMGLHeatmapLayer createViewInstance(ThemedReactContext reactContext) {
-        return new RCTMGLHeatmapLayer(reactContext);
-    }
-
-    @ReactProp(name="id")
-    public void setId(RCTMGLHeatmapLayer layer, String id) {
-        layer.setID(id);
-    }
-
-    @ReactProp(name="sourceID")
-    public void setSourceID(RCTMGLHeatmapLayer layer, String sourceID) {
-        layer.setSourceID(sourceID);
-    }
-
-    @ReactProp(name="aboveLayerID")
-    public void setAboveLayerID(RCTMGLHeatmapLayer layer, String aboveLayerID) {
-        layer.setAboveLayerID(aboveLayerID);
-    }
-
-    @ReactProp(name="belowLayerID")
-    public void setBelowLayerID(RCTMGLHeatmapLayer layer, String belowLayerID) {
-        layer.setBelowLayerID(belowLayerID);
-    }
-
-    @ReactProp(name="layerIndex")
-    public void setLayerIndex(RCTMGLHeatmapLayer layer, int layerIndex){
-        layer.setLayerIndex(layerIndex);
-    }
-
-    @ReactProp(name="minZoomLevel")
-    public void setMinZoomLevel(RCTMGLHeatmapLayer layer, double minZoomLevel) {
-        layer.setMinZoomLevel(minZoomLevel);
-    }
-
-    @ReactProp(name="maxZoomLevel")
-    public void setMaxZoomLevel(RCTMGLHeatmapLayer layer, double maxZoomLevel) {
-        layer.setMaxZoomLevel(maxZoomLevel);
-    }
-
-    @ReactProp(name="reactStyle")
-    public void setReactStyle(RCTMGLHeatmapLayer layer, ReadableMap style) {
-        layer.setReactStyle(style);
-    }
-
-    @ReactProp(name="sourceLayerID")
-    public void setSourceLayerId(RCTMGLHeatmapLayer layer, String sourceLayerID) {
-        layer.setSourceLayerID(sourceLayerID);
-    }
-
-    @ReactProp(name="filter")
-    public void setFilter(RCTMGLHeatmapLayer layer, ReadableArray filterList) {
-        layer.setFilter(filterList);
-    }
-}
+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;
+
+/**
+ * Created by dhee9000 on 6/8/2019
+ */
+
+public class RCTMGLHeatmapLayerManager extends ViewGroupManager<RCTMGLHeatmapLayer>{
+    public static final String REACT_CLASS = "RCTMGLHeatmapLayer";
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    protected RCTMGLHeatmapLayer createViewInstance(ThemedReactContext reactContext) {
+        return new RCTMGLHeatmapLayer(reactContext);
+    }
+
+    @ReactProp(name="id")
+    public void setId(RCTMGLHeatmapLayer layer, String id) {
+        layer.setID(id);
+    }
+
+    @ReactProp(name="sourceID")
+    public void setSourceID(RCTMGLHeatmapLayer layer, String sourceID) {
+        layer.setSourceID(sourceID);
+    }
+
+    @ReactProp(name="aboveLayerID")
+    public void setAboveLayerID(RCTMGLHeatmapLayer layer, String aboveLayerID) {
+        layer.setAboveLayerID(aboveLayerID);
+    }
+
+    @ReactProp(name="belowLayerID")
+    public void setBelowLayerID(RCTMGLHeatmapLayer layer, String belowLayerID) {
+        layer.setBelowLayerID(belowLayerID);
+    }
+
+    @ReactProp(name="layerIndex")
+    public void setLayerIndex(RCTMGLHeatmapLayer layer, int layerIndex){
+        layer.setLayerIndex(layerIndex);
+    }
+
+    @ReactProp(name="minZoomLevel")
+    public void setMinZoomLevel(RCTMGLHeatmapLayer layer, double minZoomLevel) {
+        layer.setMinZoomLevel(minZoomLevel);
+    }
+
+    @ReactProp(name="maxZoomLevel")
+    public void setMaxZoomLevel(RCTMGLHeatmapLayer layer, double maxZoomLevel) {
+        layer.setMaxZoomLevel(maxZoomLevel);
+    }
+
+    @ReactProp(name="reactStyle")
+    public void setReactStyle(RCTMGLHeatmapLayer layer, ReadableMap style) {
+        layer.setReactStyle(style);
+    }
+
+    @ReactProp(name="sourceLayerID")
+    public void setSourceLayerId(RCTMGLHeatmapLayer layer, String sourceLayerID) {
+        layer.setSourceLayerID(sourceLayerID);
+    }
+
+    @ReactProp(name="filter")
+    public void setFilter(RCTMGLHeatmapLayer layer, ReadableArray filterList) {
+        layer.setFilter(filterList);
+    }
+}

package/android/{rctmgl/src/main/java-mapboxgl/common → src/main/java-v10}/com/mapbox/rctmgl/components/AbstractEvent.java

@@ -1,35 +1,35 @@
-package com.mapbox.rctmgl.components;
-
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.uimanager.events.Event;
-import com.facebook.react.uimanager.events.RCTEventEmitter;
-
-import javax.annotation.Nullable;
-
-public class AbstractEvent extends Event<AbstractEvent> {
-    private String mEventName;
-    private final boolean mCanCoalesce;
-    private WritableMap mEvent;
-
-    public AbstractEvent(int viewId, String eventName, boolean canCoalesce, @Nullable WritableMap event) {
-        super(viewId);
-        mEventName = eventName;
-        mCanCoalesce = canCoalesce;
-        mEvent = event;
-    }
-
-    @Override
-    public String getEventName() {
-        return mEventName;
-    }
-
-    @Override
-    public void dispatch(RCTEventEmitter rctEventEmitter) {
-        rctEventEmitter.receiveEvent(getViewTag(), getEventName(), mEvent);
-    }
-
-    @Override
-    public boolean canCoalesce() {
-        return mCanCoalesce;
-    }
+package com.mapbox.rctmgl.components;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+import javax.annotation.Nullable;
+
+public class AbstractEvent extends Event<AbstractEvent> {
+    private String mEventName;
+    private final boolean mCanCoalesce;
+    private WritableMap mEvent;
+
+    public AbstractEvent(int viewId, String eventName, boolean canCoalesce, @Nullable WritableMap event) {
+        super(viewId);
+        mEventName = eventName;
+        mCanCoalesce = canCoalesce;
+        mEvent = event;
+    }
+
+    @Override
+    public String getEventName() {
+        return mEventName;
+    }
+
+    @Override
+    public void dispatch(RCTEventEmitter rctEventEmitter) {
+        rctEventEmitter.receiveEvent(getViewTag(), getEventName(), mEvent);
+    }
+
+    @Override
+    public boolean canCoalesce() {
+        return mCanCoalesce;
+    }
 }

package/android/{rctmgl/src → src}/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapView.kt

@@ -16,6 +16,7 @@ import androidx.lifecycle.LifecycleRegistry
 import androidx.lifecycle.ViewTreeLifecycleOwner
 import com.facebook.react.bridge.*
 import com.mapbox.android.gestures.*
+import com.mapbox.bindgen.Value
 import com.mapbox.geojson.Feature
 import com.mapbox.geojson.FeatureCollection
 import com.mapbox.geojson.Point
@@ -511,7 +512,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         }
     }
 
-    
+
     private val allTouchableSources: List<RCTSource<*>>
         private get() {
             val sources: MutableList<RCTSource<*>> = ArrayList()
@@ -825,7 +826,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
             val boundsMap = WritableNativeMap()
             boundsMap.putArray("ne", bounds.northeast.toReadableArray())
             boundsMap.putArray("sw", bounds.southwest.toReadableArray())
-            
+
             properties.putMap("bounds", boundsMap)
         } catch (ex: Exception) {
             Logger.e(LOG_TAG, "An error occurred while attempting to make the region", ex)
@@ -894,52 +895,52 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
 
     // region Callbacks
 
-    fun getCenter(callbackID: String?) {
+    fun getCenter(response: CommandResponse) {
         var center = mMap!!.cameraState!!.center
 
-        sendResponse(callbackID, {
+        response.success {
             val array: WritableArray = WritableNativeArray()
             array.pushDouble(center.longitude())
             array.pushDouble(center.latitude())
             it.putArray("center", array)
-        })
+        }
     }
 
-    fun getZoom(callbackID: String?) {
+    fun getZoom(response: CommandResponse) {
         var zoom = mMap!!.cameraState!!.zoom
 
-        sendResponse(callbackID, {
+        response.success {
             it.putDouble("zoom", zoom)
-        })
+        }
     }
 
     private fun getDisplayDensity(): Float {
         return mContext.resources.displayMetrics.density
     }
 
-    fun getCoordinateFromView(callbackID: String?, pixel: ScreenCoordinate) {
+    fun getCoordinateFromView(pixel: ScreenCoordinate, response: CommandResponse) {
         val density: Float = getDisplayDensity()
         val screenCoordinate = ScreenCoordinate(pixel.x * density, pixel.y * density)
 
         val coordinate = mMap!!.coordinateForPixel(screenCoordinate)
 
-        sendResponse(callbackID, {
+        response.success {
             it.putArray("coordinateFromView", coordinate.toReadableArray())
-        })
+        }
     }
 
-    fun getPointInView(callbackID: String?, coordinate: Point) {
+    fun getPointInView(coordinate: Point, response: CommandResponse) {
         val point = mMap!!.pixelForCoordinate(coordinate)
 
-        sendResponse(callbackID, {
+        response.success {
             val array: WritableArray = WritableNativeArray()
             array.pushDouble(point.x)
             array.pushDouble(point.y)
             it.putArray("pointInView", array)
-        })
+        }
     }
 
-    fun queryRenderedFeaturesAtPoint(callbackID: String?, point: PointF, filter: Expression?, layerIDs: List<String>?) {
+    fun queryRenderedFeaturesAtPoint(point: PointF, filter: Expression?, layerIDs: List<String>?, response: CommandResponse) {
         if (mMap == null) {
             Logger.e("queryRenderedFeaturesAtPoint", "mapbox map is null")
             return
@@ -954,16 +955,16 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
                 for (i in features.value!!) {
                     featuresList.add(i.feature)
                 }
-                sendResponse(callbackID) {
+                response.success {
                     it.putString("data", FeatureCollection.fromFeatures(featuresList).toJson())
                 }
             } else {
-                Logger.e("queryRenderedFeaturesAtPoint", features.error ?: "n/a")
+                response.error(features.error ?: "n/a")
             }
         }
     }
 
-    fun queryRenderedFeaturesInRect(callbackID: String?, rect: RectF, filter: Expression?, layerIDs: List<String>?) {
+    fun queryRenderedFeaturesInRect(rect: RectF, filter: Expression?, layerIDs: List<String>?, response: CommandResponse) {
         val size = mMap!!.getMapOptions().size
         val screenBox = if (rect.isEmpty()) ScreenBox(ScreenCoordinate(0.0, 0.0), ScreenCoordinate(size?.width!!.toDouble(), size?.height!!.toDouble())) else ScreenBox(
                 ScreenCoordinate(rect.right.toDouble(), rect.bottom.toDouble() ),
@@ -979,80 +980,79 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
                     featuresList.add(i.feature)
                 }
 
-                val payload: WritableMap = WritableNativeMap()
-                payload.putString("data", FeatureCollection.fromFeatures(featuresList).toJson())
-
-                var event = AndroidCallbackEvent(this, callbackID, payload)
-                mManager.handleEvent(event)
+                response.success {
+                   it.putString("data", FeatureCollection.fromFeatures(featuresList).toJson())
+                }
             } else {
-                Logger.e("queryRenderedFeaturesInRect", features.error ?: "n/a")
+                response.error(features.error ?: "n/a")
             }
         }
     }
 
-    fun sendResponse(callbackID: String?, buildPayload: (map: WritableMap) -> Unit) {
-        val payload: WritableMap = WritableNativeMap()
-        buildPayload(payload)
-        var event = AndroidCallbackEvent(this, callbackID, payload)
-        mManager.handleEvent(event)
+    fun querySourceFeatures(sourceId: String, filter: Expression?, sourceLayerIDs: List<String>?, response: CommandResponse) {
+        mMap?.querySourceFeatures(
+                sourceId,
+                SourceQueryOptions(sourceLayerIDs, (filter ?: Value.nullValue()) as Value),
+        ) { features ->
+            if (features.isValue) {
+                val featuresList = ArrayList<Feature?>()
+                for (i in features.value!!) {
+                    featuresList.add(i.feature)
+                }
+
+                response.success {
+                    it.putString("data", FeatureCollection.fromFeatures(featuresList).toJson())
+                }
+            } else {
+                response.error(features.error ?: "n/a")
+            }
+        }
     }
 
-    fun getVisibleBounds(callbackID: String?) {
+    fun getVisibleBounds(response: CommandResponse) {
         val bounds = mMap!!.coordinateBoundsForCamera(mMap!!.cameraState.toCameraOptions())
 
-        sendResponse(callbackID, {
+        response.success {
             it.putArray("visibleBounds", bounds.toReadableArray())
-        })
+        }
     }
 
-    fun takeSnap(callbackID: String?, writeToDisk: Boolean) {
+    fun takeSnap(writeToDisk: Boolean, response: CommandResponse) {
         mapView.snapshot { snapshot ->
             if (snapshot == null) {
-                Logger.e("takeSnap", "snapshot failed")
-
-                sendResponse(callbackID, {
-                    it.putNull("data")
-                    it.putString("error", "no snapshot")
-                })
+                response.error("snapshot failed")
             } else {
                 val uri: String = if (writeToDisk) BitmapUtils.createTempFile(
                     mContext,
                     snapshot
                 ) else BitmapUtils.createBase64(snapshot)
 
-                sendResponse(callbackID, {
+                response.success {
                     it.putString("uri", uri)
-                })
+                }
             }
         }
     }
 
-    fun queryTerrainElevation(callbackID: String?, longitude: Double, latitude: Double) {
+    fun queryTerrainElevation(longitude: Double, latitude: Double, response: CommandResponse) {
         val result = mMap?.getElevation(Point.fromLngLat(longitude, latitude))
 
-        sendResponse(callbackID, {response ->
-            if (result != null) {
-                response.putDouble("data", result)
-            } else {
-                Logger.e("queryTerrainElevation", "no elevation data")
-
-                response.putNull("data")
-                response.putString("error", "no elevation")
+        if (result != null) {
+            response.success {
+                it.putDouble("data", result)
             }
-        })
+        } else {
+            response.error("no elevation data")
+        }
     }
 
-    fun clearData(callbackID: String?) {
+    fun clearData(response: CommandResponse) {
         mapView.getMapboxMap().clearData { expected ->
-            sendResponse(callbackID) { response ->
-                if (expected.isError()) {
-                    response.putNull("data")
-                    response.putString("error", expected.error!!.toString())
-                }   else {
-                    response.putBoolean("data", true)
-                }
+            if (expected.isError()) {
+                response.error(expected.error!!.toString())
+            } else {
+                response.success { it.putBoolean("data", true) }
             }
-
         }
     }
 

package/android/{rctmgl/src → src}/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapViewManager.kt

@@ -10,19 +10,15 @@ import com.facebook.react.uimanager.LayoutShadowNode
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.annotations.ReactProp
 import com.mapbox.rctmgl.events.constants.EventKeys
-import com.mapbox.maps.MapboxMap
 import com.facebook.react.common.MapBuilder
-import com.mapbox.maps.MapInitOptions
 import com.mapbox.maps.extension.style.layers.properties.generated.ProjectionName
-import com.mapbox.maps.plugin.compass.compass
 import com.mapbox.maps.plugin.gestures.gestures
 import com.mapbox.maps.plugin.logo.logo
+import com.mapbox.rctmgl.events.AndroidCallbackEvent
 import com.mapbox.rctmgl.utils.ConvertUtils
 import com.mapbox.rctmgl.utils.ExpressionParser
-import com.mapbox.rctmgl.utils.GeoJSONUtils
 import com.mapbox.rctmgl.utils.Logger
 import com.mapbox.rctmgl.utils.extensions.toCoordinate
-import com.mapbox.rctmgl.utils.extensions.toReadableArray
 import com.mapbox.rctmgl.utils.extensions.toScreenCoordinate
 import java.lang.Exception
 import java.util.HashMap
@@ -40,6 +36,11 @@ fun ReadableArray.asArrayString(): Array<String> {
     return result
 }
 
+interface CommandResponse {
+    fun success(builder: (WritableMap) -> Unit)
+    fun error(message: String)
+}
+
 open class RCTMGLMapViewManager(context: ReactApplicationContext) :
     AbstractEventEmitter<RCTMGLMapView>(context) {
     private val mViews: MutableMap<Int, RCTMGLMapView>
@@ -259,31 +260,52 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext) :
         );
     }
 
+    fun sendResponse(mapView: RCTMGLMapView, callbackId: String, responseBuilder: (WritableMap) -> Unit) {
+        val payload: WritableMap = WritableNativeMap()
+        responseBuilder(payload)
+        var event = AndroidCallbackEvent(mapView, callbackId, payload)
+        handleEvent(event)
+    }
+
     override fun receiveCommand(mapView: RCTMGLMapView, command: String, args: ReadableArray?) {
+        val callbackId = args!!.getString(0);
         // allows method calls to work with componentDidMount
         val mapboxMap = mapView.getMapboxMap()
             ?: //            mapView.enqueuePreRenderMapMethod(commandID, args);
             return
+        val response = object : CommandResponse {
+            override fun success(builder: (WritableMap) -> Unit) {
+                sendResponse(mapView, callbackId, builder)
+            }
+
+            override fun error(message: String) {
+                Logger.e(REACT_CLASS, "Command: ${command} failed with: ${message}")
+                sendResponse(mapView, callbackId) {
+                    it.putNull("data")
+                    it.putString("error", message)
+                }
+            }
+        }
         when (command) {
             "queryTerrainElevation" -> {
                 val coords = args!!.getArray(1)
                 mapView.queryTerrainElevation(
-                    args.getString(0),
                     coords.getDouble(0),
-                    coords.getDouble(1)
+                    coords.getDouble(1),
+                    response
                 )
             }
             "getZoom" -> {
-                mapView.getZoom(args!!.getString(0));
+                mapView.getZoom(response)
             }
             "getCenter" -> {
-                mapView.getCenter(args!!.getString(0));
+                mapView.getCenter(response)
             }
             "getPointInView" -> {
-                mapView.getPointInView(args!!.getString(0), args.getArray(1).toCoordinate())
+                mapView.getPointInView(args.getArray(1).toCoordinate(), response)
             }
             "getCoordinateFromView" -> {
-                mapView.getCoordinateFromView(args!!.getString(0), args.getArray(1).toScreenCoordinate());
+                mapView.getCoordinateFromView(args.getArray(1).toScreenCoordinate(), response)
             }
             "setSourceVisibility" -> {
                 mapView!!.setSourceVisibility(
@@ -294,26 +316,35 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext) :
             }
             "queryRenderedFeaturesAtPoint" -> {
                 mapView.queryRenderedFeaturesAtPoint(
-                    args!!.getString(0),
                     ConvertUtils.toPointF(args!!.getArray(1)),
                     ExpressionParser.from(args!!.getArray(2)),
-                    ConvertUtils.toStringList(args!!.getArray(3))
-                );
+                    ConvertUtils.toStringList(args!!.getArray(3)),
+                    response
+                )
             }
             "queryRenderedFeaturesInRect" -> {
                 val layerIds = ConvertUtils.toStringList(args!!.getArray(3))
                 mapView.queryRenderedFeaturesInRect(
-                        args!!.getString(0),
                         ConvertUtils.toRectF(args.getArray(1)),
                         ExpressionParser.from(args!!.getArray(2)),
-                        if (layerIds.size == 0) null else layerIds
+                        if (layerIds.size == 0) null else layerIds,
+                        response
+                )
+            }
+            "querySourceFeatures" -> {
+                val sourceLayerIds = ConvertUtils.toStringList(args!!.getArray(3))
+                mapView.querySourceFeatures(
+                        args!!.getString(1),
+                        ExpressionParser.from(args!!.getArray(2)),
+                        if (sourceLayerIds.size == 0) null else sourceLayerIds,
+                        response
                 );
             }
             "getVisibleBounds" -> {
-                mapView.getVisibleBounds(args!!.getString(0));
+                mapView.getVisibleBounds(response)
             }
             "takeSnap" -> {
-                mapView.takeSnap(args!!.getString(0), args!!.getBoolean(1))
+                mapView.takeSnap(args!!.getBoolean(1), response)
             }
             "setHandledMapChangedEvents" -> {
                 args?.let {
@@ -321,7 +352,7 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext) :
                 }
             }
             "clearData" -> {
-                mapView.clearData(args!!.getString(0))
+                mapView.clearData(response)
             }
             else -> {
                 Logger.w("RCTMGLMapView.receiveCommand", "unexpected command: ${command}")

package/ios/RCTMGL-v10/RCTMGLMapViewManager.m

@@ -87,6 +87,13 @@ RCT_EXTERN_METHOD(queryRenderedFeaturesInRect:(nonnull NSNumber*)reactTag
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(querySourceFeatures:(nonnull NSNumber*)reactTag
+                  withSourceId:(NSString*)sourceId
+                  withFilter:(NSArray)filter
+                  withSourceLayerIds:(NSArray<NSString*>*)sourceLayerIds
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(setHandledMapChangedEvents:(nonnull NSNumber*)reactTag
                   events:(NSArray<NSString*>*)events
                   resolver:(RCTPromiseResolveBlock)resolve