@rnmapbox/maps 10.0.15 → 10.1.0-beta.11

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

@@ -0,0 +1,28 @@
+package com.rnmapbox.rnmbx.v11compat.snapshot;
+
+import com.mapbox.maps.Image
+import com.mapbox.maps.MapSnapshotInterface;
+import com.mapbox.maps.MapSnapshotOptions
+import com.mapbox.maps.ResourceOptions;
+import com.mapbox.maps.Snapshotter
+import com.mapbox.maps.bitmap
+
+
+fun MapSnapshotOptions.Builder.accessToken(accessToken: String?) {
+  if (accessToken != null) {
+    this.resourceOptions(
+      ResourceOptions.Builder().accessToken(accessToken).build()
+    )
+  }
+}
+
+
+fun MapSnapshotInterface.toMapboxImage(): Image {
+    return this.image()
+}
+
+fun Snapshotter.startV11(callback: (MapSnapshotInterface?, String?) -> Unit) {
+   this.start { image ->
+      callback(image, if (image == null) "Snapshot error" else null)
+   }
+}

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

@@ -0,0 +1,9 @@
+package com.rnmapbox.rnmbx.v11compat.style;
+
+import com.mapbox.bindgen.Value
+import com.mapbox.maps.Style
+import com.rnmapbox.rnmbx.utils.Logger
+
+fun Style?.setStyleImportConfigProperties(id: String, config: HashMap<String, Value>) {
+    Logger.w("RNBMXStyleImport", "Style imports only supported on mapbox v11")
+}

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

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

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

@@ -0,0 +1,342 @@
+package com.rnmapbox.rnmbx.v11compat.event;
+
+import com.mapbox.maps.MapboxMap;
+
+class Event {
+    // TODO data
+    // TODO message
+    val data: String
+        get() = "n/a"
+    val message: String
+        get() = "n/a"
+}
+
+data class MapLoadingErrorEventData(var message: String);
+
+fun Event.getMapLoadingErrorEventData() : MapLoadingErrorEventData // TODO
+{
+  return MapLoadingErrorEventData(message = "n/a")
+}
+
+fun interface Observer {
+    public fun notify(event: Event)
+}
+
+fun MapboxMap.subscribe(observer: Observer, events: List<String>) { 
+  //subscribe(callback: (Any?)->Void) {
+    // TODO
+}
+
+
+// MapEvents
+// MapEvents.MAP_LOADING_ERROR
+
+
+
+
+//  override fun
+
+/*
+fun Event.getMapLoadingErrorEventData(): MapLoadingErrorEventData {
+  val map = data.contents as Map<String, Value>
+  val tileIDMap = map.nullableMap(TILE_ID)
+  return MapLoadingErrorEventData(
+    begin = map.nonNullLong(BEGIN),
+    end = map.nullableLong(END),
+    type = MapLoadErrorType.valueOf(map.validEnumValue(TYPE)),
+    message = map.nonNullString(MESSAGE),
+    sourceId = map.nullableString(SOURCE_ID),
+    tileId = if (tileIDMap == null) null else TileID(
+      zoom = tileIDMap.nonNullLong(Z),
+      x = tileIDMap.nonNullLong(X),
+      y = tileIDMap.nonNullLong(Y)
+    )
+  )
+}
+ */
+
+
+object MapEvents {
+    const val MAP_LOADING_ERROR = "map-loading-error"
+}
+
+/*
+public final class MapEvents {
+    /**
+     * The style has been fully loaded, and the `map` has rendered all visible tiles.
+     *
+     * ``` text
+     * Event data format (Object).
+     * ```
+     */
+    public static final String MAP_LOADED = "map-loaded";
+    /**
+     * Describes an error that has occurred while loading the Map. The `type` property defines what resource could
+     * not be loaded and the `message` property will contain a descriptive error message.
+     * In case of `source` or `tile` loading errors, `source-id` will contain the id of the source failing.
+     * In case of `tile` loading errors, `tile-id` will contain the id of the tile
+     *
+     * ``` text
+     * Event data format (Object):
+     * .
+     * ├── type - String ("style" | "sprite" | "source" | "tile" | "glyphs")
+     * ├── message - String
+     * ├── source-id - optional String
+     * └── tile-id - optional Object
+     *     ├── z Number (zoom level)
+     *     ├── x Number (x coordinate)
+     *     └── y Number (y coordinate)
+     * ```
+     */
+    public static final String MAP_LOADING_ERROR = "map-loading-error";
+    /**
+     * The `map` has entered the idle state. The `map` is in the idle state when there are no ongoing transitions
+     * and the `map` has rendered all requested non-volatile tiles. The event will not be emitted if `setUserAnimationInProgress`
+     * and / or `setGestureInProgress` is set to `true`.
+     *
+     * ``` text
+     * Event data format (Object).
+     * ```
+     */
+    public static final String MAP_IDLE = "map-idle";
+    /**
+     * The requested style data has been loaded. The `type` property defines what kind of style data has been loaded.
+     * Event may be emitted synchronously, for example, when `setStyleJSON` is used to load style.
+     *
+     * Based on an event data `type` property value, following use-cases may be implemented:
+     * - `style`: Style is parsed, style layer properties could be read and modified, style layers and sources could be
+     *   added or removed before rendering is started.
+     * - `sprite`: Style's sprite sheet is parsed and it is possible to add or update images.
+     * - `sources`: All sources defined by the style are loaded and their properties could be read and updated if needed.
+     *
+     * ``` text
+     * Event data format (Object):
+     * .
+     * └── type - String ("style" | "sprite" | "sources")
+     * ```
+     */
+    public static final String STYLE_DATA_LOADED = "style-data-loaded";
+    /**
+     * The requested style has been fully loaded, including the style, specified sprite and sources' metadata.
+     *
+     * ``` text
+     * Event data format (Object).
+     * ```
+     *
+     * Note: The style specified sprite would be marked as loaded even with sprite loading error (An error will be emitted via `MapLoadingError`).
+     * Sprite loading error is not fatal and we don't want it to block the map rendering, thus this event will still be emitted if style and sources are fully loaded.
+     *
+     */
+    public static final String STYLE_LOADED = "style-loaded";
+    /**
+     * A style has a missing image. This event is emitted when the `map` renders visible tiles and
+     * one of the required images is missing in the sprite sheet. Subscriber has to provide the missing image
+     * by calling `addStyleImage` method.
+     *
+     * ``` text
+     * Event data format (Object):
+     * .
+     * └── id - String
+     * ```
+     */
+    public static final String STYLE_IMAGE_MISSING = "style-image-missing";
+    /**
+     * An image added to the style is no longer needed and can be removed using `removeStyleImage` method.
+     *
+     * ``` text
+     * Event data format (Object):
+     * .
+     * └── id - String
+     * ```
+     */
+    public static final String STYLE_IMAGE_REMOVE_UNUSED = "style-image-remove-unused";
+    /**
+     * A source data has been loaded.
+     * Event may be emitted synchronously in cases when source's metadata is available when source is added to the style.
+     *
+     * The `id` property defines the source id.
+     *
+     * The `type` property defines if source's metadata (e.g., TileJSON) or tile has been loaded. The property of `metadata`
+     * value might be useful to identify when particular source's metadata is loaded, thus all source's properties are
+     * readable and can be updated before `map` will start requesting data to be rendered.
+     *
+     * The `loaded` property will be set to `true` if all source's data required for visible viewport of the `map`, are loaded.
+     * The `tile-id` property defines the tile id if the `type` field equals `tile`.
+     *
+     * ``` text
+     * Event data format (Object):
+     * .
+     * ├── id - String
+     * ├── type - String ("metadata" | "tile")
+     * ├── loaded - optional Boolean
+     * └── tile-id - optional Object
+     * |   ├── z Number (zoom level)
+     * |   ├── x Number (x coordinate)
+     * |   └── y Number (y coordinate)
+     * └── data-id - optional String
+     * ```
+     */
+    public static final String SOURCE_DATA_LOADED = "source-data-loaded";
+    /**
+     * The source has been added with `addStyleSource` method.
+     * The event is emitted synchronously, therefore, it is possible to immediately
+     * read added source's properties.
+     *
+     * ``` text
+     * Event data format (Object):
+     * .
+     * └── id - String
+     * ```
+     */
+    public static final String SOURCE_ADDED = "source-added";
+    /**
+     * The source has been removed with `removeStyleSource` method.
+     * The event is emitted synchronously, thus, `getStyleSources` will be
+     * in sync when the `observer` receives the notification.
+     *
+     * ``` text
+     * Event data format (Object):
+     * .
+     * └── id - String
+     * ```
+     */
+    public static final String SOURCE_REMOVED = "source-removed";
+    /**
+     * The `map` started rendering a frame.
+     *
+     * Event data format (Object).
+     */
+    public static final String RENDER_FRAME_STARTED = "render-frame-started";
+    /**
+     * The `map` finished rendering a frame.
+     * The `render-mode` property tells whether the `map` has all data (`full`) required to render the visible viewport.
+     * The `needs-repaint` property provides information about ongoing transitions that trigger `map` repaint.
+     * The `placement-changed` property tells if the symbol placement has been changed in the visible viewport.
+     *
+     * ``` text
+     * Event data format (Object):
+     * .
+     * ├── render-mode - String ("partial" | "full")
+     * ├── needs-repaint - Boolean
+     * └── placement-changed - Boolean
+     * ```
+     */
+    public static final String RENDER_FRAME_FINISHED = "render-frame-finished";
+    /**
+     * The camera has changed. This event is emitted whenever the visible viewport
+     * changes due to the invocation of `setSize`, `setBounds` methods or when the camera
+     * is modified by calling camera methods. The event is emitted synchronously,
+     * so that an updated camera state can be fetched immediately.
+     *
+     * ``` text
+     * Event data format (Object).
+     * ```
+     */
+    public static final String CAMERA_CHANGED = "camera-changed";
+    /**
+     * The `ResourceRequest` event allows client to observe resource requests made by a
+     * `map` or `map snapshotter` objects.
+     *
+     * ``` text
+     * Event data format (Object):
+     * .
+     * ├── data-source - String ("resource-loader" | "network" | "database" | "asset" | "file-system")
+     * ├── request - Object
+     * │   ├── url - String
+     * │   ├── kind - String ("unknown" | "style" | "source" | "tile" | "glyphs" | "sprite-image" | "sprite-json" | "image")
+     * │   ├── priority - String ("regular" | "low")
+     * │   └── loading-method - Array ["cache" | "network"]
+     * ├── response - optional Object
+     * │   ├── no-content - Boolean
+     * │   ├── not-modified - Boolean
+     * │   ├── must-revalidate - Boolean
+     * │   ├── source - String ("network" | "cache" | "tile-store" | "local-file")
+     * │   ├── size - Number (size in bytes)
+     * │   ├── modified - optional String, rfc1123 timestamp
+     * │   ├── expires - optional String, rfc1123 timestamp
+     * │   ├── etag - optional String
+     * │   └── error - optional Object
+     * │       ├── reason - String ("success" | "not-found" | "server" | "connection" | "rate-limit" | "in-offline-mode" | "other")
+     * │       └── message - String
+     * └── cancelled - Boolean
+     * ```
+     */
+    public static final String RESOURCE_REQUEST = "resource-request";
+}
+
+ */
+
+/*
+public final class Event implements Serializable {
+
+    @NonNull
+    private final String type;
+    @NonNull
+    private final Value data;
+
+    public Event(@NonNull String type,
+                 @NonNull Value data) {
+        this.type = type;
+        this.data = data;
+    }
+
+    /** Type of the event. */
+    @NonNull
+    public String getType() {
+        return type;
+    }
+
+    /**
+     * Generic container for an event's data (Object). By default, event data will contain `begin` key, whose value
+     * is a number representing timestamp taken at the time of an event creation, in microseconds, since the epoch.
+     * For an interval events, an optional `end` property will be present that represents timestamp taken at the time
+     * of an event completion. Additional data properties are docummented by respective events.
+     *
+     * ``` text
+     * Event data format (Object):
+     * .
+     * ├── begin - Number
+     * └── end - optional Number
+     * ```
+     */
+    @NonNull
+    public Value getData() {
+        return data;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) {
+             return true;
+        }
+
+        if (object == null || getClass() != object.getClass()) {
+            return false;
+        }
+
+        Event other = (Event) object;
+
+        if (!Objects.equals(this.type, other.type)) {
+            return false;
+        }
+        if (!Objects.equals(this.data, other.data)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(
+            this.type,
+            this.data);
+    }
+
+    @Override
+    public String toString() {
+        return "[" + "type: " + RecordUtils.fieldToString(type) + ", " + "data: " + RecordUtils.fieldToString(data) + "]";
+    }
+
+}
+ */

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

@@ -0,0 +1,16 @@
+package com.rnmapbox.rnmbx.v11compat.feature;
+
+import com.mapbox.geojson.Feature;
+
+import com.mapbox.maps.QueriedRenderedFeature as _QueriedRenderedFeature;
+import com.mapbox.maps.QueriedSourceFeature as _QueriedSourceFeature;
+
+typealias QueriedRenderedFeature = _QueriedRenderedFeature;
+
+val QueriedRenderedFeature.feature: Feature
+    get() = this.queriedFeature.feature
+
+typealias QueriedSourceFeature = _QueriedSourceFeature
+
+val QueriedSourceFeature.feature: Feature
+    get() = this.queriedFeature.feature

package/android/src/main/mapbox-v11-compat/v11/com/mapbox/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/mapbox/rnmbx/v11compat/Image.kt

@@ -0,0 +1,68 @@
+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 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())
+}
+
+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)
+    )
+}

package/android/src/main/mapbox-v11-compat/v11/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.FlatLight
+import com.mapbox.maps.extension.style.light.generated.flatLight
+import com.mapbox.maps.extension.style.light.setLight as _setLight
+
+public typealias Light = FlatLight;
+
+fun Style.setLight(light: FlatLight) {
+    this._setLight(light)
+}
+
+fun createLight(): Light {
+    return flatLight() {}
+}

package/android/src/main/mapbox-v11-compat/v11/com/mapbox/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
+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 PuckBearingSource = 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/rnmbx/v11compat/MapboxMap.kt

@@ -0,0 +1,37 @@
+package com.rnmapbox.rnmbx.v11compat.mapboxmap
+
+import android.animation.Animator
+import com.mapbox.maps.AsyncOperationResultCallback
+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,
+    animationListener: Animator.AnimatorListener
+) {
+    this.flyTo(
+        cameraOptions,
+        animationOptions.build(),
+        animationListener
+    )
+}
+
+fun MapboxMap.easeToV11(
+    cameraOptions: CameraOptions,
+    animationOptions: MapAnimationOptions.Builder,
+    animationListener: Animator.AnimatorListener
+) {
+    this.easeTo(
+        cameraOptions,
+        animationOptions.build(),
+        animationListener
+    )
+}
+
+fun MapboxMap.clearData(callback: AsyncOperationResultCallback) {
+    return MapboxMap.clearData(callback)
+}

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

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