@rnmapbox/maps 10.0.0-beta.28

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/RCTMGLPackage.java

@@ -0,0 +1,99 @@
+package com.mapbox.rctmgl;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import com.mapbox.rctmgl.components.annotation.RCTMGLCalloutManager;
+import com.mapbox.rctmgl.components.annotation.RCTMGLPointAnnotationManager;
+import com.mapbox.rctmgl.components.annotation.RCTMGLMarkerViewManager;
+import com.mapbox.rctmgl.components.camera.RCTMGLCameraManager;
+import com.mapbox.rctmgl.components.images.RCTMGLImagesManager;
+import com.mapbox.rctmgl.components.location.RCTMGLNativeUserLocationManager;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapViewManager;
+import com.mapbox.rctmgl.components.mapview.RCTMGLAndroidTextureMapViewManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLBackgroundLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLCircleLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLFillExtrusionLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLFillLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLHeatmapLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLLineLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLRasterLayerManager;
+import com.mapbox.rctmgl.components.styles.layers.RCTMGLSymbolLayerManager;
+import com.mapbox.rctmgl.components.styles.light.RCTMGLLightManager;
+import com.mapbox.rctmgl.components.styles.sources.RCTMGLImageSourceManager;
+import com.mapbox.rctmgl.components.styles.sources.RCTMGLRasterSourceManager;
+import com.mapbox.rctmgl.components.styles.sources.RCTMGLShapeSourceManager;
+import com.mapbox.rctmgl.components.styles.sources.RCTMGLVectorSourceManager;
+import com.mapbox.rctmgl.modules.RCTMGLLocationModule;
+import com.mapbox.rctmgl.modules.RCTMGLLogging;
+import com.mapbox.rctmgl.modules.RCTMGLModule;
+import com.mapbox.rctmgl.modules.RCTMGLOfflineModule;
+import com.mapbox.rctmgl.modules.RCTMGLSnapshotModule;
+
+/**
+ * Created by nickitaliano on 8/18/17.
+ */
+
+public class RCTMGLPackage implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactApplicationContext) {
+        List<NativeModule> modules = new ArrayList<>();
+
+        modules.add(new RCTMGLModule(reactApplicationContext));
+        modules.add(new RCTMGLOfflineModule(reactApplicationContext));
+        modules.add(new RCTMGLSnapshotModule(reactApplicationContext));
+        modules.add(new RCTMGLLocationModule(reactApplicationContext));
+        modules.add(new RCTMGLLogging(reactApplicationContext));
+
+        return modules;
+    }
+
+    @Deprecated
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactApplicationContext) {
+        List<ViewManager> managers = new ArrayList<>();
+
+        // components
+        managers.add(new RCTMGLCameraManager(reactApplicationContext));
+        managers.add(new RCTMGLMapViewManager(reactApplicationContext));
+        managers.add(new RCTMGLMarkerViewManager(reactApplicationContext));
+        managers.add(new RCTMGLAndroidTextureMapViewManager(reactApplicationContext));
+        managers.add(new RCTMGLLightManager());
+        managers.add(new RCTMGLPointAnnotationManager(reactApplicationContext));
+        managers.add(new RCTMGLCalloutManager());
+        managers.add(new RCTMGLNativeUserLocationManager());
+
+        // sources
+        managers.add(new RCTMGLVectorSourceManager(reactApplicationContext));
+        managers.add(new RCTMGLShapeSourceManager(reactApplicationContext));
+        managers.add(new RCTMGLRasterSourceManager(reactApplicationContext));
+        managers.add(new RCTMGLImageSourceManager());
+
+        // images
+        managers.add(new RCTMGLImagesManager(reactApplicationContext));
+
+        // layers
+        managers.add(new RCTMGLFillLayerManager());
+        managers.add(new RCTMGLFillExtrusionLayerManager());
+        managers.add(new RCTMGLHeatmapLayerManager());
+        managers.add(new RCTMGLLineLayerManager());
+        managers.add(new RCTMGLCircleLayerManager());
+        managers.add(new RCTMGLSymbolLayerManager());
+        managers.add(new RCTMGLRasterLayerManager());
+        managers.add(new RCTMGLBackgroundLayerManager());
+
+        return managers;
+    }
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/AbstractEvent.java

@@ -0,0 +1,35 @@
+package com.mapbox.rctmgl.components;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+import javax.annotation.Nullable;
+
+public class AbstractEvent extends Event<AbstractEvent> {
+    private String mEventName;
+    private final boolean mCanCoalesce;
+    private WritableMap mEvent;
+
+    public AbstractEvent(int viewId, String eventName, boolean canCoalesce, @Nullable WritableMap event) {
+        super(viewId);
+        mEventName = eventName;
+        mCanCoalesce = canCoalesce;
+        mEvent = event;
+    }
+
+    @Override
+    public String getEventName() {
+        return mEventName;
+    }
+
+    @Override
+    public void dispatch(RCTEventEmitter rctEventEmitter) {
+        rctEventEmitter.receiveEvent(getViewTag(), getEventName(), mEvent);
+    }
+
+    @Override
+    public boolean canCoalesce() {
+        return mCanCoalesce;
+    }
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/AbstractEventEmitter.java

@@ -0,0 +1,80 @@
+package com.mapbox.rctmgl.components;
+
+import android.view.ViewGroup;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.mapbox.rctmgl.events.IEvent;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+import javax.annotation.Nonnull;
+
+/**
+ * Created by nickitaliano on 8/23/17.
+ */
+
+abstract public class AbstractEventEmitter<T extends ViewGroup> extends ViewGroupManager<T> {
+    private static final double BRIDGE_TIMEOUT_MS = 10;
+    private Map<String, Long> mRateLimitedEvents;
+    private EventDispatcher mEventDispatcher;
+    private ReactApplicationContext mRCTAppContext;
+
+    public AbstractEventEmitter(ReactApplicationContext reactApplicationContext) {
+        mRateLimitedEvents = new HashMap<>();
+        mRCTAppContext = reactApplicationContext;
+    }
+
+    public void handleEvent(IEvent event) {
+        String eventCacheKey = getEventCacheKey(event);
+
+        // fail safe to protect bridge from being spammed
+        if (shouldDropEvent(eventCacheKey, event)) {
+            return;
+        }
+
+        mRateLimitedEvents.put(eventCacheKey, System.currentTimeMillis());
+        mEventDispatcher.dispatchEvent(new AbstractEvent(event.getID(), event.getKey(), event.canCoalesce(), event.toJSON()));
+    }
+
+    @Override
+    protected void addEventEmitters(ThemedReactContext context, @Nonnull T view) {
+        mEventDispatcher = context.getNativeModule(UIManagerModule.class).getEventDispatcher();
+    }
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        Map<String, String> events = customEvents();
+
+        if (events == null) {
+            return null;
+        }
+
+        Map<String, Object> exportedEvents = new HashMap<>();
+
+        for (Map.Entry<String, String> event : events.entrySet()) {
+            exportedEvents.put(event.getKey(), MapBuilder.of("registrationName", event.getValue()));
+        }
+
+        return exportedEvents;
+    }
+
+    @Nullable
+    public abstract Map<String, String> customEvents();
+
+    private boolean shouldDropEvent(String cacheKey, IEvent event) {
+        Long lastEventTimestamp = mRateLimitedEvents.get(cacheKey);
+        return lastEventTimestamp != null && (event.getTimestamp() - lastEventTimestamp) <= BRIDGE_TIMEOUT_MS;
+    }
+
+    private String getEventCacheKey(IEvent event) {
+        return String.format("%s-%s", event.getKey(), event.getType());
+    }
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/AbstractMapFeature.java

@@ -0,0 +1,19 @@
+package com.mapbox.rctmgl.components;
+
+import android.content.Context;
+
+import com.facebook.react.views.view.ReactViewGroup;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView;
+
+/**
+ * Created by nickitaliano on 9/6/17.
+ */
+
+public abstract class AbstractMapFeature extends ReactViewGroup {
+    public AbstractMapFeature(Context context) {
+        super(context);
+    }
+
+    public abstract void addToMap(RCTMGLMapView mapView);
+    public abstract void removeFromMap(RCTMGLMapView mapView);
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/annotation/MarkerView.java

@@ -0,0 +1,23 @@
+package com.mapbox.rctmgl.components.annotation;
+
+import android.view.View;
+
+import androidx.annotation.NonNull;
+
+import com.mapbox.mapboxsdk.geometry.LatLng;
+
+/**
+ * Subclass of MarkerView so we MarkerViewManager can implement remove/restoreViews
+ */
+public class MarkerView extends com.mapbox.mapboxsdk.plugins.markerview.MarkerView {
+    View view;
+
+    public MarkerView(@NonNull LatLng latLng, @NonNull View view) {
+        super(latLng, view);
+        this.view = view;
+    }
+
+    public View getView() {
+        return this.view;
+    }
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/annotation/MarkerViewManager.java

@@ -0,0 +1,69 @@
+package com.mapbox.rctmgl.components.annotation;
+
+import androidx.annotation.NonNull;
+
+import com.mapbox.mapboxsdk.maps.MapView;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import java.lang.reflect.InvocationTargetException;
+
+/**
+ * Subclass of MarkerViewManager implementing removeViews and restoreViews
+ */
+public class MarkerViewManager extends com.mapbox.mapboxsdk.plugins.markerview.MarkerViewManager {
+    private final List<MarkerView> markers = new ArrayList<>();
+    private MapView mapView;
+    private java.lang.reflect.Method markerUpdate;
+
+    public MarkerViewManager(MapView mapView, MapboxMap mapboxMap) {
+        super(mapView, mapboxMap);
+        this.mapView = mapView;
+        // this.mapboxMap = mapboxMap;
+
+        try {     
+            markerUpdate = MarkerView.class.getSuperclass().getDeclaredMethod("update");
+            markerUpdate.setAccessible(true);
+        } 
+        catch (NoSuchMethodException e) {System.out.println(e.toString());}
+    }
+
+    public void addMarker(@NonNull MarkerView markerView) {
+        super.addMarker(markerView);
+        markers.add(markerView);
+    }
+
+    public void removeMarker(@NonNull MarkerView markerView) {
+        super.removeMarker(markerView);
+        markers.remove(markerView);
+    }
+
+    public void removeViews() {
+        for (MarkerView marker: markers) {
+            mapView.removeView(marker.getView());
+        }
+    }
+
+    public void restoreViews() {
+        for (MarkerView marker: markers) {
+            mapView.addView(marker.getView());
+        }
+    }
+
+    public void updateMarkers(){
+        
+        try {   
+            if (markerUpdate != null) {       
+                for( int i = 0; i < markers.size(); i++ ){    
+                    markerUpdate.invoke(markers.get(i));
+                }
+             }
+         } 
+        catch (IllegalArgumentException e) { System.out.println(e.toString()); }
+        catch (IllegalAccessException e) { System.out.println(e.toString()); }
+        catch (InvocationTargetException e) { System.out.println(e.toString()); }
+    }
+
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/annotation/RCTMGLCallout.java

@@ -0,0 +1,15 @@
+package com.mapbox.rctmgl.components.annotation;
+
+import android.content.Context;
+
+import com.facebook.react.views.view.ReactViewGroup;
+
+/**
+ * Created by nickitaliano on 10/11/17.
+ */
+
+public class RCTMGLCallout extends ReactViewGroup {
+    public RCTMGLCallout(Context context) {
+        super(context);
+    }
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/annotation/RCTMGLCalloutManager.java

@@ -0,0 +1,22 @@
+package com.mapbox.rctmgl.components.annotation;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+
+/**
+ * Created by nickitaliano on 10/11/17.
+ */
+
+public class RCTMGLCalloutManager extends ViewGroupManager<RCTMGLCallout> {
+    public static final String REACT_CLASS = "RCTMGLCallout";
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    protected RCTMGLCallout createViewInstance(ThemedReactContext reactContext) {
+        return new RCTMGLCallout(reactContext);
+    }
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/annotation/RCTMGLMarkerView.java

@@ -0,0 +1,112 @@
+package com.mapbox.rctmgl.components.annotation;
+
+import android.content.Context;
+import android.graphics.PointF;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+
+import com.mapbox.geojson.Point;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
+import com.mapbox.rctmgl.components.AbstractMapFeature;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView;
+import com.mapbox.rctmgl.utils.GeoJSONUtils;
+
+public class RCTMGLMarkerView extends AbstractMapFeature implements MarkerView.OnPositionUpdateListener, View.OnLayoutChangeListener {
+    private RCTMGLMarkerViewManager mManager;
+    private RCTMGLMapView mMapView;
+
+    private View mChildView;
+
+    private MarkerViewManager mMarkerViewManager;
+
+    private MarkerView mMarkerView;
+    private Point mCoordinate;
+    private Float[] mAnchor;
+
+
+    public RCTMGLMarkerView(Context context, RCTMGLMarkerViewManager manager) {
+        super(context);
+        mManager = manager;
+    }
+
+    @Override
+    public void addView(View childView, int childPosition) {
+        mChildView = childView;
+    }
+
+    public void setCoordinate(Point point) {
+        mCoordinate = point;
+
+        if (mMarkerView != null) {
+            mMarkerView.setLatLng(GeoJSONUtils.toLatLng(point));
+        }
+    }
+
+    public void setAnchor(float x, float y) {
+        mAnchor = new Float[]{x, y};
+        refresh();
+    }
+
+    public void refresh() {
+        // this will cause position to be recalculated
+        if (mMarkerView != null) {
+            mMarkerView.setLatLng(GeoJSONUtils.toLatLng(mCoordinate));
+        }
+    }
+
+    @Override
+    public void addToMap(RCTMGLMapView mapView) {
+        mMapView = mapView;
+
+        final RCTMGLMarkerView rctmglMarkerView = this;
+
+        mMapView.getMapAsync(
+            new OnMapReadyCallback() {
+                @Override
+                public void onMapReady(@NonNull MapboxMap mapboxMap) {
+                    mMarkerViewManager = mMapView.getMarkerViewManager(mapboxMap);
+
+                    if (mChildView != null) {
+                        mMarkerView = new MarkerView(GeoJSONUtils.toLatLng(mCoordinate), mChildView);
+                        mMarkerView.setOnPositionUpdateListener(rctmglMarkerView);
+                        mChildView.addOnLayoutChangeListener(rctmglMarkerView);
+                        mMarkerViewManager.addMarker(mMarkerView);
+                    }
+                }
+            }
+        );
+    }
+
+    @Override
+    public PointF onUpdate(PointF pointF) {
+        if (mAnchor != null) {
+            return new PointF(
+                    pointF.x - mChildView.getWidth() * mAnchor[0],
+                    pointF.y - mChildView.getHeight() * mAnchor[1]
+                    );
+        }
+        return pointF;
+    }
+
+    @Override
+    public void removeFromMap(RCTMGLMapView mapView) {
+        if (mMarkerView != null) {
+            mMarkerViewManager.removeMarker(mMarkerView);
+            mChildView.removeOnLayoutChangeListener(this);
+            mMarkerView.setOnPositionUpdateListener(null);
+            mMarkerView = null;
+            mMarkerViewManager = null;
+        }
+    }
+
+    @Override
+    public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop,
+                               int oldRight, int oldBottom) {
+        if (left != oldLeft || right != oldRight || top != oldTop || bottom != oldBottom) {
+            refresh();
+        }
+    }
+}
+

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/annotation/RCTMGLMarkerViewManager.java

@@ -0,0 +1,45 @@
+package com.mapbox.rctmgl.components.annotation;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+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.components.AbstractEventEmitter;
+import com.mapbox.rctmgl.utils.GeoJSONUtils;
+
+import java.util.Map;
+
+public class RCTMGLMarkerViewManager extends AbstractEventEmitter<RCTMGLMarkerView> {
+    public static final String REACT_CLASS = "RCTMGLMarkerView";
+
+    public RCTMGLMarkerViewManager(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @ReactProp(name="coordinate")
+    public void setCoordinate(RCTMGLMarkerView markerView, String geoJSONStr) {
+        markerView.setCoordinate(GeoJSONUtils.toPointGeometry(geoJSONStr));
+    }
+
+    @ReactProp(name="anchor")
+    public void setAnchor(RCTMGLMarkerView markerView, ReadableMap map) {
+        markerView.setAnchor((float) map.getDouble("x"), (float) map.getDouble("y"));
+    }
+
+    @Override
+    protected RCTMGLMarkerView createViewInstance(ThemedReactContext reactContext) {
+        return new RCTMGLMarkerView(reactContext, this);
+    }
+
+    @Override
+    public Map<String, String> customEvents() {
+        return MapBuilder.<String, String>builder()
+                .build();
+    }
+}