@rnmapbox/maps 10.0.0-beta.45 → 10.0.0-beta.47

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

@@ -5,6 +5,27 @@ import com.facebook.react.views.view.ReactViewGroup
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
 
 abstract class AbstractMapFeature(context: Context?) : ReactViewGroup(context) {
-    abstract fun addToMap(mapView: RCTMGLMapView)
-    abstract fun removeFromMap(mapView: RCTMGLMapView)
+    protected var mMapView: RCTMGLMapView? = null;
+    private var mWithMapViewCallbacks: Array<((RCTMGLMapView) -> Unit)>? = null;
+
+    open fun addToMap(mapView: RCTMGLMapView) {
+        mMapView = mapView;
+        mWithMapViewCallbacks?.forEach { it(mapView) }
+        mWithMapViewCallbacks = null;
+    }
+
+    open fun removeFromMap(mapView: RCTMGLMapView) {
+        mMapView = null;
+    }
+
+    internal fun withMapView(callback: (mapView: RCTMGLMapView) -> Unit) {
+        val mapView = mMapView;
+        if (mapView == null) {
+            val callbacks = mWithMapViewCallbacks ?: arrayOf();
+            callbacks.plus(callback)
+            mWithMapViewCallbacks = callbacks
+        } else {
+            callback(mapView)
+        }
+    }
 }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLMarkerView.kt

@@ -23,8 +23,6 @@ class RCTMGLMarkerView(context: Context?, private val mManager: RCTMGLMarkerView
     View.OnLayoutChangeListener
 {
     // region Instance variables
-
-    private var mMapView: RCTMGLMapView? = null
     private var mView: View? = null
     private var didAddToMap = false
 
@@ -72,14 +70,15 @@ class RCTMGLMarkerView(context: Context?, private val mManager: RCTMGLMarkerView
 
     // endregion
 
-    // region RCTMGLMapComponent methods
+    // region AbstractMapFeature methods
 
     override fun addToMap(mapView: RCTMGLMapView) {
-        mMapView = mapView
+        super.addToMap(mapView)
         add()
     }
 
     override fun removeFromMap(mapView: RCTMGLMapView) {
+        super.removeFromMap(mapView)
         remove(mapView)
     }
 

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLPointAnnotation.kt

@@ -28,7 +28,6 @@ class RCTMGLPointAnnotation(private val mContext: Context, private val mManager:
     var marker: PointAnnotation? = null
         private set
     private var mMap: MapboxMap? = null
-    private var mMapView: RCTMGLMapView? = null
     private val mHasChildren = false
     private var mCoordinate: Point? = null
     var iD: String? = null
@@ -74,7 +73,7 @@ class RCTMGLPointAnnotation(private val mContext: Context, private val mManager:
     }
 
     override fun addToMap(mapView: RCTMGLMapView) {
-        mMapView = mapView
+        super.addToMap(mapView)
         mMap = mapView.getMapboxMap()
         makeMarker()
         if (mChildView != null) {
@@ -103,6 +102,7 @@ class RCTMGLPointAnnotation(private val mContext: Context, private val mManager:
         if (calloutView != null) {
             map.offscreenAnnotationViewContainer?.removeView(calloutView)
         }
+        super.removeFromMap(mapView)
     }
 
     override fun onLayoutChange(v: View, left: Int, top: Int, right: Int, bottom: Int, oldLeft: Int, oldTop: Int,

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/camera/RCTMGLCamera.kt

@@ -45,11 +45,12 @@ import com.mapbox.rctmgl.modules.RCTMGLLogging
 import com.mapbox.rctmgl.utils.LatLng
 import com.mapbox.rctmgl.utils.Logger
 
+
+
 class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCameraManager) :
     AbstractMapFeature(
         mContext
     ) {
-    private var mMapView: RCTMGLMapView? = null
     private var hasSentFirstRegion = false
     private var mDefaultStop: CameraStop? = null
     private var mCameraStop: CameraStop? = null
@@ -117,7 +118,7 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
     }
 
     override fun addToMap(mapView: RCTMGLMapView) {
-        mMapView = mapView
+        super.addToMap(mapView)
         setInitialCamera()
         updateMaxMinZoomLevel()
         updateMaxBounds()
@@ -128,7 +129,9 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         }
     }
 
-    override fun removeFromMap(mapView: RCTMGLMapView) {}
+    override fun removeFromMap(mapView: RCTMGLMapView) {
+        super.removeFromMap(mapView)
+    }
     fun setStop(stop: CameraStop) {
         mCameraStop = stop
         mCameraStop!!.setCallback(mCameraCallback)
@@ -161,14 +164,20 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         updateMaxBounds()
     }
 
+
     private fun updateMaxBounds() {
-        /*
-        MapboxMap map = getMapboxMap();
-        if (map != null && mMaxBounds != null) {
-            map.setLatLngBoundsForCameraTarget(mMaxBounds);
-        }
+        withMapView { mapView ->
+            val map = mapView.getMapboxMap()
+            val maxBounds = mMaxBounds
+            if (maxBounds != null) {
+                map.setBounds(CameraBoundsOptions.Builder().bounds(
+                    maxBounds.toBounds()
+                ).build())
+            } else {
+                map.setBounds(CameraBoundsOptions.Builder().build())
+            }
 
-         */
+        }
     }
 
     private fun updateMaxMinZoomLevel() {
@@ -319,7 +328,7 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
             });
              */
         } else {
-            mLocationComponentManager!!.setCameraMode(CameraMode.NONE)
+            mLocationComponentManager!!.setCameraMode(com.mapbox.rctmgl.components.location.CameraMode.NONE)
         }
     }
 

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/camera/RCTMGLCameraManager.kt

@@ -1,24 +1,14 @@
 package com.mapbox.rctmgl.components.camera
 
-import com.mapbox.rctmgl.components.camera.CameraStop.Companion.fromReadableMap
-import com.mapbox.maps.MapboxMap
-import com.mapbox.maps.CameraOptions
-import com.mapbox.maps.plugin.animation.CameraAnimationsPlugin
-import android.view.animation.LinearInterpolator
-import android.view.animation.AccelerateDecelerateInterpolator
-import com.mapbox.rctmgl.components.camera.CameraStop
-import com.mapbox.rctmgl.components.camera.CameraUpdateQueue.OnCompleteAllListener
-import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
-import com.mapbox.rctmgl.components.camera.CameraUpdateItem
 import com.facebook.react.bridge.ReactApplicationContext
-import com.mapbox.rctmgl.components.AbstractEventEmitter
-import com.mapbox.rctmgl.components.camera.RCTMGLCamera
-import com.mapbox.rctmgl.components.camera.RCTMGLCameraManager
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.annotations.ReactProp
-import com.facebook.react.bridge.ReadableMap
-import java.lang.AssertionError
-import java.util.HashMap
+import com.mapbox.geojson.FeatureCollection
+import com.mapbox.rctmgl.components.AbstractEventEmitter
+import com.mapbox.rctmgl.components.camera.CameraStop.Companion.fromReadableMap
+import com.mapbox.rctmgl.utils.GeoJSONUtils.toLatLngBounds
+
 
 //import com.mapbox.rctmgl.utils.GeoJSONUtils;
 class RCTMGLCameraManager(private val mContext: ReactApplicationContext) :
@@ -53,15 +43,6 @@ class RCTMGLCameraManager(private val mContext: ReactApplicationContext) :
         }
     }
 
-    /*v10todo
-    @ReactProp(name="maxBounds")
-    public void setMaxBounds(RCTMGLCamera camera, String value) {
-        if (value != null) {
-            FeatureCollection collection = FeatureCollection.fromJson(value);
-            camera.setMaxBounds(GeoJSONUtils.toLatLngBounds(collection));
-        }
-    }
-*/
     @ReactProp(name = "userTrackingMode")
     fun setUserTrackingMode(camera: RCTMGLCamera, userTrackingMode: Int) {
         camera.setUserTrackingMode(userTrackingMode)
@@ -108,6 +89,16 @@ class RCTMGLCameraManager(private val mContext: ReactApplicationContext) :
         camera.setFollowZoomLevel(value)
     }
 
+    @ReactProp(name = "maxBounds")
+    fun setMaxBounds(camera: RCTMGLCamera, value: String?) {
+        if (value != null) {
+            val collection = FeatureCollection.fromJson(value)
+            camera.setMaxBounds(toLatLngBounds(collection))
+        } else {
+            camera.setMaxBounds(null)
+        }
+    }
+
     companion object {
         const val REACT_CLASS = "RCTMGLCamera"
     }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/images/RCTMGLImages.kt

@@ -82,6 +82,7 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
         mNativeImages = HashMap()
         mImages = HashMap()
         mCurrentImages = HashSet()
+        super.removeFromMap(mapView)
     }
 
     private fun removeImages(mapView: RCTMGLMapView) {
@@ -151,6 +152,7 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
     }
 
     override fun addToMap(mapView: RCTMGLMapView) {
+        super.addToMap(mapView)
         // Wait for style before adding the source to the map
         // only then we can pre-load required images / placeholders into the style
         // before we add the ShapeSource to the map

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/location/RCTMGLNativeUserLocation.kt

@@ -17,13 +17,12 @@ import com.mapbox.mapboxsdk.maps.Style;
  */   class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context), OnMapReadyCallback, Style.OnStyleLoaded {
     private var mEnabled = true
     private var mMap: MapboxMap? = null
-    private var mMapView: RCTMGLMapView? = null
 
     @RenderMode.Mode
     private var mRenderMode = RenderMode.COMPASS
     override fun addToMap(mapView: RCTMGLMapView) {
+        super.addToMap(mapView)
         mEnabled = true
-        mMapView = mapView
         mapView.getMapboxMap()
         mapView.getMapAsync(this)
         setRenderMode(mRenderMode)
@@ -32,6 +31,7 @@ import com.mapbox.mapboxsdk.maps.Style;
     override fun removeFromMap(mapView: RCTMGLMapView) {
         mEnabled = false
         mMap?.getStyle(this)
+        super.removeFromMap(mapView)
     }
 
     @SuppressLint("MissingPermission")

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

@@ -33,11 +33,14 @@ import com.mapbox.maps.plugin.annotation.generated.PointAnnotationManager
 import com.mapbox.maps.plugin.annotation.generated.createPointAnnotationManager
 import com.mapbox.maps.plugin.attribution.attribution
 import com.mapbox.maps.plugin.attribution.generated.AttributionSettings
+import com.mapbox.maps.plugin.scalebar.scalebar
 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.plugin.scalebar.generated.ScaleBarSettings
 import com.mapbox.maps.viewannotation.ViewAnnotationManager
 import com.mapbox.rctmgl.R
 import com.mapbox.rctmgl.components.AbstractMapFeature
@@ -65,6 +68,12 @@ import org.json.JSONException
 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)
@@ -608,7 +617,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)
         }
@@ -760,7 +769,7 @@ 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())
         })
     }
 
@@ -858,12 +867,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.BOTTOM or Gravity.LEFT)
+            2 -> (Gravity.TOP or Gravity.RIGHT)
+            3 -> (Gravity.BOTTOM or Gravity.RIGHT)
             else -> {
                 Logger.e(
                     "MapView",
@@ -874,13 +883,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 +932,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()
+    }
+    
+    fun setReactScaleBarViewMargins(scaleBarMargins: ReadableMap) {
+        mScaleBarSettings.margins = scaleBarMargins
+        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 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 +1058,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 +1134,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
             }
         }
     }
+ */
     // endregion
 
     // region lifecycle
@@ -1128,3 +1182,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")