Annotation tap and long press events (#977)

* Annotations tap listener as Cancelable
* add long press listener as Cancelable

Author: maios

CHANGELOG.md

@@ -1,6 +1,24 @@
 ### main
 
 * Introduce new experimental properties: `FillLayer.fillConstructBridgeGuardRail`, `FillLayer.fillBridgeGuardRailColor`, `FillLayer.fillTunnelStructureColor`, `CircleLayer.circleElevationReference`. 
+* Introduce `tapEvents` and `longPressEvents` API to the Annotation Managers to handle tap and long press event callbacks for annotations:
+  Example usage:
+  ```dart
+  manager.tapEvents(
+    onTap: (annotation) {
+      print("Tapped annotation: ${annotation.id}");
+    },
+  );
+  manager.longPressEvents(
+    onLongPress: (annotation) {
+      print("Long press annotation: ${annotation.id}");
+    },
+  );
+  ```
+
+> [!NOTE]
+> As part of this change, `AnnotationOnClickListener` is now deprecated.
+> Tap events will now not propagate to annotations below the topmost one. If you tap on overlapping annotations, only the top annotation's tap event will be triggered.
 
 ### 2.9.0
 

android/src/main/kotlin/com/mapbox/maps/mapbox_maps/annotation/AnnotationController.kt

@@ -2,10 +2,6 @@ package com.mapbox.maps.mapbox_maps.annotation
 
 import com.mapbox.maps.MapView
 import com.mapbox.maps.mapbox_maps.pigeons.*
-import com.mapbox.maps.mapbox_maps.pigeons.OnCircleAnnotationClickListener
-import com.mapbox.maps.mapbox_maps.pigeons.OnPointAnnotationClickListener
-import com.mapbox.maps.mapbox_maps.pigeons.OnPolygonAnnotationClickListener
-import com.mapbox.maps.mapbox_maps.pigeons.OnPolylineAnnotationClickListener
 import com.mapbox.maps.mapbox_maps.pigeons.PointAnnotation
 import com.mapbox.maps.plugin.annotation.Annotation
 import com.mapbox.maps.plugin.annotation.AnnotationConfig
@@ -18,22 +14,19 @@ import com.mapbox.maps.plugin.annotation.generated.PolylineAnnotation
 import io.flutter.plugin.common.BinaryMessenger
 import io.flutter.plugin.common.MethodCall
 import io.flutter.plugin.common.MethodChannel
+import kotlin.collections.set
 
 class AnnotationController(
   private val mapView: MapView,
   private val messenger: BinaryMessenger,
   private val channelSuffix: String
 ) : ControllerDelegate {
   private val managerMap = mutableMapOf<String, AnnotationManager<*, *, *, *, *, *, *>>()
-  private val streamSinkMap = mutableMapOf<String, PigeonEventSink<AnnotationInteractionContext>>()
+  private val streamSinkMap = mutableMapOf<String, InteractionEventsHandler>()
   private val pointAnnotationController = PointAnnotationController(this)
   private val circleAnnotationController = CircleAnnotationController(this)
   private val polygonAnnotationController = PolygonAnnotationController(this)
   private val polylineAnnotationController = PolylineAnnotationController(this)
-  private var onPointAnnotationClickListener: OnPointAnnotationClickListener? = null
-  private var onPolygonAnnotationClickListener: OnPolygonAnnotationClickListener? = null
-  private var onPolylineAnnotationClickListener: OnPolylineAnnotationClickListener? = null
-  private var onCircleAnnotationClickListener: OnCircleAnnotationClickListener? = null
   private var index = 0
 
   fun handleCreateManager(call: MethodCall, result: MethodChannel.Result) {
@@ -50,7 +43,13 @@ class AnnotationController(
         mapView.annotations.createCircleAnnotationManager(AnnotationConfig(belowLayerId, id, id)).apply {
           this.addClickListener(
             com.mapbox.maps.plugin.annotation.generated.OnCircleAnnotationClickListener { annotation ->
-              onCircleAnnotationClickListener?.onCircleAnnotationClick(annotation.toFLTCircleAnnotation()) {}
+              sendTapEvent(id, annotation)
+              false
+            }
+          )
+          this.addLongClickListener(
+            OnCircleAnnotationLongClickListener { annotation ->
+              sendLongPressEvent(id, annotation)
               false
             }
           )
@@ -74,7 +73,13 @@ class AnnotationController(
         mapView.annotations.createPointAnnotationManager(AnnotationConfig(belowLayerId, id, id)).apply {
           this.addClickListener(
             com.mapbox.maps.plugin.annotation.generated.OnPointAnnotationClickListener { annotation ->
-              onPointAnnotationClickListener?.onPointAnnotationClick(annotation.toFLTPointAnnotation()) {}
+              sendTapEvent(id, annotation)
+              false
+            }
+          )
+          this.addLongClickListener(
+            OnPointAnnotationLongClickListener { annotation ->
+              sendLongPressEvent(id, annotation)
               false
             }
           )
@@ -98,7 +103,13 @@ class AnnotationController(
         mapView.annotations.createPolygonAnnotationManager(AnnotationConfig(belowLayerId, id, id)).apply {
           this.addClickListener(
             com.mapbox.maps.plugin.annotation.generated.OnPolygonAnnotationClickListener { annotation ->
-              onPolygonAnnotationClickListener?.onPolygonAnnotationClick(annotation.toFLTPolygonAnnotation()) {}
+              sendTapEvent(id, annotation)
+              false
+            }
+          )
+          this.addLongClickListener(
+            OnPolygonAnnotationLongClickListener { annotation ->
+              sendLongPressEvent(id, annotation)
               false
             }
           )
@@ -122,7 +133,13 @@ class AnnotationController(
         mapView.annotations.createPolylineAnnotationManager(AnnotationConfig(belowLayerId, id, id)).apply {
           this.addClickListener(
             com.mapbox.maps.plugin.annotation.generated.OnPolylineAnnotationClickListener { annotation ->
-              onPolylineAnnotationClickListener?.onPolylineAnnotationClick(annotation.toFLTPolylineAnnotation()) {}
+              sendTapEvent(id, annotation)
+              false
+            }
+          )
+          this.addLongClickListener(
+            OnPolylineAnnotationLongClickListener { annotation ->
+              sendLongPressEvent(id, annotation)
               false
             }
           )
@@ -147,23 +164,13 @@ class AnnotationController(
         return
       }
     }
-
-    val interactionEvents = object : AnnotationDragEventsStreamHandler() {
-      override fun onListen(p0: Any?, sink: PigeonEventSink<AnnotationInteractionContext>) {
-        streamSinkMap[id] = sink
-      }
-
-      override fun onCancel(p0: Any?) {
-        streamSinkMap.remove(id)
-      }
-    }
-
-    AnnotationDragEventsStreamHandler.register(
+    managerMap[id] = manager
+    val eventsHandler = InteractionEventsHandler()
+    eventsHandler.register(
       messenger,
-      interactionEvents, "$channelSuffix/$id"
+      "$channelSuffix/$id"
     )
-
-    managerMap[id] = manager
+    streamSinkMap[id] = eventsHandler
     result.success(id)
   }
 
@@ -176,10 +183,6 @@ class AnnotationController(
   }
 
   fun setup() {
-    onPointAnnotationClickListener = OnPointAnnotationClickListener(messenger, channelSuffix)
-    onCircleAnnotationClickListener = OnCircleAnnotationClickListener(messenger, channelSuffix)
-    onPolygonAnnotationClickListener = OnPolygonAnnotationClickListener(messenger, channelSuffix)
-    onPolylineAnnotationClickListener = OnPolylineAnnotationClickListener(messenger, channelSuffix)
     _PointAnnotationMessenger.setUp(messenger, pointAnnotationController, channelSuffix)
     _CircleAnnotationMessenger.setUp(
       messenger,
@@ -200,10 +203,6 @@ class AnnotationController(
     _CircleAnnotationMessenger.setUp(messenger, null, channelSuffix)
     _PolylineAnnotationMessenger.setUp(messenger, null, channelSuffix)
     _PolygonAnnotationMessenger.setUp(messenger, null, channelSuffix)
-    onPointAnnotationClickListener = null
-    onCircleAnnotationClickListener = null
-    onPolygonAnnotationClickListener = null
-    onPolylineAnnotationClickListener = null
   }
 
   fun sendDragEvent(managerId: String, annotation: Annotation<*>, gestureState: GestureState) {
@@ -219,7 +218,39 @@ class AnnotationController(
 
       else -> throw IllegalArgumentException("$annotation is unsupported")
     }
-    streamSinkMap[managerId]?.success(context)
+    streamSinkMap[managerId]?.dragEventsSink?.success(context)
+  }
+
+  fun sendTapEvent(managerId: String, annotation: Annotation<*>) {
+    val context: AnnotationInteractionContext = when (annotation) {
+      is com.mapbox.maps.plugin.annotation.generated.PointAnnotation ->
+        PointAnnotationInteractionContext(annotation.toFLTPointAnnotation(), GestureState.ENDED)
+      is CircleAnnotation ->
+        CircleAnnotationInteractionContext(annotation.toFLTCircleAnnotation(), GestureState.ENDED)
+      is PolygonAnnotation ->
+        PolygonAnnotationInteractionContext(annotation.toFLTPolygonAnnotation(), GestureState.ENDED)
+      is PolylineAnnotation ->
+        PolylineAnnotationInteractionContext(annotation.toFLTPolylineAnnotation(), GestureState.ENDED)
+
+      else -> throw IllegalArgumentException("$annotation is unsupported")
+    }
+    streamSinkMap[managerId]?.tapEventsSink?.success(context)
+  }
+
+  fun sendLongPressEvent(managerId: String, annotation: Annotation<*>) {
+    val context: AnnotationInteractionContext = when (annotation) {
+      is com.mapbox.maps.plugin.annotation.generated.PointAnnotation ->
+        PointAnnotationInteractionContext(annotation.toFLTPointAnnotation(), GestureState.ENDED)
+      is CircleAnnotation ->
+        CircleAnnotationInteractionContext(annotation.toFLTCircleAnnotation(), GestureState.ENDED)
+      is PolygonAnnotation ->
+        PolygonAnnotationInteractionContext(annotation.toFLTPolygonAnnotation(), GestureState.ENDED)
+      is PolylineAnnotation ->
+        PolylineAnnotationInteractionContext(annotation.toFLTPolylineAnnotation(), GestureState.ENDED)
+
+      else -> throw IllegalArgumentException("$annotation is unsupported")
+    }
+    streamSinkMap[managerId]?.longPressEventsSink?.success(context)
   }
 
   override fun getManager(managerId: String): AnnotationManager<*, *, *, *, *, *, *> {
@@ -228,4 +259,45 @@ class AnnotationController(
     }
     return managerMap[managerId]!!
   }
+
+  companion object {
+    class InteractionEventsHandler {
+      var tapEventsSink: PigeonEventSink<AnnotationInteractionContext>? = null
+      var dragEventsSink: PigeonEventSink<AnnotationInteractionContext>? = null
+      var longPressEventsSink: PigeonEventSink<AnnotationInteractionContext>? = null
+
+      fun register(messenger: BinaryMessenger, channelName: String) {
+        val tapEvents = object : AnnotationInteractionEventsStreamHandler() {
+          override fun onListen(p0: Any?, sink: PigeonEventSink<AnnotationInteractionContext>) {
+            tapEventsSink = sink
+          }
+
+          override fun onCancel(p0: Any?) {
+            tapEventsSink = null
+          }
+        }
+        val longPressEvents = object : AnnotationInteractionEventsStreamHandler() {
+          override fun onListen(p0: Any?, sink: PigeonEventSink<AnnotationInteractionContext>) {
+            longPressEventsSink = sink
+          }
+
+          override fun onCancel(p0: Any?) {
+            longPressEventsSink = null
+          }
+        }
+        val dragEvents = object : AnnotationInteractionEventsStreamHandler() {
+          override fun onListen(p0: Any?, sink: PigeonEventSink<AnnotationInteractionContext>) {
+            dragEventsSink = sink
+          }
+
+          override fun onCancel(p0: Any?) {
+            dragEventsSink = null
+          }
+        }
+        AnnotationInteractionEventsStreamHandler.register(messenger, tapEvents, "$channelName/tap")
+        AnnotationInteractionEventsStreamHandler.register(messenger, tapEvents, "$channelName/drag")
+        AnnotationInteractionEventsStreamHandler.register(messenger, longPressEvents, "$channelName/long_press")
+      }
+    }
+  }
 }

android/src/main/kotlin/com/mapbox/maps/mapbox_maps/pigeons/CircleAnnotationMessenger.kt

@@ -34,10 +34,6 @@ private fun wrapError(exception: Throwable): List<Any?> {
   }
 }
 
-private fun createConnectionError(channelName: String): FlutterError {
-  return FlutterError("channel-error", "Unable to establish connection on channel: '$channelName'.", "")
-}
-
 /**
  * Selects the base of circle-elevation. Some modes might require precomputed elevation data in the tileset.
  * Default value: "none".
@@ -376,31 +372,6 @@ private open class CircleAnnotationMessengerPigeonCodec : StandardMessageCodec()
   }
 }
 
-/** Generated class from Pigeon that represents Flutter messages that can be called from Kotlin. */
-class OnCircleAnnotationClickListener(private val binaryMessenger: BinaryMessenger, private val messageChannelSuffix: String = "") {
-  companion object {
-    /** The codec used by OnCircleAnnotationClickListener. */
-    val codec: MessageCodec<Any?> by lazy {
-      CircleAnnotationMessengerPigeonCodec()
-    }
-  }
-  fun onCircleAnnotationClick(annotationArg: CircleAnnotation, callback: (Result<Unit>) -> Unit) {
-    val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
-    val channelName = "dev.flutter.pigeon.mapbox_maps_flutter.OnCircleAnnotationClickListener.onCircleAnnotationClick$separatedMessageChannelSuffix"
-    val channel = BasicMessageChannel<Any?>(binaryMessenger, channelName, codec)
-    channel.send(listOf(annotationArg)) {
-      if (it is List<*>) {
-        if (it.size > 1) {
-          callback(Result.failure(FlutterError(it[0] as String, it[1] as String, it[2] as String?)))
-        } else {
-          callback(Result.success(Unit))
-        }
-      } else {
-        callback(Result.failure(createConnectionError(channelName)))
-      }
-    }
-  }
-}
 /** Generated interface from Pigeon that represents a handler of messages from Flutter. */
 interface _CircleAnnotationMessenger {
   fun create(managerId: String, annotationOption: CircleAnnotationOptions, callback: (Result<CircleAnnotation>) -> Unit)

android/src/main/kotlin/com/mapbox/maps/mapbox_maps/pigeons/GestureListeners.kt

@@ -463,10 +463,10 @@ class PigeonEventSink<T>(private val sink: EventChannel.EventSink) {
   }
 }
 
-abstract class AnnotationDragEventsStreamHandler : GestureListenersPigeonEventChannelWrapper<AnnotationInteractionContext> {
+abstract class AnnotationInteractionEventsStreamHandler : GestureListenersPigeonEventChannelWrapper<AnnotationInteractionContext> {
   companion object {
-    fun register(messenger: BinaryMessenger, streamHandler: AnnotationDragEventsStreamHandler, instanceName: String = "") {
-      var channelName: String = "dev.flutter.pigeon.mapbox_maps_flutter.AnnotationInteractions._annotationDragEvents"
+    fun register(messenger: BinaryMessenger, streamHandler: AnnotationInteractionEventsStreamHandler, instanceName: String = "") {
+      var channelName: String = "dev.flutter.pigeon.mapbox_maps_flutter.AnnotationInteractions._annotationInteractionEvents"
       if (instanceName.isNotEmpty()) {
         channelName += ".$instanceName"
       }

android/src/main/kotlin/com/mapbox/maps/mapbox_maps/pigeons/PointAnnotationMessenger.kt

@@ -33,10 +33,6 @@ private fun wrapError(exception: Throwable): List<Any?> {
     )
   }
 }
-
-private fun createConnectionError(channelName: String): FlutterError {
-  return FlutterError("channel-error", "Unable to establish connection on channel: '$channelName'.", "")
-}
 private fun deepEqualsPointAnnotationMessenger(a: Any?, b: Any?): Boolean {
   if (a is ByteArray && b is ByteArray) {
     return a.contentEquals(b)
@@ -1219,31 +1215,6 @@ private open class PointAnnotationMessengerPigeonCodec : StandardMessageCodec()
   }
 }
 
-/** Generated class from Pigeon that represents Flutter messages that can be called from Kotlin. */
-class OnPointAnnotationClickListener(private val binaryMessenger: BinaryMessenger, private val messageChannelSuffix: String = "") {
-  companion object {
-    /** The codec used by OnPointAnnotationClickListener. */
-    val codec: MessageCodec<Any?> by lazy {
-      PointAnnotationMessengerPigeonCodec()
-    }
-  }
-  fun onPointAnnotationClick(annotationArg: PointAnnotation, callback: (Result<Unit>) -> Unit) {
-    val separatedMessageChannelSuffix = if (messageChannelSuffix.isNotEmpty()) ".$messageChannelSuffix" else ""
-    val channelName = "dev.flutter.pigeon.mapbox_maps_flutter.OnPointAnnotationClickListener.onPointAnnotationClick$separatedMessageChannelSuffix"
-    val channel = BasicMessageChannel<Any?>(binaryMessenger, channelName, codec)
-    channel.send(listOf(annotationArg)) {
-      if (it is List<*>) {
-        if (it.size > 1) {
-          callback(Result.failure(FlutterError(it[0] as String, it[1] as String, it[2] as String?)))
-        } else {
-          callback(Result.success(Unit))
-        }
-      } else {
-        callback(Result.failure(createConnectionError(channelName)))
-      }
-    }
-  }
-}
 /** Generated interface from Pigeon that represents a handler of messages from Flutter. */
 interface _PointAnnotationMessenger {
   fun create(managerId: String, annotationOption: PointAnnotationOptions, callback: (Result<PointAnnotation>) -> Unit)