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

package/android/src/main/java/org/maplibre/reactnative/components/sources/MLRNTileSource.java

@@ -0,0 +1,97 @@
+package org.maplibre.reactnative.components.sources;
+
+import android.content.Context;
+
+import org.maplibre.android.style.sources.Source;
+import org.maplibre.android.style.sources.TileSet;
+
+import java.util.Collection;
+
+@SuppressWarnings("unused")
+public abstract class MLRNTileSource<T extends Source> extends MLRNSource<T> {
+    static final String TILE_SPEC_VERSION = "2.1.0";
+
+    private String mURL;
+    private Collection<String> mTileUrlTemplates;
+    private String mAttribution;
+
+    private Integer mMinZoomLevel;
+    private Integer mMaxZoomLevel;
+
+    private boolean mIsTmsSource;
+
+    public MLRNTileSource(Context context) {
+        super(context);
+    }
+
+    public String getURL() {
+        return mURL;
+    }
+
+    public void setURL(String mURL) {
+        this.mURL = mURL;
+    }
+
+    public String getAttribution() {
+        return mAttribution;
+    }
+
+    public void setAttribution(String mAttribution) {
+        this.mAttribution = mAttribution;
+    }
+
+    public Integer getMinZoomLevel() {
+        return mMinZoomLevel;
+    }
+
+    public void setMinZoomLevel(Integer mMinZoomLevel) {
+        this.mMinZoomLevel = mMinZoomLevel;
+    }
+
+    public Integer getMaxZoomLevel() {
+        return mMaxZoomLevel;
+    }
+
+    public void setMaxZoomLevel(Integer mMaxZoomLevel) {
+        this.mMaxZoomLevel = mMaxZoomLevel;
+    }
+
+    public boolean getTMS() {
+        return mIsTmsSource;
+    }
+
+    public void setTMS(boolean mIsTmsSource) {
+        this.mIsTmsSource = mIsTmsSource;
+    }
+
+    public Collection<String> getTileUrlTemplates() {
+        return mTileUrlTemplates;
+    }
+
+    public void setTileUrlTemplates(Collection<String> tileUrlTemplates) {
+        this.mTileUrlTemplates = tileUrlTemplates;
+    }
+
+    public TileSet buildTileset() {
+        String[] tileUrlTemplates = mTileUrlTemplates.toArray(new String[mTileUrlTemplates.size()]);
+        TileSet tileSet = new TileSet(TILE_SPEC_VERSION, tileUrlTemplates);
+
+        if (mMinZoomLevel != null) {
+            tileSet.setMinZoom(mMinZoomLevel.floatValue());
+        }
+
+        if (mMaxZoomLevel != null) {
+            tileSet.setMaxZoom(mMaxZoomLevel.floatValue());
+        }
+
+        if (mIsTmsSource) {
+            tileSet.setScheme("tms");
+        }
+
+        if (mAttribution != null) {
+            tileSet.setAttribution(mAttribution);
+        }
+
+        return tileSet;
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/sources/MLRNTileSourceManager.java

@@ -0,0 +1,80 @@
+package org.maplibre.reactnative.components.sources;
+
+import android.view.View;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import org.maplibre.reactnative.components.AbstractEventEmitter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class MLRNTileSourceManager<T extends MLRNTileSource> extends AbstractEventEmitter<T> {
+
+    MLRNTileSourceManager(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+    }
+
+    @Override
+    public View getChildAt(T source, int childPosition) {
+        return source.getLayerAt(childPosition);
+    }
+
+    @Override
+    public int getChildCount(T source) {
+        return source.getLayerCount();
+    }
+
+    @Override
+    public void addView(T source, View childView, int childPosition) {
+        source.addLayer(childView, childPosition);
+    }
+
+    @Override
+    public void removeViewAt(T source, int childPosition) {
+        source.removeLayer(childPosition);
+    }
+
+    @ReactProp(name="id")
+    public void setID(T source, String id) {
+        source.setID(id);
+    }
+
+    @ReactProp(name="url")
+    public void setURL(T source, String url) {
+        source.setURL(url);
+    }
+
+    @ReactProp(name="tileUrlTemplates")
+    public void setTileUrlTemplates(T source, ReadableArray tileUrlTemplates) {
+        List<String> urls = new ArrayList<>();
+        for (int i = 0; i < tileUrlTemplates.size(); i++) {
+            if (tileUrlTemplates.getType(0) == ReadableType.String) {
+                urls.add(tileUrlTemplates.getString(i));
+            }
+        }
+        source.setTileUrlTemplates(urls);
+    }
+
+    @ReactProp(name="attribution")
+    public void setAttribution(T source, String attribution) {
+        source.setAttribution(attribution);
+    }
+
+    @ReactProp(name="minZoomLevel")
+    public void setMinZoomLevel(T source, int minZoomLevel) {
+        source.setMinZoomLevel(minZoomLevel);
+    }
+
+    @ReactProp(name="maxZoomLevel")
+    public void setMaxZoomLevel(T source, int maxZoomLevel) {
+        source.setMaxZoomLevel(maxZoomLevel);
+    }
+
+    @ReactProp(name="tms")
+    public void setTMS(T source, boolean tms) {
+        source.setTMS(tms);
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/sources/MLRNVectorSource.java

@@ -0,0 +1,60 @@
+package org.maplibre.reactnative.components.sources;
+
+import android.content.Context;
+import androidx.annotation.Nullable;
+import androidx.annotation.Size;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import org.maplibre.geojson.Feature;
+import org.maplibre.geojson.FeatureCollection;
+import org.maplibre.android.style.expressions.Expression;
+import org.maplibre.android.style.sources.VectorSource;
+import org.maplibre.reactnative.events.AndroidCallbackEvent;
+import org.maplibre.reactnative.events.FeatureClickEvent;
+
+import java.util.List;
+
+public class MLRNVectorSource extends MLRNTileSource<VectorSource> {
+    private MLRNVectorSourceManager mManager;
+
+    public MLRNVectorSource(Context context, MLRNVectorSourceManager manager) {
+        super(context);
+        mManager = manager;
+    }
+
+    public void onPress(OnPressEvent event) {
+        mManager.handleEvent(FeatureClickEvent.makeVectorSourceEvent(this, event));
+    }
+
+    @Override
+    public VectorSource makeSource() {
+        if (isDefaultSource(mID)) {
+            return (VectorSource)mMap.getStyle().getSource(DEFAULT_ID);
+        }
+
+        String configurationUrl = getURL();
+        if (configurationUrl != null) {
+            return new VectorSource(mID, getURL());
+        }
+        return new VectorSource(mID, buildTileset());
+    }
+
+    public void querySourceFeatures(String callbackID,
+                                             @Size(min = 1) List<String> layerIDs,
+                                             @Nullable Expression filter) {
+        if (mSource == null) {
+            WritableMap payload = new WritableNativeMap();
+            payload.putString("error", "source is not yet loaded");
+            AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+            mManager.handleEvent(event);
+            return;
+        }
+        List<Feature> features = mSource.querySourceFeatures(layerIDs.toArray(new String[layerIDs.size()]), filter);
+        WritableMap payload = new WritableNativeMap();
+        payload.putString("data", FeatureCollection.fromFeatures(features).toJson());
+
+        AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+        mManager.handleEvent(event);
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/sources/MLRNVectorSourceManager.java

@@ -0,0 +1,80 @@
+package org.maplibre.reactnative.components.sources;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import org.maplibre.reactnative.events.constants.EventKeys;
+import org.maplibre.reactnative.utils.ConvertUtils;
+import org.maplibre.reactnative.utils.ExpressionParser;
+
+import javax.annotation.Nonnull;
+
+import java.util.Map;
+
+public class MLRNVectorSourceManager extends MLRNTileSourceManager<MLRNVectorSource> {
+    public static final String REACT_CLASS = "MLRNVectorSource";
+
+    public MLRNVectorSourceManager(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+    }
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Nonnull
+    @Override
+    protected MLRNVectorSource createViewInstance(@Nonnull ThemedReactContext reactContext) {
+        return new MLRNVectorSource(reactContext, this);
+    }
+
+    @ReactProp(name = "hasPressListener")
+    public void setHasPressListener(MLRNVectorSource source, boolean hasPressListener) {
+        source.setHasPressListener(hasPressListener);
+    }
+
+    @ReactProp(name="hitbox")
+    public void setHitbox(MLRNVectorSource source, ReadableMap map) {
+        source.setHitbox(map);
+    }
+
+    @Override
+    public Map<String, String> customEvents() {
+        return MapBuilder.<String, String>builder()
+                .put(EventKeys.VECTOR_SOURCE_LAYER_CLICK, "onMapboxVectorSourcePress")
+                .put(EventKeys.MAP_ANDROID_CALLBACK, "onAndroidCallback")
+                .build();
+    }
+
+    //region React Methods
+    public static final int METHOD_FEATURES = 102;
+
+    @Nullable
+    @Override
+    public Map<String, Integer> getCommandsMap() {
+        return MapBuilder.<String, Integer>builder()
+                .put("features", METHOD_FEATURES)
+                .build();
+    }
+
+    @Override
+    public void receiveCommand(MLRNVectorSource vectorSource, int commandID, @Nullable ReadableArray args) {
+
+        switch (commandID) {
+            case METHOD_FEATURES:
+                vectorSource.querySourceFeatures(
+                        args.getString(0),
+                        ConvertUtils.toStringList(args.getArray(1)),
+                        ExpressionParser.from(args.getArray(2))
+                        );
+                break;
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/AbstractEvent.java

@@ -46,11 +46,8 @@ abstract public class AbstractEvent implements IEvent {
 
     public WritableMap toJSON() {
         WritableMap map = Arguments.createMap();
-        map.putString("type", getType());
-
-        WritableMap payloadClone = Arguments.createMap();
-        payloadClone.merge(getPayload());
-        map.putMap("payload", payloadClone);
+        map.merge(getPayload());
+        
         return map;
     }
 

package/android/src/main/java/org/maplibre/reactnative/events/FeatureClickEvent.java

@@ -8,10 +8,9 @@ import com.facebook.react.bridge.WritableArray;
 import com.facebook.react.bridge.WritableMap;
 import org.maplibre.geojson.Feature;
 import org.maplibre.android.geometry.LatLng;
-import org.maplibre.reactnative.components.styles.sources.MLRNSource;
+import org.maplibre.reactnative.components.sources.MLRNSource;
 import org.maplibre.reactnative.events.constants.EventKeys;
 import org.maplibre.reactnative.events.constants.EventTypes;
-import org.maplibre.reactnative.utils.ConvertUtils;
 import org.maplibre.reactnative.utils.GeoJSONUtils;
 
 import java.util.List;

package/android/src/main/java/org/maplibre/reactnative/events/MapChangeEvent.kt

@@ -0,0 +1,18 @@
+package org.maplibre.reactnative.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+class MapChangeEvent(
+    surfaceId: Int,
+    viewId: Int,
+    private val internalEventName: String,
+    private val eventData: WritableMap = Arguments.createMap()
+) : Event<MapChangeEvent>(surfaceId, viewId) {
+    override fun getEventName() = internalEventName
+
+    override fun getEventData(): WritableMap {
+        return eventData
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/MapClickEvent.java

@@ -1,17 +1,21 @@
 package org.maplibre.reactnative.events;
 
 import android.graphics.PointF;
+
 import androidx.annotation.NonNull;
+
 import android.view.View;
 
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
+
 import org.maplibre.android.geometry.LatLng;
 
 import org.maplibre.reactnative.events.constants.EventKeys;
 import org.maplibre.reactnative.events.constants.EventTypes;
 import org.maplibre.reactnative.utils.GeoJSONUtils;
 
+// TODO: Remove
 public class MapClickEvent extends AbstractEvent {
     private LatLng mTouchedLatLng;
     private PointF mScreenPoint;

package/android/src/main/java/org/maplibre/reactnative/events/MapPressEvent.kt

@@ -0,0 +1,27 @@
+package org.maplibre.reactnative.events
+
+import android.graphics.PointF
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import org.maplibre.android.geometry.LatLng
+
+class MapPressEvent(
+    surfaceId: Int,
+    viewId: Int,
+    private val internalEventName: String,
+    private val latLng: LatLng,
+    private val screenPoint: PointF,
+
+    ) : Event<MapPressEvent>(surfaceId, viewId) {
+    override fun getEventName() = internalEventName
+
+    override fun getEventData(): WritableMap {
+        return Arguments.createMap().apply {
+            putDouble("longitude", latLng.longitude)
+            putDouble("latitude", latLng.latitude)
+            putDouble("locationX", screenPoint.x.toDouble())
+            putDouble("locationY", screenPoint.y.toDouble())
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/events/PointAnnotationClickEvent.java

@@ -2,16 +2,14 @@ package org.maplibre.reactnative.events;
 
 import android.graphics.PointF;
 import androidx.annotation.NonNull;
-import android.view.View;
 
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
-import org.maplibre.android.plugins.markerview.MarkerView;
+
 import org.maplibre.android.geometry.LatLng;
-import org.maplibre.reactnative.components.annotation.MLRNPointAnnotation;
+import org.maplibre.reactnative.components.annotations.MLRNPointAnnotation;
 import org.maplibre.reactnative.events.constants.EventKeys;
 import org.maplibre.reactnative.events.constants.EventTypes;
-import org.maplibre.reactnative.utils.ConvertUtils;
 import org.maplibre.reactnative.utils.GeoJSONUtils;
 
 public class PointAnnotationClickEvent extends MapClickEvent {

package/android/src/main/java/org/maplibre/reactnative/events/PointAnnotationDragEvent.java

@@ -2,16 +2,14 @@ package org.maplibre.reactnative.events;
 
 import android.graphics.PointF;
 import androidx.annotation.NonNull;
-import android.view.View;
 
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
-import org.maplibre.android.plugins.markerview.MarkerView;
+
 import org.maplibre.android.geometry.LatLng;
-import org.maplibre.reactnative.components.annotation.MLRNPointAnnotation;
+import org.maplibre.reactnative.components.annotations.MLRNPointAnnotation;
 import org.maplibre.reactnative.events.constants.EventKeys;
 import org.maplibre.reactnative.events.constants.EventTypes;
-import org.maplibre.reactnative.utils.ConvertUtils;
 import org.maplibre.reactnative.utils.GeoJSONUtils;
 
 public class PointAnnotationDragEvent extends MapClickEvent {

package/android/src/main/java/org/maplibre/reactnative/events/constants/EventKeys.java

@@ -6,10 +6,7 @@ public class EventKeys {
     // map events
     public static final String MAP_CLICK = ns("map.press");
     public static final String MAP_LONG_CLICK = ns("map.longpress");
-    public static final String MAP_ONCHANGE = ns("map.change");
-    public static final String MAP_ON_LOCATION_CHANGE = ns("map.location.change");
     public static final String MAP_ANDROID_CALLBACK = ns("map.androidcallback");
-    public static final String MAP_USER_TRACKING_MODE_CHANGE = ns("map.usertrackingmodechange");
 
     // point annotation events
     public static final String POINT_ANNOTATION_SELECTED = ns("pointannotation.selected");
@@ -26,8 +23,6 @@ public class EventKeys {
     // images event
     public static final String IMAGES_MISSING = ns("images.missing");
 
-    // location events
-    public static final String USER_LOCATION_UPDATE = ns("user.location.update");
 
     private static String ns(String name) {
         return String.format("%s.%s", NAMESPACE, name);

package/android/src/main/java/org/maplibre/reactnative/events/constants/EventTypes.java

@@ -4,26 +4,6 @@ public class EventTypes {
     // map event types
     public static final String MAP_CLICK = "press";
     public static final String MAP_LONG_CLICK = "longpress";
-    public static final String MAP_USER_TRACKING_MODE_CHANGE = "usertrackingmodechange";
-
-    public static final String REGION_WILL_CHANGE = "regionwillchange";
-    public static final String REGION_IS_CHANGING = "regionischanging";
-    public static final String REGION_DID_CHANGE  = "regiondidchange";
-    public static final String USER_LOCATION_UPDATED = "userlocationdupdated";
-
-    public static final String WILL_START_LOADING_MAP = "willstartloadingmap";
-    public static final String DID_FINISH_LOADING_MAP = "didfinishloadingmap";
-    public static final String DID_FAIL_LOADING_MAP = "didfailloadingmap";
-
-    public static final String WILL_START_RENDERING_FRAME = "willstartrenderingframe";
-    public static final String DID_FINISH_RENDERING_FRAME = "didfinishrenderingframe";
-    public static final String DID_FINISH_RENDERING_FRAME_FULLY = "didfinishrenderingframefully";
-
-    public static final String WILL_START_RENDERING_MAP = "willstartrenderingmap";
-    public static final String DID_FINISH_RENDERING_MAP = "didfinishrenderingmap";
-    public static final String DID_FINISH_RENDERING_MAP_FULLY = "didfinishrenderingmapfully";
-
-    public static final String DID_FINISH_LOADING_STYLE = "didfinishloadingstyle";
 
     // point annotation event types
     public static final String ANNOTATION_SELECTED = "annotationselected";

package/android/src/main/java/org/maplibre/reactnative/location/LocationManager.kt

@@ -0,0 +1,165 @@
+package org.maplibre.reactnative.location
+
+import android.Manifest
+import android.content.Context
+import android.location.Location
+import android.os.Looper
+import android.util.Log
+import androidx.annotation.RequiresPermission
+import org.maplibre.android.location.engine.LocationEngine
+import org.maplibre.android.location.engine.LocationEngineCallback
+import org.maplibre.android.location.engine.LocationEngineRequest
+import org.maplibre.android.location.engine.LocationEngineResult
+import org.maplibre.android.location.permissions.PermissionsManager
+import org.maplibre.reactnative.location.engine.LocationEngineProvider
+import java.lang.ref.WeakReference
+
+class LocationManager private constructor(private val context: Context) :
+    LocationEngineCallback<LocationEngineResult> {
+    var engine: LocationEngine? = null
+        private set
+    private val listeners: MutableList<OnUserLocationChange> = ArrayList<OnUserLocationChange>()
+
+    private var mMinDisplacement = 0f
+    private var isActive = false
+    private var lastLocation: Location? = null
+
+    private var locationEngineRequest: LocationEngineRequest? = null
+
+    interface OnUserLocationChange {
+        fun onLocationChange(location: Location)
+    }
+
+    init {
+        this.buildEngineRequest()
+    }
+
+    private fun buildEngineRequest() {
+        this.engine = LocationEngineProvider().getLocationEngine(context)
+
+        locationEngineRequest = LocationEngineRequest.Builder(DEFAULT_INTERVAL_MILLIS)
+            .setFastestInterval(DEFAULT_FASTEST_INTERVAL_MILLIS)
+            .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
+            .setDisplacement(mMinDisplacement).build()
+    }
+
+    fun addLocationListener(listener: OnUserLocationChange?) {
+        if (!listeners.contains(listener)) {
+            listeners.add(listener!!)
+        }
+    }
+
+    fun removeLocationListener(listener: OnUserLocationChange?) {
+        if (listeners.contains(listener)) {
+            listeners.remove(listener)
+        }
+    }
+
+    fun setMinDisplacement(minDisplacement: Float) {
+        mMinDisplacement = minDisplacement
+    }
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    fun enable() {
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return
+        }
+
+        // Remove existing listeners
+        engine!!.removeLocationUpdates(this)
+
+        // Refresh location engine request with new values
+        this.buildEngineRequest()
+
+        // Add new listeners
+        engine!!.requestLocationUpdates(
+            locationEngineRequest!!, this, Looper.getMainLooper()
+        )
+
+        isActive = true
+    }
+
+
+    fun disable() {
+        engine!!.removeLocationUpdates(this)
+        isActive = false
+    }
+
+    fun dispose() {
+        if (this.engine == null) {
+            return
+        }
+
+        disable()
+        engine!!.removeLocationUpdates(this)
+    }
+
+    fun isActive(): Boolean {
+        return this.engine != null && this.isActive
+    }
+
+    val lastKnownLocation: Location?
+        get() {
+            if (this.engine == null) {
+                return null
+            }
+
+            return lastLocation
+        }
+
+
+    @RequiresPermission(allOf = [Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION])
+    fun getLastKnownLocation(callback: LocationEngineCallback<LocationEngineResult?>) {
+        if (this.engine == null) {
+            callback.onFailure(Exception("LocationEngine not initialized"))
+        }
+
+        try {
+            engine!!.getLastLocation(callback)
+        } catch (exception: Exception) {
+            Log.w(LOG_TAG, exception)
+            callback.onFailure(exception)
+        }
+    }
+
+    fun onLocationChanged(location: Location) {
+        lastLocation = location
+        for (listener in listeners) {
+            listener.onLocationChange(location)
+        }
+    }
+
+    override fun onFailure(exception: Exception) {
+        // TODO handle this.
+    }
+
+    override fun onSuccess(result: LocationEngineResult?) {
+        val location = result?.lastLocation ?: return
+
+        onLocationChanged(location)
+    }
+
+    companion object {
+        const val DEFAULT_FASTEST_INTERVAL_MILLIS: Long = 1000
+        const val DEFAULT_INTERVAL_MILLIS: Long = 1000
+
+        const val LOG_TAG: String = "LocationManager"
+
+        private var INSTANCE: WeakReference<LocationManager?>? = null
+
+        @JvmStatic
+        fun getInstance(context: Context): LocationManager {
+            val appContext = context.applicationContext
+            INSTANCE?.get()?.let { return it }
+
+            synchronized(LocationManager::class.java) {
+                INSTANCE?.get()?.let { return it }
+
+                val created = LocationManager(appContext)
+                INSTANCE = WeakReference(created)
+
+                return created
+            }
+        }
+    }
+}