@maydon_tech/react-native-nitro-maps 0.1.3 → 0.2.0

package/android/src/main/kotlin/com/margelo/nitro/nitromap/providers/google/GoogleMapDelegate.kt

@@ -0,0 +1,317 @@
+package com.margelo.nitro.nitromap.providers.google
+
+import android.util.Log
+import com.google.android.gms.maps.GoogleMap
+import com.google.android.gms.maps.model.LatLng
+import com.margelo.nitro.nitromap.*
+import kotlin.math.sqrt
+
+/**
+ * Sets up all GoogleMap listeners and routes events to the provider's callbacks.
+ *
+ * Uses SDK's OnCameraMoveStartedListener.REASON_* constants to distinguish
+ * user gestures from programmatic camera moves — prevents region prop infinite loops.
+ */
+class GoogleMapDelegate(private val provider: GoogleMapProvider) {
+
+    companion object {
+        private const val TAG = "NitroMap"
+    }
+
+    private var cameraMoveReason = -1
+    private var isGesture = false
+
+    fun setupListeners(map: GoogleMap) {
+        setupCameraListeners(map)
+        setupTapListeners(map)
+        setupMarkerListeners(map)
+        setupOverlayListeners(map)
+    }
+
+    // MARK: - Camera Listeners
+
+    private fun setupCameraListeners(map: GoogleMap) {
+        map.setOnCameraMoveStartedListener { reason ->
+            cameraMoveReason = reason
+            isGesture = reason == GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE
+
+            val reasonStr = when (reason) {
+                GoogleMap.OnCameraMoveStartedListener.REASON_GESTURE -> "GESTURE"
+                GoogleMap.OnCameraMoveStartedListener.REASON_API_ANIMATION -> "API_ANIMATION"
+                GoogleMap.OnCameraMoveStartedListener.REASON_DEVELOPER_ANIMATION -> "DEVELOPER_ANIMATION"
+                else -> "UNKNOWN($reason)"
+            }
+            Log.d(TAG, "onCameraMoveStarted reason=$reasonStr isGesture=$isGesture")
+
+            // Auto-break tracking mode on user gesture
+            if (isGesture) {
+                val mode = provider.userTrackingMode
+                if (mode != null && mode != UserTrackingMode.NONE) {
+                    provider.userTrackingMode = UserTrackingMode.NONE
+                    provider.onUserTrackingModeChange?.invoke(UserTrackingMode.NONE)
+                }
+            }
+
+            // Fire onRegionChange (live, during movement)
+            val event = RegionChangeEvent(
+                region = provider.getCurrentRegion(),
+                isGesture = isGesture
+            )
+            provider.onRegionChange?.invoke(event)
+        }
+
+        // Continuous camera updates — throttled clustering for realtime mode
+        // M-7: Also fire onRegionChange continuously (matching iOS didChange position)
+        map.setOnCameraMoveListener {
+            if (provider.clusterConfig?.realtimeClustering == true) {
+                provider.performClusteringThrottled()
+            }
+
+            // M-7: Fire onRegionChange during movement (not just at start)
+            val event = RegionChangeEvent(
+                region = provider.getCurrentRegion(),
+                isGesture = isGesture
+            )
+            provider.onRegionChange?.invoke(event)
+        }
+
+        map.setOnCameraIdleListener {
+            val region = provider.getCurrentRegion()
+            val event = RegionChangeEvent(
+                region = region,
+                isGesture = isGesture
+            )
+
+            Log.d(TAG, "onCameraIdle lat=${String.format("%.4f", region.latitude)} lng=${String.format("%.4f", region.longitude)} isGesture=$isGesture")
+
+            // Fire onRegionChangeComplete (with isGesture for consumer filtering)
+            provider.onRegionChangeComplete?.invoke(event)
+
+            // Skip clustering when the camera was moved programmatically for
+            // user location following — zoom hasn't changed so cluster results
+            // are identical. This prevents a performance cascade with 3000+ markers
+            // where heading updates → camera animation → onCameraIdle → performClustering
+            // would saturate the main thread.
+            // M-3: Only skip if markers haven't changed since last cluster run.
+            if (provider.isFollowingUserCamera && !provider.clusteringDirty) {
+                provider.isFollowingUserCamera = false
+            } else {
+                provider.isFollowingUserCamera = false
+                provider.performClustering()
+            }
+
+            // Always fire onMapIdle
+            provider.onMapIdle?.invoke()
+
+            // Reset gesture tracking
+            isGesture = false
+            cameraMoveReason = -1
+        }
+    }
+
+    // MARK: - Proximity Cluster Detection
+
+    /**
+     * H-4: Check if a tap coordinate is near any rendered cluster marker.
+     * Mirrors iOS findNearbyCluster(at:in:).
+     * Returns the closest cluster marker within 60dp, or null.
+     */
+    private fun findNearbyCluster(latLng: LatLng, map: GoogleMap): com.google.android.gms.maps.model.Marker? {
+        val tapPoint = map.projection.toScreenLocation(latLng)
+        val proximityThreshold = 60.0
+
+        var closestMarker: com.google.android.gms.maps.model.Marker? = null
+        var closestDistance = Double.MAX_VALUE
+
+        for (clusterMarker in provider.renderedClusterMarkers) {
+            val markerPoint = map.projection.toScreenLocation(clusterMarker.position)
+            val dx = (tapPoint.x - markerPoint.x).toDouble()
+            val dy = (tapPoint.y - markerPoint.y).toDouble()
+            val distance = sqrt(dx * dx + dy * dy)
+
+            if (distance < proximityThreshold && distance < closestDistance) {
+                closestDistance = distance
+                closestMarker = clusterMarker
+            }
+        }
+
+        return closestMarker
+    }
+
+    /**
+     * H-4: Fire onClusterPress for a cluster marker.
+     */
+    private fun fireClusterPress(marker: com.google.android.gms.maps.model.Marker) {
+        val tag = marker.tag as? MarkerTagData.Cluster ?: return
+        provider.onClusterPress?.invoke(
+            ClusterPressEvent(
+                coordinate = Coordinate(
+                    latitude = marker.position.latitude,
+                    longitude = marker.position.longitude
+                ),
+                markerIds = tag.markerIds.toTypedArray(),
+                count = tag.count.toDouble()
+            )
+        )
+    }
+
+    // MARK: - Tap Listeners
+
+    private fun setupTapListeners(map: GoogleMap) {
+        map.setOnMapClickListener { latLng ->
+            // H-4: Proximity-based cluster tap fallback (matches iOS)
+            val nearbyCluster = findNearbyCluster(latLng, map)
+            if (nearbyCluster != null) {
+                fireClusterPress(nearbyCluster)
+                return@setOnMapClickListener
+            }
+
+            Log.d(TAG, "onPress lat=${String.format("%.4f", latLng.latitude)} lng=${String.format("%.4f", latLng.longitude)}")
+            val point = map.projection.toScreenLocation(latLng)
+            val event = MapPressEvent(
+                coordinate = Coordinate(
+                    latitude = latLng.latitude,
+                    longitude = latLng.longitude
+                ),
+                position = com.margelo.nitro.nitromap.Point(
+                    x = point.x.toDouble(),
+                    y = point.y.toDouble()
+                )
+            )
+            provider.onPress?.invoke(event)
+        }
+
+        map.setOnMapLongClickListener { latLng ->
+            Log.d(TAG, "onLongPress lat=${String.format("%.4f", latLng.latitude)} lng=${String.format("%.4f", latLng.longitude)}")
+            val point = map.projection.toScreenLocation(latLng)
+            val event = MapPressEvent(
+                coordinate = Coordinate(
+                    latitude = latLng.latitude,
+                    longitude = latLng.longitude
+                ),
+                position = com.margelo.nitro.nitromap.Point(
+                    x = point.x.toDouble(),
+                    y = point.y.toDouble()
+                )
+            )
+            provider.onLongPress?.invoke(event)
+        }
+
+        // POI tap — fire onPress (matches iOS didTapPOI behavior)
+        map.setOnPoiClickListener { poi ->
+            Log.d(TAG, "onPoiClick name=${poi.name}")
+            val point = map.projection.toScreenLocation(poi.latLng)
+            val event = MapPressEvent(
+                coordinate = Coordinate(
+                    latitude = poi.latLng.latitude,
+                    longitude = poi.latLng.longitude
+                ),
+                position = com.margelo.nitro.nitromap.Point(
+                    x = point.x.toDouble(),
+                    y = point.y.toDouble()
+                )
+            )
+            provider.onPress?.invoke(event)
+        }
+    }
+
+    // MARK: - Marker Listeners
+
+    private fun setupMarkerListeners(map: GoogleMap) {
+        map.setOnMarkerClickListener { marker ->
+            when (val tag = marker.tag as? MarkerTagData) {
+                is MarkerTagData.Cluster -> {
+                    provider.onClusterPress?.invoke(
+                        ClusterPressEvent(
+                            coordinate = Coordinate(
+                                latitude = marker.position.latitude,
+                                longitude = marker.position.longitude
+                            ),
+                            markerIds = tag.markerIds.toTypedArray(),
+                            count = tag.count.toDouble()
+                        )
+                    )
+                    true
+                }
+
+                is MarkerTagData.Regular -> {
+                    provider.onMarkerPress?.invoke(
+                        MarkerPressEvent(
+                            id = tag.markerId,
+                            coordinate = Coordinate(
+                                latitude = marker.position.latitude,
+                                longitude = marker.position.longitude
+                            )
+                        )
+                    )
+                    true
+                }
+
+                is MarkerTagData.UserLocation, null -> false
+            }
+        }
+
+        map.setOnMarkerDragListener(object : GoogleMap.OnMarkerDragListener {
+            override fun onMarkerDragStart(marker: com.google.android.gms.maps.model.Marker) {
+                val tag = marker.tag as? MarkerTagData.Regular ?: return
+                provider.onMarkerDragStart?.invoke(
+                    MarkerDragEvent(
+                        id = tag.markerId,
+                        coordinate = Coordinate(marker.position.latitude, marker.position.longitude)
+                    )
+                )
+            }
+
+            override fun onMarkerDrag(marker: com.google.android.gms.maps.model.Marker) {
+                val tag = marker.tag as? MarkerTagData.Regular ?: return
+                provider.onMarkerDrag?.invoke(
+                    MarkerDragEvent(
+                        id = tag.markerId,
+                        coordinate = Coordinate(marker.position.latitude, marker.position.longitude)
+                    )
+                )
+            }
+
+            override fun onMarkerDragEnd(marker: com.google.android.gms.maps.model.Marker) {
+                val tag = marker.tag as? MarkerTagData.Regular ?: return
+                provider.onMarkerDragEnd?.invoke(
+                    MarkerDragEvent(
+                        id = tag.markerId,
+                        coordinate = Coordinate(marker.position.latitude, marker.position.longitude)
+                    )
+                )
+            }
+        })
+
+        // Info window close — fully revert marker visual state
+        // When the info window is closed (user tap on map, SDK auto-close, etc.),
+        // we must revert the icon — not just clear selectedMarkerId.
+        // If deselectCurrentMarker() already ran (programmatic deselect),
+        // selectedMarkerId is already null and this is a no-op.
+        map.setOnInfoWindowCloseListener { marker ->
+            val tag = marker.tag as? MarkerTagData.Regular ?: return@setOnInfoWindowCloseListener
+            if (provider.selectedMarkerId == tag.markerId) {
+                provider.deselectCurrentMarker()
+            }
+        }
+    }
+
+    // MARK: - Overlay Listeners
+
+    private fun setupOverlayListeners(map: GoogleMap) {
+        map.setOnPolylineClickListener { polyline ->
+            val id = polyline.tag as? String ?: return@setOnPolylineClickListener
+            provider.onPolylinePress?.invoke(id)
+        }
+
+        map.setOnPolygonClickListener { polygon ->
+            val id = polygon.tag as? String ?: return@setOnPolygonClickListener
+            provider.onPolygonPress?.invoke(id)
+        }
+
+        map.setOnCircleClickListener { circle ->
+            val id = circle.tag as? String ?: return@setOnCircleClickListener
+            provider.onCirclePress?.invoke(id)
+        }
+    }
+}