@lugg/maps 0.2.0-alpha.8 → 1.0.0-beta.0

package/android/src/main/java/com/luggmaps/core/MapProviderDelegate.kt

@@ -0,0 +1,60 @@
+package com.luggmaps.core
+
+import android.view.View
+import com.luggmaps.LuggMarkerView
+import com.luggmaps.LuggPolygonView
+import com.luggmaps.LuggPolylineView
+
+data class EdgeInsets(val top: Int = 0, val left: Int = 0, val bottom: Int = 0, val right: Int = 0)
+
+interface MapProviderDelegate {
+  fun mapProviderDidReady()
+  fun mapProviderDidMoveCamera(latitude: Double, longitude: Double, zoom: Float, gesture: Boolean)
+  fun mapProviderDidIdleCamera(latitude: Double, longitude: Double, zoom: Float, gesture: Boolean)
+  fun mapProviderDidPress(latitude: Double, longitude: Double, x: Float, y: Float)
+  fun mapProviderDidLongPress(latitude: Double, longitude: Double, x: Float, y: Float)
+}
+
+interface MapProvider {
+  var delegate: MapProviderDelegate?
+  val isMapReady: Boolean
+
+  fun initializeMap(wrapperView: View, latitude: Double, longitude: Double, zoom: Float)
+  fun destroy()
+
+  // Props
+  fun setZoomEnabled(enabled: Boolean)
+  fun setScrollEnabled(enabled: Boolean)
+  fun setRotateEnabled(enabled: Boolean)
+  fun setPitchEnabled(enabled: Boolean)
+  fun setUserLocationEnabled(enabled: Boolean)
+  fun setUserLocationButtonEnabled(enabled: Boolean)
+  fun setTheme(value: String)
+  fun setMinZoom(zoom: Double)
+  fun setMaxZoom(zoom: Double)
+  fun setEdgeInsets(edgeInsets: EdgeInsets)
+  fun setEdgeInsets(edgeInsets: EdgeInsets, duration: Int)
+
+  // Children
+  fun addMarkerView(markerView: LuggMarkerView)
+  fun removeMarkerView(markerView: LuggMarkerView)
+  fun addPolylineView(polylineView: LuggPolylineView)
+  fun removePolylineView(polylineView: LuggPolylineView)
+  fun addPolygonView(polygonView: LuggPolygonView)
+  fun removePolygonView(polygonView: LuggPolygonView)
+
+  // Lifecycle
+  fun pauseAnimations()
+  fun resumeAnimations()
+
+  // Commands
+  fun moveCamera(latitude: Double, longitude: Double, zoom: Double, duration: Int)
+  fun fitCoordinates(
+    coordinates: List<Any>,
+    edgeInsetsTop: Int,
+    edgeInsetsLeft: Int,
+    edgeInsetsBottom: Int,
+    edgeInsetsRight: Int,
+    duration: Int
+  )
+}

package/android/src/main/java/com/luggmaps/core/PolylineAnimator.kt

@@ -8,10 +8,15 @@ import com.google.android.gms.maps.model.LatLng
 import com.google.android.gms.maps.model.Polyline
 import com.google.android.gms.maps.model.StrokeStyle
 import com.google.android.gms.maps.model.StyleSpan
+import com.luggmaps.AnimatedOptions
 import kotlin.math.floor
 import kotlin.math.min
 
 class PolylineAnimator {
+  companion object {
+    private const val MAX_ANIMATION_SPANS = 16
+  }
+
   var polyline: Polyline? = null
   var coordinates: List<LatLng> = emptyList()
     set(value) {
@@ -22,6 +27,14 @@ class PolylineAnimator {
     }
   var strokeColors: List<Int> = listOf(Color.BLACK)
   var strokeWidth: Float = 1f
+  var animatedOptions: AnimatedOptions = AnimatedOptions()
+    set(value) {
+      if (field == value) return
+      field = value
+      if (animated) {
+        restartAnimation()
+      }
+    }
 
   var animated: Boolean = false
     set(value) {
@@ -40,6 +53,23 @@ class PolylineAnimator {
   private var cumulativeDistances: FloatArray = floatArrayOf()
   private var totalLength: Float = 0f
 
+  // Reusable collections to avoid per-frame allocations
+  private val reusablePoints = ArrayList<LatLng>()
+  private val reusableSpans = ArrayList<StyleSpan>()
+
+  private fun restartAnimation() {
+    stopAnimation()
+    startAnimation()
+  }
+
+  private fun applyEasing(t: Float): Float =
+    when (animatedOptions.easing) {
+      "easeIn" -> t * t
+      "easeOut" -> t * (2 - t)
+      "easeInOut" -> if (t < 0.5f) 2 * t * t else -1 + (4 - 2 * t) * t
+      else -> t
+    }
+
   fun update() {
     if (animated) return
 
@@ -60,8 +90,12 @@ class PolylineAnimator {
 
     computeCumulativeDistances()
 
-    animator = ValueAnimator.ofFloat(0f, 2.15f).apply {
-      duration = 2150
+    val trailLength = animatedOptions.trailLength.coerceIn(0.01f, 1f)
+    val maxProgress = if (trailLength < 1f) 1f else 2.15f
+
+    animator = ValueAnimator.ofFloat(0f, maxProgress).apply {
+      duration = (animatedOptions.duration * maxProgress).toLong()
+      startDelay = animatedOptions.delay
       repeatCount = ValueAnimator.INFINITE
       interpolator = LinearInterpolator()
       addUpdateListener { animation ->
@@ -97,12 +131,19 @@ class PolylineAnimator {
   }
 
   private fun indexForDistance(distance: Float): Int {
-    for (i in 1 until cumulativeDistances.size) {
-      if (cumulativeDistances[i] >= distance) {
-        return i - 1
+    var left = 0
+    var right = cumulativeDistances.size - 1
+
+    while (left < right) {
+      val mid = (left + right + 1) / 2
+      if (cumulativeDistances[mid] <= distance) {
+        left = mid
+      } else {
+        right = mid - 1
       }
     }
-    return (cumulativeDistances.size - 2).coerceAtLeast(0)
+
+    return left.coerceAtMost(cumulativeDistances.size - 2).coerceAtLeast(0)
   }
 
   private fun coordinateAtDistance(distance: Float): LatLng {
@@ -118,6 +159,9 @@ class PolylineAnimator {
     val c1 = coordinates[idx]
     val c2 = coordinates[idx + 1]
 
+    // Reuse existing coordinate if no interpolation needed
+    if (t == 0f) return c1
+
     return LatLng(
       c1.latitude + (c2.latitude - c1.latitude) * t,
       c1.longitude + (c2.longitude - c1.longitude) * t
@@ -129,6 +173,14 @@ class PolylineAnimator {
     animator = null
   }
 
+  fun pause() {
+    animator?.pause()
+  }
+
+  fun resume() {
+    animator?.resume()
+  }
+
   private fun updateAnimatedPolyline() {
     val poly = polyline ?: return
     if (coordinates.size < 2 || totalLength <= 0f) {
@@ -136,12 +188,18 @@ class PolylineAnimator {
       return
     }
 
-    val progress = min(animationProgress, 2f)
+    val trailLength = animatedOptions.trailLength.coerceIn(0.01f, 1f)
+    val maxProgress = if (trailLength < 1f) 1f else 2f
+    val rawProgress = min(animationProgress, maxProgress)
+    val progress = applyEasing(rawProgress / maxProgress) * maxProgress
 
     val headDist: Float
     val tailDist: Float
 
-    if (progress <= 1f) {
+    if (trailLength < 1f) {
+      headDist = progress * totalLength
+      tailDist = maxOf(0f, headDist - totalLength * trailLength)
+    } else if (progress <= 1f) {
       tailDist = 0f
       headDist = progress * totalLength
     } else {
@@ -151,8 +209,8 @@ class PolylineAnimator {
     }
 
     if (headDist <= tailDist) {
-      poly.setSpans(emptyList())
       poly.points = listOf(coordinates.firstOrNull() ?: LatLng(0.0, 0.0))
+      poly.color = strokeColors.firstOrNull() ?: Color.BLACK
       return
     }
 
@@ -160,31 +218,38 @@ class PolylineAnimator {
     val startIndex = indexForDistance(tailDist)
     val endIndex = indexForDistance(headDist)
 
-    val points = mutableListOf<LatLng>()
-    val spans = mutableListOf<StyleSpan>()
+    reusablePoints.clear()
 
-    points.add(coordinateAtDistance(tailDist))
+    reusablePoints.add(coordinateAtDistance(tailDist))
 
     for (i in (startIndex + 1)..endIndex) {
-      points.add(coordinates[i])
+      reusablePoints.add(coordinates[i])
     }
 
     val endCoord = coordinateAtDistance(headDist)
-    val lastAdded = points.lastOrNull()
+    val lastAdded = reusablePoints.lastOrNull()
     if (lastAdded == null || endCoord.latitude != lastAdded.latitude || endCoord.longitude != lastAdded.longitude) {
-      points.add(endCoord)
+      reusablePoints.add(endCoord)
     }
 
-    for (i in 0 until (points.size - 1)) {
-      val segMidDist = tailDist + visibleLength * (i + 0.5f) / (points.size - 1)
-      val gradientPos = (segMidDist - tailDist) / visibleLength
-      val color = colorAtGradientPosition(gradientPos)
-      spans.add(StyleSpan(StrokeStyle.colorBuilder(color).build()))
-    }
+    if (reusablePoints.size < 2) return
+
+    poly.points = ArrayList(reusablePoints)
 
-    poly.points = points
-    if (spans.isNotEmpty()) {
-      poly.setSpans(spans)
+    if (strokeColors.size <= 1) {
+      poly.color = strokeColors.firstOrNull() ?: Color.BLACK
+    } else {
+      val segmentCount = reusablePoints.size - 1
+      val spanCount = min(segmentCount, MAX_ANIMATION_SPANS)
+      val segmentsPerSpan = segmentCount.toDouble() / spanCount
+
+      reusableSpans.clear()
+      for (i in 0 until spanCount) {
+        val gradientPos = (i + 0.5f) / spanCount
+        val color = colorAtGradientPosition(gradientPos)
+        reusableSpans.add(StyleSpan(StrokeStyle.colorBuilder(color).build(), segmentsPerSpan))
+      }
+      poly.setSpans(reusableSpans)
     }
   }
 

package/android/src/main/java/com/luggmaps/events/LongPressEvent.kt

@@ -0,0 +1,29 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class LongPressEvent(view: View, private val latitude: Double, private val longitude: Double, private val x: Float, private val y: Float) :
+  Event<LongPressEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topMapLongPress"
+
+  override fun getEventData() =
+    Arguments.createMap().apply {
+      putMap(
+        "coordinate",
+        Arguments.createMap().apply {
+          putDouble("latitude", latitude)
+          putDouble("longitude", longitude)
+        }
+      )
+      putMap(
+        "point",
+        Arguments.createMap().apply {
+          putDouble("x", x.toDouble())
+          putDouble("y", y.toDouble())
+        }
+      )
+    }
+}

package/android/src/main/java/com/luggmaps/events/MarkerDragEvent.kt

@@ -0,0 +1,41 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class MarkerDragEvent(
+  view: View,
+  private val eventType: String,
+  private val latitude: Double,
+  private val longitude: Double,
+  private val x: Float,
+  private val y: Float
+) : Event<MarkerDragEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = eventType
+
+  override fun getEventData() =
+    Arguments.createMap().apply {
+      putMap(
+        "coordinate",
+        Arguments.createMap().apply {
+          putDouble("latitude", latitude)
+          putDouble("longitude", longitude)
+        }
+      )
+      putMap(
+        "point",
+        Arguments.createMap().apply {
+          putDouble("x", x.toDouble())
+          putDouble("y", y.toDouble())
+        }
+      )
+    }
+
+  companion object {
+    const val DRAG_START = "topMarkerDragStart"
+    const val DRAG_CHANGE = "topMarkerDragChange"
+    const val DRAG_END = "topMarkerDragEnd"
+  }
+}

package/android/src/main/java/com/luggmaps/events/MarkerPressEvent.kt

@@ -0,0 +1,34 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class MarkerPressEvent(
+  view: View,
+  private val latitude: Double,
+  private val longitude: Double,
+  private val x: Float,
+  private val y: Float
+) : Event<MarkerPressEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topMarkerPress"
+
+  override fun getEventData() =
+    Arguments.createMap().apply {
+      putMap(
+        "coordinate",
+        Arguments.createMap().apply {
+          putDouble("latitude", latitude)
+          putDouble("longitude", longitude)
+        }
+      )
+      putMap(
+        "point",
+        Arguments.createMap().apply {
+          putDouble("x", x.toDouble())
+          putDouble("y", y.toDouble())
+        }
+      )
+    }
+}

package/android/src/main/java/com/luggmaps/events/PolygonPressEvent.kt

@@ -0,0 +1,12 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class PolygonPressEvent(view: View) : Event<PolygonPressEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topPolygonPress"
+
+  override fun getEventData() = Arguments.createMap()
+}

package/android/src/main/java/com/luggmaps/events/PressEvent.kt

@@ -0,0 +1,29 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class PressEvent(view: View, private val latitude: Double, private val longitude: Double, private val x: Float, private val y: Float) :
+  Event<PressEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topMapPress"
+
+  override fun getEventData() =
+    Arguments.createMap().apply {
+      putMap(
+        "coordinate",
+        Arguments.createMap().apply {
+          putDouble("latitude", latitude)
+          putDouble("longitude", longitude)
+        }
+      )
+      putMap(
+        "point",
+        Arguments.createMap().apply {
+          putDouble("x", x.toDouble())
+          putDouble("y", y.toDouble())
+        }
+      )
+    }
+}

package/ios/LuggMapView.h

@@ -0,0 +1,9 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface LuggMapView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END