@rnmapbox/maps 10.0.15 → 10.1.0-beta.11

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/CoordinateBounds.kt

@@ -0,0 +1,17 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.mapbox.maps.CoordinateBounds
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils
+import com.rnmapbox.rnmbx.utils.LatLng
+
+fun CoordinateBounds.toReadableArray() : ReadableArray {
+    val array = Arguments.createArray()
+    val ne = northeast
+    val sw = southwest
+
+    array.pushArray(GeoJSONUtils.fromLatLng(LatLng(ne.latitude(), ne.longitude())));
+    array.pushArray(GeoJSONUtils.fromLatLng(LatLng(sw.latitude(), sw.longitude())));
+    return array
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/Dynamic.kt

@@ -0,0 +1,57 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.mapbox.bindgen.Value
+
+fun ReadableMap.toValueHashMap(): HashMap<String, Value> {
+    var result = hashMapOf<String, Value>()
+    var iterator = keySetIterator()
+    while (iterator.hasNextKey()) {
+        val i = iterator.nextKey()
+
+        result[i] = when (getType(i)) {
+            ReadableType.Null -> Value.nullValue()
+            ReadableType.Boolean -> Value.valueOf(getBoolean(i))
+            ReadableType.Number -> Value.valueOf(getDouble(i))
+            ReadableType.String -> Value.valueOf(getString(i)!!)
+            ReadableType.Array -> getArray(i)!!.toValue()
+            ReadableType.Map -> getMap(i)!!.toValue()
+        }
+    }
+    return result
+}
+
+fun ReadableMap.toValue() : Value {
+    return Value.valueOf(toValueHashMap())
+}
+
+fun ReadableArray.toValue(): Value {
+    var result = ArrayList<Value>(size())
+
+    for (i in 0 until size()) {
+        result.add(
+        when (getType(i)) {
+            ReadableType.Null -> Value.nullValue()
+            ReadableType.Boolean -> Value.valueOf(getBoolean(i))
+            ReadableType.Number -> Value.valueOf(getDouble(i))
+            ReadableType.String -> Value.valueOf(getString(i))
+            ReadableType.Array -> getArray(i).toValue()
+            ReadableType.Map -> getMap(i).toValue()
+        })
+    }
+    return Value.valueOf(result)
+}
+
+fun Dynamic.toValue(): Value {
+    return when (type) {
+        ReadableType.Null -> Value.nullValue()
+        ReadableType.Boolean -> Value.valueOf(asBoolean())
+        ReadableType.Number -> Value.valueOf(asDouble())
+        ReadableType.String -> Value.valueOf(asString())
+        ReadableType.Array -> asArray().toValue()
+        ReadableType.Map -> asMap().toValue()
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/FeatureCollection.kt

@@ -0,0 +1,10 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.mapbox.geojson.FeatureCollection
+import com.mapbox.geojson.GeometryCollection
+
+fun FeatureCollection.toGeometryCollection(): GeometryCollection {
+    return GeometryCollection.fromGeometries(
+        this.features()!!.map { it.geometry() !! }
+    )
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/Geometry.kt

@@ -0,0 +1,22 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.mapbox.geojson.BoundingBox
+import com.mapbox.geojson.Geometry
+import com.mapbox.geojson.Polygon
+import com.mapbox.turf.TurfMeasurement
+import org.json.JSONObject
+
+fun Geometry.toJSONObject(): JSONObject? {
+    return JSONObject(this.toJson())
+}
+
+fun Geometry.calculateBoundingBox(): BoundingBox {
+    val storedBBox = bbox()
+    if (storedBBox != null) {
+        return storedBBox
+    }
+    val bbox = TurfMeasurement.bbox(this)
+    return BoundingBox.fromLngLats(
+        bbox[0], bbox[1], bbox[2], bbox[3]
+    )
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/JSONObject.kt

@@ -0,0 +1,78 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.mapbox.bindgen.Value
+import com.mapbox.geojson.Geometry
+import com.mapbox.geojson.Polygon
+import com.rnmapbox.rnmbx.utils.Logger
+import org.json.JSONArray
+import org.json.JSONObject
+
+fun JSONObject.toGeometry(): Geometry? {
+    when (this.optString("type")) {
+        "polygon", "Polygon" -> return Polygon.fromJson(this.toString())
+        else -> {
+            Logger.w("JSONObject", "Unexpected geometry: ${this.toString()}")
+            return null
+        }
+    }
+}
+
+fun JSONObject.toMapboxValue(): Value {
+    return Value.fromJson(this.toString()).value!!
+}
+
+fun JSONObject.toWritableMap(): WritableMap? {
+    val result = Arguments.createMap()
+    val iterator = keys()
+    while (iterator.hasNext()) {
+        val key = iterator.next()
+        val value = get(key)
+        if (value is JSONObject) {
+            result.putMap(key, value.toReadableMap());
+        } else if (value is JSONArray) {
+            result.putArray(key, value.toReadableArray());
+        } else if (value is  Boolean) {
+            result.putBoolean(key, value);
+        } else if (value is  Int) {
+            result.putInt(key, value);
+        } else if (value is  Double) {
+            result.putDouble(key, value);
+        } else if (value is String)  {
+            result.putString(key, value);
+        } else {
+            result.putString(key, value.toString());
+        }
+    }
+    return result
+}
+
+fun JSONObject.toReadableMap(): ReadableMap? {
+    return toWritableMap()
+}
+
+fun JSONArray.toReadableArray(): ReadableArray? {
+    val result = Arguments.createArray()
+    for (i in 0 until length()) {
+        val value: Any = get(i)
+        if (value is JSONObject) {
+            result.pushMap(value.toReadableMap())
+        } else if (value is JSONArray) {
+            result.pushArray(value.toReadableArray())
+        } else if (value is Boolean) {
+            result.pushBoolean(value)
+        } else if (value is Int) {
+            result.pushInt(value)
+        } else if (value is Double) {
+            result.pushDouble(value)
+        } else if (value is String) {
+            result.pushString(value)
+        } else {
+            result.pushString(value.toString())
+        }
+    }
+    return result
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/Point.kt

@@ -0,0 +1,17 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableNativeArray
+import com.mapbox.geojson.Point
+import com.rnmapbox.rnmbx.utils.Logger
+
+fun Point.toReadableArray() : ReadableArray {
+    val array = WritableNativeArray()
+    array.pushDouble(this.longitude())
+    array.pushDouble(this.latitude())
+    return array
+}
+
+fun Point.toDoubleArray() : DoubleArray {
+    return doubleArrayOf(this.longitude(), this.latitude())
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/ReadableArray.kt

@@ -0,0 +1,38 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import android.graphics.RectF
+import com.facebook.react.bridge.ReadableArray
+import com.mapbox.geojson.Point
+import com.mapbox.maps.ScreenCoordinate
+import com.rnmapbox.rnmbx.utils.Logger
+import java.lang.Float.min
+import java.lang.Float.max
+
+fun ReadableArray.toCoordinate() : Point {
+    if (this.size() != 2) {
+        Logger.e("ReadableArray.toCoordinate","Cannot convert $this to point, 2 coordinates are required")
+    }
+    return Point.fromLngLat(
+        getDouble(0),
+        getDouble(1)
+    )
+}
+
+fun ReadableArray.toScreenCoordinate() : ScreenCoordinate {
+    if (this.size() != 2) {
+        Logger.e("ReadableArray.toCoordinate","Cannot convert $this to point, 2 coordinates are required")
+    }
+    return ScreenCoordinate(getDouble(0), getDouble(1))
+}
+
+fun ReadableArray.toRectF() : RectF? {
+    if (size() != 4) {
+        return null;
+    }
+    return RectF(
+        min(getDouble(3).toFloat(), getDouble(1).toFloat()),
+        min(getDouble(0).toFloat(), getDouble(2).toFloat()),
+        max(getDouble(3).toFloat(), getDouble(1).toFloat()),
+        max(getDouble(0).toFloat(), getDouble(2).toFloat())
+    )
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/ReadableMap.kt

@@ -0,0 +1,19 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+
+fun ReadableMap.forEach(action: (String, Any) -> Unit) {
+    val iterator = this.entryIterator
+    while (iterator.hasNext()) {
+        val next = iterator.next()
+        action(next.key, next.value)
+    }
+}
+fun ReadableMap.getIfDouble(key: String): Double? {
+    return if (hasKey(key) && (getType(key) == ReadableType.Number)) {
+        getDouble(key)
+    } else {
+        null
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/Value.kt

@@ -0,0 +1,9 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.mapbox.bindgen.Value
+import org.json.JSONObject
+
+fun Value.toJSONObject(): JSONObject? {
+    val jsonString = this.toJson()
+    return JSONObject(jsonString)
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/writeableMapArrayOf.kt

@@ -0,0 +1,41 @@
+package com.rnmapbox.rnmbx.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+
+fun writableMapOf(vararg values: Pair<String, *>): WritableMap {
+    val map = Arguments.createMap()
+    for ((key, value) in values) {
+        when (value) {
+            null -> map.putNull(key)
+            is Boolean -> map.putBoolean(key, value)
+            is Double -> map.putDouble(key, value)
+            is Int -> map.putInt(key, value)
+            is Long -> map.putInt(key, value.toInt())
+            is String -> map.putString(key, value)
+            is WritableMap -> map.putMap(key, value)
+            is WritableArray -> map.putArray(key, value)
+            else -> throw IllegalArgumentException("Unsupported value type ${value::class.java.name} for key [$key]")
+        }
+    }
+    return map
+}
+
+fun writableArrayOf(vararg values: Any): WritableArray {
+    val array = Arguments.createArray()
+    for (value in values) {
+        when (value) {
+            null -> array.pushNull()
+            is Boolean -> array.pushBoolean(value)
+            is Double -> array.pushDouble(value)
+            is Int -> array.pushInt(value)
+            is Long -> array.pushInt(value.toInt())
+            is String -> array.pushString(value)
+            is WritableMap -> array.pushMap(value)
+            is WritableArray -> array.pushArray(value)
+            else -> throw IllegalArgumentException("Unsupported value type ${value::class.java.name}")
+        }
+    }
+    return array
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Annotation.kt

@@ -0,0 +1,4 @@
+package com.rnmapbox.rnmbx.v11compat.annotation;
+
+public const val INVALID_ANNOTATION_ID: Long = -1
+typealias AnnotationID = Long

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Event.kt

@@ -0,0 +1,17 @@
+package com.rnmapbox.rnmbx.v11compat.event;
+
+//import com.mapbox.maps.MapboxMap
+//import com.mapbox.maps.extension.observable.getMapLoadingErrorEventData
+
+//fun MapboxMap.subscribe(callback: (Any?)->Void) {
+//
+//}
+
+import com.mapbox.maps.Event
+import com.mapbox.maps.extension.observable.eventdata.MapLoadingErrorEventData
+import com.mapbox.maps.extension.observable.getMapLoadingErrorEventData as _getMapLoadingErrorEventData
+
+fun Event.getMapLoadingErrorEventData() : MapLoadingErrorEventData {
+    return _getMapLoadingErrorEventData()
+};
+

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Feature.kt

@@ -0,0 +1,10 @@
+package com.rnmapbox.rnmbx.v11compat.feature;
+
+import com.mapbox.geojson.Feature;
+
+import com.mapbox.maps.QueriedFeature as _QueriedFeature;
+
+typealias QueriedRenderedFeature = _QueriedFeature;
+
+typealias QueriedSourceFeature = _QueriedFeature;
+

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/HttpInterceptor.kt

@@ -0,0 +1,22 @@
+package com.rnmapbox.rnmbx.v11compat.httpinterceptor;
+
+import com.mapbox.common.*
+
+open class HttpServiceBase : HttpServiceInterceptorInterface {
+  override fun onRequest(request: HttpRequest): HttpRequest {
+        return request
+    }
+
+    override fun onDownload(download: DownloadOptions): DownloadOptions {
+        return download
+    }
+
+    override fun onResponse(response: HttpResponse): HttpResponse {
+        return response
+    }
+
+/*    override fun onUpload(options: UploadOptions): UploadOptions {
+        return options
+    }
+*/
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Image.kt

@@ -0,0 +1,53 @@
+package com.rnmapbox.rnmbx.v11compat.image;
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.VectorDrawable
+import androidx.annotation.DrawableRes
+import androidx.appcompat.content.res.AppCompatResources
+import com.mapbox.maps.Image
+import com.mapbox.maps.Style
+import com.rnmapbox.rnmbx.components.images.ImageInfo
+import com.rnmapbox.rnmbx.components.images.addBitmapImage
+import java.nio.ByteBuffer
+
+typealias ImageHolder = Drawable;
+
+fun ByteArray.toByteArray(): ByteArray {
+    return this
+}
+
+fun ByteArray.toImageData() : ByteArray {
+    return this
+}
+
+fun VectorDrawable.toBitmapImageHolder(): Drawable {
+    return this
+}
+
+fun emptyImage(width: Int, height: Int): Image {
+    return Image(width, height, ByteArray(width * height * 4) /* ByteBuffer.allocateDirect(width * height * 4).array()*/)
+}
+
+fun Bitmap.toMapboxImage(): Image {
+    val byteBuffer = ByteBuffer.allocate(byteCount)
+    copyPixelsToBuffer(byteBuffer)
+    return Image(width, height, byteBuffer.array())
+}
+
+fun Style.addStyleImage(imageId: String, image: Image, info: ImageInfo, scale: Double = 1.0) {
+    addStyleImage(imageId, (info.getScaleOr(1.0) * scale).toFloat(), image, info.sdf, info.stretchX, info.stretchY, info.content)
+}
+
+fun Style.addBitmapImage(imageId: String, bitmap: Bitmap, info: ImageInfo, scale: Double = 1.0) {
+    addStyleImage(imageId, bitmap.toMapboxImage(), info, scale)
+}
+
+class AppCompatResourcesV11 {
+    companion object {
+        fun getDrawableImageHolder(context: Context, @DrawableRes resId: Int) : ImageHolder? {
+            return AppCompatResources.getDrawable(context, resId)
+        }
+    }
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Light.kt

@@ -0,0 +1,15 @@
+package com.rnmapbox.rnmbx.v11compat.light;
+
+import com.mapbox.maps.Style
+import com.mapbox.maps.extension.style.light.generated.Light as _Light;
+import com.mapbox.maps.extension.style.light.generated.setLight as _setLight
+
+typealias Light = _Light
+
+fun Style.setLight(light: Light) {
+    this._setLight(light)
+}
+
+fun createLight(): Light {
+    return Light()
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Location.kt

@@ -0,0 +1,65 @@
+package com.rnmapbox.rnmbx.v11compat.location;
+
+import android.Manifest.permission.ACCESS_COARSE_LOCATION
+import android.Manifest.permission.ACCESS_FINE_LOCATION
+import android.content.Context
+import android.location.LocationManager
+import android.os.Looper
+import androidx.annotation.RequiresPermission
+import com.mapbox.maps.MapView
+import com.mapbox.maps.plugin.PuckBearingSource
+import com.mapbox.maps.plugin.locationcomponent.LocationComponentPlugin2
+import com.mapbox.maps.plugin.locationcomponent.location2 as _location2
+
+
+import com.mapbox.android.core.location.LocationEngineResult as _LocationEngineResult
+
+import com.mapbox.android.core.location.LocationEngine as _LocationEngine
+import com.mapbox.android.core.location.LocationEngineCallback as _LocationEngineCallback
+import com.mapbox.android.core.location.LocationEngineRequest
+import com.mapbox.android.core.location.LocationEngineProvider
+import com.mapbox.common.location.LocationService
+import com.mapbox.common.location.LocationUpdatesReceiver
+import com.mapbox.common.location.LocationServiceFactory
+
+
+import android.location.Location as _Location
+//import com.mapbox.common.location.Location as _Location
+
+typealias Location = _Location;
+typealias PuckBearingSource = com.mapbox.maps.plugin.PuckBearingSource
+
+val MapView.location2 : LocationComponentPlugin2
+    get() = _location2
+
+typealias LocationEngine = _LocationEngine
+typealias LocationEngineResult = _LocationEngineResult
+typealias LocationEngineCallback = _LocationEngineCallback<LocationEngineResult>
+
+const val DEFAULT_FASTEST_INTERVAL_MILLIS: Long = 1000
+const val DEFAULT_INTERVAL_MILLIS: Long = 1000
+
+@RequiresPermission(anyOf = [ACCESS_COARSE_LOCATION, ACCESS_FINE_LOCATION])
+fun LocationEngine.requestLocationUpdatesV11(callback: LocationEngineCallback, looper: Looper?, minDisplacement: Float?) {
+  val builder = LocationEngineRequest.Builder(DEFAULT_INTERVAL_MILLIS)
+      .setFastestInterval(DEFAULT_FASTEST_INTERVAL_MILLIS)
+      .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
+  if (minDisplacement != null && minDisplacement > 0.0) {
+    builder.setDisplacement(minDisplacement)
+  }
+  val request = builder
+      .build();
+
+  this.requestLocationUpdates(
+    request,
+    callback,
+    looper
+  )
+}
+
+val Location.timestamp: Long
+  get() = this.time
+
+fun createLocationEngine(context: Context): LocationEngine {
+    return LocationEngineProvider.getBestLocationEngine(context)
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/MapboxMap.kt

@@ -0,0 +1,31 @@
+package com.rnmapbox.rnmbx.v11compat.mapboxmap;
+
+import android.animation.Animator
+import com.mapbox.maps.CameraOptions
+import com.mapbox.maps.MapboxMap
+import com.mapbox.maps.plugin.animation.MapAnimationOptions
+import com.mapbox.maps.plugin.animation.easeTo
+import com.mapbox.maps.plugin.animation.flyTo
+
+fun MapboxMap.flyToV11(
+    cameraOptions: CameraOptions,
+    animationOptions: MapAnimationOptions.Builder,
+    callback: Animator.AnimatorListener
+) {
+    this.flyTo(
+        cameraOptions,
+        animationOptions.apply { animatorListener(callback) }.build(),
+    )
+}
+
+fun MapboxMap.easeToV11(
+    cameraOptions: CameraOptions,
+    animationOptions: MapAnimationOptions.Builder,
+    callback: Animator.AnimatorListener
+) {
+    this.easeTo(
+        cameraOptions,
+        animationOptions.apply { animatorListener(callback) }.build(),
+
+    )
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/OfflineManager.kt

@@ -0,0 +1,19 @@
+package com.rnmapbox.rnmbx.v11compat.offlinemanager;
+
+import com.mapbox.common.TileStore
+import com.mapbox.maps.OfflineManager
+import com.mapbox.maps.OfflineRegionManager
+import com.mapbox.maps.ResourceOptions
+
+fun getOfflineRegionManager(getAccessToken: () -> String): OfflineRegionManager {
+  return OfflineRegionManager(ResourceOptions.Builder().accessToken(getAccessToken()).build())
+}
+
+fun getOfflineManager(tileStore: TileStore, getAccessToken: () -> String): OfflineManager {
+  return OfflineManager(
+    ResourceOptions.Builder()
+      .accessToken(getAccessToken()).tileStore(
+        tileStore
+      ).build()
+  )
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/OrnamentSettings.kt

@@ -0,0 +1,96 @@
+package com.rnmapbox.rnmbx.v11compat.ornamentsettings
+
+import com.mapbox.maps.plugin.attribution.generated.AttributionSettings
+import com.mapbox.maps.plugin.compass.generated.CompassSettings
+import com.mapbox.maps.plugin.logo.generated.LogoSettings
+import com.mapbox.maps.plugin.scalebar.generated.ScaleBarSettings
+import com.rnmapbox.rnmbx.components.mapview.OrnamentSettings
+
+fun getAttributionSettings(): AttributionSettings {
+    return AttributionSettings()
+}
+
+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 var 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 var 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 AttributionSettings.toGenericOrnamentSettings() = object : GenericOrnamentSettings {
+    private var 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
+        }
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/ResourceOption.kt

@@ -0,0 +1,12 @@
+package com.rnmapbox.rnmbx.v11compat.resourceoption;
+
+import android.content.Context
+import com.mapbox.maps.ResourceOptionsManager.Companion.getDefault
+
+fun setMapboxAccessToken(context: Context, accessToken: String?) {
+  getDefault(context, accessToken)
+}
+
+fun getMapboxAccessToken(context: Context?): String {
+  return getDefault((context)!!, null).resourceOptions.accessToken
+}