@rnmapbox/maps 10.1.0-beta.8 → 10.1.0-rc.0

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

@@ -0,0 +1,395 @@
+package com.rnmapbox.rnmbx.v11compat.stylefactory;
+
+import com.mapbox.maps.extension.style.atmosphere.generated.Atmosphere
+import com.mapbox.maps.extension.style.expressions.generated.Expression
+import com.mapbox.maps.extension.style.layers.generated.BackgroundLayer
+import com.mapbox.maps.extension.style.layers.generated.CircleLayer
+import com.mapbox.maps.extension.style.layers.generated.FillExtrusionLayer
+import com.mapbox.maps.extension.style.layers.generated.FillLayer
+import com.mapbox.maps.extension.style.layers.generated.LineLayer
+import com.mapbox.maps.extension.style.layers.generated.ModelLayer
+import com.mapbox.maps.extension.style.layers.generated.RasterLayer
+import com.mapbox.maps.extension.style.layers.generated.SymbolLayer
+import com.mapbox.maps.extension.style.types.StyleTransition
+
+internal fun RasterLayer.rasterColor(rasterColor: Int) {
+    this.rasterColor(Expression.color(rasterColor))
+}
+
+internal fun ModelLayer.modelOpacity(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun SymbolLayer.symbolZElevate(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun LineLayer.lineEmissiveStrengthTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun LineLayer.lineEmissiveStrength(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun Atmosphere.verticalRangeTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun FillLayer.fillEmissiveStrengthTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun FillLayer.fillEmissiveStrength(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun FillLayer.fillEmissiveStrength(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelHeightBasedEmissiveStrengthMultiplier(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelCutoffFadeRange(value: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelCutoffFadeRange(value: Double) {
+    TODO("v11 only")
+}
+
+internal fun BackgroundLayer.backgroundEmissiveStrengthTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun Atmosphere.verticalRange(value: Expression) {
+    TODO("v11 only")
+}
+
+internal fun Atmosphere.verticalRange(value: kotlin.collections.List<Double>) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightIntensity(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionAmbientOcclusionWallRadius(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionRoundedRoof(value: Expression?) {
+    TODO("v11 only")
+}
+
+internal fun SymbolLayer.iconImageCrossFade(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun SymbolLayer.textEmissiveStrengthTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun SymbolLayer.textEmissiveStrength(value: Double) {
+    TODO("v11 only")
+}
+
+internal fun SymbolLayer.iconEmissiveStrength(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun SymbolLayer.symbolZElevate(expression: Boolean) {
+    TODO("v11 only")
+}
+
+internal fun LineLayer.lineEmissiveStrength(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun BackgroundLayer.backgroundEmissiveStrength(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun BackgroundLayer.backgroundEmissiveStrength(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelHeightBasedEmissiveStrengthMultiplierTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelHeightBasedEmissiveStrengthMultiplier(expression: List<Double>) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelRoughnessTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelRoughness(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelRoughness(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelEmissiveStrengthTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelEmissiveStrength(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelEmissiveStrength(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelAmbientOcclusionIntensityTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelAmbientOcclusionIntensity(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelAmbientOcclusionIntensity(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelReceiveShadows(expression: Boolean) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelReceiveShadows(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelCastShadows(expression: Boolean) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelCastShadows(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelColorMixIntensityTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelColorMixIntensity(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelColorMixIntensity(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelColorTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelColor(expression: Int) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelColor(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelTranslationTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelTranslation(expression: List<Double>) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelTranslation(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelOpacityTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun ModelLayer.modelOpacity(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun RasterLayer.rasterColorRangeTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun RasterLayer.rasterColorRange(expression: List<Double>) {
+    TODO("v11 only")
+}
+
+internal fun RasterLayer.rasterColorRange(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun RasterLayer.rasterColorMixTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun RasterLayer.rasterColorMix(expression: List<Double>) {
+    TODO("v11 only")
+}
+
+internal fun RasterLayer.rasterColorMix(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun RasterLayer.rasterColor(rasterColor: Expression) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionCutoffFadeRange(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionCutoffFadeRange(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionVerticalScaleTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightIntensity(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightGroundAttenuation(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionAmbientOcclusionGroundAttenuationTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionAmbientOcclusionWallRadius(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun SymbolLayer.iconImageCrossFade(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun SymbolLayer.iconEmissiveStrength(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionVerticalScale(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionVerticalScale(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightGroundAttenuationTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightGroundAttenuation(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightGroundRadiusTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightGroundRadius(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightGroundRadius(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightWallRadiusTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightWallRadius(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightWallRadius(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightIntensityTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightColorTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightColor(expression: Int) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionFloodLightColor(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionAmbientOcclusionGroundAttenuation(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionAmbientOcclusionGroundAttenuation(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionAmbientOcclusionGroundRadiusTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionAmbientOcclusionGroundRadius(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionAmbientOcclusionGroundRadius(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionAmbientOcclusionWallRadiusTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun FillExtrusionLayer.fillExtrusionRoundedRoof(value: Boolean) {
+    TODO("v11 only")
+}
+
+internal fun CircleLayer.circleEmissiveStrengthTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun CircleLayer.circleEmissiveStrength(expression: Double) {
+    TODO("v11 only")
+}
+
+internal fun CircleLayer.circleEmissiveStrength(expression: Expression) {
+    TODO("v11 only")
+}
+
+internal fun SymbolLayer.iconImageCrossFadeTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+internal fun SymbolLayer.textEmissiveStrength(value: Expression) {
+    TODO("v11 only")
+}
+
+internal fun SymbolLayer.iconEmissiveStrengthTransition(transition: StyleTransition) {
+    TODO("v11 only")
+}
+
+

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

@@ -0,0 +1,32 @@
+package com.rnmapbox.rnmbx.v11compat.annotation;
+
+import android.view.View
+import com.mapbox.geojson.Geometry
+import com.mapbox.geojson.Point
+import com.mapbox.maps.ScreenCoordinate
+import com.mapbox.maps.ViewAnnotationAnchorConfig
+import com.mapbox.maps.ViewAnnotationOptions
+import com.mapbox.maps.viewannotation.geometry as _geometry
+
+import com.mapbox.maps.viewannotation.OnViewAnnotationUpdatedListener as _OnViewAnnotationUpdatedListener
+
+
+
+public const val INVALID_ANNOTATION_ID = ""
+typealias AnnotationID = String
+
+
+fun ViewAnnotationOptions.Builder.geometry(point: Geometry): ViewAnnotationOptions.Builder {
+  return _geometry(point)
+}
+
+fun ViewAnnotationOptions.Builder.offsets(x: Double, y: Double) {
+  this.variableAnchors(listOf(
+    ViewAnnotationAnchorConfig.Builder().offsetY(x).offsetY(y).build()
+  ))
+}
+
+
+abstract class OnViewAnnotationUpdatedListener : _OnViewAnnotationUpdatedListener {
+
+}

package/android/src/main/mapbox-v11-compat/v11/com/rnmapbox/rnmbx/v11compat/Cancelable.kt

@@ -0,0 +1,3 @@
+package com.rnmapbox.rnmbx.v11compat
+
+typealias Cancelable = com.mapbox.common.Cancelable;

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

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

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

@@ -0,0 +1,88 @@
+package com.rnmapbox.rnmbx.v11compat.image;
+
+import android.content.Context
+import android.content.res.Resources
+import android.graphics.Bitmap
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.VectorDrawable
+import androidx.annotation.DrawableRes
+import androidx.core.graphics.drawable.toBitmap
+import com.mapbox.bindgen.DataRef
+import com.mapbox.maps.Image
+import com.mapbox.maps.ImageHolder
+import com.mapbox.maps.Style
+import com.mapbox.maps.toMapboxImage
+import com.rnmapbox.rnmbx.components.images.ImageInfo
+import java.nio.ByteBuffer
+import com.mapbox.maps.toMapboxImage as _toMapboxImage
+
+typealias ImageHolder = com.mapbox.maps.ImageHolder
+
+fun ByteArray.toImageData() : DataRef {
+    val nativeDataRef = DataRef.allocateNative(this.size)
+    nativeDataRef.buffer.put(this)
+    return nativeDataRef
+}
+
+fun DataRef.toByteArray(): ByteArray {
+    return this.buffer.array()
+}
+/*
+fun Drawable.toImageHolder(drawableId: Int) : ImageHolder {
+    return ImageHolder.from(drawableId)
+}
+*/
+
+fun VectorDrawable.toBitmapImageHolder(): ImageHolder {
+    return ImageHolder.from(this.toBitmap())
+}
+
+fun BitmapDrawable.toBitmapImageHolder(): ImageHolder {
+    return ImageHolder.from(this.toBitmap())
+}
+
+class AppCompatResourcesV11 {
+    companion object {
+        fun getDrawableImageHolder(context: Context, @DrawableRes resId: Int) : ImageHolder? {
+            return ImageHolder.from(resId)
+        }
+    }
+}
+
+fun Bitmap.toMapboxImage(): Image {
+    return this._toMapboxImage()
+}
+
+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) {
+    return this.addStyleImage(
+        imageId,
+        bitmap.toMapboxImage(),
+        info,
+    )
+}
+
+fun emptyImage(width: Int, height: Int): Image {
+    return Image(
+        width, height, DataRef.allocateNative(width * height * 4)
+    )
+}
+
+fun Image.toDrawable(): Drawable {
+    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    bitmap.copyPixelsFromBuffer(data.buffer)
+
+    return BitmapDrawable(Resources.getSystem(), bitmap)
+}
+
+fun Image.toImageHolder(): ImageHolder {
+    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    bitmap.copyPixelsFromBuffer(data.buffer)
+
+    return ImageHolder.from(bitmap)
+}
+

package/android/src/main/mapbox-v11-compat/v11/com/rnmapbox/rnmbx/v11compat/Layer.kt

@@ -0,0 +1,3 @@
+package com.rnmapbox.rnmbx.v11compat.layer;
+
+import com.mapbox.maps.extension.style.layers.Layer

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

@@ -0,0 +1,116 @@
+package com.rnmapbox.rnmbx.v11compat.location;
+
+import android.content.Context
+import android.os.Looper
+import com.mapbox.common.location.AccuracyLevel
+import com.mapbox.common.location.DeviceLocationProvider
+import com.mapbox.common.location.IntervalSettings
+import com.mapbox.common.location.LocationObserver
+import com.mapbox.common.location.Location as _Location
+import com.mapbox.maps.MapView
+import com.mapbox.maps.plugin.PuckBearing as _PuckBearing
+import com.mapbox.maps.plugin.locationcomponent.LocationComponentPlugin
+import com.mapbox.maps.plugin.locationcomponent.location
+
+import com.mapbox.common.location.LocationProvider
+import com.mapbox.common.location.LocationProviderRequest
+import com.mapbox.common.location.LocationService
+import com.mapbox.common.location.LocationServiceFactory
+import com.rnmapbox.rnmbx.utils.Logger
+import kotlin.math.absoluteValue
+
+typealias PuckBearing = _PuckBearing
+
+const val DEFAULT_FASTEST_INTERVAL_MILLIS: Long = 1000
+const val DEFAULT_INTERVAL_MILLIS: Long = 1000
+
+val MapView.location2 : LocationComponentPlugin
+  get() = location
+
+var LocationComponentPlugin.puckBearingSource : PuckBearing
+  get() = puckBearing
+  set(value) {
+    puckBearing = value
+  }
+
+
+typealias Location = _Location
+
+data class LocationEngineResult(var lastLocation: Location?) {
+
+}
+
+interface LocationEngineCallback {
+  fun onSuccess(locationEngineResult: LocationEngineResult)
+  fun onFailure(e: Exception)
+}
+
+class LocationObserverAdapter(val callback: LocationEngineCallback): LocationObserver {
+  override fun onLocationUpdateReceived(locations: MutableList<com.mapbox.common.location.Location>) {
+    callback.onSuccess(LocationEngineResult(locations.last()))
+  }
+}
+class LocationEngine(var locationProvider: DeviceLocationProvider, var request: LocationProviderRequest) {
+  var observers: MutableList<LocationObserverAdapter> = mutableListOf()
+}
+
+
+fun LocationEngine.requestLocationUpdatesV11(callback: LocationEngineCallback, looper: Looper?, minDisplacement: Float?) {
+  val builder = LocationProviderRequest.Builder()
+  builder.interval(intervalSettings())
+  builder.accuracy(AccuracyLevel.HIGH)
+  if (minDisplacement != null && minDisplacement > 0) {
+    builder.displacement(minDisplacement)
+  }
+  val request = builder.build()
+  if (! request.equals(this.request)) {
+    val newProvider = LocationServiceFactory.getOrCreate().getDeviceLocationProvider(request)
+    if (newProvider.isValue) {
+      this.locationProvider = newProvider.value!!
+      this.request = request
+    } else {
+      Logger.e("RNMBXLocationEngine", "Failed to get location provider: ${newProvider.error!!.message}")
+    }
+  }
+  val observer = LocationObserverAdapter(callback)
+  if (looper != null) {
+    locationProvider.addLocationObserver(observer, looper)
+  } else {
+    locationProvider.addLocationObserver(observer)
+  }
+  observers.add(observer)
+}
+
+fun LocationEngine.removeLocationUpdates(callback: LocationEngineCallback) {
+  observers.filter { it.callback == callback }.forEach { locationProvider.removeLocationObserver(it) }
+  observers.removeAll { it.callback == callback }
+}
+
+fun LocationEngine.getLastLocation(callback: LocationEngineCallback) {
+  locationProvider?.getLastLocation {
+    it?.let { callback.onSuccess(
+      LocationEngineResult(lastLocation= it)
+    ) }
+  }
+}
+
+val Location.accuracy: Double
+  get() = ((this.verticalAccuracy?.absoluteValue ?: 0.0) +
+          (this.horizontalAccuracy?.absoluteValue ?: 0.0))/2.0
+
+
+fun intervalSettings(): IntervalSettings {
+  return IntervalSettings.Builder().interval(DEFAULT_INTERVAL_MILLIS).maximumInterval(
+    DEFAULT_FASTEST_INTERVAL_MILLIS).build()
+}
+fun createLocationEngine(context: Context): LocationEngine? {
+  val locationService : LocationService = LocationServiceFactory.getOrCreate()
+  var locationProvider: DeviceLocationProvider? = null
+  val request = LocationProviderRequest.Builder().interval(intervalSettings()).build()
+  val result = locationService.getDeviceLocationProvider(request)
+  if (result.isValue) {
+    locationProvider = result.value!!
+    return LocationEngine(locationProvider, request)
+  }
+  return null
+}

package/android/src/main/mapbox-v11-compat/v11/com/{mapbox → rnmapbox}/rnmbx/v11compat/OfflineManager.kt

@@ -1,5 +1,6 @@
 package com.rnmapbox.rnmbx.v11compat.offlinemanager;
 
+import com.mapbox.common.MapboxOptions
 import com.mapbox.common.TileStore
 import com.mapbox.maps.OfflineManager
 import com.mapbox.maps.OfflineRegionManager
@@ -9,4 +10,7 @@ fun getOfflineRegionManager(getAccessToken: () -> String): OfflineRegionManager
 }
 fun getOfflineManager(tileStore: TileStore, getAccessToken: () -> String): OfflineManager {
   return OfflineManager()
+}
+fun TileStore.setAccessToken(token: String) {
+  MapboxOptions.accessToken = token
 }

package/android/src/main/mapbox-v11-compat/v11/com/rnmapbox/rnmbx/v11compat/StyleFactory.kt

@@ -0,0 +1,8 @@
+package com.rnmapbox.rnmbx.v11compat.stylefactory;
+
+import com.mapbox.maps.extension.style.expressions.generated.Expression
+import com.mapbox.maps.extension.style.layers.generated.RasterLayer
+
+fun RasterLayer.rasterColor(rasterColor: Int) {
+    this.rasterColor(Expression.color(rasterColor))
+}