@rnmapbox/maps 10.0.0-beta.76 → 10.0.0-beta.78

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

@@ -0,0 +1,82 @@
+package com.mapbox.rctmgl.components.styles.sources
+
+import android.content.Context
+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.maps.SourceQueryOptions
+import com.mapbox.maps.extension.style.expressions.generated.Expression
+import com.mapbox.maps.extension.style.sources.generated.RasterDemSource
+import com.mapbox.maps.extension.style.sources.getSource
+import com.mapbox.rctmgl.events.AndroidCallbackEvent
+import com.mapbox.rctmgl.events.FeatureClickEvent
+import com.mapbox.rctmgl.utils.Logger
+import java.util.*
+
+// import com.mapbox.rctmgl.R;
+// import com.mapbox.rctmgl.utils.DownloadMapImageTask;
+class RCTMGLRasterDemSource(context: Context?, private val mManager: RCTMGLRasterDemSourceManager) :
+    RCTMGLTileSource<RasterDemSource?>(context) {
+    override fun onPress(event: OnPressEvent?) {
+        mManager.handleEvent(FeatureClickEvent.makeVectorSourceEvent(this, event))
+    }
+
+    override fun makeSource(): RasterDemSource? {
+        val id = iD
+        if (id == null) {
+            Logger.w("RCTMGLRasterDemSource", "id is required")
+            return null
+        }
+        if (isDefaultSource(id)) {
+            return mMap!!.getStyle()!!.getSource(DEFAULT_ID) as RasterDemSource
+        }
+        val configurationUrl = uRL
+        return if (configurationUrl != null) {
+            RasterDemSource(
+                RasterDemSource.Builder(id)
+                    .url(configurationUrl)
+            )
+        } else RasterDemSource(
+            RasterDemSource.Builder(id)
+                .tileSet(buildTileset())
+        )
+    }
+
+    fun querySourceFeatures(
+        callbackID: String?,
+        @Size(min = 1) layerIDs: List<String?>?,
+        filter: Expression?
+    ) {
+        if (mSource == null) {
+            val payload: WritableMap = WritableNativeMap()
+            payload.putString("error", "source is not yet loaded")
+            val event = AndroidCallbackEvent(this, callbackID, payload)
+            mManager.handleEvent(event)
+            return
+        }
+        val payload: WritableMap = WritableNativeMap()
+        mMap!!.querySourceFeatures(
+            iD!!,
+            SourceQueryOptions(layerIDs, filter!!)
+        ) { queriedFeatures ->
+            if (queriedFeatures.isError) {
+                //V10todo
+                payload.putString("error", queriedFeatures.error)
+            } else {
+                val features: MutableList<Feature> = LinkedList()
+                for (feature in queriedFeatures.value!!) {
+                    features.add(feature.feature)
+                }
+                payload.putString("data", FeatureCollection.fromFeatures(features).toJson())
+            }
+        }
+        val event = AndroidCallbackEvent(this, callbackID, payload)
+        mManager.handleEvent(event)
+    }
+
+    override fun hasNoDataSoRefersToExisting(): Boolean {
+        return uRL == null && tileUrlTemplates.isEmpty()
+    }
+}

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

@@ -0,0 +1,30 @@
+package com.mapbox.rctmgl.components.styles.sources
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+
+// import com.mapbox.rctmgl.components.annotation.RCTMGLCallout;
+// import com.mapbox.rctmgl.utils.ResourceUtils;
+class RCTMGLRasterDemSourceManager(private val mContext: ReactApplicationContext) :
+    RCTMGLTileSourceManager<RCTMGLRasterDemSource?>(
+        mContext
+    ) {
+    override fun customEvents(): Map<String, String>? {
+        return MapBuilder.builder<String, String>()
+            .build()
+    }
+
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    override fun createViewInstance(reactContext: ThemedReactContext): RCTMGLRasterDemSource {
+        return RCTMGLRasterDemSource(reactContext, this)
+    }
+
+    companion object {
+        const val LOG_TAG = "RCTMGLRasterDemSourceManager"
+        const val REACT_CLASS = "RCTMGLRasterDemSource"
+    }
+}

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

@@ -0,0 +1,37 @@
+package com.mapbox.rctmgl.components.styles.sources
+
+import android.content.Context
+import com.mapbox.maps.extension.style.sources.generated.RasterSource
+
+class RCTMGLRasterSource(context: Context?) : RCTMGLTileSource<RasterSource?>(context) {
+    private var mTileSize: Int? = null
+    override fun makeSource(): RasterSource {
+        val id = iD!!
+        val configurationUrl = uRL
+        val tileSize = if (mTileSize == null) DEFAULT_TILE_SIZE else mTileSize!!
+        return if (configurationUrl != null) {
+            RasterSource.Builder(id).url(configurationUrl).tileSize(tileSize.toLong()).build()
+        } else RasterSource.Builder(id).tileSet(buildTileset())
+            .tileSize(tileSize.toLong()).build()
+    }
+
+    fun setTileSize(tileSize: Int) {
+        mTileSize = tileSize
+    }
+
+    override fun hasPressListener(): Boolean {
+        return false
+    }
+
+    override fun onPress(feature: OnPressEvent?) {
+        // ignore, cannot query raster layers
+    }
+
+    override fun hasNoDataSoRefersToExisting(): Boolean {
+        return uRL == null
+    }
+
+    companion object {
+        const val DEFAULT_TILE_SIZE = 512
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.mapbox.rctmgl.components.styles.sources
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import javax.annotation.Nonnull
+
+class RCTMGLRasterSourceManager(reactApplicationContext: ReactApplicationContext?) :
+    RCTMGLTileSourceManager<RCTMGLRasterSource?>(reactApplicationContext) {
+    @Nonnull
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    @Nonnull
+    override fun createViewInstance(@Nonnull reactContext: ThemedReactContext): RCTMGLRasterSource {
+        return RCTMGLRasterSource(reactContext)
+    }
+
+    @ReactProp(name = "tileSize")
+    fun setTileSize(source: RCTMGLRasterSource, tileSize: Int) {
+        source.setTileSize(tileSize)
+    }
+
+    override fun customEvents(): Map<String, String>? {
+        return null
+    }
+
+    companion object {
+        const val REACT_CLASS = "RCTMGLRasterSource"
+    }
+}

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

@@ -34,6 +34,11 @@ class RCTMGLShapeSource(context: Context, private val mManager: RCTMGLShapeSourc
     private var mLineMetrics: Boolean? = null
     private val mImages: List<Map.Entry<String, ImageEntry>>? = null
     private val mNativeImages: List<Map.Entry<String, BitmapDrawable>>? = null
+
+    override fun hasNoDataSoRefersToExisting(): Boolean {
+        return (mURL == null) && (mShape == null)
+    }
+
     override fun addToMap(mapView: RCTMGLMapView) {
         // Wait for style before adding the source to the map
         mapView.getMapboxMap().getStyle {

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

@@ -14,6 +14,7 @@ import com.mapbox.bindgen.Value
 import com.mapbox.maps.extension.style.expressions.generated.Expression
 import com.mapbox.rctmgl.events.constants.EventKeys
 import com.mapbox.rctmgl.utils.ExpressionParser
+import com.mapbox.rctmgl.utils.Logger
 import java.net.MalformedURLException
 import java.net.URL
 import java.util.ArrayList
@@ -33,11 +34,11 @@ class RCTMGLShapeSourceManager(private val mContext: ReactApplicationContext) :
     }
 
     override fun getChildAt(source: RCTMGLShapeSource, childPosition: Int): View {
-        return source.getLayerAt(childPosition)
+        return source.getChildAt(childPosition)
     }
 
     override fun getChildCount(source: RCTMGLShapeSource): Int {
-        return source.layerCount
+        return source.childCount
     }
 
     override fun addView(source: RCTMGLShapeSource, childView: View, childPosition: Int) {
@@ -53,12 +54,17 @@ class RCTMGLShapeSourceManager(private val mContext: ReactApplicationContext) :
         source.iD = id
     }
 
+    @ReactProp(name = "existing")
+    fun setExisting(source: RCTMGLShapeSource, existing: Boolean) {
+        source.mExisting = existing;
+    }
+
     @ReactProp(name = "url")
     fun setURL(source: RCTMGLShapeSource, urlStr: String) {
         try {
             source.setURL(URL(urlStr))
         } catch (e: MalformedURLException) {
-            Log.w(LOG_TAG, e.localizedMessage ?: "Unknown URL error")
+            Logger.w(LOG_TAG, e.localizedMessage ?: "Unknown URL error")
         }
     }
 
@@ -186,7 +192,7 @@ class RCTMGLShapeSourceManager(private val mContext: ReactApplicationContext) :
     }
 
     companion object {
-        const val LOG_TAG = "RCTMGLShapeSourceManager"
+        const val LOG_TAG = "RCTMGLShapeSourceMgr"
         const val REACT_CLASS = "RCTMGLShapeSource"
 
         //region React Methods

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

@@ -0,0 +1,44 @@
+package com.mapbox.rctmgl.components.styles.sources
+
+import android.accessibilityservice.GestureDescription
+import android.content.Context
+import com.mapbox.maps.extension.style.sources.Source
+import com.mapbox.maps.extension.style.sources.TileSet
+import com.mapbox.maps.extension.style.sources.generated.Scheme
+import java.util.*
+
+abstract class RCTMGLTileSource<T : Source?>(context: Context?) : RCTSource<T>(context) {
+    var uRL: String? = null
+    public var tileUrlTemplates: Collection<String> = ArrayList()
+    var attribution: String? = null
+    var minZoomLevel: Int? = null
+    var maxZoomLevel: Int? = null
+    var tMS = false
+    fun buildTileset(): TileSet {
+        val tileUrlTemplates =
+            tileUrlTemplates.toTypedArray()
+
+        val builder = TileSet.Builder(
+            TILE_SPEC_VERSION,
+            Arrays.asList<String>(*tileUrlTemplates.clone())
+        )
+        if (minZoomLevel != null) {
+            builder.minZoom(minZoomLevel!!.toFloat().toInt())
+        }
+        if (maxZoomLevel != null) {
+            builder.maxZoom(maxZoomLevel!!.toFloat().toInt())
+        }
+        if (tMS) {
+            builder.scheme(Scheme.TMS)
+        }
+        val attribution = this.attribution
+        if (attribution != null) {
+            builder.attribution(attribution)
+        }
+        return builder.build()
+    }
+
+    companion object {
+        const val TILE_SPEC_VERSION = "2.1.0"
+    }
+}

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

@@ -0,0 +1,69 @@
+package com.mapbox.rctmgl.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 com.mapbox.rctmgl.components.AbstractEventEmitter
+
+abstract class RCTMGLTileSourceManager<T : RCTMGLTileSource<*>?> internal constructor(
+    reactApplicationContext: ReactApplicationContext?
+) : AbstractEventEmitter<T>(reactApplicationContext) {
+    override fun getChildAt(source: T, childPosition: Int): View {
+        return source!!.getChildAt(childPosition)
+    }
+
+    override fun getChildCount(source: T): Int {
+        return source!!.childCount
+    }
+
+    override fun addView(source: T, childView: View, childPosition: Int) {
+        source!!.addLayer(childView, childPosition)
+    }
+
+    override fun removeViewAt(source: T, childPosition: Int) {
+        source!!.removeLayer(childPosition)
+    }
+
+    @ReactProp(name = "id")
+    fun setID(source: T, id: String?) {
+        source!!.iD = id
+    }
+
+    @ReactProp(name = "url")
+    fun setURL(source: T, url: String?) {
+        source!!.uRL = url
+    }
+
+    @ReactProp(name = "tileUrlTemplates")
+    fun setTileUrlTemplates(source: T, tileUrlTemplates: ReadableArray) {
+        val urls: MutableList<String> = ArrayList()
+        for (i in 0 until tileUrlTemplates.size()) {
+            if (tileUrlTemplates.getType(0) == ReadableType.String) {
+                urls.add(tileUrlTemplates.getString(i))
+            }
+        }
+        source!!.tileUrlTemplates = urls
+    }
+
+    @ReactProp(name = "attribution")
+    fun setAttribution(source: T, attribution: String?) {
+        source!!.attribution = attribution
+    }
+
+    @ReactProp(name = "minZoomLevel")
+    fun setMinZoomLevel(source: T, minZoomLevel: Int) {
+        source!!.minZoomLevel = minZoomLevel
+    }
+
+    @ReactProp(name = "maxZoomLevel")
+    fun setMaxZoomLevel(source: T, maxZoomLevel: Int) {
+        source!!.maxZoomLevel = maxZoomLevel
+    }
+
+    @ReactProp(name = "tms")
+    fun setTMS(source: T, tms: Boolean) {
+        source!!.tMS = tms
+    }
+}

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

@@ -0,0 +1,78 @@
+package com.mapbox.rctmgl.components.styles.sources
+
+import android.content.Context
+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.maps.SourceQueryOptions
+import com.mapbox.maps.extension.style.expressions.generated.Expression
+import com.mapbox.maps.extension.style.sources.generated.VectorSource
+import com.mapbox.maps.extension.style.sources.getSource
+import com.mapbox.rctmgl.events.AndroidCallbackEvent
+import com.mapbox.rctmgl.events.FeatureClickEvent
+import java.util.*
+
+class RCTMGLVectorSource(context: Context?, private val mManager: RCTMGLVectorSourceManager) :
+    RCTMGLTileSource<VectorSource?>(context) {
+    override fun onPress(event: OnPressEvent?) {
+        mManager.handleEvent(FeatureClickEvent.makeVectorSourceEvent(this, event))
+    }
+
+    override fun hasNoDataSoRefersToExisting(): Boolean {
+        return uRL == null;
+    }
+
+    override fun makeSource(): VectorSource {
+        val id = iD
+        if (id == null) {
+            throw  RuntimeException("id should be specified for VectorSource");
+        }
+        if (isDefaultSource(id)) {
+            return mMap!!.getStyle()!!.getSource(DEFAULT_ID) as VectorSource
+        }
+        val configurationUrl = uRL
+        return if (configurationUrl != null) {
+            VectorSource(
+                VectorSource.Builder(id)
+                    .url(configurationUrl)
+            )
+        } else VectorSource(
+            VectorSource.Builder(id)
+                .tileSet(buildTileset())
+        )
+    }
+
+    fun querySourceFeatures(
+        callbackID: String?,
+        @Size(min = 1) layerIDs: List<String?>?,
+        filter: Expression?
+    ) {
+        if (mSource == null) {
+            val payload: WritableMap = WritableNativeMap()
+            payload.putString("error", "source is not yet loaded")
+            val event = AndroidCallbackEvent(this, callbackID, payload)
+            mManager.handleEvent(event)
+            return
+        }
+        mMap!!.querySourceFeatures(
+            iD!!,
+            SourceQueryOptions(layerIDs, filter!!)
+        ) { queriedFeatures ->
+            val payload: WritableMap = WritableNativeMap()
+            if (queriedFeatures.isError) {
+                //V10todo
+                payload.putString("error", queriedFeatures.error)
+            } else {
+                val features: MutableList<Feature> = LinkedList()
+                for (feature in queriedFeatures.value!!) {
+                    features.add(feature.feature)
+                }
+                payload.putString("data", FeatureCollection.fromFeatures(features).toJson())
+            }
+            val event = AndroidCallbackEvent(this@RCTMGLVectorSource, callbackID, payload)
+            mManager.handleEvent(event)
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+package com.mapbox.rctmgl.components.styles.sources
+
+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
+
+class RCTMGLVectorSourceManager(reactApplicationContext: ReactApplicationContext?) :
+    RCTMGLTileSourceManager<RCTMGLVectorSource?>(reactApplicationContext) {
+    @Nonnull
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    @Nonnull
+    override fun createViewInstance(@Nonnull reactContext: ThemedReactContext): RCTMGLVectorSource {
+        return RCTMGLVectorSource(reactContext, this)
+    }
+
+    @ReactProp(name = "hasPressListener")
+    fun setHasPressListener(source: RCTMGLVectorSource, hasPressListener: Boolean) {
+        source.setHasPressListener(hasPressListener)
+    }
+
+    @ReactProp(name = "hitbox")
+    fun setHitbox(source: RCTMGLVectorSource, map: ReadableMap?) {
+        source.setHitbox(map!!)
+    }
+
+    override fun customEvents(): Map<String, String>? {
+        return MapBuilder.builder<String, String>()
+            .put(EventKeys.VECTOR_SOURCE_LAYER_CLICK, "onMapboxVectorSourcePress")
+            .put(EventKeys.MAP_ANDROID_CALLBACK, "onAndroidCallback")
+            .build()
+    }
+
+    override fun getCommandsMap(): Map<String, Int>? {
+        return MapBuilder.builder<String, Int>()
+            .put("features", METHOD_FEATURES)
+            .build()
+    }
+
+    override fun receiveCommand(
+        vectorSource: RCTMGLVectorSource,
+        commandID: Int,
+        args: ReadableArray?
+    ) {
+        when (commandID) {
+            METHOD_FEATURES -> vectorSource.querySourceFeatures(
+                args!!.getString(0),
+                ConvertUtils.toStringList(args.getArray(1)),
+                ExpressionParser.from(args.getArray(2))
+            )
+        }
+    }
+
+    companion object {
+        const val REACT_CLASS = "RCTMGLVectorSource"
+
+        //region React Methods
+        const val METHOD_FEATURES = 102
+    }
+}