@rnmapbox/maps 10.0.15 → 10.1.0-beta.4

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

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

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

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

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

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

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

@@ -0,0 +1,40 @@
+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
+import androidx.core.graphics.drawable.toBitmap
+import com.mapbox.bindgen.DataRef
+import com.mapbox.maps.ImageHolder
+import java.nio.ByteBuffer
+
+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)
+        }
+    }
+}

package/android/src/main/mapbox-v11-compat/v11/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.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/rctmgl/v11compat/Location.kt

@@ -0,0 +1,58 @@
+package com.mapbox.rctmgl.v11compat.location;
+
+import android.os.Looper
+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 kotlin.math.absoluteValue
+
+typealias PuckBearingSource = PuckBearing
+
+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 LocationEngine {
+  var locationProvider: LocationProvider? = null
+}
+
+
+fun LocationEngine.requestLocationUpdatesV11(callback: LocationEngineCallback, looper: Looper?, minDisplacement: Float?) {
+ 
+}
+
+fun LocationEngine.removeLocationUpdates(callback: LocationEngineCallback) {
+
+}
+
+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

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

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

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

package/android/src/main/mapbox-v11-compat/v11/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.Builder().build()
+}
+
+interface GenericOrnamentSettings {
+    fun setHMargins(left: Float?, right: Float?)
+    fun setVMargins(top: Float?, bottom: Float?)
+    var enabled: Boolean
+    var position: Int
+}
+
+fun ScaleBarSettings.Builder.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.Builder.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.Builder.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.Builder.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/v11/com/mapbox/rctmgl/v11compat/ResourceOption.kt

@@ -0,0 +1,14 @@
+package com.mapbox.rctmgl.v11compat.resourceoption;
+
+import android.content.Context
+import com.mapbox.common.MapboxOptions
+
+fun setMapboxAccessToken(context: Context?, accessToken: String?) {
+  accessToken?.let {
+    MapboxOptions.accessToken = it
+  }
+}
+
+fun getMapboxAccessToken(context: Context?): String {
+  return MapboxOptions.accessToken;
+}