@maplibre/maplibre-react-native 8.6.0-beta.0

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/components/styles/sources/RCTMGLVectorSource.java

@@ -0,0 +1,64 @@
+package com.mapbox.rctmgl.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 com.mapbox.geojson.Feature;
+import com.mapbox.geojson.FeatureCollection;
+import com.mapbox.mapboxsdk.style.expressions.Expression;
+import com.mapbox.mapboxsdk.style.sources.VectorSource;
+import com.mapbox.rctmgl.events.AndroidCallbackEvent;
+import com.mapbox.rctmgl.events.FeatureClickEvent;
+
+import java.util.List;
+
+/**
+ * Created by nickitaliano on 9/8/17.
+ */
+
+public class RCTMGLVectorSource extends RCTMGLTileSource<VectorSource> {
+    private RCTMGLVectorSourceManager mManager;
+
+    public RCTMGLVectorSource(Context context, RCTMGLVectorSourceManager 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/rctmgl/src/main/java/com/mapbox/rctmgl/components/styles/sources/RCTMGLVectorSourceManager.java

@@ -0,0 +1,84 @@
+package com.mapbox.rctmgl.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 com.mapbox.rctmgl.events.constants.EventKeys;
+import com.mapbox.rctmgl.utils.ConvertUtils;
+import com.mapbox.rctmgl.utils.ExpressionParser;
+
+import javax.annotation.Nonnull;
+
+import java.util.Map;
+
+/**
+ * Created by nickitaliano on 9/8/17.
+ */
+
+public class RCTMGLVectorSourceManager extends RCTMGLTileSourceManager<RCTMGLVectorSource> {
+    public static final String REACT_CLASS = "RCTMGLVectorSource";
+
+    public RCTMGLVectorSourceManager(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+    }
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Nonnull
+    @Override
+    protected RCTMGLVectorSource createViewInstance(@Nonnull ThemedReactContext reactContext) {
+        return new RCTMGLVectorSource(reactContext, this);
+    }
+
+    @ReactProp(name = "hasPressListener")
+    public void setHasPressListener(RCTMGLVectorSource source, boolean hasPressListener) {
+        source.setHasPressListener(hasPressListener);
+    }
+
+    @ReactProp(name="hitbox")
+    public void setHitbox(RCTMGLVectorSource 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(RCTMGLVectorSource 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/rctmgl/src/main/java/com/mapbox/rctmgl/components/styles/sources/RCTSource.java

@@ -0,0 +1,244 @@
+package com.mapbox.rctmgl.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 com.mapbox.geojson.Feature;
+import com.mapbox.mapboxsdk.geometry.LatLng;
+import com.mapbox.mapboxsdk.log.Logger;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.Style;
+import com.mapbox.mapboxsdk.style.sources.Source;
+import com.mapbox.rctmgl.components.AbstractMapFeature;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView;
+import com.mapbox.rctmgl.components.styles.layers.RCTLayer;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by nickitaliano on 9/7/17.
+ */
+
+public abstract class RCTSource<T extends Source> extends AbstractMapFeature {
+    public static final String DEFAULT_ID = "composite";
+    public static final String LOG_TAG = "RCTSource";
+
+    public static final double DEFAULT_HITBOX_WIDTH = 44.0;
+    public static final double DEFAULT_HITBOX_HEIGHT = 44.0;
+
+    protected RCTMGLMapView mMapView;
+    protected MapboxMap mMap;
+
+    protected String mID;
+    protected T mSource;
+    protected boolean mHasPressListener;
+    protected Map<String, Double> mTouchHitbox;
+
+    protected List<RCTLayer> mLayers;
+    private List<RCTLayer> mQueuedLayers;
+
+    public RCTSource(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++) {
+            RCTLayer 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(RCTMGLMapView 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(RCTMGLMapView mapView) {
+        if (mLayers.size() > 0) {
+            for (int i = 0; i < mLayers.size(); i++) {
+                RCTLayer 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("RCTSource.removeFromMap: %s - %s", mSource, ex.getMessage()), ex);
+            }
+        }
+    }
+
+    public void addLayer(View childView, int childPosition) {
+        if (!(childView instanceof RCTLayer)) {
+            return;
+        }
+
+        RCTLayer layer = (RCTLayer) childView;
+        if (mMap == null) {
+            mQueuedLayers.add(childPosition, layer);
+        } else {
+            addLayerToMap(layer, childPosition);
+        }
+    }
+
+    public void removeLayer(int childPosition) {
+        RCTLayer layer;
+        if (mQueuedLayers != null && mQueuedLayers.size() > 0) {
+            layer = mQueuedLayers.get(childPosition);
+        } else {
+            layer = mLayers.get(childPosition);
+        }
+        removeLayerFromMap(layer, childPosition);
+    }
+
+    public RCTLayer getLayerAt(int childPosition) {
+        if (mQueuedLayers != null && mQueuedLayers.size() > 0) {
+            return mQueuedLayers.get(childPosition);
+        }
+        return mLayers.get(childPosition);
+    }
+
+    protected void addLayerToMap(RCTLayer layer, int childPosition) {
+        if (mMapView == null || layer == null) {
+            return;
+        }
+
+        layer.addToMap(mMapView);
+        if (!mLayers.contains(layer)) {
+            mLayers.add(childPosition, layer);
+        }
+    }
+
+    protected void removeLayerFromMap(RCTLayer 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/rctmgl/src/main/java/com/mapbox/rctmgl/events/AbstractEvent.java

@@ -0,0 +1,66 @@
+package com.mapbox.rctmgl.events;
+
+import android.view.View;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+/**
+ * Created by nickitaliano on 8/27/17.
+ */
+
+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/rctmgl/src/main/java/com/mapbox/rctmgl/events/AndroidCallbackEvent.java

@@ -0,0 +1,38 @@
+package com.mapbox.rctmgl.events;
+
+import android.view.View;
+
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.mapbox.rctmgl.events.constants.EventKeys;
+
+/**
+ * Created by nickitaliano on 10/3/17.
+ */
+
+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/rctmgl/src/main/java/com/mapbox/rctmgl/events/EventEmitter.java

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

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/events/FeatureClickEvent.java

@@ -0,0 +1,79 @@
+package com.mapbox.rctmgl.events;
+
+import android.graphics.PointF;
+import android.view.View;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.mapbox.geojson.Feature;
+import com.mapbox.mapboxsdk.geometry.LatLng;
+import com.mapbox.rctmgl.components.styles.sources.RCTSource;
+import com.mapbox.rctmgl.events.constants.EventKeys;
+import com.mapbox.rctmgl.events.constants.EventTypes;
+import com.mapbox.rctmgl.utils.ConvertUtils;
+import com.mapbox.rctmgl.utils.GeoJSONUtils;
+
+import java.util.List;
+
+/**
+ * Created by nickitaliano on 11/7/17.
+ */
+
+public class FeatureClickEvent extends AbstractEvent {
+    private String mEventKey;
+    private List<Feature> mFeatures;
+    private LatLng mLatLng;
+    private PointF mPoint;
+
+    public FeatureClickEvent(View view, String eventKey, String eventType, List<Feature> features, LatLng latLng, PointF point) {
+        super(view, eventType);
+        mFeatures = features;
+        mEventKey = eventKey;
+        mLatLng = latLng;
+        mPoint = point;
+    }
+
+    @Override
+    public String getKey() {
+        return mEventKey;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        WritableMap map = Arguments.createMap();
+        WritableArray features = Arguments.createArray();
+
+        for(Feature feature : mFeatures) {
+            features.pushMap(GeoJSONUtils.fromFeature(feature));
+        }
+        map.putArray("features", features);
+
+        WritableMap coordinates = Arguments.createMap();
+        coordinates.putDouble("latitude", mLatLng.getLatitude());
+        coordinates.putDouble("longitude", mLatLng.getLongitude());
+        map.putMap("coordinates", coordinates);
+
+        WritableMap point = Arguments.createMap();
+        point.putDouble("x", mPoint.x);
+        point.putDouble("y", mPoint.y);
+        map.putMap("point", point);
+
+        return map;
+    }
+
+    public static FeatureClickEvent makeShapeSourceEvent(View view, RCTSource.OnPressEvent event) {
+        return new FeatureClickEvent(view, EventKeys.SHAPE_SOURCE_LAYER_CLICK,
+                EventTypes.SHAPE_SOURCE_LAYER_CLICK, event.features, event.latLng, event.screenPoint);
+    }
+
+    public static FeatureClickEvent makeVectorSourceEvent(View view, RCTSource.OnPressEvent event) {
+        return new FeatureClickEvent(view, EventKeys.VECTOR_SOURCE_LAYER_CLICK,
+                EventTypes.VECTOR_SOURCE_LAYER_CLICK, event.features, event.latLng, event.screenPoint);
+    }
+
+    public static FeatureClickEvent makeRasterSourceEvent(View view, RCTSource.OnPressEvent event) {
+        return new FeatureClickEvent(view, EventKeys.RASTER_SOURCE_LAYER_CLICK,
+                EventTypes.RASTER_SOURCE_LAYER_CLICK, event.features, event.latLng, event.screenPoint);
+    }
+}

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/events/IEvent.java

@@ -0,0 +1,18 @@
+package com.mapbox.rctmgl.events;
+
+import com.facebook.react.bridge.WritableMap;
+
+/**
+ * Created by nickitaliano on 8/23/17.
+ */
+
+public interface IEvent {
+    int getID();
+    String getKey();
+    String getType();
+    long getTimestamp();
+    boolean equals(IEvent event);
+    boolean canCoalesce();
+    WritableMap getPayload();
+    WritableMap toJSON();
+}

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/events/ImageMissingEvent.java

@@ -0,0 +1,42 @@
+package com.mapbox.rctmgl.events;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.mapbox.rctmgl.events.constants.EventKeys;
+import com.mapbox.rctmgl.events.constants.EventTypes;
+
+import android.view.View;
+
+public class ImageMissingEvent extends AbstractEvent {
+    private String mEventKey;
+    private String mImageKey;
+
+    public ImageMissingEvent(View view, String eventKey, String eventType, String imageKey) {
+        super(view, eventType);
+        mImageKey = imageKey;
+        mEventKey = eventKey;
+    }
+
+    @Override
+    public String getKey() {
+        return mEventKey;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        WritableMap imageMissingProperties = new WritableNativeMap();
+        imageMissingProperties.putString("imageKey", mImageKey);
+        return imageMissingProperties;
+
+    }
+
+    public static ImageMissingEvent makeImageMissingEvent(View view, String imageKey) {
+        return new ImageMissingEvent(view, EventKeys.IMAGES_MISSING,
+                EventTypes.IMAGES_MISSING, imageKey);
+    }
+
+    @Override
+    public boolean canCoalesce() {
+        return false;
+    }
+}