@maplibre/maplibre-react-native 10.0.0-alpha.9 → 10.0.0-beta.2

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

@@ -0,0 +1,240 @@
+package org.maplibre.reactnative.components.styles.sources;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+
+import android.graphics.PointF;
+import android.view.View;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.MapBuilder;
+import org.maplibre.geojson.Feature;
+import org.maplibre.android.geometry.LatLng;
+import org.maplibre.android.log.Logger;
+import org.maplibre.android.maps.MapLibreMap;
+import org.maplibre.android.maps.Style;
+import org.maplibre.android.style.sources.Source;
+import org.maplibre.reactnative.components.AbstractMapFeature;
+import org.maplibre.reactnative.components.mapview.MLRNMapView;
+import org.maplibre.reactnative.components.styles.layers.MLRNLayer;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public abstract class MLRNSource<T extends Source> extends AbstractMapFeature {
+    public static final String DEFAULT_ID = "composite";
+    public static final String LOG_TAG = "MLRNSource";
+
+    public static final double DEFAULT_HITBOX_WIDTH = 44.0;
+    public static final double DEFAULT_HITBOX_HEIGHT = 44.0;
+
+    protected MLRNMapView mMapView;
+    protected MapLibreMap mMap;
+
+    protected String mID;
+    protected T mSource;
+    protected boolean mHasPressListener;
+    protected Map<String, Double> mTouchHitbox;
+
+    protected List<MLRNLayer> mLayers;
+    private List<MLRNLayer> mQueuedLayers;
+
+    public MLRNSource(Context context) {
+        super(context);
+        mLayers = new ArrayList<>();
+        mQueuedLayers = new ArrayList<>();
+    }
+
+    public String getID() {
+        return mID;
+    }
+
+    public String[] getLayerIDs() {
+        List<String> layerIDs = new ArrayList<>();
+
+        for (int i = 0; i < mLayers.size(); i++) {
+            MLRNLayer layer = mLayers.get(i);
+            layerIDs.add(layer.getID());
+        }
+
+        return layerIDs.toArray(new String[layerIDs.size()]);
+    }
+
+    public boolean hasPressListener() {
+        return mHasPressListener;
+    }
+
+    public void setHasPressListener (boolean hasPressListener) {
+        mHasPressListener = hasPressListener;
+    }
+
+    public void setHitbox(ReadableMap map) {
+        Map<String, Double> hitbox = new HashMap<>();
+        hitbox.put("width", map.getDouble("width"));
+        hitbox.put("height", map.getDouble("height"));
+        mTouchHitbox = hitbox;
+    }
+
+    public void setID(String id) {
+        mID = id;
+    }
+
+    public void setSource(T source) {
+        mSource = source;
+    }
+
+    public Map<String, Double> getTouchHitbox() {
+        if (!hasPressListener()) {
+            return null;
+        }
+
+        if (mTouchHitbox == null) {
+            return MapBuilder.<String, Double>builder()
+                    .put("width", DEFAULT_HITBOX_WIDTH)
+                    .put("height", DEFAULT_HITBOX_HEIGHT)
+                    .build();
+        }
+
+        return mTouchHitbox;
+    }
+
+    public int getLayerCount () {
+        int totalCount = 0;
+
+        if (mQueuedLayers != null) {
+            totalCount = mQueuedLayers.size();
+        }
+
+        totalCount += mLayers.size();
+        return totalCount;
+    }
+
+    @Override
+    public void addToMap(MLRNMapView mapView) {
+        mMapView = mapView;
+        mMap = mapView.getMapboxMap();
+        mMap.getStyle(new Style.OnStyleLoaded() {
+            public void onStyleLoaded(@NonNull Style style) {
+                T existingSource = style.getSourceAs(mID);
+                if (existingSource != null) {
+                    mSource = existingSource;
+                } else {
+                    mSource = makeSource();
+                    style.addSource(mSource);
+                }
+
+                if (mQueuedLayers != null && mQueuedLayers.size() > 0) { // first load
+                    for (int i = 0; i < mQueuedLayers.size(); i++) {
+                        addLayerToMap(mQueuedLayers.get(i), i);
+                    }
+                    mQueuedLayers = null;
+                } else if (mLayers.size() > 0) { // handles the case of switching style url, but keeping layers on map
+                    for (int i = 0; i < mLayers.size(); i++) {
+                        addLayerToMap(mLayers.get(i), i);
+                    }
+                }
+            }
+        });
+
+
+    }
+
+    @Override
+    public void removeFromMap(MLRNMapView mapView) {
+        if (mLayers.size() > 0) {
+            for (int i = 0; i < mLayers.size(); i++) {
+                MLRNLayer layer = mLayers.get(i);
+                layer.removeFromMap(mMapView);
+            }
+        }
+        if (mQueuedLayers != null) {
+            mQueuedLayers.clear();
+        }
+        if (mMap != null && mSource != null  && mMap.getStyle() != null) {
+            try {
+                mMap.getStyle().removeSource(mSource);
+            } catch (Throwable ex) {
+                Logger.w(LOG_TAG, String.format("MLRNSource.removeFromMap: %s - %s", mSource, ex.getMessage()), ex);
+            }
+        }
+    }
+
+    public void addLayer(View childView, int childPosition) {
+        if (!(childView instanceof MLRNLayer)) {
+            return;
+        }
+
+        MLRNLayer layer = (MLRNLayer) childView;
+        if (mMap == null) {
+            mQueuedLayers.add(childPosition, layer);
+        } else {
+            addLayerToMap(layer, childPosition);
+        }
+    }
+
+    public void removeLayer(int childPosition) {
+        MLRNLayer layer;
+        if (mQueuedLayers != null && mQueuedLayers.size() > 0) {
+            layer = mQueuedLayers.get(childPosition);
+        } else {
+            layer = mLayers.get(childPosition);
+        }
+        removeLayerFromMap(layer, childPosition);
+    }
+
+    public MLRNLayer getLayerAt(int childPosition) {
+        if (mQueuedLayers != null && mQueuedLayers.size() > 0) {
+            return mQueuedLayers.get(childPosition);
+        }
+        return mLayers.get(childPosition);
+    }
+
+    protected void addLayerToMap(MLRNLayer layer, int childPosition) {
+        if (mMapView == null || layer == null) {
+            return;
+        }
+
+        layer.addToMap(mMapView);
+        if (!mLayers.contains(layer)) {
+            mLayers.add(childPosition, layer);
+        }
+    }
+
+    protected void removeLayerFromMap(MLRNLayer layer, int childPosition) {
+        if (mMapView != null && layer != null) {
+            layer.removeFromMap(mMapView);
+        }
+        if (mQueuedLayers != null && mQueuedLayers.size() > 0) {
+            mQueuedLayers.remove(childPosition);
+        } else {
+            mLayers.remove(childPosition);
+        }
+    }
+
+    public Style getStyle() {
+        if (mMap == null) return null;
+        return mMap.getStyle();
+    }
+
+    public abstract T makeSource();
+
+    static public class OnPressEvent {
+        public List<Feature> features;
+        public LatLng latLng;
+        public PointF screenPoint;
+
+        public OnPressEvent(@NonNull List<Feature> features, @NonNull LatLng latLng, @NonNull PointF screenPoint) {
+            this.features = features;
+            this.latLng = latLng;
+            this.screenPoint = screenPoint;
+        }
+    }
+
+    public abstract void onPress(OnPressEvent event);
+
+    public static boolean isDefaultSource(String sourceID) {
+        return DEFAULT_ID.equals(sourceID);
+    }
+}

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

@@ -0,0 +1,97 @@
+package org.maplibre.reactnative.components.styles.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/styles/sources/MLRNTileSourceManager.java

@@ -0,0 +1,80 @@
+package org.maplibre.reactnative.components.styles.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/styles/sources/MLRNVectorSource.java

@@ -0,0 +1,60 @@
+package org.maplibre.reactnative.components.styles.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/styles/sources/MLRNVectorSourceManager.java

@@ -0,0 +1,80 @@
+package org.maplibre.reactnative.components.styles.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

@@ -0,0 +1,62 @@
+package org.maplibre.reactnative.events;
+
+import android.view.View;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+abstract public class AbstractEvent implements IEvent {
+    private int mTagID;
+    private String mEventType;
+    private long mTimestamp;
+
+    public AbstractEvent(String eventType) {
+        this(null, eventType);
+    }
+
+    public AbstractEvent(View view, String eventType) {
+        mEventType = eventType;
+
+        if (view != null) {
+            mTagID = view.getId();
+        }
+
+        mTimestamp = System.currentTimeMillis();
+    }
+
+    public int getID() {
+        return mTagID;
+    }
+
+    public String getType() {
+        return mEventType;
+    }
+
+    public boolean equals(IEvent event) {
+        return getKey().equals(event.getKey()) && mEventType.equals(event.getType());
+    }
+
+    public WritableMap getPayload() {
+        return Arguments.createMap();
+    }
+
+    public long getTimestamp() {
+        return mTimestamp;
+    }
+
+    public WritableMap toJSON() {
+        WritableMap map = Arguments.createMap();
+        map.putString("type", getType());
+
+        WritableMap payloadClone = Arguments.createMap();
+        payloadClone.merge(getPayload());
+        map.putMap("payload", payloadClone);
+        return map;
+    }
+
+    @Override
+    public boolean canCoalesce() {
+        // default behavior of com.facebook.react.uimanager.events.Event
+        return true;
+    }
+}

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

@@ -0,0 +1,34 @@
+package org.maplibre.reactnative.events;
+
+import android.view.View;
+
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import org.maplibre.reactnative.events.constants.EventKeys;
+
+public class AndroidCallbackEvent extends AbstractEvent {
+    private final WritableMap mPayload;
+
+    public AndroidCallbackEvent(View view, String callbackID, WritableMap payload) {
+        super(view, callbackID);
+        mPayload = payload;
+    }
+
+    @Override
+    public String getKey() {
+        return EventKeys.MAP_ANDROID_CALLBACK;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        return mPayload;
+    }
+
+    @Override
+    public boolean canCoalesce() {
+        // Make sure EventDispatcher never merges EventKeys.MAP_ANDROID_CALLBACK events.
+        // These events are couples to unique callbacks references (promises) on the JS side which
+        // each expect response with their corresponding callbackID
+        return false;
+    }
+}

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

@@ -0,0 +1,45 @@
+package org.maplibre.reactnative.events;
+
+import android.util.Log;
+
+import com.facebook.react.ReactApplication;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.modules.core.RCTNativeAppEventEmitter;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+
+public class EventEmitter {
+    public static final String LOG_TAG = "EventEmitter";
+
+
+    private static ReactContext getCurrentReactContext(ReactApplicationContext reactApplicationContext) {
+        if (reactApplicationContext.getApplicationContext() instanceof ReactApplication) {
+            ReactApplication reactApplication = ((ReactApplication) reactApplicationContext
+                    .getApplicationContext());
+
+            return reactApplication
+                    .getReactNativeHost()
+                    .getReactInstanceManager()
+                    .getCurrentReactContext();
+        } else {
+            Log.d(LOG_TAG, "getApplicationContext() application doesn't implement ReactApplication");
+            return reactApplicationContext;
+        }
+    }
+
+
+    public static RCTNativeAppEventEmitter getModuleEmitter(ReactApplicationContext reactApplicationContext) {
+        RCTNativeAppEventEmitter emitter = null;
+
+        try {
+            emitter = getCurrentReactContext(reactApplicationContext)
+                    .getJSModule(RCTNativeAppEventEmitter.class);
+        } catch (NullPointerException e) {
+            Log.d(LOG_TAG, e.getLocalizedMessage());
+        }
+
+        return emitter;
+    }
+}