@rnmapbox/maps 10.1.0-rc.3 → 10.1.0-rc.5

package/android/src/main/java/com/rnmapbox/rnmbx/modules/RNMBXOfflineModuleLegacy.kt

@@ -0,0 +1,444 @@
+package com.rnmapbox.rnmbx.modules
+
+import android.os.Build
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.mapbox.bindgen.Expected
+import com.mapbox.geojson.FeatureCollection
+import com.mapbox.geojson.Point
+import com.mapbox.maps.CoordinateBounds
+import com.mapbox.maps.GlyphsRasterizationMode
+import com.mapbox.maps.OfflineRegion
+import com.mapbox.maps.OfflineRegionCallback
+import com.mapbox.maps.OfflineRegionCreateCallback
+import com.mapbox.maps.OfflineRegionDownloadState
+import com.mapbox.maps.OfflineRegionManager
+import com.mapbox.maps.OfflineRegionStatus
+import com.mapbox.maps.OfflineRegionTilePyramidDefinition
+import com.rnmapbox.rnmbx.utils.ConvertUtils
+import com.rnmapbox.rnmbx.utils.extensions.toGeometryCollection
+import com.rnmapbox.rnmbx.utils.writableArrayOf
+import com.rnmapbox.rnmbx.v11compat.offlinemanager.getOfflineRegionManager
+import org.json.JSONException
+import org.json.JSONObject
+import java.io.File
+import java.io.UnsupportedEncodingException
+import java.nio.file.Files
+import java.nio.file.Paths
+import java.nio.file.StandardCopyOption
+import kotlin.math.ceil
+
+
+@ReactModule(name = RNMBXOfflineModuleLegacy.REACT_CLASS)
+class RNMBXOfflineModuleLegacy(private val mReactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(
+        mReactContext
+    ) {
+    companion object {
+        const val REACT_CLASS = "RNMBXOfflineModuleLegacy"
+        const val LOG_TAG = "OfflineModuleLegacy"
+        const val DEFAULT_STYLE_URL = "mapbox://styles/mapbox/streets-v11"
+        const val DEFAULT_MIN_ZOOM_LEVEL = 10.0
+        const val DEFAULT_MAX_ZOOM_LEVEL = 20.0
+        const val COMPLETE_REGION_DOWNLOAD_STATE = 2
+    }
+
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    val offlineRegionManager: OfflineRegionManager by lazy {
+        getOfflineRegionManager {
+            RNMBXModule.getAccessToken(mReactContext)
+        }
+    }
+
+    private fun makeDefinition(
+        bounds: CoordinateBounds,
+        options: ReadableMap
+    ): OfflineRegionTilePyramidDefinition {
+        return OfflineRegionTilePyramidDefinition.Builder()
+            .styleURL(ConvertUtils.getString("styleURL", options, DEFAULT_STYLE_URL))
+            .bounds(bounds)
+            .minZoom(ConvertUtils.getDouble("minZoom", options, DEFAULT_MIN_ZOOM_LEVEL))
+            .maxZoom(ConvertUtils.getDouble("maxZoom", options, DEFAULT_MAX_ZOOM_LEVEL))
+            .pixelRatio(mReactContext.getResources().getDisplayMetrics().density)
+            .glyphsRasterizationMode(GlyphsRasterizationMode.IDEOGRAPHS_RASTERIZED_LOCALLY)
+            .build()
+    }
+
+    private fun convertPointPairToBounds(boundsFC: FeatureCollection): CoordinateBounds? {
+        val geometryCollection = boundsFC.toGeometryCollection()
+        val geometries = geometryCollection.geometries()
+        if (geometries.size != 2) {
+            return null
+        }
+        val pt0 = geometries.get(0) as Point?
+        val pt1 = geometries.get(1) as Point?
+        if (pt0 == null || pt1 == null) {
+            return null
+        }
+        return CoordinateBounds(pt0, pt1)
+    }
+
+    private fun createPackCallback(promise: Promise, metadata: ByteArray): OfflineRegionCreateCallback {
+        return OfflineRegionCreateCallback { expected ->
+            if (expected.isValue) {
+                expected.value?.let {
+                    it.setOfflineRegionDownloadState(OfflineRegionDownloadState.ACTIVE)
+                    it.setMetadata(metadata) { expectedMetadata ->
+                        if (expectedMetadata.isError) {
+                            promise.reject("createPack error:", "Failed to setMetadata")
+                        } else {
+                            Log.d(LOG_TAG,  "createPack done:")
+                            promise.resolve(fromOfflineRegion(it))
+                        }
+                    }
+                }
+            } else {
+                Log.d(LOG_TAG,  "createPack error:")
+                promise.reject("createPack error:", "Failed to create OfflineRegion")
+            }
+        }
+    }
+
+
+    private fun fromOfflineRegion(region: OfflineRegion): WritableMap? {
+        val bb = region.tilePyramidDefinition?.bounds
+        val map = Arguments.createMap()
+
+        if (bb === null) return map
+
+        val jsonBounds = writableArrayOf(
+            writableArrayOf(bb.east(), bb.north()),
+            writableArrayOf(bb.west(), bb.south())
+        )
+
+        map.putArray("bounds", jsonBounds)
+        map.putString("metadata", String(region.metadata))
+
+        return map
+    }
+
+    private fun getMetadataBytes(metadata: String?): ByteArray? {
+        var metadataBytes: ByteArray? = null
+        if (metadata == null || metadata.isEmpty()) {
+            return metadataBytes
+        }
+        try {
+            metadataBytes = metadata.toByteArray(charset("utf-8"))
+        } catch (e: UnsupportedEncodingException) {
+            Log.w(LOG_TAG, e.localizedMessage)
+        }
+        return metadataBytes
+    }
+
+    private fun getRegionByName(
+        name: String?,
+        offlineRegions: List<OfflineRegion>
+    ): OfflineRegion? {
+        if (name.isNullOrEmpty()) {
+            return null
+        }
+        for (region in offlineRegions) {
+            try {
+                val byteMetadata = region.metadata
+
+                if (byteMetadata != null) {
+                    val metadata = JSONObject(String(byteMetadata))
+                    if (name == metadata.getString("name")) {
+                        return region
+                    }
+                }
+            } catch (e: JSONException) {
+                Log.w(LOG_TAG, e.localizedMessage)
+            }
+        }
+        return null
+    }
+
+    private fun makeRegionStatus(regionName: String, status: OfflineRegionStatus): WritableMap? {
+        val map = Arguments.createMap()
+        val progressPercentage = if (status.requiredResourceCount > 0) status.completedResourceCount.toDouble() / status.requiredResourceCount.toDouble() else 0.0
+        val percentage = ceil(progressPercentage * 100.0).coerceAtMost(100.0)
+        val isCompleted = percentage == 100.0
+        val downloadState = if (isCompleted) COMPLETE_REGION_DOWNLOAD_STATE else status.downloadState.ordinal
+
+        map.putString("name", regionName)
+        map.putInt("state", downloadState)
+        map.putDouble("percentage", percentage)
+        map.putInt("completedResourceCount", status.completedResourceCount.toInt())
+        map.putInt("completedResourceSize", status.completedResourceSize.toInt())
+        map.putInt("completedTileSize", status.completedTileSize.toInt())
+        map.putInt("completedTileCount", status.completedTileCount.toInt())
+        map.putInt("requiredResourceCount", status.requiredResourceCount.toInt())
+        return map
+    }
+
+    @ReactMethod
+    @Throws(JSONException::class)
+    fun createPack(options: ReadableMap, promise: Promise) {
+        try {
+            val metadataBytes: ByteArray? =
+                getMetadataBytes(ConvertUtils.getString("metadata", options, ""))
+
+            val boundsStr = options.getString("bounds")!!
+            val boundsFC = FeatureCollection.fromJson(boundsStr)
+            val bounds = convertPointPairToBounds(boundsFC)
+
+            if (metadataBytes == null || bounds == null) {
+                promise.reject("createPack error:", "No metadata or bounds set")
+                return
+            };
+
+            val definition: OfflineRegionTilePyramidDefinition = makeDefinition(bounds, options)
+
+            UiThreadUtil.runOnUiThread {
+                offlineRegionManager.createOfflineRegion(definition, createPackCallback(promise, metadataBytes))
+            }
+
+        } catch (e: Throwable) {
+            promise.reject("createPack error:", e)
+        }
+    }
+
+    @ReactMethod
+    fun getPacks(promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions(object: OfflineRegionCallback {
+                override fun run(expected: Expected<String, MutableList<OfflineRegion>>) {
+                    if (expected.isValue) {
+                        expected.value?.let {
+                            val payload = Arguments.createArray()
+
+                            for (region in it) {
+                                payload.pushMap(fromOfflineRegion(region!!))
+                            }
+
+                            Log.d(LOG_TAG,  "getPacks done:" + it.size.toString())
+                            promise.resolve(payload)
+                        }
+                    } else {
+                        promise.reject("getPacks error:", expected.error)
+                        Log.d(LOG_TAG,  "getPacks error:${expected.error}")
+                    }
+                }
+            })
+        }
+    }
+
+    @ReactMethod
+    fun deletePack(name: String?, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions { regionsExpected ->
+                if (regionsExpected.isValue) {
+                    regionsExpected.value?.let { regions ->
+                        var region = getRegionByName(name, regions);
+
+                        if (region == null) {
+                            promise.resolve(null);
+                            Log.w(LOG_TAG, "deleteRegion - Unknown offline region");
+                            return@getOfflineRegions
+                        }
+
+                        region.setOfflineRegionDownloadState(OfflineRegionDownloadState.INACTIVE)
+
+                        region.purge { purgeExpected ->
+                            if (purgeExpected.isError) {
+                                promise.reject("deleteRegion error:", purgeExpected.error);
+                            } else {
+                                promise.resolve(null);
+                            }
+                        }
+                    }
+                } else {
+                    promise.reject("deleteRegion error:", regionsExpected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun invalidatePack(name: String?, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions { expected ->
+                if (expected.isValue) {
+                    expected.value?.let { regions ->
+                        var region = getRegionByName(name, regions);
+
+                        if (region == null) {
+                            promise.resolve(null);
+                            Log.w(LOG_TAG, "invalidateRegion - Unknown offline region");
+                            return@getOfflineRegions
+                        }
+
+                        region.invalidate { expected ->
+                            if (expected.isError) {
+                                promise.reject("invalidateRegion error:", expected.error);
+                            } else {
+                                promise.resolve(null);
+                            }
+                        }
+                    }
+                } else {
+                    promise.reject("invalidateRegion error:", expected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun getPackStatus(name: String?, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions { expected ->
+                if (expected.isValue) {
+                    expected.value?.let { regions ->
+                        var region = getRegionByName(name, regions);
+
+                        if (region == null) {
+                            promise.resolve(null);
+                            Log.w(LOG_TAG, "getPackStatus - Unknown offline region");
+                            return@getOfflineRegions
+                        }
+
+                        region.getStatus {
+                           if (it.isValue) {
+                               it.value?.let { status ->
+                                   promise.resolve(makeRegionStatus(name!!, status));
+                               }
+                           } else {
+                               promise.reject("getPackStatus error:", expected.error);
+                           }
+                        }
+                    }
+                } else {
+                    promise.reject("getPackStatus error:", expected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun pausePackDownload(name: String?, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions { expected ->
+                if (expected.isValue) {
+                    expected.value?.let { regions ->
+                        var region = getRegionByName(name, regions);
+
+                        if (region == null) {
+                            promise.resolve(null);
+                            Log.w(LOG_TAG, "pausePackDownload - Unknown offline region");
+                            return@getOfflineRegions
+                        }
+
+                        region.setOfflineRegionDownloadState(OfflineRegionDownloadState.INACTIVE)
+                        promise.resolve(null)
+                    }
+                } else {
+                    promise.reject("pausePackDownload error:", expected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun resumePackDownload(name: String?, promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            offlineRegionManager.getOfflineRegions { expected ->
+                if (expected.isValue) {
+                    expected.value?.let { regions ->
+                        var region = getRegionByName(name, regions);
+
+                        if (region == null) {
+                            promise.resolve(null);
+                            Log.w(LOG_TAG, "resumeRegionDownload - Unknown offline region");
+                            return@getOfflineRegions
+                        }
+
+                        region.setOfflineRegionDownloadState(OfflineRegionDownloadState.ACTIVE)
+                        promise.resolve(null);
+                    }
+                } else {
+                    promise.reject("resumeRegionDownload error:", expected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun resetDatabase(promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            var purgedCount = 0
+            offlineRegionManager.getOfflineRegions { expected ->
+                if (expected.isValue) {
+                    expected.value?.let { regions ->
+                        if (regions.size == 0) promise.resolve(null)
+
+                        for (region in regions) {
+                            region.setOfflineRegionDownloadState(OfflineRegionDownloadState.INACTIVE)
+
+                            region.purge { expected ->
+                                if (expected.isError) {
+                                    promise.reject("resetDatabase error:", expected.error);
+                                } else {
+                                    purgedCount++
+                                    if (purgedCount == regions.size) {
+                                        Log.d(LOG_TAG, "resetDatabase done: ${regions.size} packs were purged")
+                                        promise.resolve(null)
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    promise.reject("resetDatabase error:", expected.error);
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun migrateOfflineCache(promise: Promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            // Old and new cache file paths
+            val targetDirectoryPathName = mReactContext.filesDir.absolutePath + "/.mapbox/map_data"
+            val sourcePathName = mReactContext.filesDir.absolutePath + "/mbgl-offline.db"
+            val sourcePath = Paths.get(sourcePathName)
+            val targetPath = Paths.get("$targetDirectoryPathName/map_data.db")
+
+            try {
+                val source = File(sourcePath.toString())
+
+                if (!source.exists()) {
+                    Log.d(LOG_TAG, "Nothing to migrate")
+                    promise.resolve(false)
+                    return
+                }
+
+                val directory = File(targetDirectoryPathName)
+
+                directory.mkdirs()
+                Files.move(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING)
+                Log.d(LOG_TAG, "v10 cache directory created successfully")
+                promise.resolve(true)
+            } catch (e: Exception) {
+                val mes = "${e}... file move unsuccessful"
+                Log.d(LOG_TAG, mes)
+                promise.reject(mes)
+            }
+        } else {
+            val mes = "\"migrateOfflineCache only supported on api level 26 or later\""
+            Log.w(LOG_TAG, "migrateOfflineCache only supported on api level 26 or later")
+            promise.reject(mes)
+        }
+    }
+}

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

@@ -100,6 +100,11 @@ object GeoJSONUtils {
         val map: WritableMap = WritableNativeMap()
         map.putString("type", "Feature")
         map.putMap("geometry", toPointGeometry(latLng))
+        properties?.let {
+            if (it.hasKey("id") == true) {
+                map.putString("id", it.getString("id"));
+            }
+        }
         map.putMap("properties", properties)
         return map
     }

package/android/src/main/mapbox-v11-compat/v10/com/rnmapbox/rnmbx/v11compat/Annotation.kt

@@ -21,6 +21,10 @@ fun ViewAnnotationOptions.Builder.height(value: Double): ViewAnnotationOptions.B
   return this.height(value.toInt())
 }
 
+fun com.mapbox.maps.ViewAnnotationOptions.Builder.allowOverlapWithPuck(value: Boolean): ViewAnnotationOptions.Builder {
+  return this;
+}
+
 abstract class OnViewAnnotationUpdatedListener : _OnViewAnnotationUpdatedListener {
   override fun onViewAnnotationPositionUpdated(
     view: View,

package/android/src/main/mapbox-v11-compat/v11/com/rnmapbox/rnmbx/v11compat/Annotation.kt

@@ -27,7 +27,6 @@ fun ViewAnnotationOptions.Builder.offsets(x: Double, y: Double) {
   ))
 }
 
-
 abstract class OnViewAnnotationUpdatedListener : _OnViewAnnotationUpdatedListener {
 
 }

package/android/src/main/old-arch/com/facebook/react/viewmanagers/RNMBXMapViewManagerDelegate.java

@@ -67,6 +67,9 @@ public class RNMBXMapViewManagerDelegate<T extends View, U extends BaseViewManag
       case "pitchEnabled":
         mViewManager.setPitchEnabled(view, new DynamicFromObject(value));
         break;
+      case "deselectAnnotationOnTap":
+        mViewManager.setDeselectAnnotationOnTap(view, new DynamicFromObject(value));
+        break;
       case "requestDisallowInterceptTouchEvent":
         mViewManager.setRequestDisallowInterceptTouchEvent(view, new DynamicFromObject(value));
         break;

package/android/src/main/old-arch/com/facebook/react/viewmanagers/RNMBXMapViewManagerInterface.java

@@ -28,6 +28,7 @@ public interface RNMBXMapViewManagerInterface<T extends View> {
   void setScrollEnabled(T view, Dynamic value);
   void setRotateEnabled(T view, Dynamic value);
   void setPitchEnabled(T view, Dynamic value);
+  void setDeselectAnnotationOnTap(T view, Dynamic value);
   void setRequestDisallowInterceptTouchEvent(T view, Dynamic value);
   void setProjection(T view, Dynamic value);
   void setLocalizeLabels(T view, Dynamic value);

package/ios/RNMBX/RNMBXEvent.swift

@@ -38,6 +38,8 @@ class RNMBXEvent : NSObject, RNMBXEventProtocol {
       case onUserTrackingModeChange
       case vectorSourceLayerPress
       case shapeSourceLayerPress
+      case annotationSelected = "annotationselected"
+      case annotationDeselected = "annotationdeselected"
     }
     
     init(type: EventType, payload: [String:Any?]?) {

package/ios/RNMBX/RNMBXMapView.swift

@@ -129,13 +129,16 @@ open class RNMBXMapView: UIView {
   private var isGestureActive = false
   
   var layerWaiters : [String:[(String) -> Void]] = [:]
+
+  @objc
+  public var deselectAnnotationOnTap: Bool = false
   
 #if RNMBX_11
   var cancelables = Set<AnyCancelable>()
 #endif
   
-  lazy var pointAnnotationManager : PointAnnotationManager = {
-    let result = PointAnnotationManager(annotations: mapView.annotations, mapView: mapView)
+  lazy var pointAnnotationManager : RNMBXPointAnnotationManager = {
+    let result = RNMBXPointAnnotationManager(annotations: mapView.annotations, mapView: mapView)
     self._removeMapboxLongPressGestureRecognizer()
     return result
   }()
@@ -1158,11 +1161,29 @@ extension RNMBXMapView: GestureManagerDelegate {
     return orderedLayers.lazy.reversed().compactMap { layersToSource[$0.id] }.first ?? sources.first
   }
   
+  
+  
+  func _tapEvent(_ tapPoint: CGPoint) -> RNMBXEvent {
+    let location = self.mapboxMap.coordinate(for: tapPoint)
+    var geojson = Feature(geometry: .point(Point(location)));
+    geojson.properties = [
+      "screenPointX": .number(Double(tapPoint.x)),
+      "screenPointY": .number(Double(tapPoint.y))
+    ]
+    let event = RNMBXEvent(type:.tap, payload: logged("reactOnPress") { try geojson.toJSON() })
+    return event
+  }
+  
   @objc
   func doHandleTap(_ sender: UITapGestureRecognizer) {
     let tapPoint = sender.location(in: self)
     pointAnnotationManager.handleTap(sender) { (_: UITapGestureRecognizer) in
       DispatchQueue.main.async {
+        if (self.deselectAnnotationOnTap) {
+          if (self.pointAnnotationManager.deselectCurrentlySelected(deselectAnnotationOnTap: true)) {
+            return
+          }
+        }
         let touchableSources = self.touchableSources()
         self.doHandleTapInSources(sources: touchableSources, tapPoint: tapPoint, hits: [:], touchedSources: []) { (hits, touchedSources) in
           
@@ -1194,14 +1215,7 @@ extension RNMBXMapView: GestureManagerDelegate {
             
           } else {
             if let reactOnPress = self.reactOnPress {
-              let location = self.mapboxMap.coordinate(for: tapPoint)
-              var geojson = Feature(geometry: .point(Point(location)));
-              geojson.properties = [
-                "screenPointX": .number(Double(tapPoint.x)),
-                "screenPointY": .number(Double(tapPoint.y))
-              ]
-              let event = RNMBXEvent(type:.tap, payload: logged("reactOnPress") { try geojson.toJSON() })
-              self.fireEvent(event: event, callback: reactOnPress)
+              self.fireEvent(event: self._tapEvent(tapPoint), callback: reactOnPress)
             }
           }
         }
@@ -1341,7 +1355,7 @@ extension RNMBXMapView {
   }
 }
 
-class PointAnnotationManager : AnnotationInteractionDelegate {
+class RNMBXPointAnnotationManager : AnnotationInteractionDelegate {
   weak var selected : RNMBXPointAnnotation? = nil
   private var draggedAnnotation: PointAnnotation?
   
@@ -1349,6 +1363,44 @@ class PointAnnotationManager : AnnotationInteractionDelegate {
     // We handle taps ourselfs
     //   onTap(annotations: annotations)
   }
+  
+  func deselectCurrentlySelected(deselectAnnotationOnTap: Bool = false) -> Bool {
+    if let selected = selected {
+      selected.doDeselect(deselectAnnotationOnMapTap: deselectAnnotationOnTap)
+      self.selected = nil
+      return true
+    }
+    return false
+  }
+  
+  func onAnnotationClick(pointAnnotation: RNMBXPointAnnotation) {
+    let oldSelected = selected
+    var newSelected: RNMBXPointAnnotation? = pointAnnotation
+    
+    if (newSelected == oldSelected) {
+      newSelected = nil
+    }
+    
+    deselectCurrentlySelected()
+
+    if let newSelected = newSelected {
+      newSelected.doSelect()
+      selected = newSelected
+    }
+  }
+  
+  func lookup(_ annotation: PointAnnotation) -> RNMBXPointAnnotation? {
+    guard let userInfo = annotation.userInfo else {
+        return nil
+    }
+    if let rnmbxPointAnnotationWeakRef = userInfo[RNMBXPointAnnotation.key] as? WeakRef<RNMBXPointAnnotation> {
+      if let rnmbxPointAnnotation = rnmbxPointAnnotationWeakRef.object {
+        return rnmbxPointAnnotation
+      }
+    }
+    return nil
+  }
+  
 
   func onTap(annotations: [Annotation]) {
     guard annotations.count > 0 else {
@@ -1356,34 +1408,9 @@ class PointAnnotationManager : AnnotationInteractionDelegate {
     }
     
     for annotation in annotations {
-      if let pointAnnotation = annotation as? PointAnnotation,
-         let userInfo = pointAnnotation.userInfo {
-        
-        if let RNMBXPointAnnotation = userInfo[RNMBXPointAnnotation.key] as? WeakRef<RNMBXPointAnnotation> {
-          if let pt = RNMBXPointAnnotation.object {
-            let position = pt.superview?.convert(pt.layer.position, to: nil)
-            let location = pt.map?.mapboxMap.coordinate(for: position!)
-            var geojson = Feature(geometry: .point(Point(location!)))
-            geojson.identifier = .string(pt.id)
-            geojson.properties = [
-              "screenPointX": .number(Double(position!.x)),
-              "screenPointY": .number(Double(position!.y))
-            ]
-            let event = RNMBXEvent(type:.tap, payload: logged("doHandleTap") { try geojson.toJSON() })
-            if let selected = selected {
-              guard let onDeselected = pt.onDeselected else {
-                return
-              }
-              onDeselected(event.toJSON())
-              selected.onDeselect()
-            }
-            guard let onSelected = pt.onSelected else {
-              return
-            }
-            onSelected(event.toJSON())
-            pt.onSelect()
-            selected = pt
-          }
+      if let annotation = annotation as? PointAnnotation {
+        if let pointAnnotation = lookup(annotation) {
+          onAnnotationClick(pointAnnotation: pointAnnotation)
         }
       }
     }