@rnmapbox/maps 10.0.0-beta.28

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

@@ -0,0 +1,103 @@
+package com.mapbox.rctmgl.components.styles.sources;
+
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.Size;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.mapbox.bindgen.Expected;
+import com.mapbox.geojson.Feature;
+import com.mapbox.geojson.FeatureCollection;
+
+import com.mapbox.maps.QueriedFeature;
+import com.mapbox.maps.QueryFeaturesCallback;
+import com.mapbox.maps.SourceQueryOptions;
+import com.mapbox.maps.Style;
+import com.mapbox.maps.StyleManagerInterface;
+import com.mapbox.maps.StyleObjectInfo;
+import com.mapbox.maps.extension.style.expressions.generated.Expression;
+import com.mapbox.maps.extension.style.sources.Source;
+import com.mapbox.maps.extension.style.sources.generated.VectorSource;
+import com.mapbox.maps.extension.style.sources.SourceUtils;
+
+import com.mapbox.maps.plugin.delegates.MapFeatureQueryDelegate;
+import com.mapbox.rctmgl.events.AndroidCallbackEvent;
+import com.mapbox.rctmgl.events.FeatureClickEvent;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+
+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(getID())) {
+            return (VectorSource)SourceUtils.getSource(mMap.getStyle(), DEFAULT_ID);
+        }
+
+        String configurationUrl = getURL();
+        if (configurationUrl != null) {
+            return new VectorSource(
+                    new VectorSource.Builder(getID())
+                            .url(getURL())
+            );
+        }
+        return new VectorSource(
+                new VectorSource.Builder(getID())
+                        .tileSet(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;
+        }
+
+
+        WritableMap payload = new WritableNativeMap();
+
+        mMap.querySourceFeatures(
+                getID(),
+                new SourceQueryOptions(layerIDs, filter),
+
+                new QueryFeaturesCallback() {
+                    @Override
+                    public void run(@NonNull Expected<String, List<QueriedFeature>> queriedFeatures) {
+                        if (queriedFeatures.isError()) {
+                            //V10todo
+                            payload.putString("error", queriedFeatures.getError());
+                        } else {
+                            List<Feature> features = new LinkedList<>();
+                            for (QueriedFeature feature: queriedFeatures.getValue()) {
+                                features.add(feature.getFeature());
+                            }
+                            payload.putString("data", FeatureCollection.fromFeatures(features).toJson());
+                        }
+                    }
+                }
+        );
+
+        AndroidCallbackEvent event = new AndroidCallbackEvent(this, callbackID, payload);
+        mManager.handleEvent(event);
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/sources/RCTMGLVectorSourceManager.java

@@ -0,0 +1,80 @@
+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;
+
+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-v10/com/mapbox/rctmgl/components/styles/sources/RCTSource.kt

@@ -0,0 +1,211 @@
+package com.mapbox.rctmgl.components.styles.sources
+
+import android.content.Context
+import com.mapbox.maps.extension.style.sources.getSource
+import com.mapbox.maps.extension.style.sources.addSource
+import com.mapbox.rctmgl.components.AbstractMapFeature
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.mapbox.maps.MapboxMap
+import com.mapbox.rctmgl.components.styles.sources.AbstractSourceConsumer
+import com.facebook.react.bridge.ReadableMap
+import com.mapbox.rctmgl.components.styles.sources.RCTSource
+import android.graphics.PointF
+import android.view.View
+import com.facebook.react.common.MapBuilder
+import com.mapbox.geojson.Feature
+import com.mapbox.maps.Style
+import com.mapbox.maps.extension.style.StyleContract
+import com.mapbox.maps.extension.style.sources.Source
+import com.mapbox.rctmgl.components.styles.sources.RCTSource.OnPressEvent
+import com.mapbox.rctmgl.utils.LatLng
+import com.mapbox.rctmgl.utils.Logger
+import java.lang.ClassCastException
+import java.util.ArrayList
+import java.util.HashMap
+
+abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(context) {
+    @JvmField
+    protected var mMapView: RCTMGLMapView? = null
+    @JvmField
+    protected var mMap: MapboxMap? = null
+    var iD: String? = null
+    @JvmField
+    protected var mSource: T? = null
+    protected var mHasPressListener = false
+    protected var mTouchHitbox: Map<String, Double>? = null
+    protected var mLayers: MutableList<AbstractSourceConsumer>
+    private var mQueuedLayers: MutableList<AbstractSourceConsumer>?
+    val layerIDs: List<String>
+        get() {
+            val layerIDs: MutableList<String> = ArrayList()
+            for (i in mLayers.indices) {
+                val layer = mLayers[i]
+                val id = layer.iD
+                if (id != null) {
+                    layerIDs.add(id)
+                }
+            }
+            return layerIDs
+        }
+
+    private fun getSourceAs(style: Style, id: String?): T? {
+        val result = iD?.let { style.getSource(it) }
+        return try {
+            result as T?
+        } catch (exception: ClassCastException) {
+            null
+        }
+    }
+
+    protected fun addLayerToMap(layer: AbstractSourceConsumer?, childPosition: Int) {
+        if (mMapView == null || layer == null) {
+            return
+        }
+        layer.addToMap(mMapView)
+        if (!mLayers.contains(layer)) {
+            mLayers.add(childPosition, layer)
+        }
+    }
+
+    open fun hasPressListener(): Boolean {
+        return mHasPressListener
+    }
+
+    fun setHasPressListener(hasPressListener: Boolean) {
+        mHasPressListener = hasPressListener
+    }
+
+    fun setHitbox(map: ReadableMap) {
+        val hitbox: MutableMap<String, Double> = HashMap()
+        hitbox["width"] = map.getDouble("width")
+        hitbox["height"] = map.getDouble("height")
+        mTouchHitbox = hitbox
+    }
+
+    val touchHitbox: Map<String, Double>?
+        get() {
+            if (!hasPressListener()) {
+                return null
+            }
+            return if (mTouchHitbox == null) {
+                MapBuilder.builder<String, Double>()
+                        .put("width", DEFAULT_HITBOX_WIDTH)
+                        .put("height", DEFAULT_HITBOX_HEIGHT)
+                        .build()
+            } else mTouchHitbox
+        }
+    val layerCount: Int
+        get() {
+            var totalCount = 0
+            if (mQueuedLayers != null) {
+                totalCount = mQueuedLayers!!.size
+            }
+            totalCount += mLayers.size
+            return totalCount
+        }
+
+    override fun addToMap(mapView: RCTMGLMapView) {
+        mMapView = mapView
+        mMap = mapView.getMapboxMap()
+        mMap?.getStyle(object : Style.OnStyleLoaded {
+            override fun onStyleLoaded(style: Style) {
+                val existingSource = getSourceAs(style, iD)
+                if (existingSource != null) {
+                    mSource = existingSource
+                } else {
+                    mSource = makeSource()
+                    style.addSource(mSource as StyleContract.StyleSourceExtension)
+                }
+                if (mQueuedLayers != null && mQueuedLayers!!.size > 0) { // first load
+                    for (i in mQueuedLayers!!.indices) {
+                        addLayerToMap(mQueuedLayers!![i], i)
+                    }
+                    mQueuedLayers = null
+                } else if (mLayers.size > 0) { // handles the case of switching style url, but keeping layers on map
+                    for (i in mLayers.indices) {
+                        addLayerToMap(mLayers[i], i)
+                    }
+                }
+            }
+        })
+    }
+
+    override fun removeFromMap(mapView: RCTMGLMapView) {
+        if (mLayers.size > 0) {
+            for (i in mLayers.indices) {
+                val layer = mLayers[i]
+                layer.removeFromMap(mMapView)
+            }
+        }
+        if (mQueuedLayers != null) {
+            mQueuedLayers!!.clear()
+        }
+        if (mMap != null && mSource != null && mMap!!.getStyle() != null) {
+            try {
+                iD?.let { mMap?.getStyle()?.removeStyleSource(it) }
+            } catch (ex: Throwable) {
+                Logger.w(LOG_TAG, String.format("RCTSource.removeFromMap: %s - %s", mSource, ex.message), ex)
+            }
+        }
+    }
+
+    fun addLayer(childView: View?, childPosition: Int) {
+        if (childView !is AbstractSourceConsumer) {
+            return
+        }
+        val layer = childView
+        if (mMap == null) {
+            mQueuedLayers?.add(childPosition, layer)
+        } else {
+            addLayerToMap(layer, childPosition)
+        }
+    }
+
+    fun removeLayer(childPosition: Int) {
+        val layer: AbstractSourceConsumer
+        layer = if (mQueuedLayers != null && mQueuedLayers!!.size > 0) {
+            mQueuedLayers!![childPosition]
+        } else {
+            mLayers[childPosition]
+        }
+        removeLayerFromMap(layer, childPosition)
+    }
+
+    fun getLayerAt(childPosition: Int): AbstractSourceConsumer {
+        return if (mQueuedLayers != null && mQueuedLayers!!.size > 0) {
+            mQueuedLayers!![childPosition]
+        } else mLayers[childPosition]
+    }
+
+    protected fun removeLayerFromMap(layer: AbstractSourceConsumer?, childPosition: Int) {
+        if (mMapView != null && layer != null) {
+            layer.removeFromMap(mMapView)
+        }
+        if (mQueuedLayers != null && mQueuedLayers!!.size > 0) {
+            mQueuedLayers?.removeAt(childPosition)
+        } else {
+            mLayers.removeAt(childPosition)
+        }
+    }
+
+    abstract fun makeSource(): T
+    class OnPressEvent(var features: List<Feature>, var latLng: LatLng, var screenPoint: PointF)
+
+    abstract fun onPress(event: OnPressEvent?)
+
+    companion object {
+        const val DEFAULT_ID = "composite"
+        const val LOG_TAG = "RCTSource"
+        const val DEFAULT_HITBOX_WIDTH = 44.0
+        const val DEFAULT_HITBOX_HEIGHT = 44.0
+        @JvmStatic
+        fun isDefaultSource(sourceID: String): Boolean {
+            return DEFAULT_ID == sourceID
+        }
+    }
+
+    init {
+        mLayers = ArrayList()
+        mQueuedLayers = ArrayList()
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/terrain/RCTMGLTerrain.kt

@@ -0,0 +1,58 @@
+package com.mapbox.rctmgl.components.styles.terrain
+
+import android.content.Context
+import com.facebook.react.bridge.Dynamic
+import com.mapbox.rctmgl.components.styles.sources.AbstractSourceConsumer
+import com.mapbox.maps.extension.style.terrain.generated.Terrain
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.facebook.react.bridge.ReadableType
+import com.mapbox.rctmgl.utils.ExpressionParser
+import com.mapbox.rctmgl.utils.Logger
+
+class RCTMGLTerrain(context: Context?) : AbstractSourceConsumer(context) {
+    override var iD: String? = null
+    protected var mSourceID: String? = null
+    protected var mExaggeration: Dynamic? = null
+    protected var mTerrain: Terrain? = null
+
+    fun setSourceID(sourceID: String?) {
+        mSourceID = sourceID
+    }
+
+    override fun addToMap(mapView: RCTMGLMapView) {
+        val terrain = makeTerrain()
+        addStyles(terrain)
+        mTerrain = terrain
+        mapView.savedStyle?.let { mTerrain!!.bindTo(it) }
+    }
+
+    override fun removeFromMap(mapView: RCTMGLMapView) {
+        val emptyTerrain = Terrain("no-such-source-empty")
+        mapView.savedStyle?.let { emptyTerrain.bindTo(it) }
+    }
+
+    fun makeTerrain(): Terrain {
+        return Terrain(mSourceID!!)
+    }
+
+    fun setExaggeration(exaggeration: Dynamic?) {
+        mExaggeration = exaggeration
+    }
+
+    fun addStyles(terrain: Terrain) {
+        when (mExaggeration!!.type) {
+            ReadableType.Number -> terrain.exaggeration(mExaggeration!!.asDouble())
+            ReadableType.Array -> terrain.exaggeration(
+                    ExpressionParser.from(mExaggeration!!.asArray())!!
+            )
+            else -> Logger.e(
+                    "RCTMGLTerrain",
+                    "Unexpected type passed to exaggeration:$mExaggeration"
+            )
+        }
+    }
+
+    fun setSourceLayerID(sourceLayerID: String?) {
+        Logger.e("RCTMGLSkyLayer", "Source layer should not be set for source layer id")
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/terrain/RCTMGLTerrainManager.kt

@@ -0,0 +1,41 @@
+package com.mapbox.rctmgl.components.styles.terrain
+
+import com.facebook.react.bridge.Dynamic
+import com.mapbox.rctmgl.components.styles.sources.AbstractSourceConsumer
+import com.mapbox.maps.extension.style.terrain.generated.Terrain
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.uimanager.ViewGroupManager
+import com.mapbox.rctmgl.components.styles.terrain.RCTMGLTerrain
+import com.mapbox.rctmgl.components.styles.terrain.RCTMGLTerrainManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class RCTMGLTerrainManager : ViewGroupManager<RCTMGLTerrain>() {
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    override fun createViewInstance(reactContext: ThemedReactContext): RCTMGLTerrain {
+        return RCTMGLTerrain(reactContext)
+    }
+
+    @ReactProp(name = "id")
+    fun setId(layer: RCTMGLTerrain, id: String?) {
+        layer.iD = id
+    }
+
+    @ReactProp(name = "sourceID")
+    fun setSourceID(layer: RCTMGLTerrain, sourceID: String?) {
+        layer.setSourceID(sourceID)
+    }
+
+    @ReactProp(name = "exaggeration")
+    fun setExaggeration(layer: RCTMGLTerrain, exaggeration: Dynamic?) {
+        layer.setExaggeration(exaggeration)
+    }
+
+    companion object {
+        const val REACT_CLASS = "RCTMGLTerrain"
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/events/AbstractEvent.java

@@ -0,0 +1,62 @@
+package com.mapbox.rctmgl.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/rctmgl/src/main/java-v10/com/mapbox/rctmgl/events/AndroidCallbackEvent.java

@@ -0,0 +1,34 @@
+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;
+
+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-v10/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;
+    }
+}