@rnmapbox/maps 10.1.0-beta.2 → 10.1.0-beta.4

package/android/src/main/java-v10/com/mapbox/rctmgl/modules/RCTMGLOfflineModule.kt

@@ -17,6 +17,7 @@ import com.mapbox.rctmgl.events.constants.EventTypes
 import com.mapbox.rctmgl.utils.*
 import com.mapbox.rctmgl.utils.Logger
 import com.mapbox.rctmgl.utils.extensions.*
+import com.mapbox.rctmgl.v11compat.offlinemanager.getOfflineManager
 import com.mapbox.turf.TurfMeasurement
 import org.json.JSONArray
 import org.json.JSONException
@@ -28,6 +29,8 @@ import java.nio.file.Paths
 import java.nio.file.StandardCopyOption
 import java.util.concurrent.CountDownLatch
 
+import com.mapbox.rctmgl.v11compat.offlinemanager.*
+
 data class ZoomRange(val minZoom: Byte, val maxZoom: Byte) {
 
 }
@@ -104,12 +107,9 @@ class RCTMGLOfflineModule(private val mReactContext: ReactApplicationContext) :
     }
 
     val offlineManager: OfflineManager by lazy {
-        OfflineManager(
-            ResourceOptions.Builder()
-                .accessToken(RCTMGLModule.getAccessToken(mReactContext)).tileStore(
-                    tileStore
-                ).build()
-        )
+        getOfflineManager(tileStore) {
+            RCTMGLModule.getAccessToken(mReactContext)
+        }
     }
 
     override fun getName(): String {
@@ -218,7 +218,9 @@ class RCTMGLOfflineModule(private val mReactContext: ReactApplicationContext) :
 
     @ReactMethod
     fun setTileCountLimit(tileCountLimit: Int) {
-        val offlineRegionManager = OfflineRegionManager(ResourceOptions.Builder().accessToken(RCTMGLModule.getAccessToken(mReactContext)).build())
+        val offlineRegionManager = getOfflineRegionManager {
+            RCTMGLModule.getAccessToken(mReactContext)
+        }
         offlineRegionManager.setOfflineMapboxTileCountLimit(tileCountLimit.toLong())
     }
 

package/android/src/main/java-v10/com/mapbox/rctmgl/modules/RCTMGLSnapshotModule.kt

@@ -0,0 +1,124 @@
+package com.mapbox.rctmgl.modules
+
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.mapbox.geojson.Feature
+import com.mapbox.geojson.Point
+import com.mapbox.maps.CameraOptions
+import com.mapbox.maps.MapSnapshotOptions
+import com.mapbox.maps.Size
+import com.mapbox.maps.Snapshotter
+import com.mapbox.rctmgl.modules.RCTMGLModule.Companion.getAccessToken
+import com.mapbox.rctmgl.modules.RCTMGLSnapshotModule
+import com.mapbox.rctmgl.utils.BitmapUtils
+import java.io.IOException
+import java.io.OutputStream
+import java.util.UUID
+
+import com.mapbox.rctmgl.v11compat.snapshot.*
+
+@ReactModule(name = RCTMGLSnapshotModule.REACT_CLASS)
+class RCTMGLSnapshotModule(private val mContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(
+        mContext
+    ) {
+    // prevents snapshotter from being GC'ed
+    private val mSnapshotterMap: MutableMap<String, Snapshotter>
+
+    init {
+        mSnapshotterMap = HashMap()
+    }
+
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    @ReactMethod
+    fun takeSnap(jsOptions: ReadableMap, promise: Promise) {
+        // FileSource.getInstance(mContext).activate();
+        mContext.runOnUiQueueThread {
+            val snapshotterID = UUID.randomUUID().toString()
+            val snapshotter = Snapshotter(mContext, getOptions(jsOptions))
+            snapshotter.setStyleUri(jsOptions.getString("styleURL")!!)
+            snapshotter.setCamera(getCameraOptions(jsOptions))
+            mSnapshotterMap[snapshotterID] = snapshotter
+            snapshotter.startV11 { image,error ->
+                try {
+                    if (image == null) {
+                        Log.w(REACT_CLASS, "Snapshot failed: $error")
+                        promise.reject(REACT_CLASS, "Snapshot failed: $error")
+                        mSnapshotterMap.remove(snapshotterID)
+                    } else {
+                        val image = image.toMapboxImage()
+                        var result: String? = null
+                        result = if (jsOptions.getBoolean("writeToDisk")) {
+                            BitmapUtils.createImgTempFile(mContext, image)
+                        } else {
+                            BitmapUtils.createImgBase64(image)
+                        }
+                        if (result == null) {
+                            promise.reject(
+                                REACT_CLASS,
+                                "Could not generate snapshot, please check Android logs for more info."
+                            )
+                            return@startV11
+                        }
+                        promise.resolve(result)
+                        mSnapshotterMap.remove(snapshotterID)
+                    }
+                } catch (e: IOException) {
+                    e.printStackTrace()
+                    promise.reject(REACT_CLASS, e.localizedMessage)
+                }
+            }
+        }
+    }
+
+    private fun getCameraOptions(jsOptions: ReadableMap): CameraOptions {
+        val centerPoint =
+            Feature.fromJson(jsOptions.getString("centerCoordinate")!!)
+        val point = centerPoint.geometry() as Point?
+        val cameraOptionsBuilder = CameraOptions.Builder()
+        return cameraOptionsBuilder
+            .center(point)
+            .pitch(jsOptions.getDouble("pitch"))
+            .bearing(jsOptions.getDouble("heading"))
+            .zoom(jsOptions.getDouble("zoomLevel"))
+            .build()
+    }
+
+    private fun getOptions(jsOptions: ReadableMap): MapSnapshotOptions {
+        val builder = MapSnapshotOptions.Builder()
+        builder.size(
+            Size(
+                jsOptions.getDouble("width").toInt().toFloat(),
+                jsOptions.getDouble("height").toInt().toFloat()
+            )
+        )
+        builder.pixelRatio(
+            java.lang.Float.valueOf(mContext.resources.displayMetrics.density).toInt().toFloat()
+        )
+        builder.accessToken(getAccessToken(mContext))
+        return builder.build()
+    }
+
+    private fun closeSnapshotOutputStream(outputStream: OutputStream?) {
+        if (outputStream == null) {
+            return
+        }
+        try {
+            outputStream.close()
+        } catch (e: IOException) {
+            Log.w(REACT_CLASS, e.localizedMessage)
+        }
+    }
+
+    companion object {
+        const val REACT_CLASS = "RCTMGLSnapshotModule"
+    }
+}

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

@@ -0,0 +1,174 @@
+package com.mapbox.rctmgl.utils
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import android.net.Uri
+import android.util.Base64
+import android.util.Log
+import android.util.LruCache
+import android.view.View
+import com.mapbox.maps.Image
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.OutputStream
+import java.net.URL
+import java.nio.ByteBuffer
+
+import com.mapbox.rctmgl.v11compat.image.*
+
+object BitmapUtils {
+    const val LOG_TAG = "BitmapUtils"
+    private const val CACHE_SIZE = 1024 * 1024
+    private val mCache: LruCache<String?, Bitmap> =
+        object : LruCache<String?, Bitmap>(CACHE_SIZE) {
+            override fun sizeOf(key: String?, bitmap: Bitmap): Int {
+                return bitmap.byteCount
+            }
+        }
+
+    fun getBitmapFromURL(url: String?): Bitmap? {
+        return getBitmapFromURL(url, null)
+    }
+
+    fun toImage(bitmap: Bitmap): Image {
+        if (bitmap.config != Bitmap.Config.ARGB_8888) {
+            throw RuntimeException("Only ARGB_8888 bitmap config is supported!")
+        }
+        val byteBuffer = ByteBuffer.allocate(bitmap.byteCount)
+        bitmap.copyPixelsToBuffer(byteBuffer)
+        return Image(bitmap.width, bitmap.height, byteBuffer.array().toImageData())
+    }
+
+    fun toImage(bitmapDrawable: BitmapDrawable): Image {
+        return toImage(bitmapDrawable.bitmap)
+    }
+
+    fun getBitmapFromDrawable(sourceDrawable: Drawable?): Bitmap? {
+        if (sourceDrawable == null) {
+            return null
+        }
+        return if (sourceDrawable is BitmapDrawable) {
+            sourceDrawable.bitmap
+        } else {
+            //copying drawable object to not manipulate on the same reference
+            val constantState = sourceDrawable.constantState ?: return null
+            val drawable = constantState.newDrawable().mutate()
+            val bitmap = Bitmap.createBitmap(
+                drawable.intrinsicWidth, drawable.intrinsicHeight,
+                Bitmap.Config.ARGB_8888
+            )
+            val canvas = Canvas(bitmap)
+            drawable.setBounds(0, 0, canvas.width, canvas.height)
+            drawable.draw(canvas)
+            bitmap
+        }
+    }
+
+    fun getBitmapFromURL(url: String?, options: BitmapFactory.Options?): Bitmap? {
+        var bitmap = getImage(url)
+        if (bitmap != null) {
+            return bitmap
+        }
+        try {
+            val bitmapStream = URL(url).openStream()
+            bitmap = BitmapFactory.decodeStream(bitmapStream, null, options)
+            bitmapStream.close()
+            addImage(url, bitmap)
+        } catch (e: Exception) {
+            Log.w(LOG_TAG, e.localizedMessage)
+            bitmap =
+                Bitmap.createBitmap(1, 1, Bitmap.Config.ALPHA_8) // Returns a transparent bitmap
+        }
+        return bitmap
+    }
+
+    fun getBitmapFromResource(
+        context: Context,
+        resourceName: String?,
+        options: BitmapFactory.Options?
+    ): Bitmap {
+        val resources = context.resources
+        val resID = resources.getIdentifier(resourceName, "drawable", context.packageName)
+        return BitmapFactory.decodeResource(resources, resID, options)
+    }
+
+    @Throws(IOException::class)
+    fun createImgTempFile(context: Context, image: Image): String? {
+        val bitmap = Bitmap.createBitmap(image.width, image.height, Bitmap.Config.ARGB_8888)
+        bitmap.copyPixelsFromBuffer(ByteBuffer.wrap(image.data.toByteArray()))
+        return createTempFile(context, bitmap)
+    }
+
+    fun createTempFile(context: Context, bitmap: Bitmap): String? {
+        var tempFile: File? = null
+        var outputStream: FileOutputStream? = null
+        try {
+            tempFile = File.createTempFile(LOG_TAG, ".png", context.cacheDir)
+            outputStream = FileOutputStream(tempFile)
+        } catch (e: IOException) {
+            Log.w(LOG_TAG, e.localizedMessage)
+        }
+        if (tempFile == null) {
+            return null
+        }
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
+        closeSnapshotOutputStream(outputStream)
+        return Uri.fromFile(tempFile).toString()
+    }
+
+    fun createBase64(bitmap: Bitmap): String {
+        val outputStream = ByteArrayOutputStream()
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
+        val bitmapBytes = outputStream.toByteArray()
+        closeSnapshotOutputStream(outputStream)
+        val base64Prefix = "data:image/png;base64,"
+        return base64Prefix + Base64.encodeToString(bitmapBytes, Base64.NO_WRAP)
+    }
+
+    fun createImgBase64(image: Image): String {
+        val bitmap = Bitmap.createBitmap(image.width, image.height, Bitmap.Config.ARGB_8888)
+        bitmap.copyPixelsFromBuffer(ByteBuffer.wrap(image.data.toByteArray()))
+        return createBase64(bitmap)
+    }
+
+    fun viewToBitmap(v: View?, left: Int, top: Int, right: Int, bottom: Int): Bitmap? {
+        var bitmap: Bitmap? = null
+        if (v != null) {
+            val w = right - left
+            val h = bottom - top
+            if (w > 0 && h > 0) {
+                bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
+                bitmap.eraseColor(Color.TRANSPARENT)
+                val canvas = Canvas(bitmap)
+                v.draw(canvas)
+            }
+        }
+        return bitmap
+    }
+
+    private fun addImage(imageURL: String?, bitmap: Bitmap?) {
+        mCache.put(imageURL, bitmap)
+    }
+
+    private fun getImage(imageURL: String?): Bitmap? {
+        return mCache[imageURL]
+    }
+
+    private fun closeSnapshotOutputStream(outputStream: OutputStream?) {
+        if (outputStream == null) {
+            return
+        }
+        try {
+            outputStream.close()
+        } catch (e: IOException) {
+            Log.w(LOG_TAG, e.localizedMessage)
+        }
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+package com.mapbox.rctmgl.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/rctmgl/v11compat/Feature.kt

@@ -0,0 +1,10 @@
+package com.mapbox.rctmgl.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/rctmgl/v11compat/HttpInterceptor.kt

@@ -0,0 +1,22 @@
+package com.mapbox.rctmgl.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/rctmgl/v11compat/Image.kt

@@ -0,0 +1,29 @@
+package com.mapbox.rctmgl.v11compat.image;
+
+import android.content.Context
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.VectorDrawable
+import androidx.annotation.DrawableRes
+import androidx.appcompat.content.res.AppCompatResources
+
+typealias ImageHolder = Drawable;
+
+fun ByteArray.toByteArray(): ByteArray {
+    return this
+}
+
+fun ByteArray.toImageData() : ByteArray {
+    return this
+}
+
+fun VectorDrawable.toBitmapImageHolder(): Drawable {
+    return this
+}
+
+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/rctmgl/v11compat/Light.kt

@@ -0,0 +1,15 @@
+package com.mapbox.rctmgl.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/rctmgl/v11compat/Location.kt

@@ -0,0 +1,54 @@
+package com.mapbox.rctmgl.v11compat.location;
+
+import android.Manifest.permission.ACCESS_COARSE_LOCATION
+import android.Manifest.permission.ACCESS_FINE_LOCATION
+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 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) {
+    builder.setDisplacement(minDisplacement)
+  }
+  val request = builder
+      .build();
+
+  this.requestLocationUpdates(
+    request,
+    callback,
+    looper
+  )
+}
+
+val Location.timestamp: Long
+  get() = this.time

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

@@ -0,0 +1,31 @@
+package com.mapbox.rctmgl.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/rctmgl/v11compat/OfflineManager.kt

@@ -0,0 +1,19 @@
+package com.mapbox.rctmgl.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/rctmgl/v11compat/OrnamentSettings.kt

@@ -0,0 +1,96 @@
+package com.mapbox.rctmgl.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.mapbox.rctmgl.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/rctmgl/v11compat/ResourceOption.kt

@@ -0,0 +1,12 @@
+package com.mapbox.rctmgl.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
+}