@rnmapbox/maps 10.1.0-beta.4 → 10.1.0-beta.5

package/android/src/main/{java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapView.kt → java/com/rnmapbox/rnmbx/components/mapview/RNMBXMapView.kt}

@@ -1,4 +1,4 @@
-package com.mapbox.rctmgl.components.mapview
+package com.rnmapbox.rnmbx.components.mapview
 
 import android.content.Context
 import android.graphics.BitmapFactory
@@ -47,42 +47,42 @@ import com.mapbox.maps.plugin.logo.logo
 import com.mapbox.maps.plugin.scalebar.generated.ScaleBarSettings
 import com.mapbox.maps.plugin.scalebar.scalebar
 import com.mapbox.maps.viewannotation.ViewAnnotationManager
-import com.mapbox.rctmgl.R
-import com.mapbox.rctmgl.components.AbstractMapFeature
-import com.mapbox.rctmgl.components.RemovalReason
-import com.mapbox.rctmgl.components.annotation.RCTMGLMarkerView
-import com.mapbox.rctmgl.components.annotation.RCTMGLMarkerViewManager
-import com.mapbox.rctmgl.components.annotation.RCTMGLPointAnnotation
-import com.mapbox.rctmgl.components.camera.RCTMGLCamera
-import com.mapbox.rctmgl.components.images.RCTMGLImages
-import com.mapbox.rctmgl.components.location.LocationComponentManager
-import com.mapbox.rctmgl.components.location.RCTMGLNativeUserLocation
-import com.mapbox.rctmgl.components.mapview.helpers.CameraChangeReason
-import com.mapbox.rctmgl.components.mapview.helpers.CameraChangeTracker
-import com.mapbox.rctmgl.components.styles.layers.RCTLayer
-import com.mapbox.rctmgl.components.styles.light.RCTMGLLight
-import com.mapbox.rctmgl.components.styles.sources.RCTSource
-import com.mapbox.rctmgl.components.styles.terrain.RCTMGLTerrain
-import com.mapbox.rctmgl.events.AndroidCallbackEvent
-import com.mapbox.rctmgl.events.IEvent
-import com.mapbox.rctmgl.events.MapChangeEvent
-import com.mapbox.rctmgl.events.CameraChangeEvent
-import com.mapbox.rctmgl.events.MapClickEvent
-import com.mapbox.rctmgl.events.constants.EventTypes
-import com.mapbox.rctmgl.utils.*
-import com.mapbox.rctmgl.utils.extensions.toReadableArray
-import com.mapbox.rctmgl.v11compat.annotation.AnnotationID
-import com.mapbox.rctmgl.v11compat.annotation.INVALID_ANNOTATION_ID
+import com.rnmapbox.rnmbx.R
+import com.rnmapbox.rnmbx.components.AbstractMapFeature
+import com.rnmapbox.rnmbx.components.RemovalReason
+import com.rnmapbox.rnmbx.components.annotation.RNMBXMarkerView
+import com.rnmapbox.rnmbx.components.annotation.RNMBXMarkerViewManager
+import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotation
+import com.rnmapbox.rnmbx.components.camera.RNMBXCamera
+import com.rnmapbox.rnmbx.components.images.RNMBXImages
+import com.rnmapbox.rnmbx.components.location.LocationComponentManager
+import com.rnmapbox.rnmbx.components.location.RNMBXNativeUserLocation
+import com.rnmapbox.rnmbx.components.mapview.helpers.CameraChangeReason
+import com.rnmapbox.rnmbx.components.mapview.helpers.CameraChangeTracker
+import com.rnmapbox.rnmbx.components.styles.layers.RCTLayer
+import com.rnmapbox.rnmbx.components.styles.light.RNMBXLight
+import com.rnmapbox.rnmbx.components.styles.sources.RCTSource
+import com.rnmapbox.rnmbx.components.styles.terrain.RNMBXTerrain
+import com.rnmapbox.rnmbx.events.AndroidCallbackEvent
+import com.rnmapbox.rnmbx.events.IEvent
+import com.rnmapbox.rnmbx.events.MapChangeEvent
+import com.rnmapbox.rnmbx.events.CameraChangeEvent
+import com.rnmapbox.rnmbx.events.MapClickEvent
+import com.rnmapbox.rnmbx.events.constants.EventTypes
+import com.rnmapbox.rnmbx.utils.*
+import com.rnmapbox.rnmbx.utils.extensions.toReadableArray
+import com.rnmapbox.rnmbx.v11compat.annotation.AnnotationID
+import com.rnmapbox.rnmbx.v11compat.annotation.INVALID_ANNOTATION_ID
 import org.json.JSONException
 import org.json.JSONObject
 import java.util.*
 
 import com.mapbox.maps.MapboxMap.*;
 
-import com.mapbox.rctmgl.v11compat.event.*
-import com.mapbox.rctmgl.v11compat.feature.*
-import com.mapbox.rctmgl.v11compat.mapboxmap.*
-import com.mapbox.rctmgl.v11compat.ornamentsettings.*
+import com.rnmapbox.rnmbx.v11compat.event.*
+import com.rnmapbox.rnmbx.v11compat.feature.*
+import com.rnmapbox.rnmbx.v11compat.mapboxmap.*
+import com.rnmapbox.rnmbx.v11compat.ornamentsettings.*
 
 data class OrnamentSettings(
     var enabled : Boolean? = false,
@@ -98,16 +98,16 @@ enum class MapGestureType {
  * Mapbox's MapView observers lifecycle events see MapboxLifecyclePluginImpl - (ON_START, ON_STOP, ON_DESTROY)
  * We need to emulate those.
  */
-interface RCTMGLLifeCycleOwner : LifecycleOwner {
+interface RNMBXLifeCycleOwner : LifecycleOwner {
     fun handleLifecycleEvent(event: Lifecycle.Event)
 }
 
-class RCTMGLLifeCycle {
-    private var lifecycleOwner : RCTMGLLifeCycleOwner? = null
+class RNMBXLifeCycle {
+    private var lifecycleOwner : RNMBXLifeCycleOwner? = null
 
     fun onAttachedToWindow(view: View) {
         if (lifecycleOwner == null) {
-            lifecycleOwner = object : RCTMGLLifeCycleOwner {
+            lifecycleOwner = object : RNMBXLifeCycleOwner {
                 private lateinit var lifecycleRegistry: LifecycleRegistry
                 init {
                     lifecycleRegistry = LifecycleRegistry(this)
@@ -118,7 +118,7 @@ class RCTMGLLifeCycle {
                     try {
                         lifecycleRegistry.handleLifecycleEvent(event)
                     } catch (e: RuntimeException) {
-                        Log.e("RCTMGLMapView", "handleLifecycleEvent, handleLifecycleEvent error: $e")
+                        Log.e("RNMBXMapView", "handleLifecycleEvent, handleLifecycleEvent error: $e")
                     }
                 }
 
@@ -156,7 +156,7 @@ data class FeatureEntry(val feature: AbstractMapFeature?, val view: View?, var a
 
 }
 
-open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapViewManager, options: MapInitOptions?) : FrameLayout(mContext), OnMapClickListener, OnMapLongClickListener, OnLayoutChangeListener {
+open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapViewManager, options: MapInitOptions?) : FrameLayout(mContext), OnMapClickListener, OnMapLongClickListener, OnLayoutChangeListener {
     /**
      * `PointAnnotations` are rendered to a canvas, but the React Native `Image` component is
      * implemented on top of Fresco (https://frescolib.org), which does not load images for
@@ -166,7 +166,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     public var offscreenAnnotationViewContainer: ViewGroup? = null
 
     private val mSources: MutableMap<String, RCTSource<*>>
-    private val mImages: MutableList<RCTMGLImages>
+    private val mImages: MutableList<RNMBXImages>
     private var mPointAnnotationManager: PointAnnotationManager? = null
     private var mActiveMarkerID: AnnotationID = INVALID_ANNOTATION_ID
     private var mProjection: ProjectionName = ProjectionName.MERCATOR
@@ -174,10 +174,10 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     private var mLocaleLayerIds: List<String>? = null
     private var mStyleURL: String? = null
     val isDestroyed = false
-    private var mCamera: RCTMGLCamera? = null
+    private var mCamera: RNMBXCamera? = null
     private val mFeatures = mutableListOf<FeatureEntry>()
     private var mQueuedFeatures: MutableList<AbstractMapFeature>? = ArrayList()
-    private val mPointAnnotations: MutableMap<String, RCTMGLPointAnnotation>
+    private val mPointAnnotations: MutableMap<String, RNMBXPointAnnotation>
     private val mCameraChangeTracker = CameraChangeTracker()
     private val mMap: MapboxMap?
 
@@ -223,7 +223,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
                 gesturesPlugin.removeOnMapClickListener(_this)
                 gesturesPlugin.removeOnMapLongClickListener(_this)
 
-                mPointAnnotationManager = mapView.annotations.createPointAnnotationManager(AnnotationConfig(layerId = "rctmgl-mapview-annotations"))
+                mPointAnnotationManager = mapView.annotations.createPointAnnotationManager(AnnotationConfig(layerId = "RNMBX-mapview-annotations"))
                 mPointAnnotationManager?.addClickListener(OnPointAnnotationClickListener { pointAnnotation ->
                         onMarkerClick(pointAnnotation)
                         false
@@ -232,7 +232,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
                 mPointAnnotationManager?.addDragListener(object : OnPointAnnotationDragListener {
                     override fun onAnnotationDragStarted(_annotation: Annotation<*>) {
                         mAnnotationDragged = true;
-                        var reactAnnotation: RCTMGLPointAnnotation? = null
+                        var reactAnnotation: RNMBXPointAnnotation? = null
                         for (key in mPointAnnotations.keys) {
                             val annotation = mPointAnnotations[key]
                             val curMarkerID = annotation?.mapboxID
@@ -244,7 +244,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
                     }
 
                    override fun onAnnotationDrag(_annotation: Annotation<*>) {
-                        var reactAnnotation: RCTMGLPointAnnotation? = null
+                        var reactAnnotation: RNMBXPointAnnotation? = null
                         for (key in mPointAnnotations.keys) {
                             val annotation = mPointAnnotations[key]
                             val curMarkerID = annotation?.mapboxID
@@ -257,7 +257,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
 
                     override fun onAnnotationDragFinished(_annotation: Annotation<*>) {
                         mAnnotationDragged = false;
-                        var reactAnnotation: RCTMGLPointAnnotation? = null
+                        var reactAnnotation: RNMBXPointAnnotation? = null
                         for (key in mPointAnnotations.keys) {
                             val annotation = mPointAnnotations[key]
                             val curMarkerID = annotation?.mapboxID
@@ -418,22 +418,22 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
             val source = childView
             mSources[source.iD.toString()] = source
             feature = childView as AbstractMapFeature?
-        } else if (childView is RCTMGLImages) {
+        } else if (childView is RNMBXImages) {
             mImages.add(childView)
             feature = childView
-        } else if (childView is RCTMGLLight) {
+        } else if (childView is RNMBXLight) {
             feature = childView
-        } else if (childView is RCTMGLTerrain) {
+        } else if (childView is RNMBXTerrain) {
             feature = childView as AbstractMapFeature?
-        } else if (childView is RCTMGLNativeUserLocation) {
+        } else if (childView is RNMBXNativeUserLocation) {
             feature = childView
-        } else if (childView is RCTMGLPointAnnotation) {
+        } else if (childView is RNMBXPointAnnotation) {
             val annotation = childView
             mPointAnnotations[annotation.iD.toString()] = annotation
             feature = childView
-        } else if (childView is RCTMGLMarkerView) {
+        } else if (childView is RNMBXMarkerView) {
             feature = childView
-        } else if (childView is RCTMGLCamera) {
+        } else if (childView is RNMBXCamera) {
             mCamera = childView
             feature = childView
         } else if (childView is RCTLayer<*>) {
@@ -462,13 +462,13 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         val feature = entry.feature
         if (feature is RCTSource<*>) {
             mSources.remove(feature.iD)
-        } else if (feature is RCTMGLPointAnnotation) {
+        } else if (feature is RNMBXPointAnnotation) {
             val annotation = feature
             if (annotation.mapboxID == mActiveMarkerID) {
                 mActiveMarkerID = INVALID_ANNOTATION_ID
             }
             mPointAnnotations.remove(annotation.iD)
-        } else if (feature is RCTMGLImages) {
+        } else if (feature is RNMBXImages) {
             mImages.remove(feature)
         }
         if (entry.addedToMap) {
@@ -728,8 +728,8 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     fun onMarkerClick(symbol: PointAnnotation) {
         mAnnotationClicked = true
         val selectedMarkerID = symbol.id
-        var activeAnnotation: RCTMGLPointAnnotation? = null
-        var nextActiveAnnotation: RCTMGLPointAnnotation? = null
+        var activeAnnotation: RNMBXPointAnnotation? = null
+        var nextActiveAnnotation: RNMBXPointAnnotation? = null
         for (key in mPointAnnotations.keys) {
             val annotation = mPointAnnotations[key]
             val curMarkerID = annotation?.mapboxID
@@ -744,12 +744,12 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
         nextActiveAnnotation?.let { selectAnnotation(it) }
     }
 
-    fun selectAnnotation(annotation: RCTMGLPointAnnotation) {
+    fun selectAnnotation(annotation: RNMBXPointAnnotation) {
         mActiveMarkerID = annotation.mapboxID
         annotation.onSelect(true)
     }
 
-    fun deselectAnnotation(annotation: RCTMGLPointAnnotation) {
+    fun deselectAnnotation(annotation: RNMBXPointAnnotation) {
         mActiveMarkerID = INVALID_ANNOTATION_ID
         annotation.onDeselect()
     }
@@ -1111,7 +1111,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     // endregion
 
     companion object {
-        const val LOG_TAG = "RCTMGLMapView"
+        const val LOG_TAG = "RNMBXMapView"
     }
 
     init {
@@ -1148,7 +1148,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
             }
         })
 
-        RCTMGLMarkerViewManager.markerViewContainerSizeFixer(this, mapView.viewAnnotationManager)
+        RNMBXMarkerViewManager.markerViewContainerSizeFixer(this, mapView.viewAnnotationManager)
 
         this.addOnLayoutChangeListener(this)
         this.setupEvents()
@@ -1380,7 +1380,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
     // endregion
 
     // region lifecycle
-    private val lifecycle : RCTMGLLifeCycle by lazy { RCTMGLLifeCycle() }
+    private val lifecycle : RNMBXLifeCycle by lazy { RNMBXLifeCycle() }
 
     fun getLifecycleState() : Lifecycle.State {
         return this.lifecycle.getState()
@@ -1439,7 +1439,7 @@ open class RCTMGLMapView(private val mContext: Context, var mManager: RCTMGLMapV
 }
 
 // region requestDisallowInterceptTouchEvent
-fun RCTMGLMapView.updateRequestDisallowInterceptTouchEvent(oldValue: Boolean, value: Boolean) {
+fun RNMBXMapView.updateRequestDisallowInterceptTouchEvent(oldValue: Boolean, value: Boolean) {
     if (oldValue == value) {
         return
     }

package/android/src/main/{java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLMapViewManager.kt → java/com/rnmapbox/rnmbx/components/mapview/RNMBXMapViewManager.kt}

@@ -1,30 +1,30 @@
-package com.mapbox.rctmgl.components.mapview
+package com.rnmapbox.rnmbx.components.mapview
 
 import android.content.Context
 import android.util.Log
 import android.view.View
 import com.facebook.react.bridge.*
 
-import com.mapbox.rctmgl.components.AbstractEventEmitter
+import com.rnmapbox.rnmbx.components.AbstractEventEmitter
 import com.facebook.react.uimanager.LayoutShadowNode
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.annotations.ReactProp
-import com.mapbox.rctmgl.events.constants.EventKeys
+import com.rnmapbox.rnmbx.events.constants.EventKeys
 import com.facebook.react.common.MapBuilder
 import com.facebook.react.uimanager.ViewManagerDelegate
-import com.facebook.react.viewmanagers.MBXMapViewManagerDelegate
-import com.facebook.react.viewmanagers.MBXMapViewManagerInterface
+import com.facebook.react.viewmanagers.RNMBXMapViewManagerDelegate
+import com.facebook.react.viewmanagers.RNMBXMapViewManagerInterface
 import com.mapbox.maps.MapInitOptions
 import com.mapbox.maps.extension.style.layers.properties.generated.ProjectionName
 import com.mapbox.maps.plugin.gestures.gestures
 import com.mapbox.maps.plugin.logo.logo
-import com.mapbox.rctmgl.events.AndroidCallbackEvent
-import com.mapbox.rctmgl.utils.ConvertUtils
-import com.mapbox.rctmgl.utils.ExpressionParser
-import com.mapbox.rctmgl.utils.Logger
-import com.mapbox.rctmgl.utils.extensions.toCoordinate
-import com.mapbox.rctmgl.utils.extensions.toRectF
-import com.mapbox.rctmgl.utils.extensions.toScreenCoordinate
+import com.rnmapbox.rnmbx.events.AndroidCallbackEvent
+import com.rnmapbox.rnmbx.utils.ConvertUtils
+import com.rnmapbox.rnmbx.utils.ExpressionParser
+import com.rnmapbox.rnmbx.utils.Logger
+import com.rnmapbox.rnmbx.utils.extensions.toCoordinate
+import com.rnmapbox.rnmbx.utils.extensions.toRectF
+import com.rnmapbox.rnmbx.utils.extensions.toScreenCoordinate
 import java.lang.Exception
 import java.util.HashMap
 
@@ -46,17 +46,17 @@ interface CommandResponse {
     fun error(message: String)
 }
 
-open class RCTMGLMapViewManager(context: ReactApplicationContext) :
-    AbstractEventEmitter<RCTMGLMapView>(context), MBXMapViewManagerInterface<RCTMGLMapView> {
-    private val mViews: MutableMap<Int, RCTMGLMapView>
+open class RNMBXMapViewManager(context: ReactApplicationContext) :
+    AbstractEventEmitter<RNMBXMapView>(context), RNMBXMapViewManagerInterface<RNMBXMapView> {
+    private val mViews: MutableMap<Int, RNMBXMapView>
 
-    private val mDelegate: ViewManagerDelegate<RCTMGLMapView>
+    private val mDelegate: ViewManagerDelegate<RNMBXMapView>
 
     init {
-        mDelegate = MBXMapViewManagerDelegate<RCTMGLMapView, RCTMGLMapViewManager>(this)
+        mDelegate = RNMBXMapViewManagerDelegate<RNMBXMapView, RNMBXMapViewManager>(this)
     }
 
-    override fun getDelegate(): ViewManagerDelegate<RCTMGLMapView>? {
+    override fun getDelegate(): ViewManagerDelegate<RNMBXMapView>? {
         return mDelegate
     }
 
@@ -72,7 +72,7 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext) :
         return MapShadowNode::class.java
     }
 
-    override fun onAfterUpdateTransaction(mapView: RCTMGLMapView) {
+    override fun onAfterUpdateTransaction(mapView: RNMBXMapView) {
         super.onAfterUpdateTransaction(mapView)
         if (mapView.getMapboxMap() == null) {
             mViews[mapView.id] = mapView
@@ -80,19 +80,19 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext) :
         }
     }
 
-    override fun addView(mapView: RCTMGLMapView?, childView: View?, childPosition: Int) {
+    override fun addView(mapView: RNMBXMapView?, childView: View?, childPosition: Int) {
         mapView!!.addFeature(childView, childPosition)
     }
 
-    override fun getChildCount(mapView: RCTMGLMapView?): Int {
+    override fun getChildCount(mapView: RNMBXMapView?): Int {
         return mapView!!.featureCount
     }
 
-    override fun getChildAt(mapView: RCTMGLMapView?, index: Int): View? {
+    override fun getChildAt(mapView: RNMBXMapView?, index: Int): View? {
         return mapView!!.getFeatureAt(index)
     }
 
-    override fun removeViewAt(mapView: RCTMGLMapView?, index: Int) {
+    override fun removeViewAt(mapView: RNMBXMapView?, index: Int) {
         mapView!!.removeFeatureAt(index)
     }
 
@@ -100,12 +100,12 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext) :
         return activity ?: themedReactContext
     }
 
-    override fun createViewInstance(themedReactContext: ThemedReactContext): RCTMGLMapView {
+    override fun createViewInstance(themedReactContext: ThemedReactContext): RNMBXMapView {
         val context = getMapViewContext(themedReactContext)
-        return RCTMGLMapView(context, this, options=null)
+        return RNMBXMapView(context, this, options=null)
     }
 
-    override fun onDropViewInstance(mapView: RCTMGLMapView) {
+    override fun onDropViewInstance(mapView: RNMBXMapView) {
         val reactTag = mapView.id
         if (mViews.containsKey(reactTag)) {
             mViews.remove(reactTag)
@@ -114,35 +114,35 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext) :
         super.onDropViewInstance(mapView)
     }
 
-    fun getByReactTag(reactTag: Int): RCTMGLMapView? {
+    fun getByReactTag(reactTag: Int): RNMBXMapView? {
         return mViews[reactTag]
     }
 
     // region React Props
     @ReactProp(name = "projection")
-    override fun setProjection(mapView: RCTMGLMapView, projection: String?) {
+    override fun setProjection(mapView: RNMBXMapView, projection: String?) {
         mapView.setReactProjection( if (projection == "globe") ProjectionName.GLOBE else ProjectionName.MERCATOR )
     }
 
     @ReactProp(name = "localizeLabels")
-    override fun setLocalizeLabels(mapView: RCTMGLMapView, localeMap: ReadableMap?) {
+    override fun setLocalizeLabels(mapView: RNMBXMapView, localeMap: ReadableMap?) {
         val locale = localeMap?.getString("locale")
         val layerIds = localeMap?.getArray("layerIds")?.toArrayList()?.mapNotNull {it?.toString()}
         mapView.setReactLocalizeLabels(locale, layerIds)
     }
 
     @ReactProp(name = "styleURL")
-    override fun setStyleURL(mapView: RCTMGLMapView, styleURL: String?) {
+    override fun setStyleURL(mapView: RNMBXMapView, styleURL: String?) {
         mapView.setReactStyleURL(styleURL!!)
     }
 
     @ReactProp(name = "preferredFramesPerSecond")
-    fun setPreferredFramesPerSecond(mapView: RCTMGLMapView?, preferredFramesPerSecond: Int) {
+    fun setPreferredFramesPerSecond(mapView: RNMBXMapView?, preferredFramesPerSecond: Int) {
         //mapView.setReactPreferredFramesPerSecond(preferredFramesPerSecond);
     }
 
     @ReactProp(name = "zoomEnabled")
-    override fun setZoomEnabled(map: RCTMGLMapView, zoomEnabled: Boolean) {
+    override fun setZoomEnabled(map: RNMBXMapView, zoomEnabled: Boolean) {
         val mapView = map.mapView
         mapView.gestures.pinchToZoomEnabled = zoomEnabled
         mapView.gestures.doubleTouchToZoomOutEnabled = zoomEnabled
@@ -150,130 +150,130 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext) :
     }
 
     @ReactProp(name = "scrollEnabled")
-    override fun setScrollEnabled(map: RCTMGLMapView, scrollEnabled: Boolean) {
+    override fun setScrollEnabled(map: RNMBXMapView, scrollEnabled: Boolean) {
         val mapView = map.mapView
         mapView.gestures.scrollEnabled = scrollEnabled
     }
 
     @ReactProp(name = "pitchEnabled")
-    override fun setPitchEnabled(map: RCTMGLMapView, pitchEnabled: Boolean) {
+    override fun setPitchEnabled(map: RNMBXMapView, pitchEnabled: Boolean) {
         val mapView = map.mapView
         mapView.gestures.pitchEnabled = pitchEnabled
     }
 
     @ReactProp(name = "rotateEnabled")
-    override fun setRotateEnabled(map: RCTMGLMapView, rotateEnabled: Boolean) {
+    override fun setRotateEnabled(map: RNMBXMapView, rotateEnabled: Boolean) {
         val mapView = map.mapView
         mapView.gestures.rotateEnabled = rotateEnabled
     }
 
     @ReactProp(name = "attributionEnabled")
-    override fun setAttributionEnabled(mapView: RCTMGLMapView, attributionEnabled: Boolean) {
+    override fun setAttributionEnabled(mapView: RNMBXMapView, attributionEnabled: Boolean) {
         mapView.setReactAttributionEnabled(attributionEnabled)
     }
 
     @ReactProp(name = "attributionPosition")
-    fun setAttributionPosition(mapView: RCTMGLMapView, attributionPosition: ReadableMap) {
+    fun setAttributionPosition(mapView: RNMBXMapView, attributionPosition: ReadableMap) {
         mapView.setReactAttributionPosition(attributionPosition)
     }
 
     @ReactProp(name = "attributionViewMargins")
-    fun setAttributionViewMargins(mapView: RCTMGLMapView, scaleBarMargins: ReadableMap) {
+    fun setAttributionViewMargins(mapView: RNMBXMapView, scaleBarMargins: ReadableMap) {
         mapView.setReactAttributionViewMargins(scaleBarMargins)
     }
 
     @ReactProp(name = "attributionViewPosition")
-    fun setAttributionViewPosition(mapView: RCTMGLMapView, scaleBarPosition: Int) {
+    fun setAttributionViewPosition(mapView: RNMBXMapView, scaleBarPosition: Int) {
         mapView.setReactAttributionViewPosition(scaleBarPosition)
     }
 
     @ReactProp(name = "logoEnabled")
-    override fun setLogoEnabled(mapView: RCTMGLMapView, logoEnabled: Boolean) {
+    override fun setLogoEnabled(mapView: RNMBXMapView, logoEnabled: Boolean) {
         mapView.setReactLogoEnabled(logoEnabled)
     }
 
     @ReactProp(name = "logoPosition")
-    fun setLogoPosition(mapView: RCTMGLMapView, logoPosition: ReadableMap?) {
+    fun setLogoPosition(mapView: RNMBXMapView, logoPosition: ReadableMap?) {
         mapView.setReactLogoPosition(logoPosition)
     }
 
     @ReactProp(name = "scaleBarEnabled")
-    override fun setScaleBarEnabled(mapView: RCTMGLMapView, scaleBarEnabled: Boolean) {
+    override fun setScaleBarEnabled(mapView: RNMBXMapView, scaleBarEnabled: Boolean) {
         mapView.setReactScaleBarEnabled(scaleBarEnabled)
     }
 
     @ReactProp(name = "scaleBarViewMargins")
-    fun setScaleBarViewMargins(mapView: RCTMGLMapView, scaleBarMargins: ReadableMap) {
+    fun setScaleBarViewMargins(mapView: RNMBXMapView, scaleBarMargins: ReadableMap) {
         mapView.setReactScaleBarViewMargins(scaleBarMargins)
     }
 
     @ReactProp(name = "scaleBarViewPosition")
-    fun setScaleBarViewPosition(mapView: RCTMGLMapView, scaleBarPosition: Int) {
+    fun setScaleBarViewPosition(mapView: RNMBXMapView, scaleBarPosition: Int) {
         mapView.setReactScaleBarViewPosition(scaleBarPosition)
     }
 
     @ReactProp(name = "scaleBarPosition")
-    fun scaleBarViewPosition(mapView: RCTMGLMapView?, scaleBarPosition: ReadableMap) {
+    fun scaleBarViewPosition(mapView: RNMBXMapView?, scaleBarPosition: ReadableMap) {
         mapView!!.setReactScaleBarPosition(scaleBarPosition)
     }
 
     @ReactProp(name = "compassEnabled")
-    override fun setCompassEnabled(mapView: RCTMGLMapView, compassEnabled: Boolean) {
+    override fun setCompassEnabled(mapView: RNMBXMapView, compassEnabled: Boolean) {
         mapView.setReactCompassEnabled(compassEnabled)
     }
 
     @ReactProp(name = "compassFadeWhenNorth")
-    override fun setCompassFadeWhenNorth(mapView: RCTMGLMapView, compassFadeWhenNorth: Boolean) {
+    override fun setCompassFadeWhenNorth(mapView: RNMBXMapView, compassFadeWhenNorth: Boolean) {
         mapView.setReactCompassFadeWhenNorth(compassFadeWhenNorth)
     }
 
     @ReactProp(name = "compassViewMargins")
-    override fun setCompassViewMargins(mapView: RCTMGLMapView, compassViewMargins: ReadableMap?) {
+    override fun setCompassViewMargins(mapView: RNMBXMapView, compassViewMargins: ReadableMap?) {
         mapView.setReactCompassViewMargins(compassViewMargins ?: return)
     }
 
     @ReactProp(name = "compassViewPosition")
-    override fun setCompassViewPosition(mapView: RCTMGLMapView, compassViewPosition: Int) {
+    override fun setCompassViewPosition(mapView: RNMBXMapView, compassViewPosition: Int) {
         mapView.setReactCompassViewPosition(compassViewPosition)
     }
 
     @ReactProp(name = "compassPosition")
-    fun setCompassPosition(mapView: RCTMGLMapView, compassMargins: ReadableMap) {
+    fun setCompassPosition(mapView: RNMBXMapView, compassMargins: ReadableMap) {
         mapView.setReactCompassPosition(compassMargins)
     }
 
     @ReactProp(name = "contentInset")
-    fun setContentInset(mapView: RCTMGLMapView, array: ReadableArray) {
+    fun setContentInset(mapView: RNMBXMapView, array: ReadableArray) {
         //mapView.setReactContentInset(array);
     }
 
     @ReactProp(name = "tintColor", customType = "Color")
-    fun setTintColor(mapView: RCTMGLMapView, tintColor: Int) {
+    fun setTintColor(mapView: RNMBXMapView, tintColor: Int) {
         //mapView.setTintColor(tintColor);
     }
 
     @ReactProp(name = "requestDisallowInterceptTouchEvent")
-    override fun setRequestDisallowInterceptTouchEvent(mapView: RCTMGLMapView, requestDisallowInterceptTouchEvent: Boolean) {
+    override fun setRequestDisallowInterceptTouchEvent(mapView: RNMBXMapView, requestDisallowInterceptTouchEvent: Boolean) {
         mapView.requestDisallowInterceptTouchEvent = requestDisallowInterceptTouchEvent
     }
 
-    override fun setAttributionPosition(view: RCTMGLMapView, value: Dynamic) {
+    override fun setAttributionPosition(view: RNMBXMapView, value: Dynamic) {
         this.setAttributionPosition(view, value.asMap())
     }
 
-    override fun setLogoPosition(view: RCTMGLMapView, value: Dynamic) {
+    override fun setLogoPosition(view: RNMBXMapView, value: Dynamic) {
         this.setLogoPosition(view, value.asMap())
     }
 
-    override fun setCompassPosition(view: RCTMGLMapView, value: Dynamic) {
+    override fun setCompassPosition(view: RNMBXMapView, value: Dynamic) {
         this.setCompassPosition(view, value.asMap())
     }
 
-    override fun setCompassImage(view: RCTMGLMapView, value: String?) {
+    override fun setCompassImage(view: RNMBXMapView, value: String?) {
         // TODO: No-op on Android?
     }
 
-    override fun setScaleBarPosition(view: RCTMGLMapView, value: Dynamic) {
+    override fun setScaleBarPosition(view: RNMBXMapView, value: Dynamic) {
         // TODO: should this call setScaleBarViewPosition?
     }
 
@@ -297,7 +297,7 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext) :
     }
     //endregion
 
-    private class MapShadowNode(private val mViewManager: RCTMGLMapViewManager) :
+    private class MapShadowNode(private val mViewManager: RNMBXMapViewManager) :
         LayoutShadowNode() {
         override fun dispose() {
             super.dispose()
@@ -323,8 +323,8 @@ open class RCTMGLMapViewManager(context: ReactApplicationContext) :
     }
 
     companion object {
-        const val LOG_TAG = "RCTMGLMapViewManager"
-        const val REACT_CLASS = "MBXMapView"
+        const val LOG_TAG = "RNMBXMapViewManager"
+        const val REACT_CLASS = "RNMBXMapView"
     }
 
     init {

package/android/src/main/{java-v10/com/mapbox/rctmgl → java/com/rnmapbox/rnmbx}/components/mapview/helpers/CameraChangeTracker.kt

@@ -1,4 +1,4 @@
-package com.mapbox.rctmgl.components.mapview.helpers
+package com.rnmapbox.rnmbx.components.mapview.helpers
 
 enum class CameraChangeReason {
     NONE,