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

package/android/src/main/kotlin/com/margelo/nitro/nitromap/providers/google/GoogleMapProvider+Markers.kt

@@ -0,0 +1,358 @@
+package com.margelo.nitro.nitromap.providers.google
+
+import android.util.Log
+import com.google.android.gms.maps.CameraUpdateFactory
+import com.google.android.gms.maps.model.BitmapDescriptor
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.Marker
+import com.google.android.gms.maps.model.MarkerOptions
+import com.margelo.nitro.nitromap.*
+import com.margelo.nitro.nitromap.markers.MarkerSelectionHandler
+
+/**
+ * Marker CRUD + selection for GoogleMapProvider.
+ * Mirrors iOS GoogleMapProvider+Markers.swift.
+ *
+ * ALL markers are fed to the clustering engine (matches iOS behavior).
+ * The hideOnOverlap strategy needs visibility of all markers, including non-clusterable ones.
+ *
+ * Data structures:
+ *  - markerData              : source-of-truth for ALL marker data (survives detach)
+ *  - clusteringManager       : C++ spatial engine — receives ALL markers
+ *  - nonClusteredMarkers     : native markers for non-clusterable items (direct on map)
+ *  - renderedSingleMarkers   : native markers rendered by clustering pipeline
+ *  - renderedClusterMarkers  : native cluster icons rendered by clustering pipeline
+ *
+ * Threading: All native GoogleMap operations go through withMap {} for main-thread dispatch.
+ */
+
+// MARK: - Shared MarkerOptions builder (M-1: single function used by all callers)
+
+/**
+ * Build MarkerOptions from MarkerData. Used by addMarkerSync, reapplyMarkers,
+ * selectMarker, and the clustering pipeline (GoogleMapProvider+Clustering.kt).
+ */
+fun GoogleMapProvider.buildMarkerOptions(data: MarkerData, icon: BitmapDescriptor? = null): MarkerOptions {
+    val opts = MarkerOptions()
+        .position(LatLng(data.coordinate.latitude, data.coordinate.longitude))
+        .title(data.title)
+        .snippet(data.description)
+        .draggable(data.draggable)
+        .alpha(data.opacity.toFloat())
+        .rotation(data.rotation.toFloat())
+        .zIndex(data.zIndex.toFloat())
+        .anchor(data.anchor.x.toFloat(), data.anchor.y.toFloat())
+
+    val resolvedIcon = icon ?: iconFactory?.createIcon(data)
+    if (resolvedIcon != null) opts.icon(resolvedIcon)
+
+    return opts
+}
+
+/**
+ * Update existing native Marker properties in-place from MarkerData.
+ * Avoids remove/re-add flicker for cosmetic updates.
+ */
+fun GoogleMapProvider.applyMarkerProperties(marker: Marker, data: MarkerData) {
+    marker.position = LatLng(data.coordinate.latitude, data.coordinate.longitude)
+    marker.title = data.title
+    marker.snippet = data.description
+    marker.isDraggable = data.draggable
+    marker.alpha = data.opacity.toFloat()
+    marker.rotation = data.rotation.toFloat()
+    marker.zIndex = data.zIndex.toFloat()
+    marker.setAnchor(data.anchor.x.toFloat(), data.anchor.y.toFloat())
+
+    // Regenerate icon — cache handles deduplication (mirrors iOS updateGMSMarkerProperties)
+    iconFactory?.createIcon(data)?.let { marker.setIcon(it) }
+}
+
+// M-5: Apply marker appear animation (matches iOS GMSMarker.appearAnimation)
+// H-5: Use WeakReference to prevent animator from holding marker in memory after removal
+// Semantic intent: 'appear' → platform's best native animation (alpha fade on Android)
+// Alpha animation is used because position animation causes expensive map layout
+// recalculations per frame, which degrades performance with many markers.
+internal fun applyMarkerAnimation(marker: Marker, animation: MarkerAnimation, durationSec: Double = 0.3) {
+    if (animation == MarkerAnimation.NONE) return
+
+    // 'appear' — alpha fade-in
+    val weakMarker = java.lang.ref.WeakReference(marker)
+    val durationMs = (durationSec * 1000).toLong().coerceIn(50, 5000)
+    val targetAlpha = marker.alpha
+    marker.alpha = 0f
+    android.animation.ValueAnimator.ofFloat(0f, targetAlpha).apply {
+        duration = durationMs
+        addUpdateListener { anim ->
+            val m = weakMarker.get() ?: run { anim.cancel(); return@addUpdateListener }
+            try { m.alpha = anim.animatedValue as Float } catch (_: Exception) { anim.cancel() }
+        }
+        start()
+    }
+}
+
+// MARK: - Marker CRUD
+
+internal fun GoogleMapProvider.addMarkerInternal(marker: MarkerData) {
+    // M-1: Don't call performClustering() here — let onCameraIdle handle it naturally.
+    // This matches iOS behavior and avoids redundant clustering on each single add.
+    addMarkerSync(marker)
+    clusteringDirty = true
+}
+
+internal fun GoogleMapProvider.addMarkersInternal(markers: Array<MarkerData>) {
+    markers.forEach { addMarkerSync(it) }
+    clusteringDirty = true
+    performClustering()
+}
+
+internal fun GoogleMapProvider.updateMarkerInternal(marker: MarkerData) {
+    updateMarkerInPlace(marker)
+}
+
+internal fun GoogleMapProvider.removeMarkerInternal(id: String) {
+    removeMarkerSync(id)
+    clusteringDirty = true
+    performClustering()
+}
+
+internal fun GoogleMapProvider.clearMarkersInternal() {
+    clearMarkersSync()
+}
+
+// MARK: - Internal sync helpers
+
+internal fun GoogleMapProvider.addMarkerSync(markerData: MarkerData) {
+    // Remove any existing marker with the same id first
+    removeMarkerSync(markerData.id)
+
+    // Store data (source of truth for ALL markers)
+    this.markerData[markerData.id] = markerData
+
+    // H-2: Add ALL markers to clustering engine (matches iOS behavior).
+    // hideOnOverlap strategy needs to see non-clusterable markers for overlap detection.
+    clusteringManager?.addMarker(markerData)
+
+    val shouldCluster = markerData.clusteringEnabled && clusterConfig?.enabled != false
+
+    if (!shouldCluster) {
+        // Non-clusterable → also place directly on the map (like iOS)
+        withMap { map ->
+            val icon = iconFactory?.createIcon(markerData)
+            val opts = buildMarkerOptions(markerData, icon)
+            val nativeMarker = map.addMarker(opts) ?: return@withMap
+            nativeMarker.tag = MarkerTagData.Regular(markerData.id)
+            nonClusteredMarkers[markerData.id] = nativeMarker
+            // M-5: Apply marker animation
+            if (markerData.animation != MarkerAnimation.NONE) {
+                applyMarkerAnimation(nativeMarker, markerData.animation, markerData.animationDuration)
+            }
+        }
+    }
+}
+
+internal fun GoogleMapProvider.updateMarkerInPlace(markerData: MarkerData) {
+    val id = markerData.id
+    val existing = this.markerData[id]
+    if (existing == null) {
+        // Not found — add as new
+        addMarkerSync(markerData)
+        performClustering()
+        return
+    }
+
+    // Check if clustering eligibility changed
+    val wasClusterable = existing.clusteringEnabled && clusterConfig?.enabled != false
+    val isClusterable = markerData.clusteringEnabled && clusterConfig?.enabled != false
+
+    if (wasClusterable != isClusterable) {
+        // Clustering state changed — full remove + re-add
+        removeMarkerSync(id)
+        addMarkerSync(markerData)
+        performClustering()
+        return
+    }
+
+    // Update stored data
+    this.markerData[id] = markerData
+
+    // Re-index in C++ engine only if coordinate changed
+    val coordChanged =
+        existing.coordinate.latitude != markerData.coordinate.latitude ||
+        existing.coordinate.longitude != markerData.coordinate.longitude
+    if (coordChanged) {
+        clusteringManager?.removeMarker(id)
+        clusteringManager?.addMarker(markerData)
+        performClustering()
+    }
+
+    // Update rendered marker in-place (avoids remove/re-add flicker)
+    withMap { _ ->
+        val nativeMarker = renderedSingleMarkers[id] ?: nonClusteredMarkers[id] ?: return@withMap
+        applyMarkerProperties(nativeMarker, markerData)
+    }
+}
+
+internal fun GoogleMapProvider.removeMarkerSync(id: String) {
+    this.markerData.remove(id)
+    clusteringManager?.removeMarker(id)
+
+    // Remove native marker (must be on main thread via withMap)
+    withMap { _ ->
+        renderedSingleMarkers.remove(id)?.remove()
+        nonClusteredMarkers.remove(id)?.remove()
+    }
+}
+
+internal fun GoogleMapProvider.clearMarkersSync() {
+    this.markerData.clear()
+    clusteringManager?.clearMarkers()
+    selectedMarkerId = null
+
+    // Remove all native markers (must be on main thread via withMap)
+    withMap { _ ->
+        clearRenderedClusterMarkers()
+        for ((_, marker) in nonClusteredMarkers) { marker.remove() }
+        nonClusteredMarkers.clear()
+    }
+    Log.d("NitroMap", "clearMarkers")
+}
+
+// MARK: - Selection
+
+internal fun GoogleMapProvider.selectMarkerInternal(id: String) {
+    // Deselect any previously selected marker
+    if (selectedMarkerId != null && selectedMarkerId != id) {
+        deselectCurrentMarker()
+    }
+
+    selectedMarkerId = id
+
+    // Remove marker FROM clustering engine while selected —
+    // prevents clustering from destroying the native marker object
+    clusteringManager?.removeMarker(id)
+
+    // Update marker data to selected state
+    val data = this.markerData[id]
+    if (data != null) {
+        val updatedData = MarkerSelectionHandler.updateSelectionState(data, selected = true)
+        if (updatedData != null) {
+            this.markerData[id] = updatedData
+            withMap { _ ->
+                val nativeMarker = renderedSingleMarkers[id] ?: nonClusteredMarkers[id]
+                if (nativeMarker != null) {
+                    iconFactory?.createIcon(updatedData)?.let { nativeMarker.setIcon(it) }
+                    nativeMarker.zIndex = Float.MAX_VALUE
+                }
+            }
+        } else {
+            // Style doesn't support visual selection — just elevate zIndex
+            withMap { _ ->
+                val nativeMarker = renderedSingleMarkers[id] ?: nonClusteredMarkers[id]
+                nativeMarker?.zIndex = Float.MAX_VALUE
+            }
+        }
+    }
+
+    // Animate camera to marker + show info window
+    withMap { map ->
+        val nativeMarker = renderedSingleMarkers[id] ?: nonClusteredMarkers[id]
+        if (nativeMarker != null) {
+            map.animateCamera(
+                CameraUpdateFactory.newLatLng(nativeMarker.position),
+                300,
+                null
+            )
+            nativeMarker.showInfoWindow()
+        } else if (data != null) {
+            // Marker was inside a cluster — create a single marker for it
+            val opts = buildMarkerOptions(data)
+            opts.zIndex(Float.MAX_VALUE)
+            val marker = map.addMarker(opts)
+            if (marker != null) {
+                marker.tag = MarkerTagData.Regular(id)
+                renderedSingleMarkers[id] = marker
+                map.animateCamera(
+                    CameraUpdateFactory.newLatLng(marker.position),
+                    300,
+                    null
+                )
+                marker.showInfoWindow()
+            }
+        }
+        Log.d("NitroMap", "selectMarker: $id")
+    }
+}
+
+internal fun GoogleMapProvider.deselectMarkerInternal() {
+    deselectCurrentMarker()
+}
+
+internal fun GoogleMapProvider.deselectCurrentMarker() {
+    val id = selectedMarkerId ?: return
+    selectedMarkerId = null
+
+    val data = this.markerData[id] ?: return
+    val updatedData = MarkerSelectionHandler.updateSelectionState(data, selected = false)
+    if (updatedData != null) {
+        this.markerData[id] = updatedData
+        withMap { _ ->
+            val nativeMarker = renderedSingleMarkers[id] ?: nonClusteredMarkers[id]
+            if (nativeMarker != null) {
+                iconFactory?.createIcon(updatedData)?.let { nativeMarker.setIcon(it) }
+                nativeMarker.zIndex = data.zIndex.toFloat()
+                nativeMarker.hideInfoWindow()
+            }
+        }
+    } else {
+        withMap { _ ->
+            val nativeMarker = renderedSingleMarkers[id] ?: nonClusteredMarkers[id]
+            if (nativeMarker != null) {
+                nativeMarker.zIndex = data.zIndex.toFloat()
+                nativeMarker.hideInfoWindow()
+            }
+        }
+    }
+
+    // Add marker back into clustering engine
+    clusteringManager?.addMarker(data)
+
+    Log.d("NitroMap", "deselectMarker")
+}
+
+// MARK: - Re-apply on map ready (called from applyAllSettings)
+
+/**
+ * Re-adds all stored markers to the (new) GoogleMap after reattach.
+ * Called from GoogleMapProvider.applyAllSettings().
+ */
+fun GoogleMapProvider.reapplyMarkers() {
+    if (markerData.isEmpty()) return
+
+    // Clear stale native references (old map instance)
+    nonClusteredMarkers.clear()
+
+    // H-2: Rebuild clustering engine from stored data — add ALL markers
+    clusteringManager?.clearMarkers()
+
+    for ((_, data) in markerData) {
+        // H-2: ALL markers go to clustering engine (matches iOS)
+        clusteringManager?.addMarker(data)
+
+        val shouldCluster = data.clusteringEnabled && clusterConfig?.enabled != false
+        if (!shouldCluster) {
+            // Re-create non-clustered marker
+            withMap { map ->
+                val opts = buildMarkerOptions(data)
+                val nativeMarker = map.addMarker(opts) ?: return@withMap
+                nativeMarker.tag = MarkerTagData.Regular(data.id)
+                if (data.id == selectedMarkerId) nativeMarker.zIndex = Float.MAX_VALUE
+                nonClusteredMarkers[data.id] = nativeMarker
+            }
+        }
+    }
+
+    // Clustered markers will be rendered when performClustering runs
+    performClustering()
+
+    Log.d("NitroMap", "reapplyMarkers: ${markerData.size} markers")
+}

package/android/src/main/kotlin/com/margelo/nitro/nitromap/providers/google/GoogleMapProvider+Overlays.kt

@@ -0,0 +1,272 @@
+package com.margelo.nitro.nitromap.providers.google
+
+import android.graphics.Color
+import com.margelo.nitro.nitromap.*
+import android.util.Log
+import com.google.android.gms.maps.model.CircleOptions
+import com.google.android.gms.maps.model.Dash
+import com.google.android.gms.maps.model.Gap
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.PatternItem
+import com.google.android.gms.maps.model.PolygonOptions
+import com.google.android.gms.maps.model.PolylineOptions
+
+/**
+ * Overlay CRUD for GoogleMapProvider — Polylines, Polygons, Circles.
+ *
+ * Mirrors iOS GoogleMapProvider+Overlays.swift.
+ *
+ * Data dictionaries (polylineData, polygonData, circleData) survive detach/reattach.
+ * Native overlay objects (renderedPolylines, renderedPolygons, renderedCircles) are
+ * recreated from data on reattach via reapplyOverlays().
+ */
+
+// ============================================================================
+// MARK: - Shared Color Helper (M-4: single resolveColor for all overlay code)
+// ============================================================================
+
+/**
+ * Convert a MarkerColor to an Android ARGB int.
+ * Used by overlays and available to other files that need color conversion.
+ */
+fun MarkerColor.toArgb(): Int =
+    Color.argb(a.toInt(), r.toInt(), g.toInt(), b.toInt())
+
+// ============================================================================
+// MARK: - Shared Overlay Builders (M-3: extract from duplicated code)
+// ============================================================================
+
+/**
+ * Build PolylineOptions from PolylineData. Used by both addPolyline and reapplyOverlays.
+ */
+private fun GoogleMapProvider.buildPolylineOptions(data: PolylineData): PolylineOptions {
+    val opts = PolylineOptions()
+
+    for (coord in data.coordinates) {
+        opts.add(LatLng(coord.latitude, coord.longitude))
+    }
+
+    opts.width(data.strokeWidth.toFloat())
+    opts.color(data.strokeColor.toArgb())
+    opts.geodesic(data.geodesic)
+    opts.zIndex(data.zIndex.toFloat())
+    opts.clickable(data.tappable)
+
+    // Dashed line support
+    // M-6: Standardize density access
+    if (data.dashed) {
+        val density = context.resources.displayMetrics.density
+        val pattern: List<PatternItem> = listOf(
+            Dash(20f * density),
+            Gap(10f * density)
+        )
+        opts.pattern(pattern)
+    }
+
+    return opts
+}
+
+/**
+ * Build PolygonOptions from PolygonData. Used by both addPolygon and reapplyOverlays.
+ */
+private fun buildPolygonOptions(data: PolygonData): PolygonOptions {
+    val opts = PolygonOptions()
+
+    for (coord in data.coordinates) {
+        opts.add(LatLng(coord.latitude, coord.longitude))
+    }
+
+    opts.fillColor(data.fillColor.toArgb())
+    opts.strokeColor(data.strokeColor.toArgb())
+    opts.strokeWidth(data.strokeWidth.toFloat())
+    opts.zIndex(data.zIndex.toFloat())
+    opts.clickable(data.tappable)
+
+    // Add holes
+    for (hole in data.holes) {
+        val holePath = hole.map { LatLng(it.latitude, it.longitude) }
+        opts.addHole(holePath)
+    }
+
+    return opts
+}
+
+/**
+ * Build CircleOptions from CircleData. Used by both addCircle and reapplyOverlays.
+ */
+private fun buildCircleOptions(data: CircleData): CircleOptions {
+    return CircleOptions()
+        .center(LatLng(data.center.latitude, data.center.longitude))
+        .radius(data.radius)
+        .fillColor(data.fillColor.toArgb())
+        .strokeColor(data.strokeColor.toArgb())
+        .strokeWidth(data.strokeWidth.toFloat())
+        .zIndex(data.zIndex.toFloat())
+        .clickable(data.tappable)
+}
+
+// ============================================================================
+// MARK: - Polyline CRUD
+// ============================================================================
+
+internal fun GoogleMapProvider.addPolylineInternal(polyline: PolylineData) {
+    // Store data (survives detach)
+    polylineData[polyline.id] = polyline
+
+    // Remove existing + place new native Polyline (all on main thread)
+    withMap { map ->
+        renderedPolylines.remove(polyline.id)?.remove()
+        val opts = buildPolylineOptions(polyline)
+        val nativePolyline = map.addPolyline(opts)
+        nativePolyline.tag = polyline.id
+        renderedPolylines[polyline.id] = nativePolyline
+        Log.d("NitroMap", "addPolyline: ${polyline.id}")
+    }
+}
+
+internal fun GoogleMapProvider.updatePolylineInternal(polyline: PolylineData) {
+    addPolylineInternal(polyline)
+}
+
+internal fun GoogleMapProvider.removePolylineInternal(id: String) {
+    polylineData.remove(id)
+    withMap { _ ->
+        renderedPolylines.remove(id)?.remove()
+    }
+}
+
+internal fun GoogleMapProvider.clearPolylinesInternal() {
+    polylineData.clear()
+    withMap { _ ->
+        renderedPolylines.values.forEach { it.remove() }
+        renderedPolylines.clear()
+    }
+}
+
+// ============================================================================
+// MARK: - Polygon CRUD
+// ============================================================================
+
+internal fun GoogleMapProvider.addPolygonInternal(polygon: PolygonData) {
+    // Store data (survives detach)
+    polygonData[polygon.id] = polygon
+
+    // Remove existing + place new native Polygon (all on main thread)
+    withMap { map ->
+        renderedPolygons.remove(polygon.id)?.remove()
+        val opts = buildPolygonOptions(polygon)
+        val nativePolygon = map.addPolygon(opts)
+        nativePolygon.tag = polygon.id
+        renderedPolygons[polygon.id] = nativePolygon
+        Log.d("NitroMap", "addPolygon: ${polygon.id}")
+    }
+}
+
+internal fun GoogleMapProvider.updatePolygonInternal(polygon: PolygonData) {
+    addPolygonInternal(polygon)
+}
+
+internal fun GoogleMapProvider.removePolygonInternal(id: String) {
+    polygonData.remove(id)
+    withMap { _ ->
+        renderedPolygons.remove(id)?.remove()
+    }
+}
+
+internal fun GoogleMapProvider.clearPolygonsInternal() {
+    polygonData.clear()
+    withMap { _ ->
+        renderedPolygons.values.forEach { it.remove() }
+        renderedPolygons.clear()
+    }
+}
+
+// ============================================================================
+// MARK: - Circle CRUD
+// ============================================================================
+
+internal fun GoogleMapProvider.addCircleInternal(circle: CircleData) {
+    // Store data (survives detach)
+    circleData[circle.id] = circle
+
+    // Remove existing + place new native Circle (all on main thread)
+    withMap { map ->
+        renderedCircles.remove(circle.id)?.remove()
+        val opts = buildCircleOptions(circle)
+        val nativeCircle = map.addCircle(opts)
+        nativeCircle.tag = circle.id
+        renderedCircles[circle.id] = nativeCircle
+        Log.d("NitroMap", "addCircle: ${circle.id}")
+    }
+}
+
+internal fun GoogleMapProvider.updateCircleInternal(circle: CircleData) {
+    addCircleInternal(circle)
+}
+
+internal fun GoogleMapProvider.removeCircleInternal(id: String) {
+    circleData.remove(id)
+    withMap { _ ->
+        renderedCircles.remove(id)?.remove()
+    }
+}
+
+internal fun GoogleMapProvider.clearCirclesInternal() {
+    circleData.clear()
+    withMap { _ ->
+        renderedCircles.values.forEach { it.remove() }
+        renderedCircles.clear()
+    }
+}
+
+// ============================================================================
+// MARK: - Reapply on MapView Reattach (M-3: uses shared builder helpers)
+// ============================================================================
+
+/**
+ * Re-adds all stored overlays to the (new) GoogleMap after reattach.
+ * Called from GoogleMapProvider.applyAllSettings() after reapplyMarkers().
+ */
+fun GoogleMapProvider.reapplyOverlays() {
+    // Clear old native references (invalid after detach)
+    renderedPolylines.clear()
+    renderedPolygons.clear()
+    renderedCircles.clear()
+
+    // Re-create from stored data using shared builder helpers
+    if (polylineData.isNotEmpty()) {
+        polylineData.values.toList().forEach { data ->
+            withMap { map ->
+                val opts = buildPolylineOptions(data)
+                val native = map.addPolyline(opts)
+                native.tag = data.id
+                renderedPolylines[data.id] = native
+            }
+        }
+        Log.d("NitroMap", "reapplyOverlays: ${polylineData.size} polylines")
+    }
+
+    if (polygonData.isNotEmpty()) {
+        polygonData.values.toList().forEach { data ->
+            withMap { map ->
+                val opts = buildPolygonOptions(data)
+                val native = map.addPolygon(opts)
+                native.tag = data.id
+                renderedPolygons[data.id] = native
+            }
+        }
+        Log.d("NitroMap", "reapplyOverlays: ${polygonData.size} polygons")
+    }
+
+    if (circleData.isNotEmpty()) {
+        circleData.values.toList().forEach { data ->
+            withMap { map ->
+                val opts = buildCircleOptions(data)
+                val native = map.addCircle(opts)
+                native.tag = data.id
+                renderedCircles[data.id] = native
+            }
+        }
+        Log.d("NitroMap", "reapplyOverlays: ${circleData.size} circles")
+    }
+}