@rnmapbox/maps 10.0.0-beta.58 → 10.0.0-beta.60

package/android/rctmgl/build.gradle

@@ -130,7 +130,7 @@ dependencies {
             implementation 'com.mapbox.mapboxsdk:mapbox-sdk-turf:5.1.0'
         }
         else if (safeExtGet("RNMapboxMapsImpl", defaultMapboxMapsImpl) == "mapbox") {
-            implementation 'com.mapbox.maps:android:10.9.0'
+            implementation 'com.mapbox.maps:android:10.9.1'
             implementation 'com.mapbox.mapboxsdk:mapbox-sdk-turf:6.8.0'
             implementation 'androidx.asynclayoutinflater:asynclayoutinflater:1.0.0'
         }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/camera/RCTMGLCamera.kt

@@ -77,15 +77,7 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
     private var mMaxBounds: LatLngBounds? = null
     private var mFollowUserLocation = false
     private var mFollowUserMode: String? = null
-    private val mLocationChangeListener: OnUserLocationChange = object : OnUserLocationChange {
-        override fun onLocationChange(nextLocation: Location?) {
-            if (mapboxMap == null || mLocationComponentManager == null || !mLocationComponentManager!!.hasLocationComponent() || !mFollowUserLocation) {
-                return
-            }
-            mUserLocation.currentLocation = nextLocation
-            sendUserLocationUpdateEvent(toPoint(nextLocation!!))
-        }
-    }
+
     private val mLocationBearingChangedListener = OnIndicatorBearingChangedListener { v ->
         if (mFollowUserLocation) {
             mMapView!!.getMapboxMap().setCamera(CameraOptions.Builder().bearing(v).build())
@@ -95,7 +87,6 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         if (mFollowUserLocation) {
             mMapView!!.getMapboxMap().setCamera(CameraOptions.Builder().center(point).build())
             mMapView!!.gestures.focalPoint = mMapView!!.getMapboxMap().pixelForCoordinate(point)
-            sendUserLocationUpdateEvent(point)
         }
     }
     private val mCameraCallback: Animator.AnimatorListener = object : Animator.AnimatorListener {
@@ -122,10 +113,7 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         setInitialCamera()
         updateMaxBounds()
         mCameraStop?.let { updateCamera(it) }
-        if (mFollowUserLocation) {
-            // updateFollowLocation(mFollowUserLocation);
-            enableLocation()
-        }
+        _updateViewportState();
     }
 
     override fun removeFromMap(mapView: RCTMGLMapView) {
@@ -221,18 +209,6 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
             return direction
         }
 
-    private fun sendUserLocationUpdateEvent(point: Point?) {
-        if (point == null) {
-            return
-        }
-        val event: IEvent = MapChangeEvent(
-            this, EventTypes.USER_LOCATION_UPDATED, makeLocationChangePayload(
-                toLocation(point)
-            )
-        )
-        mManager.handleEvent(event)
-    }
-
     private fun hasSetCenterCoordinate(): Boolean {
         val state = mapboxMap!!.cameraState
         val center = state.center
@@ -244,78 +220,11 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
         mLocationManager = getInstance(mContext)
     }
 
-    private fun enableLocation() {
-        if (!PermissionsManager.areLocationPermissionsGranted(mContext)) {
-            return
-        }
-        if (!mLocationManager!!.isActive()) {
-            mLocationManager.enable()
-        }
-        mMapView!!.getMapboxMap().getStyle {
-            enableLocationComponent(it)
-        }
-    }
-
-    private fun enableLocationComponent(style: Style) {
-        updateUserLocation(false)
-        updateLocationLayer(style)
-        val lastKnownLocation = mLocationManager!!.lastKnownLocation
-        mLocationManager.addLocationListener(mLocationChangeListener)
-        if (lastKnownLocation != null) {
-            mLocationChangeListener.onLocationChange(lastKnownLocation)
-            postDelayed({ mMapView!!.sendRegionDidChangeEvent() }, 200)
-        }
-    }
-
     private fun updateLocationLayer(style: Style) {
         if (mLocationComponentManager == null) {
             mLocationComponentManager = mMapView!!.locationComponentManager
         }
         mLocationComponentManager!!.update(style)
-        if (mFollowUserLocation) {
-            mLocationComponentManager!!.setCameraMode(
-                UserTrackingMode.getCameraMode(
-                    mUserTrackingMode
-                )
-            )
-        }
-        mLocationComponentManager!!.setFollowUserLocation(mFollowUserLocation)
-        if (mFollowUserLocation) {
-            mLocationComponentManager!!.setCameraMode(
-                UserTrackingMode.getCameraMode(
-                    mUserTrackingMode
-                )
-            )
-
-            /*
-            mLocationComponentManager.addOnCameraTrackingChangedListener(new OnCameraTrackingChangedListener() {
-                    @Override public void onCameraTrackingChanged(int currentMode) {
-                        int userTrackingMode = UserTrackingMode.NONE;
-                        switch (currentMode) {
-                            case CameraMode.NONE:
-                                userTrackingMode = UserTrackingMode.NONE;
-                                break;
-                            case CameraMode.TRACKING:
-                                userTrackingMode = UserTrackingMode.FOLLOW;
-                                break;
-                            case CameraMode.TRACKING_COMPASS:
-                                userTrackingMode = UserTrackingMode.FollowWithHeading;
-                                break;
-                            case CameraMode.TRACKING_GPS:
-                                userTrackingMode = UserTrackingMode.FollowWithCourse;
-                                break;
-                            default:
-                                userTrackingMode = UserTrackingMode.NONE;
-                        }
-                        updateUserTrackingMode(userTrackingMode);
-                    }
-                    @Override public void onCameraTrackingDismissed() {
-                    }
-            });
-             */
-        } else {
-            mLocationComponentManager!!.setCameraMode(com.mapbox.rctmgl.components.location.CameraMode.NONE)
-        }
     }
 
     fun setMinZoomLevel(zoomLevel: Double?) {
@@ -383,16 +292,16 @@ class RCTMGLCamera(private val mContext: Context, private val mManager: RCTMGLCa
             val viewport = map.viewport;
             if (mFollowUserLocation == false) {
                 viewport.idle()
-                mLocationManager?.disable()
+                mLocationComponentManager?.setFollowLocation(false)
                 return;
             }
 
+            mLocationComponentManager?.setFollowLocation(true)
             mLocationManager?.let {
-                val provider = it.provider
 
+                val provider = it.provider
                 map.location.setLocationProvider(provider);
                 map.location2.setLocationProvider(provider);
-                it.enable();
             }
 
             val location = map.location2

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/camera/RCTMGLCameraManager.kt

@@ -49,7 +49,7 @@ class RCTMGLCameraManager(private val mContext: ReactApplicationContext) :
         throw AssertionError("Unused code")
     }
 
-    @ReactProp(name = "followZoomLevel")
+    @ReactProp(name = "zoomLevel")
     fun setZoomLevel(camera: RCTMGLCamera, zoomLevel: Double) {
         camera.setZoomLevel(zoomLevel)
     }

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

@@ -0,0 +1,125 @@
+package com.mapbox.rctmgl.components.location
+
+import android.content.Context
+import android.graphics.Color
+import android.graphics.drawable.VectorDrawable
+import androidx.appcompat.content.res.AppCompatResources
+import com.mapbox.maps.plugin.locationcomponent.location
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.mapbox.maps.Style
+import com.mapbox.maps.plugin.LocationPuck2D
+import com.mapbox.rctmgl.R
+import com.mapbox.rctmgl.location.LocationManager
+
+/**
+ * The LocationComponent on android implements display of user's current location.
+ * But viewport seems to be tied to it in the sense that if location is not enbabled then it's viewport user tracking is not working.
+ * LocationComponentManager attempts to separate that, so that Camera can ask for location tracking independent of display of user current location.
+ * And NativeUserLocation can ask for display of user's current location - independent of Camera's user tracking.
+ */
+class LocationComponentManager(mapView: RCTMGLMapView, context: Context) {
+    private var mShowNativeUserLocation = false
+    private var mFollowLocation = false
+    var mMapView = mapView
+    var mContext = context
+    var mState = State(enabled=true, hidden=false, tintColor= null)
+    var mLocationManager: LocationManager? = LocationManager.getInstance(context!!)
+
+    data class State(
+        val enabled: Boolean, // in case followUserLocation is active or visible
+        val hidden: Boolean, // in case it isn't native
+        val tintColor: Int?, // tint of location puck
+    )
+
+    fun showNativeUserLocation(showUserLocation: Boolean) {
+        mShowNativeUserLocation = showUserLocation
+
+        _applyChanges()
+    }
+
+    fun setFollowLocation(followLoation: Boolean) {
+        mFollowLocation = followLoation
+
+        _applyChanges()
+    }
+
+    fun update(style: Style) {
+        _applyChanges()
+    }
+
+    fun setRenderMode(renderMode: RenderMode) {
+        _applyChanges()
+    }
+
+    fun _applyChanges() {
+        mMapView?.let {
+            val newState = State(
+                enabled = mShowNativeUserLocation || mFollowLocation,
+                hidden = !mShowNativeUserLocation,
+                tintColor = mMapView!!.tintColor,
+            )
+
+            if (! mState.equals(newState)) {
+                it.location.updateSettings {
+                    val trackLocation = true
+                    enabled = newState.enabled
+
+                    if ((newState.hidden != mState.hidden) || (newState.tintColor != mState.tintColor)) {
+                        if (newState.hidden) {
+                            var emptyLocationPuck = LocationPuck2D()
+                            val empty = AppCompatResources.getDrawable(mContext!!, R.drawable.empty)
+                            emptyLocationPuck.bearingImage = empty
+                            emptyLocationPuck.shadowImage = empty
+                            emptyLocationPuck.topImage = empty
+                            //emptyLocationPuck.opacity = 0.0
+                            locationPuck = emptyLocationPuck
+                            pulsingEnabled = false
+                        } else {
+                            val mapboxBlueColor = Color.parseColor("#4A90E2")
+                            val tintColor = newState.tintColor
+                            val defaultLocationPuck = LocationPuck2D()
+                            var topImage = AppCompatResources.getDrawable(mContext!!, R.drawable.mapbox_user_icon)
+                            if (tintColor != null) {
+                                val drawable = topImage as VectorDrawable?
+                                drawable!!.setTint(tintColor)
+                                topImage = drawable
+                            }
+                            defaultLocationPuck.topImage = topImage
+                            val bearingImage = AppCompatResources.getDrawable(
+                                mContext!!, R.drawable.mapbox_user_stroke_icon
+                            )
+                            defaultLocationPuck.bearingImage = bearingImage
+                            val shadowImage = AppCompatResources.getDrawable(
+                                mContext!!, R.drawable.mapbox_user_icon_shadow
+                            )
+                            defaultLocationPuck.shadowImage = shadowImage
+                            locationPuck = defaultLocationPuck
+                            pulsingEnabled = true
+                            if (tintColor != null) {
+                                pulsingColor = tintColor
+                            } else {
+                                pulsingColor = mapboxBlueColor
+                            }
+                        }
+                    }
+                }
+
+                if (newState.enabled != mState.enabled) {
+                    if (newState.enabled) {
+                        mLocationManager?.startCounted()
+                        val provider = mLocationManager?.provider
+                        if (provider != null) {
+                            it.location.setLocationProvider(provider)
+                        }
+                    } else {
+                        mLocationManager?.stopCounted()
+                    }
+                }
+
+                mState = newState;
+            }
+
+
+        }
+    }
+}

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

@@ -9,27 +9,23 @@ import com.mapbox.maps.Style
 import com.mapbox.rctmgl.components.AbstractMapFeature
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
 
-/*
-import com.mapbox.mapboxsdk.location.modes.RenderMode;
-import com.mapbox.mapboxsdk.maps.MapboxMap;
-import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
-import com.mapbox.mapboxsdk.maps.Style;
- */   class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context), OnMapReadyCallback, Style.OnStyleLoaded {
+class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context), OnMapReadyCallback, Style.OnStyleLoaded {
     private var mEnabled = true
     private var mMap: MapboxMap? = null
 
-    @RenderMode.Mode
-    private var mRenderMode = RenderMode.COMPASS
+    private var mRenderMode : RenderMode = RenderMode.COMPASS
     override fun addToMap(mapView: RCTMGLMapView) {
         super.addToMap(mapView)
         mEnabled = true
         mapView.getMapboxMap()
         mapView.getMapAsync(this)
         setRenderMode(mRenderMode)
+        mMapView?.locationComponentManager?.showNativeUserLocation(true)
     }
 
     override fun removeFromMap(mapView: RCTMGLMapView) {
         mEnabled = false
+        mMapView?.locationComponentManager?.showNativeUserLocation(false)
         mMap?.getStyle(this)
         super.removeFromMap(mapView)
     }
@@ -48,10 +44,10 @@ import com.mapbox.mapboxsdk.maps.Style;
         }
 
         mMapView?.locationComponentManager?.update(style)
-        mMapView?.locationComponentManager?.showUserLocation(mEnabled)
+        mMapView?.locationComponentManager?.showNativeUserLocation(mEnabled)
     }
 
-    fun setRenderMode(@RenderMode.Mode renderMode: Int) {
+    fun setRenderMode(renderMode: RenderMode) {
         mRenderMode = renderMode
         mMapView?.locationComponentManager?.setRenderMode(renderMode)
     }

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

@@ -0,0 +1,21 @@
+package com.mapbox.rctmgl.components.location
+
+/**
+ * Contains the variety of ways the user location can be rendered on the map.
+ */
+enum class RenderMode {
+    /**
+     * Basic tracking is enabled, bearing ignored.
+     */
+    NORMAL,
+    /**
+     * Tracking the user location with bearing considered
+     * from a [CompassEngine].
+     */
+    COMPASS,
+    /**
+     * Tracking the user location with bearing considered from [android.location.Location].
+     */
+    GPS
+}
+

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapView.kt

@@ -713,7 +713,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         val density: Float = getDisplayDensity()
         val screenCoordinate = ScreenCoordinate(pixel.x * density, pixel.y * density)
 
-        val coordinate = mMap!!.coordinateForPixel(pixel)
+        val coordinate = mMap!!.coordinateForPixel(screenCoordinate)
 
         sendResponse(callbackID, {
             it.putArray("coordinateFromView", coordinate.toReadableArray())
@@ -1069,48 +1069,33 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     }
 
     // region Attribution
-    private var mAttributionEnabled: Boolean? = null;
-    private var mAttributionGravity: Int? = null
-    private var mAttributionMargin: IntArray? = null
+    var mAttributionSettings = OrnamentSettings(enabled = AttributionSettings().enabled)
 
     fun setReactAttributionEnabled(attributionEnabled: Boolean?) {
-        mAttributionEnabled = attributionEnabled ?: AttributionSettings().enabled
+        mAttributionSettings.enabled = attributionEnabled
         updateAttribution()
     }
 
-    fun setReactAttributionPosition(position: ReadableMap?) {
-        if (position == null) {
-            // reset from explicit to default
-            if (mAttributionGravity != null) {
-                val defaultOptions = AttributionSettings()
-                mAttributionGravity = defaultOptions.position
-                mAttributionMargin = intArrayOf(defaultOptions.marginLeft.toInt(),defaultOptions.marginTop.toInt(),defaultOptions.marginRight.toInt(),defaultOptions.marginBottom.toInt())
-                updateAttribution()
-            }
-            return
-        }
+    fun setReactAttributionViewMargins(margins: ReadableMap) {
+        mAttributionSettings.margins = margins
+        updateAttribution()
+    }
 
-        val (attributionGravity, attributionMargin) = getGravityAndMargin(position)
-        mAttributionGravity = attributionGravity
-        mAttributionMargin = attributionMargin
+    fun setReactAttributionViewPosition(position: Int) {
+        mAttributionSettings.position = position
+        updateAttribution()
+    }
+
+    fun setReactAttributionPosition(position: ReadableMap?) {
+        mAttributionSettings.setPosAndMargins(position)
         updateAttribution()
     }
 
     private fun updateAttribution() {
         attribution.updateSettings {
-            if(mAttributionEnabled!= null){
-                enabled = mAttributionEnabled!!
-            }
-            if(mAttributionGravity != null){
-                position = mAttributionGravity!!
-            }
-            if(mAttributionMargin != null){
-                marginLeft = mAttributionMargin!![0].toFloat()
-                marginTop = mAttributionMargin!![1].toFloat()
-                marginRight = mAttributionMargin!![2].toFloat()
-                marginBottom = mAttributionMargin!![3].toFloat()
-            }
+            updateOrnament("attribution", mAttributionSettings, this.toGenericOrnamentSettings())
         }
+        workaroundToRelayoutChildOfMapView()
     }
     //endregion
 
@@ -1147,46 +1132,6 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         }
         workaroundToRelayoutChildOfMapView()
     }
-/*
-    fun setReactLogoEnabled(logoEnabled: Boolean?) {
-        mLogoEnabled = logoEnabled ?: LogoSettings().enabled
-        updateLogo()
-    }
-
-    fun setReactLogoPosition(position: ReadableMap?) {
-        if (position == null) {
-            // reset from explicit to default
-            if (mLogoGravity != null) {
-                val defaultOptions = LogoSettings()
-                mLogoGravity = defaultOptions.position
-                mLogoMargin = intArrayOf(defaultOptions.marginLeft.toInt(),defaultOptions.marginTop.toInt(),defaultOptions.marginRight.toInt(),defaultOptions.marginBottom.toInt())
-                updateLogo()
-            }
-            return
-        }
-        val (logoGravity, logoMargin) = getGravityAndMargin(position)
-        mLogoGravity = logoGravity
-        mLogoMargin = logoMargin
-        updateLogo()
-    }
-
-    private fun updateLogo() {
-        logo.updateSettings {
-            if(mLogoEnabled != null){
-                enabled = mLogoEnabled!!
-            }
-            if(mLogoGravity != null){
-                position = mLogoGravity!!
-            }
-            if(mLogoMargin != null){
-                marginLeft = mLogoMargin!![0].toFloat()
-                marginTop = mLogoMargin!![1].toFloat()
-                marginRight = mLogoMargin!![2].toFloat()
-                marginBottom = mLogoMargin!![3].toFloat()
-            }
-        }
-    }
- */
     // endregion
 
     // region lifecycle
@@ -1332,7 +1277,26 @@ fun LogoSettings.toGenericOrnamentSettings() = object : GenericOrnamentSettings
     override var position: Int
         get() = settings.position
         set(value) {
-            println(String.format("logo :: position: 0x%08x", value))
+            settings.position = value
+        }
+}
+
+fun AttributionSettings.toGenericOrnamentSettings() = object : GenericOrnamentSettings {
+    private var settings = this@toGenericOrnamentSettings;
+    override fun setHMargins(left: Float?, right: Float?) {
+        left?.let { settings.marginLeft = it }
+        right?.let { settings.marginRight = it }
+    }
+    override fun setVMargins(top: Float?, bottom: Float?) {
+        top?.let { settings.marginTop = it }
+        bottom?.let { settings.marginBottom = it }
+    }
+    override var enabled: Boolean
+        get() = settings.enabled
+        set(value) { settings.enabled = value }
+    override var position: Int
+        get() = settings.position
+        set(value) {
             settings.position = value
         }
 }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapViewManager.kt

@@ -132,6 +132,16 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext?) :
         mapView!!.setReactAttributionPosition(attributionPosition);
     }
 
+    @ReactProp(name = "attributionViewMargins")
+    fun setAttributionViewMargins(mapView: RCTMGLMapView?, scaleBarMargins: ReadableMap?) {
+        mapView!!.setReactAttributionViewMargins(scaleBarMargins!!);
+    }
+
+    @ReactProp(name = "attributionViewPosition")
+    fun setAttributionViewPosition(mapView: RCTMGLMapView?, scaleBarPosition: Int) {
+        mapView!!.setReactAttributionViewPosition(scaleBarPosition!!)
+    }
+
     @ReactProp(name = "logoEnabled")
     fun setLogoEnabled(mapView: RCTMGLMapView?, logoEnabled: Boolean?) {
         mapView!!.setReactLogoEnabled(logoEnabled);

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

@@ -24,6 +24,7 @@ import com.mapbox.maps.extension.style.types.StyleTransition;
 import com.mapbox.maps.extension.style.light.generated.Light;
 import com.mapbox.maps.extension.style.light.LightPosition;
 import com.mapbox.rctmgl.utils.DownloadMapImageTask;
+import com.mapbox.rctmgl.utils.Logger;
 
 import java.util.List;
 
@@ -82,7 +83,11 @@ public class RCTMGLStyleFactory {
               style.addImage(styleValue, new DownloadMapImageTask.OnAllImagesLoaded() {
                   @Override
                   public void onAllImagesLoaded() {
-                      RCTMGLStyleFactory.setFillPattern(layer, styleValue);
+                      try {
+                          RCTMGLStyleFactory.setFillPattern(layer, styleValue);
+                      } catch (RuntimeException exception) {
+                          Logger.INSTANCE.e("RCTMGLFill",String.format("Exception failed during setFillPattern: %s", exception.getMessage()));
+                      }
                   }
               });
               break;
@@ -176,7 +181,11 @@ public class RCTMGLStyleFactory {
               style.addImage(styleValue, new DownloadMapImageTask.OnAllImagesLoaded() {
                   @Override
                   public void onAllImagesLoaded() {
-                      RCTMGLStyleFactory.setLinePattern(layer, styleValue);
+                      try {
+                          RCTMGLStyleFactory.setLinePattern(layer, styleValue);
+                      } catch (RuntimeException exception) {
+                          Logger.INSTANCE.e("RCTMGLLine",String.format("Exception failed during setLinePattern: %s", exception.getMessage()));
+                      }
                   }
               });
               break;
@@ -243,7 +252,11 @@ public class RCTMGLStyleFactory {
               style.addImage(styleValue, new DownloadMapImageTask.OnAllImagesLoaded() {
                   @Override
                   public void onAllImagesLoaded() {
-                      RCTMGLStyleFactory.setIconImage(layer, styleValue);
+                      try {
+                          RCTMGLStyleFactory.setIconImage(layer, styleValue);
+                      } catch (RuntimeException exception) {
+                          Logger.INSTANCE.e("RCTMGLSymbol",String.format("Exception failed during setIconImage: %s", exception.getMessage()));
+                      }
                   }
               });
               break;
@@ -572,7 +585,11 @@ public class RCTMGLStyleFactory {
               style.addImage(styleValue, new DownloadMapImageTask.OnAllImagesLoaded() {
                   @Override
                   public void onAllImagesLoaded() {
-                      RCTMGLStyleFactory.setFillExtrusionPattern(layer, styleValue);
+                      try {
+                          RCTMGLStyleFactory.setFillExtrusionPattern(layer, styleValue);
+                      } catch (RuntimeException exception) {
+                          Logger.INSTANCE.e("RCTMGLFillExtrusion",String.format("Exception failed during setFillExtrusionPattern: %s", exception.getMessage()));
+                      }
                   }
               });
               break;
@@ -727,7 +744,11 @@ public class RCTMGLStyleFactory {
               style.addImage(styleValue, new DownloadMapImageTask.OnAllImagesLoaded() {
                   @Override
                   public void onAllImagesLoaded() {
-                      RCTMGLStyleFactory.setBackgroundPattern(layer, styleValue);
+                      try {
+                          RCTMGLStyleFactory.setBackgroundPattern(layer, styleValue);
+                      } catch (RuntimeException exception) {
+                          Logger.INSTANCE.e("RCTMGLBackground",String.format("Exception failed during setBackgroundPattern: %s", exception.getMessage()));
+                      }
                   }
               });
               break;

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

@@ -21,8 +21,6 @@ import com.mapbox.rctmgl.utils.ExpressionParser
 import java.lang.ClassCastException
 import com.mapbox.rctmgl.utils.Logger
 
-
-// import com.mapbox.rctmgl.utils.ExpressionParser;
 abstract class RCTLayer<T : Layer?>(protected var mContext: Context) : AbstractSourceConsumer(
     mContext
 ) {
@@ -253,15 +251,12 @@ abstract class RCTLayer<T : Layer?>(protected var mContext: Context) : AbstractS
         super.removeFromMap(mapView)
     }
 
-    // v10TOOD: adding anything seems to make getStyle null
-    //        return mMap.getStyle();
     private val style: Style?
-        private get() =// v10TOOD: adding anything seems to make getStyle null
+        private get() =
             if (mMap == null) {
                 null
-            } else mMapView!!.savedStyle
+            } else mMapView?.savedStyle
 
-    //        return mMap.getStyle();
     abstract fun makeLayer(): T
     abstract fun addStyles()
     private fun hasInitialized(): Boolean {