@maplibre/maplibre-react-native 11.0.0-alpha.2 → 11.0.0-alpha.20

package/android/src/main/java/org/maplibre/reactnative/utils/GeoJSONUtils.kt

@@ -0,0 +1,322 @@
+package org.maplibre.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 com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import org.maplibre.android.geometry.LatLng
+import org.maplibre.android.geometry.LatLngBounds
+import org.maplibre.android.geometry.LatLngQuad
+import org.maplibre.android.log.Logger
+import org.maplibre.geojson.Feature
+import org.maplibre.geojson.FeatureCollection
+import org.maplibre.geojson.Geometry
+import org.maplibre.geojson.GeometryCollection
+import org.maplibre.geojson.LineString
+import org.maplibre.geojson.MultiLineString
+import org.maplibre.geojson.MultiPoint
+import org.maplibre.geojson.MultiPolygon
+import org.maplibre.geojson.Point
+import org.maplibre.geojson.Polygon
+import org.maplibre.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 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)
+            "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 {
+        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()
+
+        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 = 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.longitude, latLng.latitude)
+        val writableCoords: WritableArray = WritableNativeArray()
+        writableCoords.pushDouble(coords[0])
+        writableCoords.pushDouble(coords[1])
+        return writableCoords
+    }
+
+    @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)
+        if (feature == null) {
+            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/org/maplibre/reactnative/utils/ImageEntry.java

@@ -4,6 +4,7 @@ public class ImageEntry {
     public String uri;
     public double scale = 1.0;
     public static final double defaultScale = 0.0;
+    public boolean sdf;
 
     public ImageEntry(String _uri, Double _scale) {
         uri = _uri;

package/android/src/main/java/org/maplibre/reactnative/utils/ReactTagResolver.kt

@@ -0,0 +1,85 @@
+package org.maplibre.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 org.maplibre.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/location-engine-default/org/maplibre/reactnative/location/engine/LocationEngineProvider.kt

@@ -0,0 +1,10 @@
+package org.maplibre.reactnative.location.engine
+
+import android.content.Context
+import org.maplibre.android.location.engine.LocationEngine
+
+class LocationEngineProvider : LocationEngineProvidable {
+    override fun getLocationEngine(context: Context): LocationEngine {
+        return DefaultLocationEngineProvider().getLocationEngine(context)
+    }
+}

package/android/src/main/location-engine-google/org/maplibre/reactnative/location/engine/GoogleLocationEngineImpl.kt

@@ -0,0 +1,131 @@
+package org.maplibre.reactnative.location.engine
+
+import android.annotation.SuppressLint
+import android.app.PendingIntent
+import android.content.Context
+import android.location.Location
+import android.os.Looper
+import androidx.annotation.VisibleForTesting
+import com.google.android.gms.location.FusedLocationProviderClient
+import com.google.android.gms.location.LocationCallback
+import com.google.android.gms.location.LocationRequest
+import com.google.android.gms.location.LocationResult
+import com.google.android.gms.location.LocationServices
+import com.google.android.gms.location.Priority
+import com.google.android.gms.tasks.OnFailureListener
+import com.google.android.gms.tasks.OnSuccessListener
+import org.maplibre.android.location.engine.LocationEngineCallback
+import org.maplibre.android.location.engine.LocationEngineImpl
+import org.maplibre.android.location.engine.LocationEngineRequest
+import org.maplibre.android.location.engine.LocationEngineResult
+
+/**
+ * Wraps implementation of Fused Location Provider
+ */
+class GoogleLocationEngineImpl : LocationEngineImpl<LocationCallback?> {
+    private val fusedLocationProviderClient: FusedLocationProviderClient
+
+    @VisibleForTesting
+    internal constructor(fusedLocationProviderClient: FusedLocationProviderClient) {
+        this.fusedLocationProviderClient = fusedLocationProviderClient
+    }
+
+    constructor(context: Context) {
+        this.fusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(context)
+    }
+
+    override fun createListener(callback: LocationEngineCallback<LocationEngineResult?>): LocationCallback {
+        return GoogleLocationEngineCallbackTransport(callback)
+    }
+
+    @SuppressLint("MissingPermission")
+    @Throws(SecurityException::class)
+    override fun getLastLocation(callback: LocationEngineCallback<LocationEngineResult?>) {
+        val transport = GoogleLastLocationEngineCallbackTransport(callback)
+        fusedLocationProviderClient.lastLocation.addOnSuccessListener(transport)
+            .addOnFailureListener(transport)
+    }
+
+    @SuppressLint("MissingPermission")
+    @Throws(SecurityException::class)
+    override fun requestLocationUpdates(
+        request: LocationEngineRequest, listener: LocationCallback, looper: Looper?
+    ) {
+        fusedLocationProviderClient.requestLocationUpdates(
+            toGMSLocationRequest(request), listener, looper
+        )
+    }
+
+    @SuppressLint("MissingPermission")
+    @Throws(SecurityException::class)
+    override fun requestLocationUpdates(
+        request: LocationEngineRequest, pendingIntent: PendingIntent
+    ) {
+        fusedLocationProviderClient.requestLocationUpdates(
+            toGMSLocationRequest(request), pendingIntent
+        )
+    }
+
+    override fun removeLocationUpdates(listener: LocationCallback?) {
+        if (listener != null) {
+            fusedLocationProviderClient.removeLocationUpdates(listener)
+        }
+    }
+
+    override fun removeLocationUpdates(pendingIntent: PendingIntent?) {
+        if (pendingIntent != null) {
+            fusedLocationProviderClient.removeLocationUpdates(pendingIntent)
+        }
+    }
+
+    private class GoogleLocationEngineCallbackTransport(private val callback: LocationEngineCallback<LocationEngineResult?>) :
+        LocationCallback() {
+        override fun onLocationResult(locationResult: LocationResult) {
+            super.onLocationResult(locationResult)
+            val locations = locationResult.locations
+            if (!locations.isEmpty()) {
+                callback.onSuccess(LocationEngineResult.create(locations))
+            } else {
+                callback.onFailure(Exception("Unavailable location"))
+            }
+        }
+    }
+
+    @VisibleForTesting
+    internal class GoogleLastLocationEngineCallbackTransport
+        (private val callback: LocationEngineCallback<LocationEngineResult?>) :
+        OnSuccessListener<Location?>, OnFailureListener {
+        override fun onSuccess(location: Location?) {
+            callback.onSuccess(
+                if (location != null) LocationEngineResult.create(location) else LocationEngineResult.create(
+                    mutableListOf<Location?>()
+                )
+            )
+        }
+
+        override fun onFailure(e: Exception) {
+            callback.onFailure(e)
+        }
+    }
+
+    companion object {
+        private fun toGMSLocationRequest(request: LocationEngineRequest): LocationRequest {
+            val builder = LocationRequest.Builder(request.interval)
+            builder.setMinUpdateIntervalMillis(request.fastestInterval)
+            builder.setMinUpdateDistanceMeters(request.displacement)
+            builder.setMaxUpdateDelayMillis(request.maxWaitTime)
+            builder.setPriority(toGMSLocationPriority(request.priority))
+            return builder.build()
+        }
+
+        private fun toGMSLocationPriority(enginePriority: Int): Int {
+            return when (enginePriority) {
+                LocationEngineRequest.PRIORITY_HIGH_ACCURACY -> Priority.PRIORITY_HIGH_ACCURACY
+                LocationEngineRequest.PRIORITY_BALANCED_POWER_ACCURACY -> Priority.PRIORITY_BALANCED_POWER_ACCURACY
+                LocationEngineRequest.PRIORITY_LOW_POWER -> Priority.PRIORITY_LOW_POWER
+                LocationEngineRequest.PRIORITY_NO_POWER -> Priority.PRIORITY_PASSIVE
+                else -> Priority.PRIORITY_PASSIVE
+            }
+        }
+    }
+}

package/android/src/main/location-engine-google/org/maplibre/reactnative/location/engine/GoogleLocationEngineProvider.kt

@@ -0,0 +1,28 @@
+package org.maplibre.reactnative.location.engine
+
+import android.content.Context
+import android.util.Log
+import com.google.android.gms.common.ConnectionResult
+import com.google.android.gms.common.GoogleApiAvailability
+import com.google.android.gms.location.LocationCallback
+import org.maplibre.android.location.engine.LocationEngine
+import org.maplibre.android.location.engine.LocationEngineProxy
+
+class GoogleLocationEngineProvider : LocationEngineProvidable {
+    override fun getLocationEngine(context: Context): LocationEngine {
+        if (GoogleApiAvailability.getInstance()
+                .isGooglePlayServicesAvailable(context) == ConnectionResult.SUCCESS
+        ) {
+            val locationEngine: LocationEngine =
+                LocationEngineProxy<LocationCallback?>(GoogleLocationEngineImpl(context.applicationContext))
+            Log.d(LOG_TAG, "GoogleLocationEngine will be used.")
+            return locationEngine
+        } else {
+            return DefaultLocationEngineProvider().getLocationEngine(context)
+        }
+    }
+
+    companion object {
+        private const val LOG_TAG = "GoogleLocationEngineProvider"
+    }
+}

package/android/src/main/location-engine-google/org/maplibre/reactnative/location/engine/LocationEngineProvider.kt

@@ -0,0 +1,10 @@
+package org.maplibre.reactnative.location.engine
+
+import android.content.Context
+import org.maplibre.android.location.engine.LocationEngine
+
+class LocationEngineProvider : LocationEngineProvidable {
+    override fun getLocationEngine(context: Context): LocationEngine {
+        return GoogleLocationEngineProvider().getLocationEngine(context)
+    }
+}

package/ios/components/annotations/MLRNCallout.h

@@ -0,0 +1,7 @@
+#import <React/RCTView.h>
+
+#import <MapLibre/MapLibre.h>
+
+@interface MLRNCallout : RCTView <MLNCalloutView>
+
+@end

package/ios/components/annotations/MLRNPointAnnotation.h

@@ -0,0 +1,33 @@
+#import <React/RCTComponent.h>
+#import <React/RCTView.h>
+#import <UIKit/UIKit.h>
+#import "MLRNCallout.h"
+
+#import <MapLibre/MapLibre.h>
+
+@interface MLRNPointAnnotation : MLNAnnotationView <MLNAnnotation>
+
+@property (nonatomic, weak) MLNMapView *map;
+@property (nonatomic, strong) MLRNCallout *calloutView;
+
+@property (nonatomic, copy) NSString *id;
+@property (nonatomic, copy) NSString *reactTitle;
+@property (nonatomic, copy) NSString *reactSnippet;
+
+@property (nonatomic, copy) NSString *reactCoordinate;
+@property (nonatomic, assign) CLLocationCoordinate2D coordinate;
+
+@property (nonatomic, copy) NSDictionary<NSString *, NSNumber *> *anchor;
+
+@property (nonatomic, copy) RCTBubblingEventBlock onSelected;
+@property (nonatomic, copy) RCTBubblingEventBlock onDeselected;
+@property (nonatomic, copy) RCTBubblingEventBlock onDragStart;
+@property (nonatomic, copy) RCTBubblingEventBlock onDrag;
+@property (nonatomic, copy) RCTBubblingEventBlock onDragEnd;
+
+@property (nonatomic, assign) BOOL reactSelected;
+@property (nonatomic, assign) BOOL reactDraggable;
+
+- (MLNAnnotationView *)getAnnotationView;
+
+@end

package/ios/components/camera/CameraEasing.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, MLRNCameraEasing) {
+  MLRNCameraEasingNone = 0,
+  MLRNCameraEasingLinear = 1,
+  MLRNCameraEasingEase = 2,
+  MLRNCameraEasingFly = 3,
+};

package/ios/components/camera/CameraStop.h

@@ -0,0 +1,22 @@
+#import <MapLibre/MapLibre.h>
+
+#import "CameraEasing.h"
+#import "MLRNCamera.h"
+
+@interface CameraStop : NSObject
+
+@property (nonatomic, assign) CLLocationCoordinate2D center;
+
+@property (nonatomic, strong) NSNumber *zoom;
+@property (nonatomic, strong) NSNumber *bearing;
+@property (nonatomic, strong) NSNumber *pitch;
+
+@property (nonatomic, assign) MLNCoordinateBounds bounds;
+@property (nonatomic, assign) UIEdgeInsets padding;
+
+@property (nonatomic, assign) NSTimeInterval duration;
+@property (nonatomic, strong) NSNumber *easing;
+
++ (CameraStop *)fromDictionary:(NSDictionary *)args;
+
+@end