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

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

@@ -0,0 +1,296 @@
+package com.margelo.nitro.nitromap.providers.google
+
+import android.animation.ValueAnimator
+import com.margelo.nitro.nitromap.*
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.RectF
+import android.location.Location
+import android.util.Log
+import android.view.animation.LinearInterpolator
+import com.google.android.gms.maps.CameraUpdateFactory
+import com.google.android.gms.maps.model.BitmapDescriptorFactory
+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 kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.Dispatchers
+import java.net.HttpURLConnection
+import java.net.URL
+import kotlin.math.abs
+
+/**
+ * User location management for GoogleMapProvider.
+ * Mirrors iOS GoogleMapProvider+UserLocation.swift.
+ *
+ * Handles:
+ * - Custom user location marker (URL or local asset image)
+ * - Tracking modes (none, follow, followWithHeading)
+ * - Camera following
+ * - centerOnUserLocation() method
+ */
+
+// MARK: - User Location State (stored in GoogleMapProvider)
+// These fields are already declared in GoogleMapProvider:
+// - var lastKnownUserLocation: Location? (add to GoogleMapProvider)
+// - var customUserLocationMarker: Marker? (add to GoogleMapProvider)
+
+// MARK: - Location Update Handler
+
+/**
+ * Called when the UserLocationManager fires a location/heading update.
+ * Updates custom marker position + rotation and handles camera following.
+ */
+/** Animation duration matching iOS CATransaction (0.3s) */
+private const val LOCATION_ANIMATION_MS = 300L
+
+internal fun GoogleMapProvider.updateUserLocationInternal(location: Location, heading: Float?) {
+    lastKnownUserLocation = location
+    if (heading != null && heading >= 0) lastKnownHeading = heading
+
+    val marker = customUserLocationMarker
+    val shouldFollow = userTrackingMode != null && userTrackingMode != UserTrackingMode.NONE
+    val targetLatLng = LatLng(location.latitude, location.longitude)
+
+    val targetRotation: Float? = when {
+        heading != null && heading >= 0 -> heading
+        location.hasBearing() -> location.bearing
+        else -> null
+    }
+
+    withMap { map ->
+        if (marker != null) {
+            animateMarkerPosition(marker, targetLatLng)
+            targetRotation?.let { animateMarkerRotation(marker, it) }
+        }
+
+        // Camera following — mark as programmatic so onCameraIdle skips clustering
+        if (shouldFollow) {
+            isFollowingUserCamera = true
+            when (userTrackingMode) {
+                UserTrackingMode.FOLLOW -> {
+                    map.animateCamera(
+                        CameraUpdateFactory.newLatLng(targetLatLng),
+                        LOCATION_ANIMATION_MS.toInt(),
+                        null
+                    )
+                }
+                UserTrackingMode.FOLLOWWITHHEADING -> {
+                    val bearing = targetRotation ?: map.cameraPosition.bearing
+                    val cameraPos = com.google.android.gms.maps.model.CameraPosition.Builder()
+                        .target(targetLatLng)
+                        .zoom(map.cameraPosition.zoom)
+                        .bearing(bearing)
+                        .tilt(map.cameraPosition.tilt)
+                        .build()
+                    map.animateCamera(
+                        CameraUpdateFactory.newCameraPosition(cameraPos),
+                        LOCATION_ANIMATION_MS.toInt(),
+                        null
+                    )
+                }
+                else -> {}
+            }
+        }
+    }
+}
+
+/**
+ * Smoothly animate marker position from current to target.
+ * Cancels any in-flight position animation to avoid conflicts.
+ */
+private fun GoogleMapProvider.animateMarkerPosition(marker: Marker, target: LatLng) {
+    userLocationPositionAnimator?.cancel()
+
+    val startLat = marker.position.latitude
+    val startLng = marker.position.longitude
+
+    val animator = ValueAnimator.ofFloat(0f, 1f).apply {
+        duration = LOCATION_ANIMATION_MS
+        interpolator = LinearInterpolator()
+        addUpdateListener { animation ->
+            val t = animation.animatedFraction.toDouble()
+            val lat = startLat + (target.latitude - startLat) * t
+            val lng = startLng + (target.longitude - startLng) * t
+            marker.position = LatLng(lat, lng)
+        }
+    }
+    userLocationPositionAnimator = animator
+    animator.start()
+}
+
+/**
+ * Smoothly animate marker rotation from current to target.
+ * Uses shortest-path rotation (handles 0°/360° wraparound).
+ */
+private fun GoogleMapProvider.animateMarkerRotation(marker: Marker, target: Float) {
+    userLocationRotationAnimator?.cancel()
+
+    val start = marker.rotation
+    // Shortest angular path
+    var delta = (target - start) % 360f
+    if (delta > 180f) delta -= 360f
+    if (delta < -180f) delta += 360f
+    val end = start + delta
+
+    val animator = ValueAnimator.ofFloat(start, end).apply {
+        duration = LOCATION_ANIMATION_MS
+        interpolator = LinearInterpolator()
+        addUpdateListener { animation ->
+            var rot = animation.animatedValue as Float
+            rot = ((rot % 360f) + 360f) % 360f
+            marker.rotation = rot
+        }
+    }
+    userLocationRotationAnimator = animator
+    animator.start()
+}
+
+// MARK: - Custom User Location Marker
+
+/**
+ * Sets up a custom user location marker with the provided image.
+ * Called when userLocationImage or userLocationSize changes.
+ */
+internal fun GoogleMapProvider.setupCustomUserLocationMarkerInternal(context: Context) {
+    // Remove old custom marker
+    customUserLocationMarker?.remove()
+    customUserLocationMarker = null
+
+    if (userLocationImage.isEmpty()) {
+        // No custom image — re-enable default blue dot
+        cachedUserLocationImageUrl = ""
+        // H-1: Recycle old bitmap before clearing reference
+        userLocationImageBitmap?.recycle()
+        userLocationImageBitmap = null
+        withMap { map ->
+            try {
+                map.isMyLocationEnabled = showsUserLocation ?: false
+            } catch (_: SecurityException) {}
+        }
+        return
+    }
+
+    // Disable native blue dot — custom marker replaces it
+    withMap { map ->
+        try {
+            map.isMyLocationEnabled = false
+        } catch (_: SecurityException) {}
+    }
+
+    // Create custom marker
+    withMap { map ->
+        val opts = MarkerOptions()
+            .position(
+                lastKnownUserLocation?.let {
+                    LatLng(it.latitude, it.longitude)
+                } ?: LatLng(0.0, 0.0)
+            )
+            .anchor(
+                userLocationAnchor?.x?.toFloat() ?: 0.5f,
+                userLocationAnchor?.y?.toFloat() ?: 0.5f
+            )
+            .flat(true)
+            .zIndex(Float.MAX_VALUE)
+
+        // Reuse cached image if URL is the same (only size changed)
+        val cachedBitmap = userLocationImageBitmap
+        if (cachedBitmap != null && cachedUserLocationImageUrl == userLocationImage) {
+            val size = userLocationSize.toInt().coerceAtLeast(1)
+            val density = context.resources.displayMetrics.density
+            val sizePx = (size * density).toInt()
+            val resized = Bitmap.createScaledBitmap(cachedBitmap, sizePx, sizePx, true)
+            opts.icon(BitmapDescriptorFactory.fromBitmap(resized))
+        }
+
+        val marker = map.addMarker(opts)
+        if (marker != null) {
+            marker.tag = MarkerTagData.UserLocation
+            // Restore last known heading so rotation isn't lost on marker recreation
+            lastKnownHeading?.let { marker.rotation = it }
+            customUserLocationMarker = marker
+        }
+
+        // Skip download if same URL and we already have cached data
+        if (cachedUserLocationImageUrl == userLocationImage && userLocationImageBitmap != null) {
+            return@withMap
+        }
+
+        // Load image
+        val size = userLocationSize.toInt().coerceAtLeast(1)
+        val density = context.resources.displayMetrics.density
+        val sizePx = (size * density).toInt()
+
+        if (userLocationImage.startsWith("http://") || userLocationImage.startsWith("https://")) {
+            // Remote image — async load
+            val imageUrl = userLocationImage
+            cachedUserLocationImageUrl = imageUrl
+
+            // C-3: Use providerScope instead of unstructured CoroutineScope
+            providerScope.launch {
+                val bitmap = withContext(Dispatchers.IO) {
+                    var connection: HttpURLConnection? = null
+                    try {
+                        val url = URL(imageUrl)
+                        connection = url.openConnection() as HttpURLConnection
+                        connection.connectTimeout = 10_000
+                        connection.readTimeout = 10_000
+                        connection.connect()
+                        if (connection.responseCode in 200..299) {
+                            BitmapFactory.decodeStream(connection.inputStream)
+                        } else null
+                    } catch (e: Exception) {
+                        Log.w("NitroMap", "Failed to load user location image: ${e.message}")
+                        null
+                    } finally {
+                        // H-6: Always disconnect HttpURLConnection
+                        connection?.disconnect()
+                    }
+                } ?: return@launch
+
+                // H-1/H-2: Recycle old bitmap before replacing
+                userLocationImageBitmap?.recycle()
+                userLocationImageBitmap = bitmap
+                val resized = Bitmap.createScaledBitmap(bitmap, sizePx, sizePx, true)
+                customUserLocationMarker?.setIcon(BitmapDescriptorFactory.fromBitmap(resized))
+            }
+        } else {
+            // Local asset (from resources)
+            cachedUserLocationImageUrl = userLocationImage
+            val resId = context.resources.getIdentifier(
+                userLocationImage, "drawable", context.packageName
+            )
+            if (resId != 0) {
+                val bitmap = BitmapFactory.decodeResource(context.resources, resId)
+                if (bitmap != null) {
+                    // H-1/H-2: Recycle old bitmap before replacing
+                    userLocationImageBitmap?.recycle()
+                    userLocationImageBitmap = bitmap
+                    val resized = Bitmap.createScaledBitmap(bitmap, sizePx, sizePx, true)
+                    marker?.setIcon(BitmapDescriptorFactory.fromBitmap(resized))
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Center on User Location
+
+internal fun GoogleMapProvider.centerOnUserLocationInternal() {
+    val location = lastKnownUserLocation ?: return
+
+    withMap { map ->
+        map.animateCamera(
+            CameraUpdateFactory.newLatLng(
+                LatLng(location.latitude, location.longitude)
+            ),
+            300,
+            null
+        )
+    }
+    Log.d("NitroMap", "centerOnUserLocation: lat=${location.latitude}, lng=${location.longitude}")
+}