@rnmapbox/maps 10.1.4 → 10.1.6

package/README.md

@@ -74,7 +74,7 @@ _See [iOS](ios/install.md) & [Android](android/install.md) setup guide for using
 
 - [node](https://nodejs.org)
 - [npm](https://www.npmjs.com/)
-- [React Native](https://facebook.github.io/react-native/) (0.64+)
+- [React Native](https://facebook.github.io/react-native/) (0.70+, older versions from 0.64+ might or might not work)
 
 
 ## Installation

package/android/build.gradle

@@ -43,7 +43,11 @@ if (safeExtGet("RNMapboxMapsImpl", defaultMapboxMapsImpl) == "mapbox") {
 }
 
 android {
-    namespace = "com.rnmapbox.rnmbx"
+    def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+    // Check AGP version for backward compatibility reasons
+    if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
+        namespace = "com.rnmapbox.rnmbx"
+    }
     if (safeExtGet("RNMapboxMapsImpl", defaultMapboxMapsImpl) == "maplibre") {
         msg = '@rnmapbox/maps: Maplibre implementation has been removed, set RNMapboxMapsImpl to mapbox- see https://github.com/rnmapbox/maps/wiki/Deprecated-RNMapboxImpl-Maplibre#android'
         logger.error(msg)
@@ -161,4 +165,15 @@ dependencies {
         implementation "com.squareup.okhttp3:okhttp:4.9.0"
         implementation "com.squareup.okhttp3:okhttp-urlconnection:4.9.0"
     }
+
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
+    testImplementation 'org.jetbrains.kotlin:kotlin-test'
+    testImplementation "org.mockito.kotlin:mockito-kotlin:5.2.1"
 }
+
+
+tasks.withType(Test).configureEach {
+    useJUnitPlatform()
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXPointAnnotation.kt

@@ -25,6 +25,8 @@ import java.util.*
 import com.rnmapbox.rnmbx.v11compat.annotation.*;
 
 class RNMBXPointAnnotation(private val mContext: Context, private val mManager: RNMBXPointAnnotationManager) : AbstractMapFeature(mContext), View.OnLayoutChangeListener {
+
+    var pointAnnotations: RNMBXPointAnnotationCoordinator? = null
     var annotation: PointAnnotation? = null
         private set
     private var mMap: MapboxMap? = null
@@ -79,6 +81,7 @@ class RNMBXPointAnnotation(private val mContext: Context, private val mManager:
     override fun addToMap(mapView: RNMBXMapView) {
         super.addToMap(mapView)
         mMap = mapView.getMapboxMap()
+        pointAnnotations = mapView.pointAnnotations
         makeMarker()
         if (mChildView != null) {
             if (!mChildView!!.isAttachedToWindow) {
@@ -96,16 +99,13 @@ class RNMBXPointAnnotation(private val mContext: Context, private val mManager:
     }
 
     override fun removeFromMap(mapView: RNMBXMapView, reason: RemovalReason): Boolean {
-        val map = (if (mMapView != null) mMapView else mapView) ?: return true
-        if (annotation != null) {
-            map.pointAnnotationManager?.delete(annotation!!)
-        }
-        if (mChildView != null) {
-            map.offscreenAnnotationViewContainer?.removeView(mChildView)
-        }
-        if (calloutView != null) {
-            map.offscreenAnnotationViewContainer?.removeView(calloutView)
-        }
+        val map = mMapView ?: mapView
+
+        annotation?.let { map.pointAnnotations?.delete(it) }
+
+        mChildView?.let { map.offscreenAnnotationViewContainer?.removeView(it) }
+        calloutView?.let { map.offscreenAnnotationViewContainer?.removeView(it)}
+
         return super.removeFromMap(mapView, reason)
     }
 
@@ -138,33 +138,36 @@ class RNMBXPointAnnotation(private val mContext: Context, private val mManager:
     val latLng: LatLng?
         get() = mCoordinate?.let { GeoJSONUtils.toLatLng(it) }
     val mapboxID: AnnotationID
-        get() = if (annotation == null) INVALID_ANNOTATION_ID else annotation!!.id
+        get() = annotation?.id ?: INVALID_ANNOTATION_ID
+
+    val calloutMapboxID: AnnotationID
+        get() = mCalloutSymbol?.id ?: INVALID_ANNOTATION_ID
 
     fun setCoordinate(point: Point) {
         mCoordinate = point
         annotation?.let {
             it.point = point
-            mMapView?.pointAnnotationManager?.update(it)
+            pointAnnotations?.update(it)
         }
         mCalloutSymbol?.let {
             it.point = point
-            mMapView?.pointAnnotationManager?.update(it)
+            pointAnnotations?.update(it)
         }
     }
 
     fun setAnchor(x: Float, y: Float) {
         mAnchor = arrayOf(x, y)
-        if (annotation != null) {
+        annotation?.let { annotation ->
             updateAnchor()
-            mMapView?.pointAnnotationManager?.update(annotation!!)
+            pointAnnotations?.update(annotation)
         }
     }
 
     fun setDraggable(draggable: Boolean) {
         mDraggable = draggable
-        annotation?.let {
-            it.isDraggable = draggable
-            mMapView?.pointAnnotationManager?.update(it)
+        annotation?.let { annotation ->
+            annotation.isDraggable = draggable
+            pointAnnotations?.update(annotation)
         }
     }
 
@@ -179,8 +182,8 @@ class RNMBXPointAnnotation(private val mContext: Context, private val mManager:
 
     fun doDeselect() {
         mManager.handleEvent(makeEvent(false))
-        if (mCalloutSymbol != null) {
-            mMapView?.pointAnnotationManager?.delete(mCalloutSymbol!!)
+        mCalloutSymbol?.let { mCalloutSymbol ->
+            pointAnnotations?.delete(mCalloutSymbol)
         }
     }
 
@@ -207,19 +210,18 @@ class RNMBXPointAnnotation(private val mContext: Context, private val mManager:
                 .withIconSize(1.0)
                 .withSymbolSortKey(10.0)
         }
-        mMapView?.pointAnnotationManager?.let { annotationManager ->
-            options?.let {
-                annotation = annotationManager.create(options)
-                updateOptions()
-            }
+        annotation = null
+        options?.let {
+            annotation = pointAnnotations?.create(it)
+            updateOptions()
         }
     }
 
     private fun updateOptions() {
-        if (annotation != null) {
+        annotation?.let {
             updateIconImage()
             updateAnchor()
-            mMapView?.pointAnnotationManager?.update(annotation!!)
+            pointAnnotations?.update(it)
         }
     }
 
@@ -268,7 +270,7 @@ class RNMBXPointAnnotation(private val mContext: Context, private val mManager:
                     .withDraggable(false)
             }
         }
-        val symbolManager = mMapView?.pointAnnotationManager
+        val symbolManager = pointAnnotations
         if (symbolManager != null && options != null) {
             mCalloutSymbol = symbolManager.create(options)
         }

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXPointAnnotationCoordinator.kt

@@ -0,0 +1,168 @@
+package com.rnmapbox.rnmbx.components.annotation
+
+import com.mapbox.maps.MapView
+import com.mapbox.maps.plugin.annotation.Annotation
+import com.mapbox.maps.plugin.annotation.AnnotationConfig
+import com.mapbox.maps.plugin.annotation.annotations
+import com.mapbox.maps.plugin.annotation.generated.OnPointAnnotationClickListener
+import com.mapbox.maps.plugin.annotation.generated.OnPointAnnotationDragListener
+import com.mapbox.maps.plugin.annotation.generated.PointAnnotation
+import com.mapbox.maps.plugin.annotation.generated.PointAnnotationManager
+import com.mapbox.maps.plugin.annotation.generated.PointAnnotationOptions
+import com.mapbox.maps.plugin.annotation.generated.createPointAnnotationManager
+import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotation
+import com.rnmapbox.rnmbx.utils.Logger
+
+class RNMBXPointAnnotationCoordinator(val mapView: MapView) {
+    val manager: PointAnnotationManager;
+    var annotationClicked = false
+    var annotationDragged = false
+
+    var selected: RNMBXPointAnnotation? = null
+
+    val annotations: MutableMap<String, RNMBXPointAnnotation> = hashMapOf()
+    val callouts: MutableMap<String, RNMBXPointAnnotation> = hashMapOf()
+
+    init {
+        manager = mapView.annotations.createPointAnnotationManager(AnnotationConfig(layerId = "RNMBX-mapview-annotations"))
+        manager.addClickListener(OnPointAnnotationClickListener { pointAnnotation ->
+            onAnnotationClick(pointAnnotation)
+            false
+        })
+    }
+
+    fun getAndClearAnnotationClicked(): Boolean {
+        if (annotationClicked) {
+            annotationClicked = false
+            return true
+        }
+        return false
+    }
+
+    fun getAndClearAnnotationDragged(): Boolean {
+        if (annotationDragged) {
+            annotationDragged = false
+            return true
+        }
+        return false
+    }
+
+    fun lookupForClick(point: PointAnnotation): RNMBXPointAnnotation? {
+        for (annotation in annotations.values) {
+            if (point.id == annotation.mapboxID) {
+                return annotation;
+            }
+            if (point.id == annotation.calloutMapboxID) {
+                return null;
+            }
+        }
+        Logger.e(LOG_TAG, "Failed to find RNMBXPointAnnotation for ${point.id}")
+        return null;
+    }
+
+    fun onAnnotationClick(pointAnnotation: RNMBXPointAnnotation) {
+        var oldSelected: RNMBXPointAnnotation? = selected
+        var newSelected: RNMBXPointAnnotation? = pointAnnotation
+
+        annotationClicked = true
+
+        if (newSelected == oldSelected) {
+            newSelected = null
+        }
+
+        manager.addDragListener(object : OnPointAnnotationDragListener {
+            override fun onAnnotationDragStarted(_annotation: Annotation<*>) {
+                annotationDragged = true;
+                var reactAnnotation: RNMBXPointAnnotation? = null
+                for (key in annotations.keys) {
+                    val annotation = annotations[key]
+                    val curMarkerID = annotation?.mapboxID
+                    if (_annotation.id == curMarkerID) {
+                        reactAnnotation = annotation
+                    }
+                }
+                reactAnnotation?.let { it.onDragStart() }
+            }
+
+            override fun onAnnotationDrag(_annotation: Annotation<*>) {
+                var reactAnnotation: RNMBXPointAnnotation? = null
+                for (key in annotations.keys) {
+                    val annotation = annotations[key]
+                    val curMarkerID = annotation?.mapboxID
+                    if (_annotation.id == curMarkerID) {
+                        reactAnnotation = annotation
+                    }
+                }
+                reactAnnotation?.let { it.onDrag() }
+            }
+
+            override fun onAnnotationDragFinished(_annotation: Annotation<*>) {
+                annotationDragged = false;
+                var reactAnnotation: RNMBXPointAnnotation? = null
+                for (key in annotations.keys) {
+                    val annotation = annotations[key]
+                    val curMarkerID = annotation?.mapboxID
+                    if (_annotation.id == curMarkerID) {
+                        reactAnnotation = annotation
+                    }
+                }
+                reactAnnotation?.let { it.onDragEnd() }
+            }
+        })
+
+        oldSelected?.let { deselectAnnotation(it) }
+        newSelected?.let { selectAnnotation(it) }
+
+    }
+
+    fun onAnnotationClick(point: PointAnnotation) {
+        lookupForClick(point)?.let {
+            onAnnotationClick(it)
+        }
+    }
+
+    fun deselectSelectedAnnotation(): Boolean {
+        selected?.let {
+            deselectAnnotation(it)
+            return true
+        }
+        return false
+    }
+
+    fun selectAnnotation(annotation: RNMBXPointAnnotation) {
+        selected = annotation
+        annotation.doSelect(true)
+    }
+
+    fun deselectAnnotation(annotation: RNMBXPointAnnotation) {
+        selected = null
+        annotation.doDeselect()
+    }
+
+    fun remove(annotation: RNMBXPointAnnotation) {
+        if (annotation == selected) {
+            selected = null
+        }
+        annotations.remove(annotation.iD)
+    }
+
+    fun delete(annotation: PointAnnotation) {
+        manager.delete(annotation)
+    }
+
+    fun update(annotation: PointAnnotation) {
+        manager.update(annotation)
+    }
+
+    fun create(options: PointAnnotationOptions): PointAnnotation {
+        return manager.create(options)
+    }
+
+    fun add(annotation: RNMBXPointAnnotation) {
+        annotations[annotation.iD!!] = annotation
+    }
+
+    companion object {
+        const val LOG_TAG = "RNMBXPointAnnotationCoordinator";
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/RNMBXCamera.kt

@@ -59,7 +59,7 @@ class RNMBXCamera(private val mContext: Context, private val mManager: RNMBXCame
     private val mAnimated = false
     private val mHeading = 0.0
 
-    private var mFollowUserLocation = false
+    private var mFollowUserLocation = defaultFollowUserLocation
     private var mFollowUserMode: String? = null
     private var mFollowZoomLevel : Double? = null
     private var mFollowPitch : Double? = null
@@ -126,8 +126,8 @@ class RNMBXCamera(private val mContext: Context, private val mManager: RNMBXCame
         _updateViewportState()
     }
 
-    fun setFollowUserLocation(value: Boolean) {
-        mFollowUserLocation = value
+    fun setFollowUserLocation(value: Boolean?) {
+        mFollowUserLocation = value ?: defaultFollowUserLocation
         _updateViewportState()
     }
 
@@ -559,5 +559,7 @@ class RNMBXCamera(private val mContext: Context, private val mManager: RNMBXCame
         const val minimumZoomLevelForUserTracking = 10.5
         const val defaultZoomLevelForUserTracking = 14.0
         const val LOG_TAG = "RNMBXCamera"
+
+        const val defaultFollowUserLocation = false
     }
 }

package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/RNMBXCameraManager.kt

@@ -9,7 +9,7 @@ import com.mapbox.geojson.FeatureCollection
 import com.rnmapbox.rnmbx.components.AbstractEventEmitter
 import com.rnmapbox.rnmbx.components.camera.CameraStop.Companion.fromReadableMap
 import com.rnmapbox.rnmbx.utils.GeoJSONUtils.toLatLngBounds
-
+import com.rnmapbox.rnmbx.utils.extensions.asBooleanOrNull
 
 class RNMBXCameraManager(private val mContext: ReactApplicationContext) :
     AbstractEventEmitter<RNMBXCamera?>(
@@ -66,7 +66,7 @@ class RNMBXCameraManager(private val mContext: ReactApplicationContext) :
 
     @ReactProp(name = "followUserLocation")
     override fun setFollowUserLocation(camera: RNMBXCamera, value: Dynamic) {
-        camera.setFollowUserLocation(value.asBoolean())
+        camera.setFollowUserLocation(value.asBooleanOrNull())
     }
 
     @ReactProp(name = "followUserMode")

package/android/src/main/java/com/rnmapbox/rnmbx/components/mapview/RNMBXMapView.kt

@@ -34,18 +34,10 @@ import com.mapbox.maps.extension.style.layers.properties.generated.ProjectionNam
 import com.mapbox.maps.extension.style.layers.properties.generated.Visibility
 import com.mapbox.maps.extension.style.projection.generated.Projection
 import com.mapbox.maps.extension.style.projection.generated.setProjection
-import com.mapbox.maps.plugin.annotation.Annotation
-import com.mapbox.maps.plugin.annotation.AnnotationConfig
-import com.mapbox.maps.plugin.annotation.annotations
-import com.mapbox.maps.plugin.annotation.generated.*
 import com.mapbox.maps.plugin.attribution.attribution
 import com.mapbox.maps.plugin.compass.compass
 import com.mapbox.maps.plugin.delegates.listeners.*
 import com.mapbox.maps.plugin.gestures.*
-import com.mapbox.maps.plugin.locationcomponent.DefaultLocationProvider
-import com.mapbox.maps.plugin.locationcomponent.LocationConsumer
-import com.mapbox.maps.plugin.locationcomponent.LocationProvider
-import com.mapbox.maps.plugin.locationcomponent.location
 import com.mapbox.maps.plugin.logo.logo
 import com.mapbox.maps.plugin.scalebar.scalebar
 import com.mapbox.maps.viewannotation.ViewAnnotationManager
@@ -72,11 +64,9 @@ 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 java.util.*
 
-import com.mapbox.maps.MapboxMap.*;
+import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotationCoordinator
 import com.rnmapbox.rnmbx.components.images.ImageManager
 
 import com.rnmapbox.rnmbx.v11compat.event.*
@@ -85,7 +75,6 @@ import com.rnmapbox.rnmbx.v11compat.mapboxmap.*
 import com.rnmapbox.rnmbx.v11compat.ornamentsettings.*
 import org.json.JSONException
 import org.json.JSONObject
-import java.util.*
 
 fun <T> MutableList<T>.removeIf21(predicate: (T) -> Boolean): Boolean {
     var removed = false
@@ -205,7 +194,7 @@ public class RNMBXMapViewFactory {
         }
 
         fun get(impl: String): Factory? {
-            val (impl, options) = impl.split(":",limit=2);
+            val (impl, options) = impl.split(":",limit=2) + null;
             return factories.get(impl);
         }
     }
@@ -225,12 +214,12 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
 
     private val mSources: MutableMap<String, RNMBXSource<*>>
     private val mImages: MutableList<RNMBXImages>
-    public val pointAnnotationManager: RNMBXPointAnnotationManager by lazy {
+    public val pointAnnotations: RNMBXPointAnnotationCoordinator by lazy {
         val gesturesPlugin: GesturesPlugin = mapView.gestures
         gesturesPlugin.removeOnMapClickListener(this)
         gesturesPlugin.removeOnMapLongClickListener(this)
 
-        val result = RNMBXPointAnnotationManager(mapView)
+        val result = RNMBXPointAnnotationCoordinator(mapView)
 
         gesturesPlugin.addOnMapClickListener(this)
         gesturesPlugin.addOnMapLongClickListener(this)
@@ -445,7 +434,7 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
             feature = childView
         } else if (childView is RNMBXPointAnnotation) {
             val annotation = childView
-            pointAnnotationManager.add(annotation)
+            pointAnnotations.add(annotation)
             feature = childView
         } else if (childView is RNMBXMarkerView) {
             feature = childView
@@ -481,7 +470,7 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
             mSources.remove(feature.iD)
         } else if (feature is RNMBXPointAnnotation) {
             val annotation = feature
-            pointAnnotationManager.remove(annotation)
+            pointAnnotations.remove(annotation)
         } else if (feature is RNMBXImages) {
             mImages.remove(feature)
         }
@@ -729,13 +718,15 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
                     )
             ) { features ->
                 if (features.isValue) {
-                    if (features.value!!.size > 0) {
-                        val featuresList = ArrayList<Feature?>()
-                        for (i in features.value!!) {
-                            featuresList.add(i.feature)
+                    features.value?.let { features ->
+                        if (features.size > 0) {
+                            val featuresList = ArrayList<Feature?>()
+                            for (i in features) {
+                                featuresList.add(i.feature)
+                            }
+                            hits[source.iD] = featuresList
+                            hitTouchableSources.add(source)
                         }
-                        hits[source.iD] = featuresList
-                        hitTouchableSources.add(source)
                     }
                 } else {
                     Logger.e("handleTapInSources", features.error ?: "n/a")
@@ -747,11 +738,11 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
 
     override fun onMapClick(point: Point): Boolean {
         val _this = this
-        if (pointAnnotationManager.getAndClearAnnotationClicked()) {
+        if (pointAnnotations.getAndClearAnnotationClicked()) {
             return true
         }
         if (deselectAnnotationOnTap) {
-            if (pointAnnotationManager.deselectSelectedAnnotation()) {
+            if (pointAnnotations.deselectSelectedAnnotation()) {
                 return true
             }
         }
@@ -783,7 +774,7 @@ open class RNMBXMapView(private val mContext: Context, var mManager: RNMBXMapVie
 
     override fun onMapLongClick(point: Point): Boolean {
         val _this = this
-        if (pointAnnotationManager.getAndClearAnnotationDragged()) {
+        if (pointAnnotations.getAndClearAnnotationDragged()) {
             return true
         }
         val screenPoint = mMap?.pixelForCoordinate(point)
@@ -1565,154 +1556,5 @@ fun OrnamentSettings.setPosAndMargins(posAndMargins: ReadableMap?) {
     this.margins = margins
 }
 
-class RNMBXPointAnnotationManager(val mapView: MapView) {
-    val manager: PointAnnotationManager;
-    var annotationClicked = false
-    var annotationDragged = false
-
-    var selected: RNMBXPointAnnotation? = null
-
-    val annotations: MutableMap<String, RNMBXPointAnnotation> = hashMapOf()
-
-    init {
-        manager = mapView.annotations.createPointAnnotationManager(AnnotationConfig(layerId = "RNMBX-mapview-annotations"))
-        manager.addClickListener(OnPointAnnotationClickListener { pointAnnotation ->
-            onAnnotationClick(pointAnnotation)
-            false
-        })
-    }
-
-    fun getAndClearAnnotationClicked(): Boolean {
-        if (annotationClicked) {
-            annotationClicked = false
-            return true
-        }
-        return false
-    }
-
-    fun getAndClearAnnotationDragged(): Boolean {
-        if (annotationDragged) {
-            annotationDragged = false
-            return true
-        }
-        return false
-    }
-
-    fun lookup(point: PointAnnotation): RNMBXPointAnnotation? {
-        for (annotation in annotations.values) {
-            if (point.id == annotation.mapboxID) {
-                return annotation;
-            }
-        }
-        Logger.e(LOG_TAG, "Failed to find RNMBXPointAnntoation for ${point.id}")
-        return null;
-    }
-
-    fun onAnnotationClick(pointAnnotation: RNMBXPointAnnotation) {
-        var oldSelected: RNMBXPointAnnotation? = selected
-        var newSelected: RNMBXPointAnnotation? = pointAnnotation
-
-        annotationClicked = true
-
-        if (newSelected == oldSelected) {
-            newSelected = null
-        }
-
-        manager.addDragListener(object : OnPointAnnotationDragListener {
-            override fun onAnnotationDragStarted(_annotation: Annotation<*>) {
-                annotationDragged = true;
-                var reactAnnotation: RNMBXPointAnnotation? = null
-                for (key in annotations.keys) {
-                    val annotation = annotations[key]
-                    val curMarkerID = annotation?.mapboxID
-                    if (_annotation.id == curMarkerID) {
-                        reactAnnotation = annotation
-                    }
-                }
-                reactAnnotation?.let { it.onDragStart() }
-            }
-
-            override fun onAnnotationDrag(_annotation: Annotation<*>) {
-                var reactAnnotation: RNMBXPointAnnotation? = null
-                for (key in annotations.keys) {
-                    val annotation = annotations[key]
-                    val curMarkerID = annotation?.mapboxID
-                    if (_annotation.id == curMarkerID) {
-                        reactAnnotation = annotation
-                    }
-                }
-                reactAnnotation?.let { it.onDrag() }
-            }
-
-            override fun onAnnotationDragFinished(_annotation: Annotation<*>) {
-                annotationDragged = false;
-                var reactAnnotation: RNMBXPointAnnotation? = null
-                for (key in annotations.keys) {
-                    val annotation = annotations[key]
-                    val curMarkerID = annotation?.mapboxID
-                    if (_annotation.id == curMarkerID) {
-                        reactAnnotation = annotation
-                    }
-                }
-                reactAnnotation?.let { it.onDragEnd() }
-            }
-        })
-
-        oldSelected?.let { deselectAnnotation(it) }
-        newSelected?.let { selectAnnotation(it) }
-
-    }
-
-    fun onAnnotationClick(point: PointAnnotation) {
-        lookup(point)?.let {
-            onAnnotationClick(it)
-        }
-    }
-
-    fun deselectSelectedAnnotation(): Boolean {
-        selected?.let {
-            deselectAnnotation(it)
-            return true
-        }
-        return false
-    }
-
-    fun selectAnnotation(annotation: RNMBXPointAnnotation) {
-        selected = annotation
-        annotation.doSelect(true)
-    }
-
-    fun deselectAnnotation(annotation: RNMBXPointAnnotation) {
-        selected = null
-        annotation.doDeselect()
-    }
-
-    fun remove(annotation: RNMBXPointAnnotation) {
-        if (annotation == selected) {
-            selected = null
-        }
-        annotations.remove(annotation.iD)
-    }
-
-    fun delete(annotation: PointAnnotation) {
-        manager.delete(annotation)
-    }
-
-    fun update(annotation: PointAnnotation) {
-        manager.update(annotation)
-    }
-
-    fun create(options: PointAnnotationOptions): PointAnnotation {
-        return manager.create(options)
-    }
-
-    fun add(annotation: RNMBXPointAnnotation) {
-        annotations[annotation.iD!!] = annotation
-    }
-
-    companion object {
-        const val LOG_TAG = "RNMBXPointAnnotationManager";
-    }
-}
 
 

package/android/src/main/java/com/rnmapbox/rnmbx/components/styles/RNMBXStyleValue.kt

@@ -40,7 +40,7 @@ class RNMBXStyleValue(config: ReadableMap) {
     }
 
     fun getEnumName(): String {
-        return mPayload!!.getString("value")!!.toUpperCase().replace("-", "_")
+        return mPayload!!.getString("value")!!.uppercase().replace("-", "_")
     }
 
     fun getDouble(key: String?): Double {

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/Dynamic.kt

@@ -54,4 +54,12 @@ fun Dynamic.toValue(): Value {
         ReadableType.Array -> asArray().toValue()
         ReadableType.Map -> asMap().toValue()
     }
+}
+
+fun Dynamic.asBooleanOrNull(): Boolean? {
+    return if (isNull) {
+        null
+    } else {
+        asBoolean()
+    }
 }