@rnmapbox/maps 10.1.0-rc.6 → 10.1.0

package/android/src/main/java/com/rnmapbox/rnmbx/modules/RNMBXOfflineModuleLegacy.kt

@@ -1,444 +0,0 @@
-package com.rnmapbox.rnmbx.modules
-
-import android.os.Build
-import android.util.Log
-import com.facebook.react.bridge.Arguments
-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.bridge.UiThreadUtil
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.module.annotations.ReactModule
-import com.mapbox.bindgen.Expected
-import com.mapbox.geojson.FeatureCollection
-import com.mapbox.geojson.Point
-import com.mapbox.maps.CoordinateBounds
-import com.mapbox.maps.GlyphsRasterizationMode
-import com.mapbox.maps.OfflineRegion
-import com.mapbox.maps.OfflineRegionCallback
-import com.mapbox.maps.OfflineRegionCreateCallback
-import com.mapbox.maps.OfflineRegionDownloadState
-import com.mapbox.maps.OfflineRegionManager
-import com.mapbox.maps.OfflineRegionStatus
-import com.mapbox.maps.OfflineRegionTilePyramidDefinition
-import com.rnmapbox.rnmbx.utils.ConvertUtils
-import com.rnmapbox.rnmbx.utils.extensions.toGeometryCollection
-import com.rnmapbox.rnmbx.utils.writableArrayOf
-import com.rnmapbox.rnmbx.v11compat.offlinemanager.getOfflineRegionManager
-import org.json.JSONException
-import org.json.JSONObject
-import java.io.File
-import java.io.UnsupportedEncodingException
-import java.nio.file.Files
-import java.nio.file.Paths
-import java.nio.file.StandardCopyOption
-import kotlin.math.ceil
-
-
-@ReactModule(name = RNMBXOfflineModuleLegacy.REACT_CLASS)
-class RNMBXOfflineModuleLegacy(private val mReactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(
-        mReactContext
-    ) {
-    companion object {
-        const val REACT_CLASS = "RNMBXOfflineModuleLegacy"
-        const val LOG_TAG = "OfflineModuleLegacy"
-        const val DEFAULT_STYLE_URL = "mapbox://styles/mapbox/streets-v11"
-        const val DEFAULT_MIN_ZOOM_LEVEL = 10.0
-        const val DEFAULT_MAX_ZOOM_LEVEL = 20.0
-        const val COMPLETE_REGION_DOWNLOAD_STATE = 2
-    }
-
-    override fun getName(): String {
-        return REACT_CLASS
-    }
-
-    val offlineRegionManager: OfflineRegionManager by lazy {
-        getOfflineRegionManager {
-            RNMBXModule.getAccessToken(mReactContext)
-        }
-    }
-
-    private fun makeDefinition(
-        bounds: CoordinateBounds,
-        options: ReadableMap
-    ): OfflineRegionTilePyramidDefinition {
-        return OfflineRegionTilePyramidDefinition.Builder()
-            .styleURL(ConvertUtils.getString("styleURL", options, DEFAULT_STYLE_URL))
-            .bounds(bounds)
-            .minZoom(ConvertUtils.getDouble("minZoom", options, DEFAULT_MIN_ZOOM_LEVEL))
-            .maxZoom(ConvertUtils.getDouble("maxZoom", options, DEFAULT_MAX_ZOOM_LEVEL))
-            .pixelRatio(mReactContext.getResources().getDisplayMetrics().density)
-            .glyphsRasterizationMode(GlyphsRasterizationMode.IDEOGRAPHS_RASTERIZED_LOCALLY)
-            .build()
-    }
-
-    private fun convertPointPairToBounds(boundsFC: FeatureCollection): CoordinateBounds? {
-        val geometryCollection = boundsFC.toGeometryCollection()
-        val geometries = geometryCollection.geometries()
-        if (geometries.size != 2) {
-            return null
-        }
-        val pt0 = geometries.get(0) as Point?
-        val pt1 = geometries.get(1) as Point?
-        if (pt0 == null || pt1 == null) {
-            return null
-        }
-        return CoordinateBounds(pt0, pt1)
-    }
-
-    private fun createPackCallback(promise: Promise, metadata: ByteArray): OfflineRegionCreateCallback {
-        return OfflineRegionCreateCallback { expected ->
-            if (expected.isValue) {
-                expected.value?.let {
-                    it.setOfflineRegionDownloadState(OfflineRegionDownloadState.ACTIVE)
-                    it.setMetadata(metadata) { expectedMetadata ->
-                        if (expectedMetadata.isError) {
-                            promise.reject("createPack error:", "Failed to setMetadata")
-                        } else {
-                            Log.d(LOG_TAG,  "createPack done:")
-                            promise.resolve(fromOfflineRegion(it))
-                        }
-                    }
-                }
-            } else {
-                Log.d(LOG_TAG,  "createPack error:")
-                promise.reject("createPack error:", "Failed to create OfflineRegion")
-            }
-        }
-    }
-
-
-    private fun fromOfflineRegion(region: OfflineRegion): WritableMap? {
-        val bb = region.tilePyramidDefinition?.bounds
-        val map = Arguments.createMap()
-
-        if (bb === null) return map
-
-        val jsonBounds = writableArrayOf(
-            writableArrayOf(bb.east(), bb.north()),
-            writableArrayOf(bb.west(), bb.south())
-        )
-
-        map.putArray("bounds", jsonBounds)
-        map.putString("metadata", String(region.metadata))
-
-        return map
-    }
-
-    private fun getMetadataBytes(metadata: String?): ByteArray? {
-        var metadataBytes: ByteArray? = null
-        if (metadata == null || metadata.isEmpty()) {
-            return metadataBytes
-        }
-        try {
-            metadataBytes = metadata.toByteArray(charset("utf-8"))
-        } catch (e: UnsupportedEncodingException) {
-            Log.w(LOG_TAG, e.localizedMessage)
-        }
-        return metadataBytes
-    }
-
-    private fun getRegionByName(
-        name: String?,
-        offlineRegions: List<OfflineRegion>
-    ): OfflineRegion? {
-        if (name.isNullOrEmpty()) {
-            return null
-        }
-        for (region in offlineRegions) {
-            try {
-                val byteMetadata = region.metadata
-
-                if (byteMetadata != null) {
-                    val metadata = JSONObject(String(byteMetadata))
-                    if (name == metadata.getString("name")) {
-                        return region
-                    }
-                }
-            } catch (e: JSONException) {
-                Log.w(LOG_TAG, e.localizedMessage)
-            }
-        }
-        return null
-    }
-
-    private fun makeRegionStatus(regionName: String, status: OfflineRegionStatus): WritableMap? {
-        val map = Arguments.createMap()
-        val progressPercentage = if (status.requiredResourceCount > 0) status.completedResourceCount.toDouble() / status.requiredResourceCount.toDouble() else 0.0
-        val percentage = ceil(progressPercentage * 100.0).coerceAtMost(100.0)
-        val isCompleted = percentage == 100.0
-        val downloadState = if (isCompleted) COMPLETE_REGION_DOWNLOAD_STATE else status.downloadState.ordinal
-
-        map.putString("name", regionName)
-        map.putInt("state", downloadState)
-        map.putDouble("percentage", percentage)
-        map.putInt("completedResourceCount", status.completedResourceCount.toInt())
-        map.putInt("completedResourceSize", status.completedResourceSize.toInt())
-        map.putInt("completedTileSize", status.completedTileSize.toInt())
-        map.putInt("completedTileCount", status.completedTileCount.toInt())
-        map.putInt("requiredResourceCount", status.requiredResourceCount.toInt())
-        return map
-    }
-
-    @ReactMethod
-    @Throws(JSONException::class)
-    fun createPack(options: ReadableMap, promise: Promise) {
-        try {
-            val metadataBytes: ByteArray? =
-                getMetadataBytes(ConvertUtils.getString("metadata", options, ""))
-
-            val boundsStr = options.getString("bounds")!!
-            val boundsFC = FeatureCollection.fromJson(boundsStr)
-            val bounds = convertPointPairToBounds(boundsFC)
-
-            if (metadataBytes == null || bounds == null) {
-                promise.reject("createPack error:", "No metadata or bounds set")
-                return
-            };
-
-            val definition: OfflineRegionTilePyramidDefinition = makeDefinition(bounds, options)
-
-            UiThreadUtil.runOnUiThread {
-                offlineRegionManager.createOfflineRegion(definition, createPackCallback(promise, metadataBytes))
-            }
-
-        } catch (e: Throwable) {
-            promise.reject("createPack error:", e)
-        }
-    }
-
-    @ReactMethod
-    fun getPacks(promise: Promise) {
-        UiThreadUtil.runOnUiThread {
-            offlineRegionManager.getOfflineRegions(object: OfflineRegionCallback {
-                override fun run(expected: Expected<String, MutableList<OfflineRegion>>) {
-                    if (expected.isValue) {
-                        expected.value?.let {
-                            val payload = Arguments.createArray()
-
-                            for (region in it) {
-                                payload.pushMap(fromOfflineRegion(region!!))
-                            }
-
-                            Log.d(LOG_TAG,  "getPacks done:" + it.size.toString())
-                            promise.resolve(payload)
-                        }
-                    } else {
-                        promise.reject("getPacks error:", expected.error)
-                        Log.d(LOG_TAG,  "getPacks error:${expected.error}")
-                    }
-                }
-            })
-        }
-    }
-
-    @ReactMethod
-    fun deletePack(name: String?, promise: Promise) {
-        UiThreadUtil.runOnUiThread {
-            offlineRegionManager.getOfflineRegions { regionsExpected ->
-                if (regionsExpected.isValue) {
-                    regionsExpected.value?.let { regions ->
-                        var region = getRegionByName(name, regions);
-
-                        if (region == null) {
-                            promise.resolve(null);
-                            Log.w(LOG_TAG, "deleteRegion - Unknown offline region");
-                            return@getOfflineRegions
-                        }
-
-                        region.setOfflineRegionDownloadState(OfflineRegionDownloadState.INACTIVE)
-
-                        region.purge { purgeExpected ->
-                            if (purgeExpected.isError) {
-                                promise.reject("deleteRegion error:", purgeExpected.error);
-                            } else {
-                                promise.resolve(null);
-                            }
-                        }
-                    }
-                } else {
-                    promise.reject("deleteRegion error:", regionsExpected.error);
-                }
-            }
-        }
-    }
-
-    @ReactMethod
-    fun invalidatePack(name: String?, promise: Promise) {
-        UiThreadUtil.runOnUiThread {
-            offlineRegionManager.getOfflineRegions { expected ->
-                if (expected.isValue) {
-                    expected.value?.let { regions ->
-                        var region = getRegionByName(name, regions);
-
-                        if (region == null) {
-                            promise.resolve(null);
-                            Log.w(LOG_TAG, "invalidateRegion - Unknown offline region");
-                            return@getOfflineRegions
-                        }
-
-                        region.invalidate { expected ->
-                            if (expected.isError) {
-                                promise.reject("invalidateRegion error:", expected.error);
-                            } else {
-                                promise.resolve(null);
-                            }
-                        }
-                    }
-                } else {
-                    promise.reject("invalidateRegion error:", expected.error);
-                }
-            }
-        }
-    }
-
-    @ReactMethod
-    fun getPackStatus(name: String?, promise: Promise) {
-        UiThreadUtil.runOnUiThread {
-            offlineRegionManager.getOfflineRegions { expected ->
-                if (expected.isValue) {
-                    expected.value?.let { regions ->
-                        var region = getRegionByName(name, regions);
-
-                        if (region == null) {
-                            promise.resolve(null);
-                            Log.w(LOG_TAG, "getPackStatus - Unknown offline region");
-                            return@getOfflineRegions
-                        }
-
-                        region.getStatus {
-                           if (it.isValue) {
-                               it.value?.let { status ->
-                                   promise.resolve(makeRegionStatus(name!!, status));
-                               }
-                           } else {
-                               promise.reject("getPackStatus error:", expected.error);
-                           }
-                        }
-                    }
-                } else {
-                    promise.reject("getPackStatus error:", expected.error);
-                }
-            }
-        }
-    }
-
-    @ReactMethod
-    fun pausePackDownload(name: String?, promise: Promise) {
-        UiThreadUtil.runOnUiThread {
-            offlineRegionManager.getOfflineRegions { expected ->
-                if (expected.isValue) {
-                    expected.value?.let { regions ->
-                        var region = getRegionByName(name, regions);
-
-                        if (region == null) {
-                            promise.resolve(null);
-                            Log.w(LOG_TAG, "pausePackDownload - Unknown offline region");
-                            return@getOfflineRegions
-                        }
-
-                        region.setOfflineRegionDownloadState(OfflineRegionDownloadState.INACTIVE)
-                        promise.resolve(null)
-                    }
-                } else {
-                    promise.reject("pausePackDownload error:", expected.error);
-                }
-            }
-        }
-    }
-
-    @ReactMethod
-    fun resumePackDownload(name: String?, promise: Promise) {
-        UiThreadUtil.runOnUiThread {
-            offlineRegionManager.getOfflineRegions { expected ->
-                if (expected.isValue) {
-                    expected.value?.let { regions ->
-                        var region = getRegionByName(name, regions);
-
-                        if (region == null) {
-                            promise.resolve(null);
-                            Log.w(LOG_TAG, "resumeRegionDownload - Unknown offline region");
-                            return@getOfflineRegions
-                        }
-
-                        region.setOfflineRegionDownloadState(OfflineRegionDownloadState.ACTIVE)
-                        promise.resolve(null);
-                    }
-                } else {
-                    promise.reject("resumeRegionDownload error:", expected.error);
-                }
-            }
-        }
-    }
-
-    @ReactMethod
-    fun resetDatabase(promise: Promise) {
-        UiThreadUtil.runOnUiThread {
-            var purgedCount = 0
-            offlineRegionManager.getOfflineRegions { expected ->
-                if (expected.isValue) {
-                    expected.value?.let { regions ->
-                        if (regions.size == 0) promise.resolve(null)
-
-                        for (region in regions) {
-                            region.setOfflineRegionDownloadState(OfflineRegionDownloadState.INACTIVE)
-
-                            region.purge { expected ->
-                                if (expected.isError) {
-                                    promise.reject("resetDatabase error:", expected.error);
-                                } else {
-                                    purgedCount++
-                                    if (purgedCount == regions.size) {
-                                        Log.d(LOG_TAG, "resetDatabase done: ${regions.size} packs were purged")
-                                        promise.resolve(null)
-                                    }
-                                }
-                            }
-                        }
-                    }
-                } else {
-                    promise.reject("resetDatabase error:", expected.error);
-                }
-            }
-        }
-    }
-
-    @ReactMethod
-    fun migrateOfflineCache(promise: Promise) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            // Old and new cache file paths
-            val targetDirectoryPathName = mReactContext.filesDir.absolutePath + "/.mapbox/map_data"
-            val sourcePathName = mReactContext.filesDir.absolutePath + "/mbgl-offline.db"
-            val sourcePath = Paths.get(sourcePathName)
-            val targetPath = Paths.get("$targetDirectoryPathName/map_data.db")
-
-            try {
-                val source = File(sourcePath.toString())
-
-                if (!source.exists()) {
-                    Log.d(LOG_TAG, "Nothing to migrate")
-                    promise.resolve(false)
-                    return
-                }
-
-                val directory = File(targetDirectoryPathName)
-
-                directory.mkdirs()
-                Files.move(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING)
-                Log.d(LOG_TAG, "v10 cache directory created successfully")
-                promise.resolve(true)
-            } catch (e: Exception) {
-                val mes = "${e}... file move unsuccessful"
-                Log.d(LOG_TAG, mes)
-                promise.reject(mes)
-            }
-        } else {
-            val mes = "\"migrateOfflineCache only supported on api level 26 or later\""
-            Log.w(LOG_TAG, "migrateOfflineCache only supported on api level 26 or later")
-            promise.reject(mes)
-        }
-    }
-}

package/android/src/main/java/com/rnmapbox/rnmbx/shape_animators/RNMBXMovePointShapeAnimatorModule.kt

@@ -1,55 +0,0 @@
-package com.rnmapbox.rnmbx.shape_animators
-
-import com.facebook.react.bridge.ReadableArray
-import com.rnmapbox.rnmbx.NativeRNMBXMovePointShapeAnimatorModuleSpec
-import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotation
-
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.module.annotations.ReactModule
-import com.google.gson.JsonObject
-import com.mapbox.geojson.GeoJson
-import com.mapbox.geojson.Point
-import com.rnmapbox.rnmbx.NativeRNMBXPointAnnotationModuleSpec
-import com.rnmapbox.rnmbx.utils.Logger
-import com.rnmapbox.rnmbx.utils.ViewTagResolver
-import org.json.JSONObject
-import java.util.Date
-import java.util.Timer
-import java.util.TimerTask
-import kotlin.time.Duration
-import kotlin.time.Duration.Companion.milliseconds
-import kotlin.time.DurationUnit
-
-
-/// Simple dummy animator that moves the point lng, lat by 0.01, 0.01 each second.
-class MovePointShapeAnimator(tag: Tag, val lng: Double, val lat: Double) : ShapeAnimatorCommon(tag) {
-   override fun getAnimatedShape(timeSinceStart: Duration): Pair<GeoJson, Boolean> {
-       return Pair(Point.fromLngLat(lng + timeSinceStart.toDouble(DurationUnit.SECONDS) * 0.01, lat + timeSinceStart.toDouble(DurationUnit.SECONDS) * 0.01), true);
-   }
-}
-
-
-@ReactModule(name = RNMBXMovePointShapeAnimatorModule.NAME)
-class RNMBXMovePointShapeAnimatorModule(reactContext: ReactApplicationContext?, val shapeAnimatorManager: ShapeAnimatorManager) :
-    NativeRNMBXMovePointShapeAnimatorModuleSpec(reactContext) {
-
-    companion object {
-        const val LOG_TAG = "RNMBXMovePointShapeAnimatorModule"
-        const val NAME = "RNMBXMovePointShapeAnimatorModule"
-    }
-
-    @ReactMethod
-    override fun start(tag: Double, promise: Promise?) {
-        shapeAnimatorManager?.get(tag.toLong())?.let {
-            it.start()
-        }
-    }
-
-    @ReactMethod
-    override fun create(tag: Double, from: ReadableArray, promise: Promise) {
-        shapeAnimatorManager.add(MovePointShapeAnimator(tag.toLong(), from.getDouble(0), from.getDouble(1)))
-        promise.resolve(tag.toInt())
-    }
-}

package/android/src/main/java/com/rnmapbox/rnmbx/shape_animators/ShapeAnimatorCommon.kt

@@ -1,110 +0,0 @@
-package com.rnmapbox.rnmbx.shape_animators
-
-import com.facebook.react.bridge.UiThreadUtil.runOnUiThread
-import com.mapbox.geojson.GeoJson
-import com.rnmapbox.rnmbx.utils.Logger
-import org.json.JSONObject
-import java.util.Date
-import java.util.Timer
-import java.util.TimerTask
-import kotlin.time.Duration
-import kotlin.time.Duration.Companion.milliseconds
-
-typealias Tag = Long
-
-interface ShapeAnimationConsumer {
-    fun shapeUpdated(geoJson: GeoJson)
-}
-abstract class ShapeAnimator(val tag: Tag) {
-
-    abstract fun getShape(): GeoJson;
-    abstract fun start()
-
-    abstract fun subscribe(consumer: ShapeAnimationConsumer)
-    abstract fun unsubscribe(consumer: ShapeAnimationConsumer)
-}
-
-abstract class ShapeAnimatorCommon(tag: Tag): ShapeAnimator(tag) {
-    var timer: Timer? = null
-    var progress: Duration? = null
-
-    // region subscribers
-    var subscribers = mutableListOf<ShapeAnimationConsumer>()
-
-    override fun subscribe(consumer: ShapeAnimationConsumer) {
-        subscribers.add(consumer)
-    }
-
-    override fun unsubscribe(consumer: ShapeAnimationConsumer) {
-        subscribers.remove(consumer)
-    }
-    // endregion
-
-    override fun start() {
-        timer?.let { it.cancel() }
-        timer = null
-
-        val fps = 30.0
-        val period = (1000.0 / fps).toLong()
-        val start = Date()
-        val timer = Timer()
-        this.timer = timer
-        val animator = this
-
-        timer.schedule(object : TimerTask() {
-            override fun run() {
-
-                val now = Date()
-                val diff = now.time - start.time
-                val progress = diff.milliseconds
-                animator.progress = progress
-
-                val (shape,doContinue) = getAnimatedShape(progress)
-                if (!doContinue) {
-                    timer.cancel()
-                }
-                runOnUiThread {
-                    subscribers.forEach { it.shapeUpdated(shape) }
-                }
-            }
-        },0, period)
-    }
-
-    override fun getShape(): GeoJson {
-        return getAnimatedShape(progress ?: 0.0.milliseconds).first
-    }
-    abstract fun getAnimatedShape(timeSinceStart: Duration): Pair<GeoJson,Boolean>
-
-}
-class ShapeAnimatorManager {
-    private val animators = hashMapOf<Tag, ShapeAnimator>();
-    fun add(animator: ShapeAnimator) {
-        animators.put(animator.tag, animator)
-    }
-
-    fun isShapeAnimatorTag(shape: String): Boolean {
-        return shape.startsWith("{\"__nativeTag\":")
-    }
-
-    fun get(tag: String): ShapeAnimator? {
-        if (isShapeAnimatorTag(tag)) {
-            val obj = JSONObject(tag)
-            val tag = obj.getLong("__nativeTag")
-            return get(tag);
-        }
-        else {
-            return null
-        }
-    }
-    fun get(tag: Tag): ShapeAnimator? {
-        val result = animators[tag]
-        if (result == null) {
-            Logger.e(LOG_TAG, "Shape animator for tag: $tag was not found")
-        }
-        return result
-    }
-
-    companion object {
-        const val LOG_TAG = "RNMBXShapeAnimators"
-    }
-}

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

@@ -1,15 +0,0 @@
-package com.rnmapbox.rnmbx.v11compat
-/**
- * Allows to cancel the associated asynchronous operation
- *
- * The associated asynchronous operation is not automatically canceled if this
- * object goes out of scope.
- */
-interface Cancelable {
-    /**
-     * Cancels the associated asynchronous operation
-     *
-     * If the associated asynchronous operation has already finished, this call is ignored.
-     */
-    fun cancel()
-}

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

@@ -1,7 +0,0 @@
-package com.rnmapbox.rnmbx.v11compat.layer;
-
-import com.mapbox.maps.extension.style.layers.Layer
-
-fun Layer.slot(slot: String) {
-    // V11 only
-}