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

package/android/src/main/java/com/rnmapbox/rnmbx/utils/DownloadMapImageTask.kt

@@ -0,0 +1,121 @@
+package com.rnmapbox.rnmbx.utils
+
+import android.content.Context
+import android.graphics.Bitmap
+import com.mapbox.maps.Style
+import com.mapbox.maps.MapboxMap
+import android.os.AsyncTask
+import com.rnmapbox.rnmbx.utils.ImageEntry
+import android.util.DisplayMetrics
+import android.graphics.BitmapFactory
+import android.net.Uri
+import android.util.Log
+import com.facebook.common.logging.FLog
+import com.facebook.common.references.CloseableReference
+import com.facebook.datasource.DataSources
+import com.facebook.drawee.backends.pipeline.Fresco
+import com.facebook.imagepipeline.common.RotationOptions
+import com.facebook.imagepipeline.image.CloseableImage
+import com.facebook.imagepipeline.image.CloseableStaticBitmap
+import com.facebook.imagepipeline.request.ImageRequestBuilder
+import com.facebook.react.views.imagehelper.ImageSource
+import com.rnmapbox.rnmbx.components.images.ImageInfo
+import com.rnmapbox.rnmbx.components.images.ImageManager
+import java.io.File
+import java.lang.ref.WeakReference
+import java.util.HashMap
+import com.rnmapbox.rnmbx.v11compat.image.*
+
+data class DownloadedImage(val name: String, val bitmap: Bitmap, val info: ImageInfo)
+
+class DownloadMapImageTask(context: Context, map: MapboxMap, imageManager: ImageManager?, callback: OnAllImagesLoaded? = null) :
+    AsyncTask<Map.Entry<String, ImageEntry>, Void?, List<DownloadedImage>>() {
+    private val mContext: WeakReference<Context>
+    private val mMap: WeakReference<MapboxMap>
+    private val mCallback: OnAllImagesLoaded?
+    private val mCallerContext: Any
+    private val mImageManager: WeakReference<ImageManager>
+
+    interface OnAllImagesLoaded {
+        fun onAllImagesLoaded()
+    }
+
+    @SafeVarargs
+    protected override fun doInBackground(vararg objects: Map.Entry<String, ImageEntry>): List<DownloadedImage> {
+        val images = mutableListOf<DownloadedImage>()
+        val context = mContext.get() ?: return images
+        val resources = context.resources
+        val metrics = resources.displayMetrics
+        for ((key, imageEntry) in objects) {
+            var uri = imageEntry.uri
+            if (uri.startsWith("/")) {
+                uri = Uri.fromFile(File(uri)).toString()
+            }
+            val source = ImageSource(context, uri)
+            val request = ImageRequestBuilder.newBuilderWithSource(source.uri)
+                .setRotationOptions(RotationOptions.autoRotate())
+                .build()
+            val dataSource =
+                Fresco.getImagePipeline().fetchDecodedImage(request, mCallerContext)
+            var result: CloseableReference<CloseableImage>? = null
+            try {
+                result = DataSources.waitForFinalResult(dataSource)
+                if (result != null) {
+                    val image = result.get()
+                    if (image is CloseableStaticBitmap) {
+                        val bitmap =
+                            image.underlyingBitmap // Copy the bitmap to make sure it doesn't get recycled when we release
+                                // the fresco reference.
+                                .copy(Bitmap.Config.ARGB_8888, true)
+                        Log.e("RNMBXImageManager", "downloadImage: $key $uri $image ${image.width}x${image.height}")
+                        bitmap.density = DisplayMetrics.DENSITY_DEFAULT
+                        images.add(
+                            DownloadedImage(name=key, bitmap=bitmap, info=imageEntry.info)
+                        )
+                    } else {
+                        FLog.e(LOG_TAG, "Failed to load bitmap from: $uri")
+                    }
+                } else {
+                    FLog.e(LOG_TAG, "Failed to load bitmap from: $uri")
+                }
+            } catch (e: Throwable) {
+                Log.w(LOG_TAG, e.localizedMessage)
+            } finally {
+                dataSource.close()
+                if (result != null) {
+                    CloseableReference.closeSafely(result)
+                }
+            }
+        }
+        return images
+    }
+
+    override fun onPostExecute(images: List<DownloadedImage>) {
+        val map = mMap.get()
+        if (map != null && images != null && images.size > 0) {
+            val style = map.getStyle()
+            if (style != null) {
+                val bitmapImages = HashMap<String, Bitmap>()
+                for (image in images) {
+                    bitmapImages[image.name] = image.bitmap
+                    val info = image.info
+                    mImageManager.get()?.resolve(image.name, image.bitmap)
+                    style.addBitmapImage(image.name, image.bitmap, info)
+                }
+            }
+        }
+        mCallback?.onAllImagesLoaded()
+    }
+
+    companion object {
+        const val LOG_TAG = "DownloadMapImageTask"
+    }
+
+    init {
+        mContext = WeakReference(context.applicationContext)
+        mMap = WeakReference(map)
+        mImageManager = WeakReference(imageManager)
+        mCallback = callback
+        mCallerContext = this
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/ExpressionParser.java

@@ -0,0 +1,73 @@
+package com.rnmapbox.rnmbx.utils;
+
+import com.facebook.react.bridge.ReadableArray;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.mapbox.maps.extension.style.expressions.generated.Expression;
+
+import java.util.Locale;
+
+import javax.annotation.Nullable;
+
+public class ExpressionParser {
+  static final String TYPE_STRING = "string";
+  static final String TYPE_ARRAY = "array";
+  static final String TYPE_NUMBER = "number";
+  static final String TYPE_MAP = "hashmap";
+  static final String TYPE_BOOL = "boolean";
+
+  public static @Nullable Expression from(@Nullable  ReadableArray rawExpressions) {
+    if (rawExpressions == null || rawExpressions.size() == 0) {
+      return null;
+    }
+
+    JsonArray array = ConvertUtils.toJsonArray(rawExpressions);
+    String jsonString = new Gson().toJson(array);
+    return Expression.fromRaw(jsonString);
+  }
+
+  public static @Nullable Expression fromTyped(ReadableMap rawExpressions) {
+    JsonArray array = (JsonArray)ConvertUtils.typedToJsonElement(rawExpressions);
+    String jsonString = new Gson().toJson(array);
+    return Expression.fromRaw(jsonString);
+  }
+
+  public static Expression from(ReadableMap rawExpression) {
+    return Expression.fromRaw("[" + stringExpression(rawExpression) + "]");
+  }
+
+  private static String stringExpression(ReadableMap item) {
+    String expression = "";
+    String type = item.getString("type");
+
+    if (TYPE_STRING.equals(type)) {
+      String value = item.getString("value");
+      expression = String.format(Locale.ENGLISH, "\"%s\"", value);
+    } else if (TYPE_NUMBER.equals(type)) {
+      Double value = item.getDouble("value");
+      expression = String.format(Locale.ENGLISH, "%f", value);
+    } else if (TYPE_BOOL.equals(type)) {
+      Boolean value = item.getBoolean("value");
+      expression = String.format(Locale.ENGLISH, "%b", value);
+    } else if (TYPE_ARRAY.equals(type)) {
+      ReadableArray entries = item.getArray("value");
+
+      expression += "[";
+
+      for (int i = 0; i < entries.size(); i++) {
+        String entryExpression = stringExpression(entries.getMap(i));
+        expression += entryExpression;
+
+        if (i < entries.size() - 1) {
+          expression += ",";
+        }
+      }
+
+      expression += "]";
+    }
+
+    return expression;
+  }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/GeoJSONUtils.kt

@@ -0,0 +1,225 @@
+package com.rnmapbox.rnmbx.utils
+
+import android.location.Location
+import android.location.LocationManager
+import com.facebook.react.bridge.*
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils
+import com.mapbox.geojson.*
+import com.mapbox.maps.CoordinateBounds
+import com.mapbox.maps.CameraBounds
+import com.rnmapbox.rnmbx.utils.LatLngBounds
+import com.mapbox.turf.TurfMeasurement
+import com.rnmapbox.rnmbx.utils.LatLngQuad
+import com.rnmapbox.rnmbx.utils.extensions.toReadableArray
+import java.util.ArrayList
+
+
+
+object GeoJSONUtils {
+    @JvmStatic
+    fun fromFeature(feature: Feature): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "Feature")
+        map.putString("id", feature.id())
+        feature.geometry()?.also {
+            val geometry = fromGeometry(it)
+            map.putMap("geometry", geometry)
+        } ?: run {
+            Logger.w(
+                LOG_TAG,
+                "GeoJSONUtils.fromFeature geometry was null for feature: ${feature.toJson()}"
+            )
+        }
+        val properties = ConvertUtils.toWritableMap(feature.properties())
+        map.putMap("properties", properties)
+        return map
+    }
+
+    fun fromGeometry(geometry: Geometry): WritableMap? {
+        val type = geometry.type()
+        val coordinates : WritableArray = when (type) {
+            "Point" -> coordinates(geometry as Point)
+            "LineString" -> coordinatesL((geometry as LineString).coordinates())
+            "Polygon" -> coordinatesLL((geometry as Polygon).coordinates())
+            "MultiLineString" -> coordinatesLL((geometry as MultiLineString).coordinates())
+            "MultiPolygon" -> coordinatesLLL((geometry as MultiPolygon).coordinates())
+            "GeometryCollection" -> {
+                return multiGeometry(type,
+                    Arguments.fromList((geometry as GeometryCollection).geometries().map {
+                        fromGeometry(it)
+                    })
+                )
+            }
+            else -> {
+                Logger.w(LOG_TAG, "GeoJSONUtils.fromGeometry unsupported type:$type")
+                return null
+            }
+        }
+        return geometry(type, coordinates);
+    }
+
+    private fun multiGeometry(type: String, geometries: WritableArray):WritableMap {
+        val map = Arguments.createMap();
+        map.putString("type", type);
+        map.putArray("geometries", geometries);
+        return map
+    }
+    private fun geometry(type: String, coordinates: WritableArray):WritableMap {
+        val map = Arguments.createMap();
+        map.putString("type", type);
+        map.putArray("coordinates", coordinates);
+        return map
+    }
+
+    private fun coordinates(point: Point): WritableArray {
+        return Arguments.fromArray(pointToDoubleArray(point))
+    }
+
+    private fun fromList(items: List<ReadableArray>): WritableArray {
+        val ret = WritableNativeArray();
+        items.forEach {
+            ret.pushArray(it)
+        }
+        return ret;
+    }
+
+    private fun coordinatesL(points: List<Point>): WritableArray {
+        return fromList(points.map { it.toReadableArray() })
+    }
+
+    private fun coordinatesLL(points: List<List<Point>>): WritableArray {
+        return fromList(points.map { coordinatesL(it) })
+    }
+
+    private fun coordinatesLLL(points: List<List<List<Point>>>): WritableArray {
+        return fromList(points.map { coordinatesLL(it) })
+    }
+
+    @JvmStatic
+    fun toPointFeature(latLng: LatLng, properties: WritableMap?): WritableMap {
+        val map: WritableMap = WritableNativeMap()
+        map.putString("type", "Feature")
+        map.putMap("geometry", toPointGeometry(latLng))
+        map.putMap("properties", properties)
+        return map
+    }
+
+    fun toPointGeometry(latLng: LatLng): WritableMap {
+        val geometry: WritableMap = WritableNativeMap()
+        geometry.putString("type", "Point")
+        geometry.putArray("coordinates", fromLatLng(latLng))
+        return geometry
+    }
+
+    fun fromLatLng(latLng: LatLng): WritableArray {
+        val coords = doubleArrayOf(latLng.getLongitude(), latLng.getLatitude())
+        val writableCoords: WritableArray = WritableNativeArray()
+        writableCoords.pushDouble(coords[0])
+        writableCoords.pushDouble(coords[1])
+        return writableCoords
+    }
+
+    fun toLatLng(point: Point): LatLng {
+        return LatLng(point.latitude(), point.longitude())
+    }
+
+    fun toLatLng(coordinates: ReadableArray?): LatLng? {
+        return if (coordinates == null || coordinates.size() < 2) {
+            null
+        } else LatLng(coordinates.getDouble(1), coordinates.getDouble(0))
+    }
+
+    @JvmStatic
+    fun toPointGeometry(featureJSONString: String?): Point? {
+        val feature = Feature.fromJson(featureJSONString!!) ?: return null
+        return feature.geometry() as Point?
+    }
+
+    fun fromCoordinateBounds(bounds: CoordinateBounds): WritableArray {
+        val array = Arguments.createArray()
+        val ne = bounds.northeast
+        val sw = bounds.southwest
+
+        array.pushArray(fromLatLng(LatLng(ne.latitude(), ne.longitude())));
+        array.pushArray(fromLatLng(LatLng(sw.latitude(), sw.longitude())));
+        return array
+    }
+
+    fun fromCameraBounds(bounds: CameraBounds): WritableArray {
+        return fromCoordinateBounds(bounds.bounds)
+    }
+
+    fun fromLatLngBounds(latLngBounds: LatLngBounds): WritableArray {
+        val array = Arguments.createArray()
+        val latLngs = latLngBounds.toLatLngs()
+        for (latLng in latLngs) {
+            array.pushArray(fromLatLng(latLng))
+        }
+        return array
+    }
+
+    fun fromLatLngBoundsToPolygon(latLngBounds: LatLngBounds): Polygon {
+        val contours = ArrayList<List<Point>>()
+        val contour = ArrayList<Point>()
+        contour.add(Point.fromLngLat(latLngBounds.lonEast, latLngBounds.latNorth))
+        contour.add(Point.fromLngLat(latLngBounds.lonEast, latLngBounds.latSouth))
+        contour.add(Point.fromLngLat(latLngBounds.lonWest, latLngBounds.latSouth))
+        contour.add(Point.fromLngLat(latLngBounds.lonWest, latLngBounds.latNorth))
+        contour.add(Point.fromLngLat(latLngBounds.lonEast, latLngBounds.latNorth))
+        contours.add(contour)
+        return Polygon.fromLngLats(contours)
+    }
+
+    private fun toGeometryCollection(features: List<Feature>?): GeometryCollection {
+        val geometries = ArrayList<Geometry?>()
+        geometries.ensureCapacity(features!!.size)
+        for (feature in features) {
+            geometries.add(feature.geometry())
+        }
+        return GeometryCollection.fromGeometries(geometries)
+    }
+
+    @JvmStatic
+    fun toLatLngBounds(featureCollection: FeatureCollection): LatLngBounds {
+        val features = featureCollection.features()
+        val bbox = TurfMeasurement.bbox(toGeometryCollection(features))
+        return LatLngBounds.from(bbox[3], bbox[2], bbox[1], bbox[0])
+    }
+
+    @JvmStatic
+    fun toLatLngQuad(array: ReadableArray?): LatLngQuad? {
+        // [top left, top right, bottom right, bottom left]
+        return if (array == null || array.size() < 4) {
+            null
+        } else LatLngQuad(
+            toLatLng(array.getArray(0)),
+            toLatLng(array.getArray(1)),
+            toLatLng(array.getArray(2)),
+            toLatLng(array.getArray(3))
+        )
+    }
+
+    fun pointToDoubleArray(point: Point?): DoubleArray {
+        return if (point == null) {
+            doubleArrayOf(0.0, 0.0)
+        } else doubleArrayOf(point.longitude(), point.latitude())
+    }
+
+    @JvmStatic
+    fun toPoint(location: Location): Point {
+        return Point.fromLngLat(location.longitude, location.latitude)
+    }
+
+    @JvmStatic
+    fun toLocation(point: Point): Location {
+        val result = Location(LocationManager.GPS_PROVIDER)
+        result.latitude = point.latitude()
+        result.longitude = point.longitude()
+        if (point.hasAltitude()) {
+            result.altitude = point.altitude()
+        }
+        return result
+    }
+
+    const val LOG_TAG = "GeoJSONUtils"
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/ImageEntry.kt

@@ -0,0 +1,9 @@
+package com.rnmapbox.rnmbx.utils
+
+import com.rnmapbox.rnmbx.components.images.ImageInfo
+
+data class ImageEntry(val uri: String, val info: ImageInfo) {
+    fun getScaleOr(v: Double): Double {
+        return info.getScaleOr(v)
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/LatLng.java

@@ -0,0 +1,51 @@
+package com.rnmapbox.rnmbx.utils;
+
+
+import com.mapbox.geojson.Point;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LatLng {
+  double latitude;
+  double longitude;
+
+  public LatLng(double latitude, double longitude) {
+    this.latitude = latitude;
+    this.longitude = longitude;
+  }
+
+  public LatLng(Point point) {
+    this.latitude = point.latitude();
+    this.longitude = point.longitude();
+  }
+
+  public Point getPoint() {
+    return Point.fromLngLat(this.longitude, this.latitude);
+  }
+
+  public List<Double> getArray() {
+    ArrayList<Double> ret = new ArrayList<>();
+    ret.add(this.longitude);
+    ret.add(this.latitude);
+    return ret;
+  }
+
+  public double getLongitude() {
+    return longitude;
+  }
+
+  public double getLatitude() {
+    return latitude;
+  }
+
+  double latitude() {
+    return latitude;
+  }
+
+  double longitude() {
+    return longitude;
+  }
+
+  
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/LatLngBounds.kt

@@ -0,0 +1,35 @@
+package com.rnmapbox.rnmbx.utils
+
+import com.mapbox.geojson.Point
+import com.mapbox.maps.CoordinateBounds
+import com.rnmapbox.rnmbx.utils.LatLngBounds
+
+class LatLngBounds internal constructor(
+    var latNorth: Double,
+    var lonEast: Double,
+    var latSouth: Double,
+    var lonWest: Double
+) {
+    val southWest: LatLng
+        get() = LatLng(latSouth, lonWest)
+    val northEast: LatLng
+        get() = LatLng(latNorth, lonEast)
+
+    fun toLatLngs(): Array<LatLng> {
+        return arrayOf(northEast, southWest)
+    }
+
+    fun toBounds(): CoordinateBounds {
+        return CoordinateBounds(
+            Point.fromLngLat(lonWest, latSouth),
+            Point.fromLngLat(lonEast, latNorth),
+            false
+        )
+    }
+
+    companion object {
+        fun from(bbox: Double, bbox1: Double, bbox2: Double, bbox3: Double): LatLngBounds {
+            return LatLngBounds(bbox, bbox1, bbox2, bbox3)
+        }
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/LatLngQuad.java

@@ -0,0 +1,27 @@
+package com.rnmapbox.rnmbx.utils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LatLngQuad {
+    private final LatLng topLeft;
+    private final LatLng topRight;
+    private final LatLng bottomRight;
+    private final LatLng bottomLeft;
+
+    public LatLngQuad(LatLng topLeft, LatLng topRight, LatLng bottomRight, LatLng bottomLeft) {
+        this.topLeft = topLeft;
+        this.topRight = topRight;
+        this.bottomRight = bottomRight;
+        this.bottomLeft = bottomLeft;
+    }
+
+    public List<List<Double>> getCoordinates() {
+        ArrayList<List<Double>> result = new ArrayList<>();
+        result.add(topLeft.getArray());
+        result.add(topRight.getArray());
+        result.add(bottomRight.getArray());
+        result.add(bottomLeft.getArray());
+        return result;
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/Logger.kt

@@ -0,0 +1,120 @@
+package com.rnmapbox.rnmbx.utils
+
+import android.util.Log
+import com.rnmapbox.rnmbx.utils.Logger.LoggerDefinition
+
+object Logger {
+    var logger: LoggerDefinition = object : LoggerDefinition {
+        override fun v(tag: String, msg: String) {
+            Log.v(tag, msg!!)
+        }
+
+        override fun v(tag: String, msg: String, tr: Throwable) {
+            Log.v(tag, msg, tr)
+        }
+
+        override fun d(tag: String, msg: String) {
+            Log.d(tag, msg!!)
+        }
+
+        override fun d(tag: String, msg: String, tr: Throwable) {
+            Log.d(tag, msg!!)
+        }
+
+        override fun i(tag: String, msg: String) {
+            Log.i(tag, msg!!)
+        }
+
+        override fun i(tag: String, msg: String, tr: Throwable) {
+            Log.i(tag, msg, tr)
+        }
+
+        override fun w(tag: String, msg: String) {
+            Log.w(tag, msg!!)
+        }
+
+        override fun w(tag: String, msg: String, tr: Throwable) {
+            Log.w(tag, msg!!)
+        }
+
+        override fun e(tag: String, msg: String) {
+            Log.e(tag, msg!!)
+        }
+
+        override fun e(tag: String, msg: String, tr: Throwable) {
+            Log.e(tag, msg, tr)
+        }
+    }
+
+    fun setVerbosity(logLevel: Int) {
+        Logger.logLevel = logLevel
+    }
+
+    fun setLoggerDefinition(dest: LoggerDefinition) {
+        logger = dest
+    }
+
+    private var logLevel = 0
+    fun d(tag: String, msg: String) {
+        if (logLevel <= Log.DEBUG) {
+            logger.d(tag, msg)
+        }
+    }
+
+    fun v(tag: String, msg: String) {
+        if (logLevel <= Log.VERBOSE) {
+            logger.v(tag, msg)
+        }
+    }
+
+    fun i(tag: String, msg: String) {
+        if (logLevel <= Log.INFO) {
+            logger.i(tag, msg)
+        }
+    }
+
+    fun w(tag: String, msg: String) {
+        if (logLevel <= Log.VERBOSE) {
+            logger.w(tag, msg)
+        }
+    }
+
+    fun w(tag: String, msg: String, tr: Throwable) {
+        if (logLevel <= Log.VERBOSE) {
+            logger.w(tag, msg, tr)
+        }
+    }
+
+    fun e(tag: String, msg: String) {
+        if (logLevel <= Log.ERROR) {
+            logger.e(tag, msg)
+        }
+    }
+
+    fun e(tag: String, msg: String, tr: Throwable) {
+        if (logLevel <= Log.ERROR) {
+            logger.e(tag, msg, tr)
+        }
+    }
+
+    fun logged(tag:String, callback: () -> Unit) {
+        try {
+            callback()
+        } catch (error: Exception) {
+            Logger.e(tag, "Exception - error: $error")
+        }
+    }
+
+    interface LoggerDefinition {
+        fun v(tag: String, msg: String)
+        fun v(tag: String, msg: String, tr: Throwable)
+        fun d(tag: String, msg: String)
+        fun d(tag: String, msg: String, tr: Throwable)
+        fun i(tag: String, msg: String)
+        fun i(tag: String, msg: String, tr: Throwable)
+        fun w(tag: String, msg: String)
+        fun w(tag: String, msg: String, tr: Throwable)
+        fun e(tag: String, msg: String)
+        fun e(tag: String, msg: String, tr: Throwable)
+    }
+}