@rnmapbox/maps 10.0.0-beta.46 → 10.0.0-beta.48

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

@@ -26,19 +26,17 @@ import com.mapbox.maps.extension.style.layers.getLayer
 import com.mapbox.maps.extension.style.layers.properties.generated.Visibility
 import com.mapbox.maps.plugin.annotation.Annotation
 import com.mapbox.maps.plugin.annotation.annotations
-import com.mapbox.maps.plugin.annotation.generated.OnPointAnnotationClickListener
-import com.mapbox.maps.plugin.annotation.generated.OnPointAnnotationDragListener
-import com.mapbox.maps.plugin.annotation.generated.PointAnnotation
-import com.mapbox.maps.plugin.annotation.generated.PointAnnotationManager
-import com.mapbox.maps.plugin.annotation.generated.createPointAnnotationManager
+import com.mapbox.maps.plugin.annotation.generated.*
 import com.mapbox.maps.plugin.attribution.attribution
 import com.mapbox.maps.plugin.attribution.generated.AttributionSettings
 import com.mapbox.maps.plugin.compass.compass
+import com.mapbox.maps.plugin.compass.generated.CompassSettings
 import com.mapbox.maps.plugin.delegates.listeners.*
 import com.mapbox.maps.plugin.gestures.*
 import com.mapbox.maps.plugin.logo.generated.LogoSettings
 import com.mapbox.maps.plugin.logo.logo
-import com.mapbox.maps.viewannotation.ViewAnnotationManager
+import com.mapbox.maps.plugin.scalebar.generated.ScaleBarSettings
+import com.mapbox.maps.plugin.scalebar.scalebar
 import com.mapbox.rctmgl.R
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.annotation.RCTMGLMarkerView
@@ -57,6 +55,7 @@ import com.mapbox.rctmgl.events.IEvent
 import com.mapbox.rctmgl.events.MapChangeEvent
 import com.mapbox.rctmgl.events.MapClickEvent
 import com.mapbox.rctmgl.events.constants.EventTypes
+import com.mapbox.rctmgl.utils.BitmapUtils
 import com.mapbox.rctmgl.utils.GeoJSONUtils
 import com.mapbox.rctmgl.utils.LatLng
 import com.mapbox.rctmgl.utils.Logger
@@ -66,6 +65,13 @@ import org.json.JSONObject
 import java.util.*
 
 
+data class OrnamentSettings(
+    var enabled : Boolean? = false,
+    var margins: ReadableMap? =null,
+    var position: Int = -1
+)
+
+
 interface RCTMGLMapViewLifecycleOwner : LifecycleOwner {
     fun handleLifecycleEvent(event: Lifecycle.Event)
 }
@@ -389,6 +395,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     }
 
     fun setReactStyleURL(styleURL: String) {
+        mStyleURL = styleURL
         if (mMap != null) {
             removeAllFeaturesFromMap()
             if (isJSONValid(mStyleURL)) {
@@ -608,7 +615,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         properties.putBoolean("isUserInteraction", mCameraChangeTracker.isUserInteraction)
         try {
             val bounds = mMap.coordinateBoundsForCamera(position.toCameraOptions())
-            properties.putArray("visibleBounds", GeoJSONUtils.fromCoordinateBounds(bounds))
+            properties.putArray("visibleBounds", bounds.toReadableArray())
         } catch (ex: Exception) {
             Logger.e(LOG_TAG, "An error occurred while attempting to make the region", ex)
         }
@@ -724,7 +731,8 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     }
 
     fun queryRenderedFeaturesInRect(callbackID: String?, rect: RectF, filter: Expression?, layerIDs: List<String>?) {
-        val screenBox = ScreenBox(
+        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() ),
                 ScreenCoordinate(rect.left.toDouble(), rect.top.toDouble()),
         )
@@ -760,10 +768,32 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         val bounds = mMap!!.coordinateBoundsForCamera(mMap!!.cameraState.toCameraOptions())
 
         sendResponse(callbackID, {
-            it.putArray("visibleBounds", GeoJSONUtils.fromCoordinateBounds(bounds))
+            it.putArray("visibleBounds", bounds.toReadableArray())
         })
     }
 
+    fun takeSnap(callbackID: String?, writeToDisk: Boolean) {
+        this.snapshot { snapshot ->
+            if (snapshot == null) {
+                Logger.e("takeSnap", "snapshot failed")
+
+                sendResponse(callbackID, {
+                    it.putNull("data")
+                    it.putString("error", "no snapshot")
+                })
+            } else {
+                val uri: String = if (writeToDisk) BitmapUtils.createTempFile(
+                    mContext,
+                    snapshot
+                ) else BitmapUtils.createBase64(snapshot)
+
+                sendResponse(callbackID, {
+                    it.putString("uri", uri)
+                })
+            }
+        }
+    }
+
     fun queryTerrainElevation(callbackID: String?, longitude: Double, latitude: Double) {
         val result = mMap?.getElevation(Point.fromLngLat(longitude, latitude))
 
@@ -858,12 +888,12 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
 
     // region Ornaments
 
-    fun toGravity(kind: String, viewPosition: Int): Int {
+    private fun toGravity(kind: String, viewPosition: Int): Int {
         return when (viewPosition) {
-            0 -> (Gravity.TOP or Gravity.START)
-            1 -> (Gravity.TOP or Gravity.END)
-            2 -> (Gravity.BOTTOM or Gravity.START)
-            3 -> (Gravity.BOTTOM or Gravity.END)
+            0 -> (Gravity.TOP or Gravity.LEFT)
+            1 -> (Gravity.TOP or Gravity.RIGHT)
+            2 -> (Gravity.BOTTOM or Gravity.LEFT)
+            3 -> (Gravity.BOTTOM or Gravity.RIGHT)
             else -> {
                 Logger.e(
                     "MapView",
@@ -874,13 +904,46 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         }
     }
 
-    var mCompassEnabled = false
+    private fun updateOrnament(kind: String, from: OrnamentSettings, to: GenericOrnamentSettings) {
+        from.enabled?.let { to.enabled = it }
+        if (from.position >= 0) {
+            to.position = toGravity(kind, from.position)
+        }
+
+        from.margins?.let {
+            val pixelDensity = resources.displayMetrics.density
+            val x: Int? = it.getDouble("x")?.let { (it * pixelDensity).toInt() }
+            val y: Int? = it.getDouble("y")?.let { (it * pixelDensity).toInt() }
+
+            val horizontalGravity = to.position and Gravity.HORIZONTAL_GRAVITY_MASK
+            val verticalGravity = to.position and Gravity.VERTICAL_GRAVITY_MASK
+
+            when (horizontalGravity) {
+                Gravity.LEFT -> { to.setHMargins(x?.toFloat(), 0f)  }
+                Gravity.RIGHT -> { to.setHMargins(0f, x?.toFloat())  }
+                Gravity.CENTER_HORIZONTAL ->{ to.setHMargins(x?.toFloat(), x?.toFloat())  }
+                else -> Logger.e(
+                    "MapView",
+                    "${kind}ViewMargins: unexpected absolute pos: $horizontalGravity"
+                )
+            }
+            when (verticalGravity) {
+                Gravity.TOP -> { to.setVMargins(y?.toFloat(), 0f)  }
+                Gravity.BOTTOM -> { to.setVMargins(0f, y?.toFloat())  }
+                Gravity.CENTER_VERTICAL -> { to.setVMargins(y?.toFloat(), y?.toFloat())  }
+                else -> Logger.e(
+                    "MapView",
+                    "${kind}ViewMargins: unexpected vertical pos: $verticalGravity"
+                )
+            }
+        }
+    }
+
+    var mCompassSettings = OrnamentSettings(enabled = false)
     var mCompassFadeWhenNorth = false
-    var mCompassViewMargins: ReadableMap? = null
-    var mCompassViewPosition: Int = -1
 
     fun setReactCompassEnabled(compassEnabled: Boolean) {
-        mCompassEnabled = compassEnabled
+        mCompassSettings.enabled = compassEnabled
         updateCompass()
     }
 
@@ -890,82 +953,55 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     }
 
     fun setReactCompassViewMargins(compassViewMargins: ReadableMap) {
-        mCompassViewMargins = compassViewMargins
+        mCompassSettings.margins = compassViewMargins
         updateCompass()
     }
 
     fun setReactCompassViewPosition(compassViewPosition: Int) {
-        mCompassViewPosition = compassViewPosition
+        mCompassSettings.position = compassViewPosition
         updateCompass()
     }
 
-    fun setReactCompassMargins(compassMargins: ReadableMap) {
-        val bottom_mask = 1;
-        val right_mask = 2;
-
-        var margins = WritableNativeMap()
-        var position = 0;
-        if (compassMargins.hasKey("bottom")) {
-            margins.putInt("y", compassMargins.getInt("bottom"))
-            position = position or bottom_mask
-        } else {
-            if (compassMargins.hasKey("top")) {
-                margins.putInt("y", compassMargins.getInt("top"))
-            }
-        }
-
-        if (compassMargins.hasKey("left")) {
-            margins.putInt("x", compassMargins.getInt("left"))
-        } else {
-            if (compassMargins.hasKey("right")) {
-                margins.putInt("x", compassMargins.getInt("right"))
-            }
-        }
-        mCompassViewPosition = position
-        mCompassViewMargins = margins
+    fun setReactCompassPosition(compassPosition: ReadableMap) {
+        mCompassSettings.setPosAndMargins(compassPosition)
         updateCompass()
     }
 
     private fun updateCompass() {
         compass.updateSettings {
-            enabled = mCompassEnabled
             fadeWhenFacingNorth = mCompassFadeWhenNorth
-            if (mCompassViewPosition >= 0) {
-                position = toGravity("compass", mCompassViewPosition)
-            }
+            updateOrnament("compass", mCompassSettings, this.toGenericOrnamentSettings())
+        }
+    }
 
-            val compassViewMargins = mCompassViewMargins
-            if (compassViewMargins != null) {
-                val pixelDensity = resources.displayMetrics.density.toInt()
-                val x: Int = compassViewMargins.getInt("x") * pixelDensity
-                val y: Int = compassViewMargins.getInt("y") * pixelDensity
+    var mScaleBarSettings = OrnamentSettings(enabled = false)
 
-                val horizontalGravity = position and Gravity.HORIZONTAL_GRAVITY_MASK
-                val verticalGravity = position and Gravity.VERTICAL_GRAVITY_MASK
+    fun setReactScaleBarEnabled(scaleBarEnabled: Boolean) {
+        mScaleBarSettings.enabled = scaleBarEnabled
+        updateScaleBar()
+    }
 
-                when (horizontalGravity) {
-                    Gravity.LEFT -> {
-                        marginLeft = x.toFloat()
-                    }
-                    Gravity.RIGHT -> marginRight = x.toFloat()
-                    Gravity.CENTER_HORIZONTAL -> marginLeft = x.toFloat()
-                    else -> Logger.e(
-                        "MapView",
-                        "compassViewMargins: unexpected absolute pos: $horizontalGravity"
-                    )
-                }
-                when (verticalGravity) {
-                    Gravity.TOP -> marginTop = y.toFloat()
-                    Gravity.BOTTOM -> marginBottom = y.toFloat()
-                    Gravity.CENTER_VERTICAL -> marginTop = y.toFloat()
-                    else -> Logger.e(
-                        "MapView",
-                        "compassViewMargins: unexpected vertical pos: $verticalGravity"
-                    )
-                }
-            }
+    fun setReactScaleBarViewMargins(scaleBarMargins: ReadableMap) {
+        mScaleBarSettings.margins = scaleBarMargins
+        updateScaleBar()
+    }
+
+    fun setReactScaleBarViewPosition(scaleBarPosition: Int) {
+        mScaleBarSettings.position = scaleBarPosition
+        updateScaleBar()
+    }
+
+    fun setReactScaleBarPosition(scaleBarPosition: ReadableMap) {
+        mScaleBarSettings.setPosAndMargins(scaleBarPosition)
+        updateScaleBar()
+    }
+
+    private fun updateScaleBar() {
+        scalebar.updateSettings {
+            updateOrnament("scaleBar", mScaleBarSettings, this.toGenericOrnamentSettings())
         }
     }
+
     // endregion
 
     private fun getGravityAndMargin (position:ReadableMap): Pair<Int, IntArray> {
@@ -1043,6 +1079,44 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     private var mLogoGravity: Int? = null
     private var mLogoMargin: IntArray? = null
 
+    var mLogoSettings = OrnamentSettings(enabled = null)
+
+    fun setReactLogoEnabled(enabled: Boolean?) {
+        mLogoSettings.enabled = enabled
+        updateLogo()
+    }
+
+    fun setReactLogoMargins(margins: ReadableMap) {
+        mLogoSettings.margins = margins
+        updateLogo()
+    }
+
+    fun setReactLogoViewPosition(position: Int) {
+        mLogoSettings.position = position
+        updateLogo()
+    }
+
+    fun setReactLogoPosition(position: ReadableMap?) {
+        mLogoSettings.setPosAndMargins(position)
+        updateLogo()
+    }
+
+    private fun updateLogo() {
+        logo.updateSettings {
+            updateOrnament("logo", mLogoSettings, this.toGenericOrnamentSettings())
+        }
+
+        logo.updateSettings {
+            println(String.format("logo :: position - before 0x%08x", position))
+            //position = Gravity.BOTTOM or Gravity.RIGHT
+            println(String.format("eq bottom|right %b", position == (Gravity.BOTTOM or Gravity.RIGHT)))
+            if (position == Gravity.BOTTOM or Gravity.RIGHT) {
+                position = Gravity.BOTTOM or Gravity.RIGHT
+            }
+            println(String.format("logo :: position - after 0x%08x", position))
+        }
+    }
+/*
     fun setReactLogoEnabled(logoEnabled: Boolean?) {
         mLogoEnabled = logoEnabled ?: LogoSettings().enabled
         updateLogo()
@@ -1081,6 +1155,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
             }
         }
     }
+ */
     // endregion
 
     // region lifecycle
@@ -1128,3 +1203,97 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
 
     // endregion
 }
+
+fun OrnamentSettings.setPosAndMargins(posAndMargins: ReadableMap?) {
+    if (posAndMargins == null) { return }
+
+    val bottom_mask = 1;
+    val right_mask = 2;
+
+    var margins = WritableNativeMap()
+    var position = 0;
+    if (posAndMargins
+            .hasKey("bottom")) {
+        margins.putInt("y", posAndMargins.getInt("bottom"))
+        position = position or bottom_mask
+    } else {
+        if (posAndMargins.hasKey("top")) {
+            margins.putInt("y", posAndMargins.getInt("top"))
+        }
+    }
+
+    if (posAndMargins.hasKey("left")) {
+        margins.putInt("x", posAndMargins.getInt("left"))
+    } else {
+        if (posAndMargins.hasKey("right")) {
+            position = position or right_mask
+            margins.putInt("x", posAndMargins.getInt("right"))
+        }
+    }
+    this.position = position
+    this.margins = margins
+}
+
+interface GenericOrnamentSettings {
+    fun setHMargins(left: Float?, right: Float?)
+    fun setVMargins(top: Float?, bottom: Float?)
+    var enabled: Boolean
+    var position: Int
+}
+
+fun ScaleBarSettings.toGenericOrnamentSettings() = object : GenericOrnamentSettings {
+    private val settings = this@toGenericOrnamentSettings
+    override fun setHMargins(left: Float?, right: Float?) {
+        left?.let { settings.marginLeft = it }
+        right?.let { settings.marginRight = it }
+    }
+    override fun setVMargins(top: Float?, bottom: Float?) {
+        top?.let { settings.marginTop = it }
+        bottom?.let { settings.marginBottom = it }
+    }
+    override var enabled: Boolean
+        get() = settings.enabled
+        set(value) { settings.enabled = value }
+    override var position: Int
+        get() = settings.position
+        set(value) { settings.position = value }
+}
+
+fun CompassSettings.toGenericOrnamentSettings() = object : GenericOrnamentSettings {
+    private val settings = this@toGenericOrnamentSettings
+    override fun setHMargins(left: Float?, right: Float?) {
+        left?.let { settings.marginLeft = it }
+        right?.let { settings.marginRight = it }
+    }
+    override fun setVMargins(top: Float?, bottom: Float?) {
+        top?.let { settings.marginTop = it }
+        bottom?.let { settings.marginBottom = it }
+    }
+    override var enabled: Boolean
+        get() = settings.enabled
+        set(value) { settings.enabled = value }
+    override var position: Int
+        get() = settings.position
+        set(value) { settings.position = value }
+}
+
+fun LogoSettings.toGenericOrnamentSettings() = object : GenericOrnamentSettings {
+    private val settings = this@toGenericOrnamentSettings
+    override fun setHMargins(left: Float?, right: Float?) {
+        left?.let { settings.marginLeft = it }
+        right?.let { settings.marginRight = it }
+    }
+    override fun setVMargins(top: Float?, bottom: Float?) {
+        top?.let { settings.marginTop = it }
+        bottom?.let { settings.marginBottom = it }
+    }
+    override var enabled: Boolean
+        get() = settings.enabled
+        set(value) { settings.enabled = value }
+    override var position: Int
+        get() = settings.position
+        set(value) {
+            println(String.format("logo :: position: 0x%08x", value))
+            settings.position = value
+        }
+}

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

@@ -136,6 +136,26 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext?) :
         mapView!!.setReactLogoPosition(logoPosition);
     }
 
+    @ReactProp(name = "scaleBarEnabled")
+    fun setScaleBarEnabled(mapView: RCTMGLMapView?, scaleBarEnabled: Boolean) {
+        mapView!!.setReactScaleBarEnabled(scaleBarEnabled);
+    }
+
+    @ReactProp(name = "scaleBarViewMargins")
+    fun setScaleBarViewMargins(mapView: RCTMGLMapView?, scaleBarMargins: ReadableMap?) {
+        mapView!!.setReactScaleBarViewMargins(scaleBarMargins!!);
+    }
+
+    @ReactProp(name = "scaleBarViewPosition")
+    fun setScaleBarViewPosition(mapView: RCTMGLMapView?, scaleBarPosition: Int) {
+        mapView!!.setReactScaleBarViewPosition(scaleBarPosition!!)
+    }
+
+    @ReactProp(name = "scaleBarPosition")
+    fun scaleBarViewPosition(mapView: RCTMGLMapView?, scaleBarPosition: ReadableMap) {
+        mapView!!.setReactScaleBarPosition(scaleBarPosition)
+    }
+
     @ReactProp(name = "compassEnabled")
     fun setCompassEnabled(mapView: RCTMGLMapView?, compassEnabled: Boolean) {
         mapView!!.setReactCompassEnabled(compassEnabled);
@@ -157,8 +177,8 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext?) :
     }
 
     @ReactProp(name = "compassPosition")
-    fun setCompassMargins(mapView: RCTMGLMapView?, compassMargins: ReadableMap) {
-        mapView!!.setReactCompassMargins(compassMargins)
+    fun setCompassPosition(mapView: RCTMGLMapView?, compassMargins: ReadableMap) {
+        mapView!!.setReactCompassPosition(compassMargins)
     }
 
     @ReactProp(name = "contentInset")
@@ -253,6 +273,9 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext?) :
             METHOD_VISIBLE_BOUNDS -> {
                 mapView.getVisibleBounds(args!!.getString(0));
             }
+            METHOD_TAKE_SNAP -> {
+                mapView.takeSnap(args!!.getString(0), args!!.getBoolean(1))
+            }
         }
         /*
         switch (commandID) {

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

@@ -32,6 +32,7 @@ class RCTMGLAtmosphere(context: Context?) : AbstractSourceConsumer(context) {
     // endregion RCTLayer
 
     override fun addToMap(mapView: RCTMGLMapView) {
+        super.addToMap(mapView)
         mMap = mapView.getMapboxMap()
         val atmosphere = makeAtmosphere()
         mAtmosphere = atmosphere
@@ -42,6 +43,7 @@ class RCTMGLAtmosphere(context: Context?) : AbstractSourceConsumer(context) {
     override fun removeFromMap(mapView: RCTMGLMapView) {
         mapView.savedStyle?.let { it.removeTerrain() }
         mMap = null
+        super.removeFromMap(mapView)
     }
 
     fun makeAtmosphere(): Atmosphere {

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

@@ -42,7 +42,6 @@ abstract class RCTLayer<T : Layer?>(protected var mContext: Context) : AbstractS
     protected var mMap: MapboxMap? = null
     @JvmField
     protected var mLayer: T? = null
-    protected var mMapView: RCTMGLMapView? = null
     protected var mHadFilter = false
 
     fun setSourceID(sourceID: String?) {
@@ -230,8 +229,8 @@ abstract class RCTLayer<T : Layer?>(protected var mContext: Context) : AbstractS
     }
 
     override fun addToMap(mapView: RCTMGLMapView) {
+        super.addToMap(mapView)
         mMap = mapView.getMapboxMap()
-        mMapView = mapView
         if (style == null) return
         val existingLayer = getLayerAs(style, iD)
         if (existingLayer != null) {
@@ -251,6 +250,7 @@ abstract class RCTLayer<T : Layer?>(protected var mContext: Context) : AbstractS
         if (style != null) {
             style!!.removeStyleLayer(mLayer!!.layerId)
         }
+        super.removeFromMap(mapView)
     }
 
     // v10TOOD: adding anything seems to make getStyle null

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

@@ -77,6 +77,10 @@ class RCTMGLShapeSource(context: Context, private val mManager: RCTMGLShapeSourc
 
     fun setClusterMaxZoom(clusterMaxZoom: Long) {
         mClusterMaxZoom = clusterMaxZoom
+        if (mSource != null && mMapView != null && !mMapView!!.isDestroyed) {
+            val result = mMap!!.getStyle()!!
+                .setStyleSourceProperty(iD!!, "clusterMaxZoom", Value.valueOf(clusterMaxZoom))
+        }
     }
 
     fun setClusterProperties(clusterProperties: HashMap<String, Any>) {

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

@@ -24,8 +24,6 @@ import java.util.ArrayList
 import java.util.HashMap
 
 abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(context) {
-    @JvmField
-    protected var mMapView: RCTMGLMapView? = null
     @JvmField
     protected var mMap: MapboxMap? = null
     var iD: String? = null
@@ -107,7 +105,7 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
         }
 
     override fun addToMap(mapView: RCTMGLMapView) {
-        mMapView = mapView
+        super.addToMap(mapView)
         mMap = mapView.getMapboxMap()
         mMap?.getStyle(object : Style.OnStyleLoaded {
             override fun onStyleLoaded(style: Style) {
@@ -149,6 +147,7 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
                 Logger.w(LOG_TAG, String.format("RCTSource.removeFromMap: %s - %s", mSource, ex.message), ex)
             }
         }
+        super.removeFromMap(mapView)
     }
 
     fun addLayer(childView: View?, childPosition: Int) {

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

@@ -36,6 +36,7 @@ class RCTMGLTerrain(context: Context?) : AbstractSourceConsumer(context) {
     }
 
     override fun addToMap(mapView: RCTMGLMapView) {
+        super.addToMap(mapView)
         mMap = mapView.getMapboxMap()
         val terrain = makeTerrain()
         mTerrain = terrain
@@ -46,6 +47,7 @@ class RCTMGLTerrain(context: Context?) : AbstractSourceConsumer(context) {
     override fun removeFromMap(mapView: RCTMGLMapView) {
         mapView.savedStyle?.let { it.removeTerrain() }
         mMap = null
+        super.removeFromMap(mapView)
     }
 
     fun makeTerrain(): Terrain {

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/ConvertUtils.java

@@ -217,7 +217,7 @@ public class ConvertUtils {
     public static RectF toRectF(ReadableArray array) {
         RectF rectF = new RectF();
 
-        if (array == null) {
+        if (array == null || array.size() == 0) {
             return rectF;
         }
 

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/LatLngBounds.kt

@@ -0,0 +1,35 @@
+package com.mapbox.rctmgl.utils
+
+import com.mapbox.geojson.Point
+import com.mapbox.maps.CoordinateBounds
+import com.mapbox.rctmgl.utils.LatLngBounds
+
+class LatLngBounds internal constructor(
+    var latNorth: Double,
+    var lonEast: Double,
+    var latSouth: Double,
+    var lonWest: Double
+) {
+    val southWest: LatLng
+        get() = LatLng(latSouth, lonWest)
+    val northEast: LatLng
+        get() = LatLng(latNorth, lonEast)
+
+    fun toLatLngs(): Array<LatLng> {
+        return arrayOf(northEast, southWest)
+    }
+
+    fun toBounds(): CoordinateBounds {
+        return CoordinateBounds(
+            Point.fromLngLat(lonWest, latSouth),
+            Point.fromLngLat(lonEast, latNorth),
+            false
+        )
+    }
+
+    companion object {
+        fun from(bbox: Double, bbox1: Double, bbox2: Double, bbox3: Double): LatLngBounds {
+            return LatLngBounds(bbox, bbox1, bbox2, bbox3)
+        }
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/extensions/CoordinateBounds.kt

@@ -0,0 +1,23 @@
+package com.mapbox.rctmgl.utils.extensions
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.mapbox.maps.CoordinateBounds
+import com.mapbox.rctmgl.utils.GeoJSONUtils
+import com.mapbox.rctmgl.utils.LatLng
+
+fun CoordinateBounds.toReadableArray() : ReadableArray {
+    val array = Arguments.createArray()
+    val ne = northeast
+    val sw = southwest
+    val latLngs = arrayOf(
+        LatLng(ne.latitude(), ne.longitude()),
+        LatLng(ne.latitude(), sw.longitude()),
+        LatLng(sw.latitude(), sw.longitude()),
+        LatLng(sw.latitude(), ne.longitude())
+    )
+    for (latLng in latLngs) {
+        array.pushArray(GeoJSONUtils.fromLatLng(latLng))
+    }
+    return array
+}

package/docs/MapView.md

@@ -118,12 +118,12 @@ this._map.queryRenderedFeaturesAtPoint([30, 40], ['==', 'type', 'Point'], ['id1'
 
 ### queryRenderedFeaturesInRect(bbox[, filter][, layerIDs])
 
-Returns an array of rendered map features that intersect with the given rectangle,<br/>restricted to the given style layers and filtered by the given predicate.
+Returns an array of rendered map features that intersect with the given rectangle,<br/>restricted to the given style layers and filtered by the given predicate. In v10,<br/>passing an empty array will query the entire visible bounds of the map.
 
 #### arguments
 | Name | Type | Required | Description  |
 | ---- | :--: | :------: | :----------: |
-| `bbox` | `Array` | `Yes` | A rectangle expressed in the map view’s coordinate system. |
+| `bbox` | `Array` | `Yes` | A rectangle expressed in the map view’s coordinate system. For v10, this can be an empty array to query the visible map area. |
 | `filter` | `Array` | `No` | A set of strings that correspond to the names of layers defined in the current style. Only the features contained in these layers are included in the returned array. |
 | `layerIDs` | `Array` | `No` |  A array of layer id's to filter the features by |