@rnmapbox/maps 10.0.0-beta.28

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/DownloadMapImageTask.kt

@@ -0,0 +1,151 @@
+package com.mapbox.rctmgl.utils
+
+import android.content.Context
+import android.graphics.Bitmap
+import com.mapbox.maps.Style
+import com.mapbox.maps.MapboxMap
+import com.mapbox.rctmgl.utils.DownloadMapImageTask.OnAllImagesLoaded
+import android.os.AsyncTask
+import com.mapbox.rctmgl.utils.ImageEntry
+import android.util.DisplayMetrics
+import com.mapbox.rctmgl.utils.DownloadMapImageTask
+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 java.io.File
+import java.lang.ref.WeakReference
+import java.util.AbstractMap
+import java.util.ArrayList
+import java.util.HashMap
+
+class DownloadMapImageTask(context: Context, map: MapboxMap, callback: OnAllImagesLoaded?) :
+    AsyncTask<Map.Entry<String, ImageEntry>, Void?, List<Map.Entry<String, Bitmap>>?>() {
+    private val mContext: WeakReference<Context>
+    private val mMap: WeakReference<MapboxMap>
+    private val mCallback: OnAllImagesLoaded?
+    private val mCallerContext: Any
+
+    interface OnAllImagesLoaded {
+        fun onAllImagesLoaded()
+    }
+
+    @SafeVarargs
+    protected override fun doInBackground(vararg objects: Map.Entry<String, ImageEntry>): List<Map.Entry<String, Bitmap>>? {
+        val images: MutableList<Map.Entry<String, Bitmap>> = ArrayList()
+        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()
+            }
+            if (uri.startsWith("http://") || uri.startsWith("https://") ||
+                uri.startsWith("file://") || uri.startsWith("asset://") || uri.startsWith("data:")
+            ) {
+                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)
+                            bitmap.density =
+                                (DisplayMetrics.DENSITY_DEFAULT.toDouble() * imageEntry.getScaleOr(
+                                    1.0
+                                )).toInt()
+                            images.add(
+                                AbstractMap.SimpleEntry(
+                                    key, bitmap
+                                )
+                            )
+                        } 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)
+                    }
+                }
+            } else {
+                // local asset required from JS require('image.png') or import icon from 'image.png' while in release mode
+                val bitmap = BitmapUtils.getBitmapFromResource(
+                    context,
+                    uri,
+                    getBitmapOptions(metrics, imageEntry.scale)
+                )
+                if (bitmap != null) {
+                    images.add(
+                        AbstractMap.SimpleEntry(
+                            key, bitmap
+                        )
+                    )
+                } else {
+                    FLog.e(LOG_TAG, "Failed to load bitmap from: $uri")
+                }
+            }
+        }
+        return images
+    }
+
+    override fun onPostExecute(images: List<Map.Entry<String, Bitmap>>?) {
+        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 ((key, value) in images) {
+                    bitmapImages[key] = value
+                    style.addImage(key, value)
+                }
+                // style.addImages(bitmapImages);
+            }
+        }
+        mCallback?.onAllImagesLoaded()
+    }
+
+    private fun getBitmapOptions(metrics: DisplayMetrics, scale: Double): BitmapFactory.Options {
+        val options = BitmapFactory.Options()
+        options.inScreenDensity = metrics.densityDpi
+        options.inTargetDensity = metrics.densityDpi
+        if (scale != ImageEntry.defaultScale) {
+            options.inDensity = (DisplayMetrics.DENSITY_DEFAULT.toDouble() * scale).toInt()
+        }
+        return options
+    }
+
+    companion object {
+        const val LOG_TAG = "DownloadMapImageTask"
+    }
+
+    init {
+        mContext = WeakReference(context.applicationContext)
+        mMap = WeakReference(map)
+        mCallback = callback
+        mCallerContext = this
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/ExpressionParser.java

@@ -0,0 +1,73 @@
+package com.mapbox.rctmgl.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/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/GeoJSONUtils.kt

@@ -0,0 +1,217 @@
+package com.mapbox.rctmgl.utils
+
+import android.location.Location
+import android.location.LocationManager
+import com.facebook.react.bridge.*
+import com.mapbox.rctmgl.utils.GeoJSONUtils
+import com.mapbox.geojson.*
+import com.mapbox.maps.CoordinateBounds
+import com.mapbox.maps.CameraBounds
+import com.mapbox.rctmgl.utils.LatLngBounds
+import com.mapbox.turf.TurfMeasurement
+import com.mapbox.rctmgl.utils.LatLngQuad
+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())
+        val geometry = fromGeometry(feature.geometry())
+        map.putMap("geometry", geometry)
+        val properties = ConvertUtils.toWritableMap(feature.properties())
+        map.putMap("properties", properties)
+        return map
+    }
+
+    fun fromGeometry(geometry: Geometry?): WritableMap? {
+        val type = geometry!!.type()
+        return when (type) {
+            "Point" -> fromPoint(geometry as Point?)
+            "LineString" -> fromLineString(geometry as LineString?)
+            "Polygon" -> fromPolygon(geometry as Polygon?)
+            else -> null
+        }
+    }
+
+    fun fromPoint(point: Point?): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "Point")
+        map.putArray("coordinates", getCoordinates(point))
+        return map
+    }
+
+    fun fromLineString(lineString: LineString?): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "LineString")
+        map.putArray("coordinates", getCoordinates(lineString))
+        return map
+    }
+
+    fun fromPolygon(polygon: Polygon?): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "Polygon")
+        map.putArray("coordinates", getCoordinates(polygon))
+        return map
+    }
+
+    fun getCoordinates(point: Point?): WritableArray {
+        return Arguments.fromArray(pointToDoubleArray(point))
+    }
+
+    fun getCoordinates(lineString: LineString?): WritableArray {
+        val array = Arguments.createArray()
+        val points = lineString!!.coordinates()
+        for (point in points) {
+            array.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+        }
+        return array
+    }
+
+    fun getCoordinates(polygon: Polygon?): WritableArray {
+        val array = Arguments.createArray()
+        val points = polygon!!.coordinates()
+            ?: return array
+        for (curPoint in points) {
+            val innerArray = Arguments.createArray()
+            for (point in curPoint) {
+                innerArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+            }
+            array.pushArray(innerArray)
+        }
+        return array
+    }
+
+    @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
+        val latLngs = arrayOf(
+            LatLng(ne.latitude(), ne.longitude()),
+            LatLng(ne.latitude(), sw.longitude()),
+            LatLng(sw.latitude(), sw.longitude()),
+            LatLng(sw.latitude(), ne.longitude())
+        )
+        for (latLng in latLngs) {
+            array.pushArray(fromLatLng(latLng))
+        }
+        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
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/ImageEntry.java

@@ -0,0 +1,25 @@
+package com.mapbox.rctmgl.utils;
+
+public class ImageEntry {
+    public String uri;
+    public double scale = 1.0;
+    public static final double defaultScale = 0.0;
+
+    public ImageEntry(String _uri, Double _scale) {
+        uri = _uri;
+        scale = _scale;
+    }
+
+    public ImageEntry(String _uri) {
+        uri = _uri;
+        scale = ImageEntry.defaultScale;
+    }
+
+    public double getScaleOr(double v) {
+        if (scale == ImageEntry.defaultScale) {
+            return v;
+        } else {
+            return scale;
+        }
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/LatLng.java

@@ -0,0 +1,51 @@
+package com.mapbox.rctmgl.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/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/LatLngBounds.java

@@ -0,0 +1,42 @@
+package com.mapbox.rctmgl.utils;
+
+import com.mapbox.geojson.Point;
+import com.mapbox.maps.CoordinateBounds;
+
+public class LatLngBounds {
+  public static LatLngBounds from(double bbox, double bbox1, double bbox2, double bbox3) {
+    return new LatLngBounds(bbox, bbox1, bbox2, bbox3);
+  }
+
+  LatLng getSouthWest() {
+    return new LatLng(latSouth, lonWest);
+  }
+
+  LatLng getNorthEast() {
+    return new LatLng(latNorth, lonEast);
+  }
+
+  LatLng[] toLatLngs() {
+    return new LatLng[] {getNorthEast(), getSouthWest()};
+  }
+  
+  double latNorth;
+  double lonEast;
+  double latSouth;
+  double lonWest;
+
+  LatLngBounds(double latNorth,double lonEast, double latSouth, double lonWest) {
+    this.latNorth = latNorth;
+    this.lonEast = lonEast;
+    this.latSouth = latSouth;
+    this.lonWest = lonWest;
+  }
+
+  public CoordinateBounds toBounds() {
+    return new CoordinateBounds(
+            Point.fromLngLat(lonWest, latSouth),
+            Point.fromLngLat(lonEast, latNorth),
+            false
+    );
+  }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/utils/LatLngQuad.java

@@ -0,0 +1,27 @@
+package com.mapbox.rctmgl.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;
+    }
+}