@mapvina-com/mapvina-react-native 1.0.0

package/android/src/main/java/io/github/mapvina/reactnative/utils/GeoJSONUtils.kt

@@ -0,0 +1,368 @@
+package io.github.mapvina.reactnative.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import io.github.mapvina.android.geometry.LatLng
+import io.github.mapvina.android.geometry.LatLngBounds
+import io.github.mapvina.android.geometry.LatLngQuad
+import io.github.mapvina.android.log.Logger
+import io.github.mapvina.geojson.Feature
+import io.github.mapvina.geojson.FeatureCollection
+import io.github.mapvina.geojson.Geometry
+import io.github.mapvina.geojson.GeometryCollection
+import io.github.mapvina.geojson.LineString
+import io.github.mapvina.geojson.MultiLineString
+import io.github.mapvina.geojson.MultiPoint
+import io.github.mapvina.geojson.MultiPolygon
+import io.github.mapvina.geojson.Point
+import io.github.mapvina.geojson.Polygon
+import io.github.mapvina.turf.TurfMeasurement
+import java.util.stream.Collectors
+
+object GeoJSONUtils {
+    const val LOG_TAG: String = "GeoJSONUtils"
+
+    @JvmStatic
+    fun fromFeature(feature: Feature): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "Feature")
+        map.putString("id", feature.id())
+
+        val geometry = feature.geometry()
+        if (geometry == null) {
+            map.putNull("geometry")
+        } else {
+            map.putMap("geometry", fromGeometry(geometry))
+        }
+
+        val properties = feature.properties()
+        if (properties == null) {
+            map.putNull("properties")
+        } else {
+            map.putMap("properties", ConvertUtils.toWritableMap(properties))
+        }
+
+        return map
+    }
+
+    fun fromFeatureCollection(featureCollection: FeatureCollection): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "FeatureCollection")
+
+        map.putArray("features", fromFeatureList(featureCollection.features() ?: emptyList()))
+
+        return map
+    }
+
+    fun fromFeatureList(featureList: List<Feature>): WritableArray {
+        val featuresArray = Arguments.createArray()
+        featureList.forEach { feature ->
+            featuresArray.pushMap(fromFeature(feature))
+        }
+
+        return featuresArray
+    }
+
+    fun fromGeometry(geometry: Geometry): WritableMap? =
+        when (val type = geometry.type()) {
+            "Point" -> {
+                fromPoint(geometry as Point)
+            }
+
+            "LineString" -> {
+                fromLineString(geometry as LineString)
+            }
+
+            "Polygon" -> {
+                fromPolygon(geometry as Polygon)
+            }
+
+            "MultiPoint" -> {
+                fromMultiPoint(geometry as MultiPoint)
+            }
+
+            "MultiLineString" -> {
+                fromMultiLineString(geometry as MultiLineString)
+            }
+
+            "MultiPolygon" -> {
+                fromMultiPolygon(geometry as MultiPolygon)
+            }
+
+            "GeometryCollection" -> {
+                fromGeometryCollection(geometry as GeometryCollection)
+            }
+
+            else -> {
+                Logger.w(LOG_TAG, "GeoJSONUtils.fromGeometry unsupported type: \"$type\"")
+
+                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 fromMultiPoint(multiPoint: MultiPoint): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "MultiPoint")
+        map.putArray("coordinates", getCoordinates(multiPoint))
+        return map
+    }
+
+    fun fromMultiLineString(multiLineString: MultiLineString): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "MultiLineString")
+        map.putArray("coordinates", getCoordinates(multiLineString))
+        return map
+    }
+
+    fun fromMultiPolygon(multiPolygon: MultiPolygon): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "MultiPolygon")
+        map.putArray("coordinates", getCoordinates(multiPolygon))
+        return map
+    }
+
+    fun fromGeometryCollection(geometryCollection: GeometryCollection): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", "GeometryCollection")
+
+        map.putArray(
+            "geometries",
+            Arguments.fromList(
+                geometryCollection
+                    .geometries()
+                    .stream()
+                    .map<WritableMap?> { obj: Geometry -> fromGeometry(obj) }
+                    .collect(Collectors.toList()),
+            ),
+        )
+
+        return map
+    }
+
+    fun getCoordinates(point: Point?): WritableArray = 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()
+
+        for (curPoint in points) {
+            val innerArray = Arguments.createArray()
+
+            for (point in curPoint) {
+                innerArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+            }
+
+            array.pushArray(innerArray)
+        }
+
+        return array
+    }
+
+    fun getCoordinates(multiPoint: MultiPoint): WritableArray {
+        val array = Arguments.createArray()
+
+        val points = multiPoint.coordinates()
+        for (point in points) {
+            array.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+        }
+
+        return array
+    }
+
+    fun getCoordinates(multiLineString: MultiLineString): WritableArray {
+        val array = Arguments.createArray()
+
+        val lines = multiLineString.coordinates()
+        for (line in lines) {
+            val lineArray = Arguments.createArray()
+
+            for (point in line) {
+                lineArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+            }
+
+            array.pushArray(lineArray)
+        }
+
+        return array
+    }
+
+    fun getCoordinates(multiPolygon: MultiPolygon): WritableArray {
+        val array = Arguments.createArray()
+
+        val polygons = multiPolygon.coordinates()
+        for (polygon in polygons) {
+            val polygonArray = Arguments.createArray()
+
+            for (ring in polygon) {
+                val ringArray = Arguments.createArray()
+
+                for (point in ring!!) {
+                    ringArray.pushArray(Arguments.fromArray(pointToDoubleArray(point)))
+                }
+
+                polygonArray.pushArray(ringArray)
+            }
+
+            array.pushArray(polygonArray)
+        }
+
+        return array
+    }
+
+    @JvmStatic
+    fun toPointFeature(
+        latLng: LatLng,
+        properties: WritableMap?,
+    ): WritableMap {
+        val map: WritableMap =
+            Arguments.createMap().apply {
+                putString("type", "Feature")
+                putMap("geometry", toPointGeometry(latLng))
+                putMap("properties", properties)
+            }
+
+        return map
+    }
+
+    fun toPointGeometry(latLng: LatLng): WritableMap {
+        val geometry: WritableMap =
+            Arguments.createMap().apply {
+                putString("type", "Point")
+                putArray("coordinates", fromLatLng(latLng))
+            }
+
+        return geometry
+    }
+
+    @JvmStatic
+    fun fromLatLng(latLng: LatLng): WritableArray {
+        val coordinates: WritableArray =
+            Arguments.createArray().apply {
+                pushDouble(latLng.longitude)
+                pushDouble(latLng.latitude)
+            }
+
+        return coordinates
+    }
+
+    @JvmStatic
+    fun toLatLng(point: Point?): LatLng? {
+        if (point == null) {
+            return null
+        }
+        return LatLng(point.latitude(), point.longitude())
+    }
+
+    fun toLatLng(coordinates: ReadableArray?): LatLng? {
+        if (coordinates == null || coordinates.size() < 2) {
+            return null
+        }
+        return 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?
+    }
+
+    @JvmStatic
+    fun fromLatLngBounds(latLngBounds: LatLngBounds): WritableArray {
+        val array = Arguments.createArray()
+        array.pushDouble(latLngBounds.getLonWest())
+        array.pushDouble(latLngBounds.getLatSouth())
+        array.pushDouble(latLngBounds.getLonEast())
+        array.pushDouble(latLngBounds.getLatNorth())
+
+        return array
+    }
+
+    private fun toGeometryCollection(features: MutableList<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 toLatLngBounds(array: ReadableArray?): LatLngBounds? {
+        if (array != null && array.size() == 4) {
+            return LatLngBounds.from(
+                array.getDouble(3),
+                array.getDouble(2),
+                array.getDouble(1),
+                array.getDouble(0),
+            )
+        }
+
+        return null
+    }
+
+    @JvmStatic
+    fun toLatLngQuad(array: ReadableArray?): LatLngQuad? {
+        // [top left, top right, bottom right, bottom left]
+        if (array == null || array.size() < 4) {
+            return null
+        }
+        return LatLngQuad(
+            toLatLng(array.getArray(0))!!,
+            toLatLng(array.getArray(1))!!,
+            toLatLng(array.getArray(2))!!,
+            toLatLng(array.getArray(3))!!,
+        )
+    }
+
+    fun pointToDoubleArray(point: Point?): DoubleArray {
+        if (point == null) {
+            return doubleArrayOf(0.0, 0.0)
+        }
+        return doubleArrayOf(point.longitude(), point.latitude())
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/utils/GeoViewport.java

@@ -0,0 +1,37 @@
+package io.github.mapvina.reactnative.utils;
+
+import android.graphics.PointF;
+
+import io.github.mapvina.android.geometry.LatLng;
+import io.github.mapvina.android.geometry.LatLngBounds;
+import io.github.mapvina.android.geometry.VisibleRegion;
+
+/**
+ * Ported from https://github.com/mapbox/geo-viewport/blob/master/index.js
+ * This port only assumes we will have 512 vector tile sizes
+ */
+
+public class GeoViewport {
+    private static SphericalMercator sphericalMercator = new SphericalMercator();
+
+    public static VisibleRegion getRegion(LatLng centerCoord, int zoomLevel, int viewportWidth, int viewportHeight) {
+        PointF px = sphericalMercator.getPX(centerCoord, zoomLevel);
+
+        LatLng tl = sphericalMercator.getLatLng(new PointF(
+                px.x - (viewportWidth / 2),
+                px.y - (viewportHeight / 2)
+        ), zoomLevel);
+
+        LatLng br = sphericalMercator.getLatLng(new PointF(
+                px.x + (viewportWidth / 2),
+                px.y + (viewportHeight / 2)
+        ), zoomLevel);
+
+        LatLng farLeft = tl;
+        LatLng farRight = new LatLng(tl.getLatitude(), br.getLongitude());
+        LatLng nearLeft = new LatLng(br.getLatitude(), tl.getLongitude());
+        LatLng nearRight = br;
+
+        return new VisibleRegion(farLeft, farRight, nearLeft, nearRight, null);
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/utils/ImageEntry.kt

@@ -0,0 +1,14 @@
+package io.github.mapvina.reactnative.utils
+
+class ImageEntry(
+    @JvmField var uri: String?,
+    scale: Double?,
+    @JvmField var sdf: Boolean,
+) {
+    @JvmField
+    var scale: Double = scale ?: DEFAULT_SCALE
+
+    companion object {
+        const val DEFAULT_SCALE: Double = 1.0
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/utils/ReactTagResolver.kt

@@ -0,0 +1,91 @@
+package io.github.mapvina.reactnative.utils
+
+import android.view.View
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.uimanager.IllegalViewOperationException
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import io.github.mapvina.android.log.Logger
+
+data class Await<V>(
+    val fn: (V) -> Unit,
+    val reject: Promise?,
+)
+
+const val LOG_TAG = "ReactTagResolver"
+
+typealias ReactTag = Double
+
+// https://github.com/rnmapbox/maps/pull/3074
+open class ReactTagResolver(
+    val context: ReactApplicationContext,
+) {
+    private val createdViews: HashSet<Int> = hashSetOf<Int>()
+    private val awaitedViews: HashMap<Int, MutableList<Await<View?>>> = hashMapOf()
+
+    // To be called from view.setId
+    fun tagAssigned(reactTag: Int) {
+        createdViews.add(reactTag)
+
+        val list = awaitedViews[reactTag]
+        if (list != null) {
+            context.runOnUiQueueThread {
+                try {
+                    val view = manager.resolveView(reactTag)
+
+                    list.forEach { it.fn(view) }
+                } catch (err: IllegalViewOperationException) {
+                    list.forEach { it.reject?.reject(err) }
+                }
+                awaitedViews.remove(reactTag)
+            }
+        }
+    }
+
+    fun viewRemoved(reactTag: Int) {
+        awaitedViews.remove(reactTag)
+        createdViews.remove(reactTag)
+    }
+
+    private val manager: UIManager
+        get() = UIManagerHelper.getUIManager(context, UIManagerType.FABRIC)!!
+
+    fun <V> withViewResolved(
+        reactTag: Int,
+        promise: Promise? = null,
+        fn: (V) -> Unit,
+    ) {
+        context.runOnUiQueueThread {
+            try {
+                val resolvedView: View? = manager.resolveView(reactTag)
+                val view = resolvedView as? V
+                if (view != null) {
+                    fn(view)
+                } else {
+                    val message =
+                        "`reactTag` $reactTag resolved to `view` $resolvedView which is null or a wrong type"
+                    Logger.e(LOG_TAG, message)
+                    promise?.reject(Throwable(message))
+                }
+            } catch (err: IllegalViewOperationException) {
+                if (!createdViews.contains(reactTag)) {
+                    awaitedViews.getOrPut(reactTag) { mutableListOf() }.add(
+                        Await({ view ->
+                            if (view != null) {
+                                fn(view as V)
+                            } else {
+                                val message = "`reactTag` $reactTag resolved null"
+                                Logger.e(LOG_TAG, message)
+                                promise?.reject(Throwable(message))
+                            }
+                        }, promise),
+                    )
+                } else {
+                    promise?.reject(err)
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/utils/ResourceUtils.java

@@ -0,0 +1,26 @@
+package io.github.mapvina.reactnative.utils;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
+import androidx.core.content.ContextCompat;
+
+public class ResourceUtils {
+    public static Drawable getDrawableByName(Context context, String resourceName) {
+        if (context == null || resourceName == null || resourceName.isEmpty()) {
+            return null;
+        }
+
+        Resources resources = context.getResources();
+        if (resources == null) {
+            return null;
+        }
+
+        final int resID = resources.getIdentifier(resourceName, "drawable", context.getPackageName());
+        if (resID == 0) {
+            return null;
+        }
+        
+        return ContextCompat.getDrawable(context, resID);
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/utils/SphericalMercator.java

@@ -0,0 +1,68 @@
+package io.github.mapvina.reactnative.utils;
+
+import android.graphics.Point;
+import android.graphics.PointF;
+
+import io.github.mapvina.android.geometry.LatLng;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Ported from https://github.com/mapbox/sphericalmercator/blob/master/sphericalmercator.js
+ * This port only assumes we will have 512 vector tile sizes
+ */
+
+public class SphericalMercator {
+    public static final double D2R = Math.PI / 180;
+    public static final double R2D = 180 / Math.PI;
+
+    private static Map<String, List<Double>> cache;
+
+    public SphericalMercator() {
+        int tileSize = 512;
+
+        if (cache == null) {
+            cache = new HashMap<>();
+            cache.put("Bc", new ArrayList<Double>());
+            cache.put("Cc", new ArrayList<Double>());
+            cache.put("zc", new ArrayList<Double>());
+            cache.put("Ac", new ArrayList<Double>());
+
+            double size = (double) tileSize;
+            for (int d = 0; d < 30; d++) {
+                cache.get("Bc").add(size / 360);
+                cache.get("Cc").add(size / (2 * Math.PI));
+                cache.get("zc").add(size / 2);
+                cache.get("Ac").add(size);
+                size *= 2;
+            }
+        }
+    }
+
+    public PointF getPX(LatLng latLng, int zoomLevel) {
+        double d = cache.get("zc").get(zoomLevel);
+        double f = Math.min(Math.max(Math.sin(D2R * latLng.getLatitude()), -0.9999), 0.9999);
+        double x = Math.round(d + latLng.getLongitude() * cache.get("Bc").get(zoomLevel));
+        double y = Math.round(d + 0.5 * Math.log((1 + f) / (1 - f)) * (-cache.get("Cc").get(zoomLevel)));
+
+        if (x > cache.get("Ac").get(zoomLevel)) {
+            x = cache.get("Ac").get(zoomLevel);
+        }
+
+        if (y > cache.get("Ac").get(zoomLevel)) {
+            y = cache.get("Ac").get(zoomLevel);
+        }
+
+        return new PointF((float) x, (float) y);
+    }
+
+    public LatLng getLatLng(PointF px, int zoomLevel) {
+        double g = ((double)px.y - cache.get("zc").get(zoomLevel)) / (-cache.get("Cc").get(zoomLevel));
+        double lon = ((double) px.x - cache.get("zc").get(zoomLevel)) / cache.get("Bc").get(zoomLevel);
+        double lat = R2D * (2 * Math.atan(Math.exp(g)) - 0.5 * Math.PI);
+        return new LatLng(lat, lon);
+    }
+}

package/android/src/main/location-engine-default/io/github/mapvina/reactnative/location/engine/LocationEngineProvider.kt

@@ -0,0 +1,8 @@
+package io.github.mapvina.reactnative.location.engine
+
+import android.content.Context
+import io.github.mapvina.android.location.engine.LocationEngine
+
+class LocationEngineProvider : LocationEngineProvidable {
+    override fun getLocationEngine(context: Context): LocationEngine = DefaultLocationEngineProvider().getLocationEngine(context)
+}