@rnmapbox/maps 10.0.0-beta.72 → 10.0.0-beta.74

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

@@ -15,6 +15,7 @@ import com.mapbox.rctmgl.components.camera.RCTMGLCameraManager;
 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.images.RCTMGLImageManager;
 import com.mapbox.rctmgl.components.images.RCTMGLImagesManager;
 import com.mapbox.rctmgl.components.location.RCTMGLNativeUserLocationManager;
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapViewManager;
@@ -94,6 +95,7 @@ public class RCTMGLPackage implements ReactPackage {
 
         // images
         managers.add(new RCTMGLImagesManager(reactApplicationContext));
+        managers.add(new RCTMGLImageManager(reactApplicationContext));
 
         // layers
         managers.add(new RCTMGLFillLayerManager());

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLPointAnnotation.kt

@@ -53,7 +53,6 @@ class RCTMGLPointAnnotation(private val mContext: Context, private val mManager:
         childView.addOnLayoutChangeListener(this)
 
         mMapView?.offscreenAnnotationViewContainer?.addView(childView)
-
     }
 
     override fun removeView(childView: View) {

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/images/RCTMGLImage.kt

@@ -0,0 +1,74 @@
+package com.mapbox.rctmgl.components.images
+
+import android.graphics.Bitmap
+import android.view.View
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.views.view.ReactViewGroup
+import com.mapbox.maps.ImageContent
+import com.mapbox.maps.ImageStretches
+import com.mapbox.rctmgl.components.annotation.RCTMGLCallout
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.mapbox.rctmgl.utils.BitmapUtils
+import com.mapbox.rctmgl.utils.Logger
+
+class RCTMGLImage(private val mContext: ReactApplicationContext, private val mManager: RCTMGLImageManager): ReactViewGroup(mContext), View.OnLayoutChangeListener {
+    var name: String? = null
+    var sdf: Boolean = false
+    var scale: Double = 1.0
+    var stretchX = listOf<ImageStretches>();
+    var stretchY = listOf<ImageStretches>();
+    var content: ImageContent? = null;
+
+    var mChildView: View? = null;
+
+    var mMapView: RCTMGLMapView? = null;
+
+    var nativeImageUpdater: NativeImageUpdater? = null;
+
+    var mBitmap : Bitmap? = null
+
+    override fun onLayoutChange(v: View, left: Int, top: Int, right: Int, bottom: Int, oldLeft: Int, oldTop: Int,
+                                oldRight: Int, oldBottom: Int) {
+        if (left == 0 && top == 0 && right == 0 && bottom == 0) {
+            return
+        }
+        if (left != oldLeft || right != oldRight || top != oldTop || bottom != oldBottom) {
+            refreshBitmap(v, left, top, right, bottom)
+        }
+    }
+
+    private fun refreshBitmap(v: View, left: Int = v.left, top: Int = v.top, right: Int = v.right, bottom: Int = v.bottom) {
+        val name = this.name
+        if (name == null) {
+            Logger.e("RCTMGLImage", "Image component has no name")
+            return
+        }
+        val bitmap = BitmapUtils.viewToBitmap(v, left, top, right, bottom)
+        nativeImageUpdater?.let {
+            it.updateImage(name, bitmap, sdf, stretchX, stretchY, content, scale)
+            mBitmap = null;
+        }
+    }
+
+    fun refresh() {
+        mChildView?.let {
+            refreshBitmap(it)
+        }
+    }
+
+    override fun addView(childView: View, childPosition: Int) {
+        if (childPosition != 0) {
+            Logger.e("RCTMGLImage", "expected a single subview got childView:$childView position:$childPosition")
+        }
+        mMapView?.offscreenAnnotationViewContainer?.addView(childView)
+        mChildView = childView
+        childView.addOnLayoutChangeListener(this)
+    }
+
+    // region add/remove to Map
+    fun addToMap(mapView: RCTMGLMapView) {
+        mMapView = mapView
+    }
+    // endregion
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/images/RCTMGLImageManager.kt

@@ -0,0 +1,67 @@
+package com.mapbox.rctmgl.components.images
+
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.DynamicFromArray
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+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.events.constants.EventKeys
+
+class RCTMGLImageManager(private val mContext: ReactApplicationContext) : AbstractEventEmitter<RCTMGLImage>(
+mContext
+) {
+    override fun getName(): String {
+        return "RCTMGLImage"
+    }
+
+    override fun createViewInstance(p0: ThemedReactContext): RCTMGLImage {
+        return RCTMGLImage(mContext, this)
+    }
+
+    override fun customEvents(): MutableMap<String, String>? {
+        return mutableMapOf();
+    }
+
+    // region React properties
+    @ReactProp(name="name")
+    fun setName(image: RCTMGLImage, value: String) {
+        image.name = value
+    }
+
+    @ReactProp(name="sdf")
+    fun setSdf(image: RCTMGLImage, value: Boolean) {
+        image.sdf = value
+    }
+
+    @ReactProp(name="stretchX")
+    fun setStretchX(image: RCTMGLImage, value: Dynamic) {
+        image.stretchX = RCTMGLImagesManager.convertStretch(value) ?: listOf()
+    }
+
+    @ReactProp(name="stretchY")
+    fun setStretchY(image: RCTMGLImage, value: Dynamic) {
+        image.stretchY = RCTMGLImagesManager.convertStretch(value) ?: listOf()
+    }
+
+    @ReactProp(name="content")
+    fun setContent(image: RCTMGLImage, value: Dynamic) {
+        image.content = RCTMGLImagesManager.convertContent(value)
+    }
+
+    @ReactProp(name="scale")
+    fun setScale(image: RCTMGLImage, value: Double) {
+        image.scale = value
+    }
+    // endregion
+
+    // region React methods
+    override fun receiveCommand(root: RCTMGLImage, commandId: String?, args: ReadableArray?) {
+        if (commandId == "refresh") {
+            root.refresh()
+        }
+    }
+    // endregion
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/images/RCTMGLImages.kt

@@ -10,6 +10,8 @@ import androidx.core.content.res.ResourcesCompat
 import com.mapbox.bindgen.Expected
 import com.mapbox.bindgen.None
 import com.mapbox.maps.Image
+import com.mapbox.maps.ImageContent
+import com.mapbox.maps.ImageStretches
 import com.mapbox.maps.MapboxMap
 import com.mapbox.maps.Style
 import com.mapbox.rctmgl.R
@@ -24,28 +26,40 @@ import java.util.ArrayList
 import java.util.HashMap
 import java.util.HashSet
 
-fun Style.addBitmapImage(imageId: String, bitmap: Bitmap) : Expected<String, None> {
+fun Style.addBitmapImage(imageId: String, bitmap: Bitmap, sdf: Boolean = false, stretchX: List<ImageStretches> = listOf(), stretchY: List<ImageStretches> = listOf(), content: ImageContent? = null, scale: Double = 1.0) : Expected<String, None> {
     val byteBuffer = ByteBuffer.allocate(bitmap.byteCount)
     bitmap.copyPixelsToBuffer(byteBuffer)
-    val sdf = false
     return this.addStyleImage(
         imageId,
-        (1.0/((160.0/bitmap.density))).toFloat(),
+        (1.0/((160.0/bitmap.density)) * scale).toFloat() ,
         Image(bitmap.width, bitmap.height, byteBuffer.array()),
         sdf,
-        listOf(),
-        listOf(),
-        null
+        stretchX,
+        stretchY,
+        content,
     )
 }
 
-class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager) : AbstractMapFeature(context) {
+fun Style.addBitmapImage(nativeImage: NativeImage) : Expected<String, None> {
+    return addBitmapImage(nativeImage.name, nativeImage.drawable.bitmap, nativeImage.sdf, nativeImage.stretchX, nativeImage.stretchY, nativeImage.content, nativeImage.scale)
+}
+
+data class NativeImage(val name: String, val drawable: BitmapDrawable, val scale: Double = 1.0, val sdf: Boolean = false, val stretchX: List<ImageStretches> = listOf(),
+                       val stretchY: List<ImageStretches> = listOf(), val content: ImageContent? = null
+);
+
+interface NativeImageUpdater {
+    fun updateImage(imageId: String, bitmap: Bitmap, sdf: Boolean = false, stretchX: List<ImageStretches> = listOf(), stretchY: List<ImageStretches> = listOf(), content: ImageContent? = null, scale: Double = 1.0)
+}
+
+class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager) : AbstractMapFeature(context), NativeImageUpdater {
     var mCurrentImages: MutableSet<String?>
+    var mImageViews = mutableListOf<RCTMGLImage>();
     private var mImages: MutableMap<String, ImageEntry>?
-    private var mNativeImages: MutableMap<String?, BitmapDrawable?>?
+    private var mNativeImages = mutableMapOf<String, NativeImage>()
     private var mSendMissingImageEvents = false
     private var mMap: MapboxMap? = null
-    var iD: String? = null
+
     fun setImages(images: List<Map.Entry<String, ImageEntry>>) {
         val newImages: MutableMap<String, ImageEntry> = HashMap()
         for ((key, value) in images) {
@@ -59,16 +73,18 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
         }
     }
 
-    fun setNativeImages(nativeImages: List<Map.Entry<String, BitmapDrawable>>) {
-        val newImages: MutableMap<String?, BitmapDrawable?> = HashMap()
-        for ((key, value) in nativeImages) {
-            val oldValue = mNativeImages?.put(key, value)
+    fun setNativeImages(nativeImages: List<NativeImage>) {
+        val newImages: MutableMap<String, NativeImage> = HashMap()
+        for (nativeImage in nativeImages) {
+            val oldValue = mNativeImages.put(nativeImage.name, nativeImage)
             if (oldValue == null) {
-                newImages[key] = value
+                newImages[nativeImage.name] = nativeImage
             }
         }
-        if (mMap != null && mMap?.getStyle() != null) {
-            addNativeImagesToStyle(newImages, mMap!!)
+        mMap?.let {
+            if (it.getStyle() != null) {
+                addNativeImagesToStyle(newImages, it)
+            }
         }
     }
 
@@ -79,7 +95,7 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
     override fun removeFromMap(mapView: RCTMGLMapView) {
         removeImages(mapView)
         mMap = null
-        mNativeImages = HashMap()
+        mNativeImages = mutableMapOf()
         mImages = HashMap()
         mCurrentImages = HashSet()
         super.removeFromMap(mapView)
@@ -111,12 +127,10 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
     }
 
     fun addMissingImageToStyle(id: String, map: MapboxMap): Boolean {
-        if (mNativeImages != null) {
-            val drawable = mNativeImages!![id]
-            if (drawable != null) {
-                addNativeImages(entry<String?, BitmapDrawable?>(id, drawable), map)
-                return true
-            }
+        val nativeImage = mNativeImages.get(id)
+        if (nativeImage != null) {
+            addNativeImages(listOf(nativeImage), map)
+            return true
         }
         if (mImages != null) {
             val entry = mImages!![id]
@@ -134,10 +148,8 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
         }
     }
 
-    fun addNativeImagesToStyle(images: Map<String?, BitmapDrawable?>?, map: MapboxMap) {
-        if (images != null) {
-            addNativeImages(ArrayList(images.entries), map)
-        }
+    fun addNativeImagesToStyle(images: Map<String, NativeImage>, map: MapboxMap) {
+        addNativeImages(images.values.toList(), map)
     }
 
     fun sendImageMissingEvent(id: String, map: MapboxMap) {
@@ -153,6 +165,10 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
 
     override fun addToMap(mapView: RCTMGLMapView) {
         super.addToMap(mapView)
+
+        mImageViews.forEach {
+            it.addToMap(mapView)
+        }
         // Wait for style before adding the source to the map
         // only then we can pre-load required images / placeholders into the style
         // before we add the ShapeSource to the map
@@ -163,18 +179,22 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
                 addNativeImagesToStyle(mNativeImages, map)
                 addImagesToStyle(mImages, map)
                 // super.addToMap(mapView);
+
+                mImageViews.forEach {
+                    it.refresh()
+                }
             }
         })
     }
 
-    private fun addNativeImages(imageEntries: List<Map.Entry<String?, BitmapDrawable?>>?, map: MapboxMap) {
+    private fun addNativeImages(imageEntries: List<NativeImage>, map: MapboxMap) {
         val style = map.getStyle()
-        if (style == null || imageEntries == null) return
-        for ((key, value) in imageEntries) {
-            if (key != null && !hasImage(key, map)) {
-                val bitmap = value!!.bitmap
-                style.addBitmapImage(key, bitmap)
-                mCurrentImages.add(key)
+        if (style == null) return
+        for (nativeImage in imageEntries) {
+            if (!hasImage(nativeImage.name, map)) {
+                val bitmap = nativeImage.drawable
+                style.addBitmapImage(nativeImage)
+                mCurrentImages.add(nativeImage.name)
             }
         }
     }
@@ -193,7 +213,7 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
         // See also: https://github.com/mapbox/mapbox-gl-native/pull/14253#issuecomment-478827792
         for (imageEntry in imageEntries) {
             if (!hasImage(imageEntry.key, map)) {
-                mImagePlaceholder?.let { style.addBitmapImage(imageEntry.key, it) }
+                mImagePlaceholder?.let { style.addBitmapImage(imageEntry.key, it, false, listOf(), listOf(), null,1.0) }
                 missingImages.add(imageEntry)
                 mCurrentImages.add(imageEntry.key)
             }
@@ -220,4 +240,11 @@ class RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager)
             mImagePlaceholder = BitmapUtils.getBitmapFromDrawable(ResourcesCompat.getDrawable(context.resources, R.drawable.empty_drawable, null))
         }
     }
+
+    override fun updateImage(imageId: String, bitmap: Bitmap, sdf: Boolean, stretchX: List<ImageStretches>, stretchY: List<ImageStretches>, content: ImageContent?, scale: Double)
+    {
+        mMap?.getStyle()?.let {
+            it.addBitmapImage(imageId, bitmap, sdf, stretchX, stretchY, content, scale);
+        }
+    }
 }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/images/RCTMGLImagesManager.kt

@@ -0,0 +1,216 @@
+package com.mapbox.rctmgl.components.images
+
+import android.graphics.drawable.BitmapDrawable
+import android.view.View
+import com.facebook.react.bridge.*
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.mapbox.maps.ImageContent
+import com.mapbox.maps.ImageStretches
+import com.mapbox.rctmgl.components.AbstractEventEmitter
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.mapbox.rctmgl.events.constants.EventKeys
+import com.mapbox.rctmgl.modules.RCTMGLLogging
+import com.mapbox.rctmgl.utils.ImageEntry
+import com.mapbox.rctmgl.utils.Logger
+import com.mapbox.rctmgl.utils.ResourceUtils
+import java.util.*
+
+class RCTMGLImagesManager(private val mContext: ReactApplicationContext) :
+    AbstractEventEmitter<RCTMGLImages?>(
+        mContext
+    ) {
+    override fun getName(): String {
+        return "RCTMGLImages"
+    }
+
+    public override fun createViewInstance(context: ThemedReactContext): RCTMGLImages {
+        return RCTMGLImages(context, this)
+    }
+
+    @ReactProp(name = "images")
+    fun setImages(images: RCTMGLImages, map: ReadableMap) {
+        val imagesList: MutableList<Map.Entry<String, ImageEntry>> = ArrayList()
+        val iterator = map.keySetIterator()
+        while (iterator.hasNextKey()) {
+            val imageName = iterator.nextKey()
+            var imageEntry: ImageEntry? = null
+            imageEntry = if (map.getType(imageName) == ReadableType.Map) {
+                val imageMap = map.getMap(imageName)
+                val uri = imageMap!!.getString("uri")
+                val hasScale =
+                    imageMap.hasKey("scale") && imageMap.getType("scale") == ReadableType.Number
+                val scale = if (hasScale) imageMap.getDouble("scale") else ImageEntry.defaultScale
+                ImageEntry(uri, scale)
+            } else {
+                ImageEntry(map.getString(imageName))
+            }
+            imagesList.add(AbstractMap.SimpleEntry(imageName, imageEntry))
+        }
+        images.setImages(imagesList)
+    }
+
+    @ReactProp(name = "hasOnImageMissing")
+    fun setHasOnImageMissing(images: RCTMGLImages, value: Boolean?) {
+        images.setHasOnImageMissing(value!!)
+    }
+
+    fun toNativeImage(dynamic: Dynamic): NativeImage? {
+        when (dynamic.type) {
+            ReadableType.String -> {
+                val resourceName = dynamic.asString();
+                val drawable =
+                    ResourceUtils.getDrawableByName(mContext, resourceName) as BitmapDrawable
+                if (drawable != null) {
+                    return NativeImage(name, drawable)
+                } else {
+                    Logger.e("RCTMGLImages", "cound not get native drawable with name: $name")
+                    return null
+                }
+            }
+            ReadableType.Map -> {
+                val map = dynamic.asMap()
+                val resourceName = map.getString("name")
+                var sdf = false
+                var stretchX = listOf<ImageStretches>();
+                var stretchY = listOf<ImageStretches>();
+                var content : ImageContent? = null;
+                var scale : Double = 1.0;
+                if (map.hasKey("sdf")) {
+                    sdf = map.getBoolean("sdf");
+                }
+                if (map.hasKey("stretchX")) {
+                    stretchX = convertStretch(map.getDynamic("stretchX")) ?: listOf()
+                }
+                if (map.hasKey("stretchY")) {
+                    stretchY = convertStretch(map.getDynamic("stretchY")) ?: listOf()
+                }
+                if (map.hasKey("content")) {
+                    content = convertContent(map.getDynamic("content")) ?: null
+                }
+                if (map.hasKey("scale")) {
+                    if (map.getType("scale") != ReadableType.Number) {
+                        Logger.e("RCTMGLImages", "scale should be a number found: $scale in $dynamic")
+                        return null
+                    }
+                    scale = map.getDouble("scale")
+                }
+                val drawable =
+                    ResourceUtils.getDrawableByName(mContext, resourceName) as BitmapDrawable
+                if (drawable != null) {
+                    return NativeImage(name, drawable, scale, sdf, stretchX, stretchY)
+                } else {
+                    Logger.e("RCTMGLImages", "cound not get native drawable with name: $name")
+                    return null
+                }
+            }
+            else -> {
+                Logger.e("RCTMGLImages", "nativeImages element should be a string or a object, but was: $dynamic")
+                return null
+            }
+        }
+    }
+
+    @ReactProp(name = "nativeImages")
+    fun setNativeImages(images: RCTMGLImages, arr: ReadableArray) {
+        val nativeImages = mutableListOf<NativeImage>();
+        for (i in 0 until arr.size()) {
+            val nativeImage = toNativeImage(arr.getDynamic(i))
+            if (nativeImage != null) {
+                nativeImages.add(nativeImage)
+            }
+        }
+        images.setNativeImages(nativeImages)
+    }
+
+    override fun customEvents(): Map<String, String>? {
+        return MapBuilder.builder<String, String>()
+            .put(EventKeys.IMAGES_MISSING, "onImageMissing")
+            .build()
+    }
+
+    // region RCTMGLImage children
+
+    override fun addView(parent: RCTMGLImages?, childView: View?, childPosition: Int) {
+        if (parent == null || childView == null) {
+            Logger.e("RCTMGLImages", "addView: parent or childView is null")
+            return
+        }
+
+        if (childView !is RCTMGLImage) {
+            Logger.e("RCTMGLImages", "child view should be RCTMGLImage")
+            return
+        }
+
+        parent.mImageViews.add(childPosition, childView)
+        childView.nativeImageUpdater = parent
+    }
+
+    override fun removeView(parent: RCTMGLImages?, view: View?) {
+        if (parent == null || view == null) {
+            Logger.e("RCTMGLImages", "removeView: parent or view is null")
+            return
+        }
+
+        parent.mImageViews.remove(view)
+    }
+
+    override fun removeAllViews(parent: RCTMGLImages?) {
+        if (parent == null) {
+            Logger.e("RCTMGLImages", "removeAllViews parent is null")
+            return
+        }
+
+        parent.mImageViews.clear()
+    }
+
+    // endregion
+
+    companion object {
+        const val REACT_CLASS = "RCTMGLImages"
+
+        fun convertStretch(stretch: Dynamic) : List<ImageStretches>? {
+            if (stretch.type != ReadableType.Array) {
+                Logger.e("RCTMGLImages", "stretch should be an array, got $stretch")
+                return null
+            }
+            val array = stretch.asArray()
+            var result = mutableListOf<ImageStretches>();
+            for (i in 0 until array.size()) {
+                if (array.getType(i) != ReadableType.Array) {
+                    Logger.e("RTMGLImages", "each element of strech should be an array but was: ${array.getDynamic(i)}")
+                } else {
+                    val pair = array.getArray(i)
+                    if (pair.size() != 2 || pair.getType(0) != ReadableType.Number || pair.getType(1) != ReadableType.Number) {
+                        Logger.e("RCTMGLImages", "each element of stretch should be pair of 2 integers but was ${pair}")
+                    }
+                    result.add(ImageStretches(pair.getDouble(0).toFloat(), pair.getDouble(1).toFloat()))
+                }
+            }
+            return result;
+        }
+
+        fun convertContent(content: Dynamic) : ImageContent? {
+            if (content.type != ReadableType.Array) {
+                Logger.e("RCTMGLImages", "content should be an array, got $content")
+                return null
+            }
+            val array = content.asArray()
+            if (array.size() != 4) {
+                Logger.e("RCTMGLImages", "content should be an array of 4 numbers, got $content")
+                return null
+            }
+            val result = arrayOf(0.0, 0.0, 0.0, 0.0, 0.0)
+            for (i in 0 until array.size()) {
+                if (array.getType(i) != ReadableType.Number) {
+                    Logger.e("RTMGLImages", "each element of content should be an number but was : ${array}")
+                    return null
+                } else {
+                    result[i] = array.getDouble(i)
+                }
+            }
+            return ImageContent(result[0].toFloat(), result[1].toFloat() ,result[2].toFloat(), result[3].toFloat())
+        }
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/location/LocationComponentManager.kt

@@ -23,7 +23,7 @@ import com.mapbox.rctmgl.location.LocationManager
 class LocationComponentManager(mapView: RCTMGLMapView, context: Context) {
     var mMapView = mapView
     var mContext = context
-    private var mState = State(showUserLocation=false, followUserLocation=false, hidden=false, tintColor= null, bearingImage = null, puckBearingSource =null)
+    private var mState = State(showUserLocation=false, followUserLocation=false, tintColor= null, bearingImage = null, puckBearingSource =null)
 
     private var mLocationManager: LocationManager = LocationManager.getInstance(context)
 
@@ -34,13 +34,15 @@ class LocationComponentManager(mapView: RCTMGLMapView, context: Context) {
     data class State(
         val showUserLocation: Boolean,
         val followUserLocation: Boolean,
-        val hidden: Boolean, // in case it isn't native
         val tintColor: Int?, // tint of location puck
         var bearingImage: Drawable?, // bearing image (background)
         var puckBearingSource: PuckBearingSource? // bearing source
     ) {
         val enabled: Boolean
             get() = showUserLocation || followUserLocation
+
+        val hidden: Boolean
+            get() = followUserLocation && !showUserLocation
     }
 
     fun update(newStateCallback: (currentState: State) -> State) {

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/layers/RCTLayer.kt

@@ -11,6 +11,7 @@ import com.mapbox.maps.MapboxMap
 import com.facebook.react.bridge.ReadableArray
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView.FoundLayerCallback
 import com.facebook.common.logging.FLog
+import com.mapbox.maps.extension.style.expressions.dsl.generated.all
 import com.mapbox.maps.extension.style.expressions.dsl.generated.literal
 import com.mapbox.maps.extension.style.expressions.generated.Expression
 import com.mapbox.maps.extension.style.layers.*
@@ -115,7 +116,7 @@ abstract class RCTLayer<T : Layer?>(protected var mContext: Context) : AbstractS
                 mHadFilter = true
                 updateFilter(mFilter)
             } else if (mHadFilter) {
-                updateFilter(literal(true))
+                updateFilter(/* literal(true)*/all {} )
             }
         }
     }
@@ -245,8 +246,13 @@ abstract class RCTLayer<T : Layer?>(protected var mContext: Context) : AbstractS
     }
 
     override fun removeFromMap(mapView: RCTMGLMapView) {
-        if (style != null) {
-            style!!.removeStyleLayer(mLayer!!.layerId)
+        style?.let {
+            val layer = mLayer
+            if (layer != null) {
+                it.removeStyleLayer(layer.layerId)
+            } else {
+                Logger.e("RCTLayer","mLayer is null on removal layer from map")
+            }
         }
         super.removeFromMap(mapView)
     }