Implement draggable markers

Author: afarber

openmapview/src/main/kotlin/de/afarber/openmapview/Marker.kt

@@ -12,24 +12,26 @@ import android.graphics.Bitmap
 /**
  * Represents a marker on the map at a specific geographic location.
  *
- * @property position The geographic location of the marker
+ * @property position The geographic location of the marker (mutable for dragging)
  * @property title Optional title text displayed when marker is clicked
  * @property snippet Optional snippet text displayed below the title
  * @property icon Custom icon bitmap. If null, a default marker icon will be used
  * @property anchor Anchor point for the marker icon. Default (0.5f, 1.0f) means
  *                  the marker is centered horizontally and anchored at the bottom
  * @property visible Whether the marker is visible. Default is true
  * @property alpha Opacity of the marker from 0.0 (transparent) to 1.0 (opaque). Default is 1.0
+ * @property draggable Whether the marker can be dragged. Default is false
  * @property tag Optional user data associated with the marker
  */
 data class Marker(
-    val position: LatLng,
+    var position: LatLng,
     val title: String? = null,
     val snippet: String? = null,
     val icon: Bitmap? = null,
     val anchor: Pair<Float, Float> = Pair(0.5f, 1.0f),
     val visible: Boolean = true,
     val alpha: Float = 1.0f,
+    val draggable: Boolean = false,
     val tag: Any? = null,
 ) {
     init {

openmapview/src/main/kotlin/de/afarber/openmapview/OnMarkerDragListener.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2025 Alexander Farber
+ * SPDX-License-Identifier: MIT
+ *
+ * This file is part of the OpenMapView project (https://github.com/afarber/OpenMapView)
+ */
+
+package de.afarber.openmapview
+
+/**
+ * Interface for receiving marker drag events.
+ *
+ * Compatible with Google Maps API. Implement this interface to receive
+ * callbacks when a draggable marker is dragged across the map.
+ */
+interface OnMarkerDragListener {
+    /**
+     * Called when a marker starts being dragged.
+     *
+     * @param marker The marker being dragged
+     */
+    fun onMarkerDragStart(marker: Marker)
+
+    /**
+     * Called repeatedly while a marker is being dragged.
+     *
+     * @param marker The marker being dragged
+     */
+    fun onMarkerDrag(marker: Marker)
+
+    /**
+     * Called when a marker has finished being dragged.
+     *
+     * @param marker The marker that was dragged
+     */
+    fun onMarkerDragEnd(marker: Marker)
+}

openmapview/src/main/kotlin/de/afarber/openmapview/OpenMapView.kt

@@ -51,6 +51,9 @@ class OpenMapView
         private var lastTouchY = 0f
         private var onMapClickListener: OnMapClickListener? = null
         private var onMapLongClickListener: OnMapLongClickListener? = null
+        private var onMarkerDragListener: OnMarkerDragListener? = null
+        private var draggedMarker: Marker? = null
+        private var isDragging = false
 
         private val gestureDetector =
             GestureDetector(
@@ -103,30 +106,76 @@ class OpenMapView
         }
 
         override fun onTouchEvent(event: MotionEvent): Boolean {
-            // Let gesture detector handle long press
-            gestureDetector.onTouchEvent(event)
+            // Let gesture detector handle long press (but not during drag)
+            if (!isDragging) {
+                gestureDetector.onTouchEvent(event)
+            }
 
             // Let scale detector handle pinch gestures
             scaleGestureDetector.onTouchEvent(event)
 
-            // Handle panning only if not scaling
+            // Handle dragging and panning only if not scaling
             if (!scaleGestureDetector.isInProgress) {
                 when (event.action) {
                     MotionEvent.ACTION_DOWN -> {
                         lastTouchX = event.x
                         lastTouchY = event.y
+                        // Check if touch is on a draggable marker
+                        val touchedMarker = controller.handleMarkerTouch(event.x, event.y)
+                        if (touchedMarker != null && touchedMarker.draggable) {
+                            draggedMarker = touchedMarker
+                            isDragging = false
+                        }
                         return true
                     }
                     MotionEvent.ACTION_MOVE -> {
                         val dx = event.x - lastTouchX
                         val dy = event.y - lastTouchY
-                        controller.updatePanOffset(dx, dy)
-                        lastTouchX = event.x
-                        lastTouchY = event.y
-                        invalidate()
+                        val movementDistance = kotlin.math.sqrt((dx * dx + dy * dy).toDouble())
+
+                        if (draggedMarker != null) {
+                            // Start dragging if moved more than threshold
+                            if (!isDragging && movementDistance > 10) {
+                                isDragging = true
+                                controller.commitPan()
+                                onMarkerDragListener?.onMarkerDragStart(draggedMarker!!)
+                            }
+
+                            // Continue dragging
+                            if (isDragging) {
+                                val latLng = controller.screenToLatLng(event.x, event.y)
+                                draggedMarker!!.position = latLng
+                                onMarkerDragListener?.onMarkerDrag(draggedMarker!!)
+                                invalidate()
+                                lastTouchX = event.x
+                                lastTouchY = event.y
+                                return true
+                            }
+                        }
+
+                        // Pan the map if not dragging a marker
+                        if (!isDragging) {
+                            controller.updatePanOffset(dx, dy)
+                            lastTouchX = event.x
+                            lastTouchY = event.y
+                            invalidate()
+                        }
                         return true
                     }
                     MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+                        // Handle drag end
+                        if (isDragging && draggedMarker != null) {
+                            onMarkerDragListener?.onMarkerDragEnd(draggedMarker!!)
+                            draggedMarker = null
+                            isDragging = false
+                            invalidate()
+                            return true
+                        }
+
+                        // Reset drag state
+                        draggedMarker = null
+                        isDragging = false
+
                         // Check if touch is on a marker (only if there was minimal movement)
                         val dx = event.x - lastTouchX
                         val dy = event.y - lastTouchY
@@ -404,6 +453,35 @@ class OpenMapView
             controller.onMarkerClickListener = listener
         }
 
+        /**
+         * Sets a listener to handle marker drag events.
+         *
+         * Called when a draggable marker is dragged by the user. The marker must have
+         * its draggable property set to true to receive drag events.
+         *
+         * Example:
+         * ```kotlin
+         * mapView.setOnMarkerDragListener(object : OnMarkerDragListener {
+         *     override fun onMarkerDragStart(marker: Marker) {
+         *         Log.d("Map", "Drag started: ${marker.title}")
+         *     }
+         *
+         *     override fun onMarkerDrag(marker: Marker) {
+         *         Log.d("Map", "Dragging: ${marker.position}")
+         *     }
+         *
+         *     override fun onMarkerDragEnd(marker: Marker) {
+         *         Log.d("Map", "Drag ended: ${marker.position}")
+         *     }
+         * })
+         * ```
+         *
+         * @param listener The listener to receive drag events, or null to clear the listener
+         */
+        fun setOnMarkerDragListener(listener: OnMarkerDragListener?) {
+            onMarkerDragListener = listener
+        }
+
         /**
          * Sets a listener to handle map click events.
          *

openmapview/src/test/kotlin/de/afarber/openmapview/MarkerTest.kt

@@ -156,4 +156,27 @@ class MarkerTest {
     fun testMarkerAlpha_InvalidAboveOne() {
         Marker(position = LatLng(0.0, 0.0), alpha = 1.1f)
     }
+
+    @Test
+    fun testMarkerDraggable_Default() {
+        val marker = Marker(position = LatLng(0.0, 0.0))
+        assertEquals(false, marker.draggable)
+    }
+
+    @Test
+    fun testMarkerDraggable_SetToTrue() {
+        val marker = Marker(position = LatLng(0.0, 0.0), draggable = true)
+        assertEquals(true, marker.draggable)
+    }
+
+    @Test
+    fun testMarkerPosition_Mutable() {
+        val marker = Marker(position = LatLng(0.0, 0.0))
+        assertEquals(0.0, marker.position.latitude, 0.001)
+        assertEquals(0.0, marker.position.longitude, 0.001)
+
+        marker.position = LatLng(10.0, 20.0)
+        assertEquals(10.0, marker.position.latitude, 0.001)
+        assertEquals(20.0, marker.position.longitude, 0.001)
+    }
 }