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

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
+    }
+}

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

@@ -23,6 +23,9 @@ import java.lang.ClassCastException
 import java.util.ArrayList
 import java.util.HashMap
 
+data class FeatureInfo(val feature: AbstractMapFeature?, var added: Boolean) {
+}
+
 abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(context) {
     @JvmField
     protected var mMap: MapboxMap? = null
@@ -31,19 +34,40 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
     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>?
+    private var mSubFeatures = mutableListOf<FeatureInfo>()
+
     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 mSubFeatures.mapIndexed { index, featureInfo ->
+                if (featureInfo.added && featureInfo.feature is AbstractSourceConsumer)  {
+                    featureInfo.feature.iD
+                } else {
+                    null
+                }
+            }.filterNotNull()
+        }
+
+    abstract fun hasNoDataSoRefersToExisting(): Boolean;
+
+    public var mExisting: Boolean? = null
+
+    val existing: Boolean
+        get() {
+            var result: Boolean = false
+            mExisting?.also {
+                result = it
+            } ?: run {
+                if (hasNoDataSoRefersToExisting()) {
+                    Logger.w(
+                        LOG_TAG,
+                        "RCTSource: soure with id: $id seems to refer to existing value but existing flag is not set. This is deprecated."
+                    )
+                    result = true
+                } else {
+                    result = false
                 }
             }
-            return layerIDs
+            return result
         }
 
     private fun getSourceAs(style: Style, id: String?): T? {
@@ -55,18 +79,6 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
         }
     }
 
-    protected fun addLayerToMap(layer: AbstractSourceConsumer?, childPosition: Int) {
-        mMapView?.let {
-            val mapView = it
-            layer?.let {
-                it.addToMap(mapView)
-                if (!mLayers.contains(it)) {
-                    mLayers.add(childPosition, it)
-                }
-            }
-        }
-    }
-
     open fun hasPressListener(): Boolean {
         return mHasPressListener
     }
@@ -94,51 +106,56 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
                         .build()
             } else mTouchHitbox
         }
-    val layerCount: Int
-        get() {
-            var totalCount = 0
-            if (mQueuedLayers != null) {
-                totalCount = mQueuedLayers!!.size
+
+    fun addToMap(existings: Boolean, style: Style, mapView: RCTMGLMapView) {
+        mSource = null
+        if (existings) {
+            val existingSource = getSourceAs(style, iD)
+            if (existingSource != null) {
+                mSource = existingSource
+            } else {
+                Logger.w(LOG_TAG, "Source $iD was makred as existing but was not found in style")
             }
-            totalCount += mLayers.size
-            return totalCount
         }
+        if (mSource == null) {
+            mSource = makeSource()
+            style.addSource(mSource as StyleContract.StyleSourceExtension)
+        }
+        mSubFeatures?.forEach {
+            it.feature?.let {
+                it.addToMap(mapView)
+            }
+            it.added = true
+        }
+    }
 
     override fun addToMap(mapView: RCTMGLMapView) {
         super.addToMap(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)
-                    }
+        val map = mMap
+        if (map == null) {
+            Logger.e("RCTSource", "map is exepted to be valid but was null, $iD")
+            return
+        }
+        val style = map.getStyle()
+        if (existing || style == null) {
+            map.getStyle(object : Style.OnStyleLoaded {
+                override fun onStyleLoaded(style: Style) {
+                    addToMap(existing, style, mapView)
                 }
-            }
-        })
+            })
+        } else {
+            addToMap(existing, style, mapView)
+        }
+
     }
 
     override fun removeFromMap(mapView: RCTMGLMapView) {
-        if (mLayers.size > 0) {
-            for (i in mLayers.indices) {
-                val layer = mLayers[i]
-                layer.removeFromMap(mapView)
+        mSubFeatures.forEach { it
+            it.feature?.let {
+                it.removeFromMap(mapView)
             }
-        }
-        if (mQueuedLayers != null) {
-            mQueuedLayers!!.clear()
+            it.added = false
         }
         if (mMap != null && mSource != null && mMap!!.getStyle() != null) {
             try {
@@ -151,47 +168,48 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
     }
 
     fun addLayer(childView: View?, childPosition: Int) {
-        if (childView !is AbstractSourceConsumer) {
-            return
+        var feature: AbstractMapFeature? = null
+        if (childView !is AbstractMapFeature) {
+            Logger.w(LOG_TAG, "Attempted to insert view: $childView to shape source: $iD, since it's not a MapFeature it will not be added")
+        } else {
+            feature = childView
         }
-        val layer = childView
-        if (mMap == null) {
-            mQueuedLayers?.add(childPosition, layer)
+
+        val mapView = mMapView
+
+        val added = if (mapView != null && feature != null) {
+            feature.addToMap(mapView)
+            true
         } else {
-            addLayerToMap(layer, childPosition)
+            false
         }
+        mSubFeatures.add(childPosition, FeatureInfo(feature, added))
     }
 
     fun removeLayer(childPosition: Int) {
-        val layer: AbstractSourceConsumer
-        layer = if (mQueuedLayers != null && mQueuedLayers!!.size > 0) {
-            mQueuedLayers!![childPosition]
-        } else {
-            mLayers[childPosition]
+        var featureInfo = mSubFeatures[childPosition]
+        if (featureInfo.added) {
+            val mapView = mMapView
+            if (mapView != null) {
+                featureInfo.feature?.let { it.removeFromMap(mapView) }
+            }
+            featureInfo.added = false
         }
-        removeLayerFromMap(layer, childPosition)
+        mSubFeatures.removeAt(childPosition)
     }
 
-    fun getLayerAt(childPosition: Int): AbstractSourceConsumer {
-        return if (mQueuedLayers != null && mQueuedLayers!!.size > 0) {
-            mQueuedLayers!![childPosition]
-        } else mLayers[childPosition]
+    val childViews: List<AbstractMapFeature>
+        get() = mSubFeatures.map { it.feature }.filterNotNull()
+
+    override fun getChildAt(childPosition: Int): View {
+        return childViews[childPosition]
     }
 
-    protected fun removeLayerFromMap(layer: AbstractSourceConsumer?, childPosition: Int) {
-        mMapView?.let {
-            val mapView = it
-            layer?.let {
-                it.removeFromMap(mapView)
-            }
-        }
-        if (mQueuedLayers != null && mQueuedLayers!!.size > 0) {
-            mQueuedLayers?.removeAt(childPosition)
-        } else {
-            mLayers.removeAt(childPosition)
-        }
+    override fun getChildCount(): Int {
+        return childViews.size;
     }
 
+
     abstract fun makeSource(): T
     class OnPressEvent(var features: List<Feature>, var latLng: LatLng, var screenPoint: PointF)
 
@@ -209,7 +227,5 @@ abstract class RCTSource<T : Source?>(context: Context?) : AbstractMapFeature(co
     }
 
     init {
-        mLayers = ArrayList()
-        mQueuedLayers = ArrayList()
     }
 }