@lugg/maps 0.2.0-alpha.2 → 0.2.0-alpha.21

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

@@ -1,21 +1,37 @@
 package com.luggmaps.core
 
+import android.animation.TimeInterpolator
 import android.animation.ValueAnimator
 import android.graphics.Color
+import android.location.Location
 import android.view.animation.LinearInterpolator
 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.max
 import kotlin.math.min
 
 class PolylineAnimator {
   var polyline: Polyline? = null
   var coordinates: List<LatLng> = emptyList()
+    set(value) {
+      field = value
+      if (animated && animator != null) {
+        computeCumulativeDistances()
+      }
+    }
   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) {
@@ -31,6 +47,30 @@ class PolylineAnimator {
 
   private var animator: ValueAnimator? = null
   private var animationProgress: Float = 0f
+  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 getInterpolator(): TimeInterpolator =
+    when (animatedOptions.easing) {
+      "easeIn" -> TimeInterpolator { t -> t * t }
+
+      "easeOut" -> TimeInterpolator { t -> t * (2 - t) }
+
+      "easeInOut" -> TimeInterpolator { t ->
+        if (t < 0.5f) 2 * t * t else -1 + (4 - 2 * t) * t
+      }
+
+      else -> LinearInterpolator()
+    }
 
   fun update() {
     if (animated) return
@@ -50,10 +90,16 @@ class PolylineAnimator {
   private fun startAnimation() {
     if (animator != null) return
 
-    animator = ValueAnimator.ofFloat(0f, 2.15f).apply {
-      duration = 3650 // ~1.75s per phase * 2 + pause
+    computeCumulativeDistances()
+
+    val trailLength = animatedOptions.trailLength.coerceIn(0.01f, 1f)
+    val endValue = if (trailLength < 1f) 1f else 2.15f
+
+    animator = ValueAnimator.ofFloat(0f, endValue).apply {
+      duration = animatedOptions.duration
+      startDelay = animatedOptions.delay
       repeatCount = ValueAnimator.INFINITE
-      interpolator = LinearInterpolator()
+      interpolator = getInterpolator()
       addUpdateListener { animation ->
         animationProgress = animation.animatedValue as Float
         updateAnimatedPolyline()
@@ -62,83 +108,142 @@ class PolylineAnimator {
     }
   }
 
+  private fun computeCumulativeDistances() {
+    if (coordinates.size < 2) {
+      cumulativeDistances = floatArrayOf(0f)
+      totalLength = 0f
+      return
+    }
+
+    val distances = FloatArray(coordinates.size)
+    distances[0] = 0f
+    var total = 0f
+
+    for (i in 1 until coordinates.size) {
+      val prev = coordinates[i - 1]
+      val curr = coordinates[i]
+      val results = FloatArray(1)
+      Location.distanceBetween(prev.latitude, prev.longitude, curr.latitude, curr.longitude, results)
+      total += results[0]
+      distances[i] = total
+    }
+
+    cumulativeDistances = distances
+    totalLength = total
+  }
+
+  private fun indexForDistance(distance: Float): Int {
+    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 left.coerceAtMost(cumulativeDistances.size - 2).coerceAtLeast(0)
+  }
+
+  private fun coordinateAtDistance(distance: Float): LatLng {
+    if (distance <= 0f) return coordinates.first()
+    if (distance >= totalLength) return coordinates.last()
+
+    val idx = indexForDistance(distance)
+    val segStart = cumulativeDistances[idx]
+    val segEnd = cumulativeDistances[idx + 1]
+    val segLength = segEnd - segStart
+
+    val t = if (segLength > 0) (distance - segStart) / segLength else 0f
+    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
+    )
+  }
+
   private fun stopAnimation() {
     animator?.cancel()
     animator = null
   }
 
+  fun pause() {
+    animator?.pause()
+  }
+
+  fun resume() {
+    animator?.resume()
+  }
+
   private fun updateAnimatedPolyline() {
     val poly = polyline ?: return
-    if (coordinates.size < 2) {
+    if (coordinates.size < 2 || totalLength <= 0f) {
       poly.points = coordinates
       return
     }
 
-    val segmentCount = coordinates.size - 1
-    val progress = min(animationProgress, 2f)
+    val trailLength = animatedOptions.trailLength.coerceIn(0.01f, 1f)
+    val progress = min(animationProgress, if (trailLength < 1f) 1f else 2f)
 
-    val headPos: Float
-    val tailPos: Float
+    val headDist: Float
+    val tailDist: Float
 
-    if (progress <= 1f) {
-      tailPos = 0f
-      headPos = progress * segmentCount
+    if (trailLength < 1f) {
+      headDist = progress * totalLength
+      tailDist = maxOf(0f, headDist - totalLength * trailLength)
+    } else if (progress <= 1f) {
+      tailDist = 0f
+      headDist = progress * totalLength
     } else {
       val shrinkProgress = progress - 1f
-      tailPos = shrinkProgress * segmentCount
-      headPos = segmentCount.toFloat()
+      tailDist = shrinkProgress * totalLength
+      headDist = totalLength
     }
 
-    if (headPos <= tailPos || coordinates.isEmpty()) {
+    if (headDist <= tailDist) {
       poly.setSpans(emptyList())
       poly.points = listOf(coordinates.firstOrNull() ?: LatLng(0.0, 0.0))
       return
     }
 
-    val startIndex = floor(tailPos).toInt()
-    val endIndex = kotlin.math.ceil(headPos.toDouble()).toInt()
-    val visibleLength = headPos - tailPos
+    val visibleLength = headDist - tailDist
+    val startIndex = indexForDistance(tailDist)
+    val endIndex = indexForDistance(headDist)
 
-    val points = mutableListOf<LatLng>()
-    val spans = mutableListOf<StyleSpan>()
+    reusablePoints.clear()
+    reusableSpans.clear()
 
-    for (i in startIndex..minOf(endIndex, coordinates.size - 1)) {
-      var coord = coordinates[i]
+    reusablePoints.add(coordinateAtDistance(tailDist))
 
-      // Interpolate tail
-      if (i == startIndex && tailPos > startIndex.toFloat() && i + 1 < coordinates.size) {
-        val t = tailPos - startIndex
-        val next = coordinates[i + 1]
-        coord = LatLng(
-          coord.latitude + (next.latitude - coord.latitude) * t,
-          coord.longitude + (next.longitude - coord.longitude) * t
-        )
-      }
-
-      // Interpolate head
-      if (i == endIndex && headPos < endIndex.toFloat() && i > 0) {
-        val t = headPos - (endIndex - 1)
-        val prev = coordinates[i - 1]
-        coord = LatLng(
-          prev.latitude + (coordinates[i].latitude - prev.latitude) * t,
-          prev.longitude + (coordinates[i].longitude - prev.longitude) * t
-        )
-      }
+    for (i in (startIndex + 1)..endIndex) {
+      reusablePoints.add(coordinates[i])
+    }
 
-      points.add(coord)
+    val endCoord = coordinateAtDistance(headDist)
+    val lastAdded = reusablePoints.lastOrNull()
+    if (lastAdded == null || endCoord.latitude != lastAdded.latitude || endCoord.longitude != lastAdded.longitude) {
+      reusablePoints.add(endCoord)
+    }
 
-      if (i < endIndex && i < segmentCount) {
-        val segStartPos = max(i.toFloat(), tailPos)
-        val segEndPos = min((i + 1).toFloat(), headPos)
-        val gradientMid = ((segStartPos + segEndPos) / 2f - tailPos) / visibleLength
-        val color = colorAtGradientPosition(gradientMid)
-        spans.add(StyleSpan(StrokeStyle.colorBuilder(color).build()))
-      }
+    val pointCount = reusablePoints.size
+    for (i in 0 until (pointCount - 1)) {
+      val segMidDist = tailDist + visibleLength * (i + 0.5f) / (pointCount - 1)
+      val gradientPos = (segMidDist - tailDist) / visibleLength
+      val color = colorAtGradientPosition(gradientPos)
+      reusableSpans.add(StyleSpan(StrokeStyle.colorBuilder(color).build()))
     }
 
-    poly.points = points
-    if (spans.isNotEmpty()) {
-      poly.setSpans(spans)
+    poly.points = reusablePoints
+    if (reusableSpans.isNotEmpty()) {
+      poly.setSpans(reusableSpans)
     }
   }
 

package/ios/LuggAppleMapView.mm

@@ -44,6 +44,7 @@ using namespace luggmaps::events;
   BOOL _isDragging;
   double _minZoom;
   double _maxZoom;
+  NSMapTable<id<MKOverlay>, LuggPolylineView *> *_overlayToPolylineMap;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -56,6 +57,7 @@ using namespace luggmaps::events;
     static const auto defaultProps =
         std::make_shared<const LuggAppleMapViewProps>();
     _props = defaultProps;
+    _overlayToPolylineMap = [NSMapTable strongToWeakObjectsMapTable];
   }
 
   return self;
@@ -101,16 +103,19 @@ using namespace luggmaps::events;
         (AppleMarkerAnnotation *)markerView.marker;
 
     if (annotation) {
+      annotation.annotationView.transform = CGAffineTransformIdentity;
       annotation.markerView = nil;
       annotation.annotationView = nil;
       [_mapView removeAnnotation:annotation];
       markerView.marker = nil;
     }
+    [markerView resetIconViewTransform];
   } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
     LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
     polylineView.delegate = nil;
     MKPolyline *polyline = (MKPolyline *)polylineView.polyline;
     if (polyline) {
+      [_overlayToPolylineMap removeObjectForKey:polyline];
       [_mapView removeOverlay:polyline];
       polylineView.polyline = nil;
     }
@@ -167,10 +172,13 @@ using namespace luggmaps::events;
 
   [_mapWrapperView addSubview:_mapView];
 
-  [self setCameraWithLatitude:viewProps.initialCoordinate.latitude
-                    longitude:viewProps.initialCoordinate.longitude
-                         zoom:viewProps.initialZoom
-                     animated:NO];
+  CLLocationCoordinate2D center =
+      CLLocationCoordinate2DMake(viewProps.initialCoordinate.latitude,
+                                 viewProps.initialCoordinate.longitude);
+  MKCoordinateRegion region =
+      [_mapView regionForCenterCoordinate:center
+                                zoomLevel:viewProps.initialZoom];
+  [_mapView setRegion:region animated:NO];
 
   // Add annotations for any markers that were mounted before map was ready
   for (UIView *subview in self.subviews) {
@@ -230,6 +238,8 @@ using namespace luggmaps::events;
 
 - (void)updateProps:(Props::Shared const &)props
            oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps =
+      *std::static_pointer_cast<LuggAppleMapViewProps const>(oldProps);
   const auto &newViewProps =
       *std::static_pointer_cast<LuggAppleMapViewProps const>(props);
 
@@ -239,9 +249,49 @@ using namespace luggmaps::events;
     _mapView.rotateEnabled = newViewProps.rotateEnabled;
     _mapView.pitchEnabled = newViewProps.pitchEnabled;
     _mapView.showsUserLocation = newViewProps.userLocationEnabled;
-    _mapView.layoutMargins = UIEdgeInsetsMake(
-        newViewProps.padding.top, newViewProps.padding.left,
-        newViewProps.padding.bottom, newViewProps.padding.right);
+
+    // Check if padding changed
+    BOOL paddingChanged =
+        oldViewProps.padding.top != newViewProps.padding.top ||
+        oldViewProps.padding.left != newViewProps.padding.left ||
+        oldViewProps.padding.bottom != newViewProps.padding.bottom ||
+        oldViewProps.padding.right != newViewProps.padding.right;
+
+    if (paddingChanged) {
+      // Calculate the offset difference to keep visual center stable
+      CGFloat oldOffsetX =
+          (oldViewProps.padding.left - oldViewProps.padding.right) / 2.0;
+      CGFloat oldOffsetY =
+          (oldViewProps.padding.top - oldViewProps.padding.bottom) / 2.0;
+      CGFloat newOffsetX =
+          (newViewProps.padding.left - newViewProps.padding.right) / 2.0;
+      CGFloat newOffsetY =
+          (newViewProps.padding.top - newViewProps.padding.bottom) / 2.0;
+
+      CGFloat deltaX = newOffsetX - oldOffsetX;
+      CGFloat deltaY = newOffsetY - oldOffsetY;
+
+      // Apply new padding first
+      _mapView.layoutMargins = UIEdgeInsetsMake(
+          newViewProps.padding.top, newViewProps.padding.left,
+          newViewProps.padding.bottom, newViewProps.padding.right);
+
+      // Convert pixel offset to coordinate offset
+      if (deltaX != 0 || deltaY != 0) {
+        CLLocationCoordinate2D currentCenter = _mapView.centerCoordinate;
+        CGPoint centerPoint = [_mapView convertCoordinate:currentCenter
+                                            toPointToView:_mapView];
+        CGPoint newPoint =
+            CGPointMake(centerPoint.x - deltaX, centerPoint.y - deltaY);
+        CLLocationCoordinate2D newCenter = [_mapView convertPoint:newPoint
+                                             toCoordinateFromView:_mapView];
+        [_mapView setCenterCoordinate:newCenter animated:NO];
+      }
+    } else {
+      _mapView.layoutMargins = UIEdgeInsetsMake(
+          newViewProps.padding.top, newViewProps.padding.left,
+          newViewProps.padding.bottom, newViewProps.padding.right);
+    }
 
     _minZoom = newViewProps.minZoom;
     _maxZoom = newViewProps.maxZoom;
@@ -253,6 +303,38 @@ using namespace luggmaps::events;
 
 #pragma mark - Annotation Helpers
 
+- (void)applyMarkerStyle:(LuggMarkerView *)markerView
+          annotationView:(MKAnnotationView *)annotationView {
+  annotationView.transform = CGAffineTransformIdentity;
+
+  UIView *iconView = markerView.iconView;
+  CGRect frame = iconView.frame;
+  if (frame.size.width <= 0 || frame.size.height <= 0)
+    return;
+
+  CGFloat scale = markerView.scale;
+  CGPoint anchor = markerView.anchor;
+
+  if (markerView.rasterize) {
+    annotationView.image = [markerView createScaledIconImage];
+  } else {
+    iconView.layer.anchorPoint = anchor;
+    iconView.transform = CGAffineTransformMakeScale(scale, scale);
+    iconView.frame =
+        CGRectMake(frame.size.width * (0.5 - anchor.x) * (scale - 1),
+                   frame.size.height * (0.5 - anchor.y) * (scale - 1),
+                   frame.size.width, frame.size.height);
+  }
+
+  annotationView.bounds =
+      CGRectMake(0, 0, frame.size.width * scale, frame.size.height * scale);
+  annotationView.centerOffset =
+      CGPointMake(frame.size.width * scale * (anchor.x - 0.5),
+                  -frame.size.height * scale * (anchor.y - 0.5));
+  annotationView.transform =
+      CGAffineTransformMakeRotation(markerView.rotate * M_PI / 180.0);
+}
+
 - (void)updateAnnotationViewFrame:(AppleMarkerAnnotation *)annotation {
   MKAnnotationView *annotationView = annotation.annotationView;
   LuggMarkerView *markerView = annotation.markerView;
@@ -261,16 +343,7 @@ using namespace luggmaps::events;
     return;
   }
 
-  UIView *iconView = markerView.iconView;
-  CGRect frame = iconView.frame;
-  if (frame.size.width > 0 && frame.size.height > 0) {
-    annotationView.frame = frame;
-
-    CGPoint anchor = markerView.anchor;
-    annotationView.centerOffset =
-        CGPointMake(frame.size.width * (anchor.x - 0.5),
-                    -frame.size.height * (anchor.y - 0.5));
-  }
+  [self applyMarkerStyle:markerView annotationView:annotationView];
 }
 
 #pragma mark - PolylineViewDelegate
@@ -302,7 +375,8 @@ using namespace luggmaps::events;
   free(coords);
 
   polylineView.polyline = polyline;
-  [_mapView addOverlay:polyline];
+  [_overlayToPolylineMap setObject:polylineView forKey:polyline];
+  [self insertOverlay:polyline withZIndex:polylineView.zIndex];
 }
 
 - (void)syncPolylineView:(LuggPolylineView *)polylineView {
@@ -316,7 +390,11 @@ using namespace luggmaps::events;
   // Build new polyline from coordinates
   NSArray<CLLocation *> *coordinates = polylineView.coordinates;
   if (coordinates.count == 0) {
+    if (renderer) {
+      renderer.animated = NO;
+    }
     if (oldPolyline) {
+      [_overlayToPolylineMap removeObjectForKey:oldPolyline];
       [_mapView removeOverlay:oldPolyline];
       polylineView.polyline = nil;
       polylineView.renderer = nil;
@@ -334,35 +412,54 @@ using namespace luggmaps::events;
   free(coords);
 
   polylineView.polyline = newPolyline;
+  [_overlayToPolylineMap setObject:polylineView forKey:newPolyline];
 
   // If we have an existing renderer, update it in place
   if (renderer && oldPolyline) {
+    [_overlayToPolylineMap removeObjectForKey:oldPolyline];
+    [_mapView removeOverlay:oldPolyline];
+    [self insertOverlay:newPolyline withZIndex:polylineView.zIndex];
     [renderer updatePolyline:newPolyline];
     renderer.lineWidth = polylineView.strokeWidth;
     renderer.strokeColor = polylineView.strokeColors.firstObject;
     renderer.strokeColors =
         polylineView.strokeColors.count > 1 ? polylineView.strokeColors : nil;
+    renderer.animatedOptions = polylineView.animatedOptions;
     renderer.animated = polylineView.animated;
     return;
   }
 
   // Otherwise do full add
   if (oldPolyline) {
+    [_overlayToPolylineMap removeObjectForKey:oldPolyline];
     [_mapView removeOverlay:oldPolyline];
   }
-  [_mapView addOverlay:newPolyline];
+  [self insertOverlay:newPolyline withZIndex:polylineView.zIndex];
 }
 
-- (LuggPolylineView *)findPolylineViewForOverlay:(id<MKOverlay>)overlay {
-  for (UIView *subview in self.subviews) {
-    if ([subview isKindOfClass:[LuggPolylineView class]]) {
-      LuggPolylineView *polylineView = (LuggPolylineView *)subview;
-      if (polylineView.polyline == overlay) {
-        return polylineView;
-      }
+- (void)insertOverlay:(id<MKOverlay>)overlay withZIndex:(NSInteger)zIndex {
+  if (zIndex == 0) {
+    [_mapView addOverlay:overlay];
+    return;
+  }
+
+  NSArray<id<MKOverlay>> *overlays = _mapView.overlays;
+  NSInteger insertIndex = overlays.count;
+
+  for (NSInteger i = 0; i < overlays.count; i++) {
+    LuggPolylineView *existingPolylineView =
+        [self findPolylineViewForOverlay:overlays[i]];
+    if (existingPolylineView && existingPolylineView.zIndex > zIndex) {
+      insertIndex = i;
+      break;
     }
   }
-  return nil;
+
+  [_mapView insertOverlay:overlay atIndex:insertIndex];
+}
+
+- (LuggPolylineView *)findPolylineViewForOverlay:(id<MKOverlay>)overlay {
+  return [_overlayToPolylineMap objectForKey:overlay];
 }
 
 #pragma mark - MarkerViewDelegate
@@ -388,6 +485,12 @@ using namespace luggmaps::events;
   annotation.title = markerView.title;
   annotation.subtitle = markerView.markerDescription;
 
+  MKAnnotationView *annotationView = annotation.annotationView;
+  if (annotationView) {
+    annotationView.layer.zPosition = markerView.zIndex;
+    annotationView.zPriority = markerView.zIndex;
+  }
+
   [self updateAnnotationViewFrame:annotation];
 }
 
@@ -395,6 +498,15 @@ using namespace luggmaps::events;
 
 - (void)mapView:(MKMapView *)mapView regionWillChangeAnimated:(BOOL)animated {
   _isDragging = [self isUserInteracting:mapView];
+  if (_isDragging) {
+    for (UIView *subview in self.subviews) {
+      if ([subview isKindOfClass:[LuggPolylineView class]]) {
+        MKPolylineAnimator *renderer =
+            (MKPolylineAnimator *)((LuggPolylineView *)subview).renderer;
+        [renderer pause];
+      }
+    }
+  }
 }
 
 - (BOOL)isUserInteracting:(MKMapView *)mapView {
@@ -418,6 +530,15 @@ using namespace luggmaps::events;
 - (void)mapView:(MKMapView *)mapView regionDidChangeAnimated:(BOOL)animated {
   BOOL wasDragging = _isDragging;
   _isDragging = NO;
+  if (wasDragging) {
+    for (UIView *subview in self.subviews) {
+      if ([subview isKindOfClass:[LuggPolylineView class]]) {
+        MKPolylineAnimator *renderer =
+            (MKPolylineAnimator *)((LuggPolylineView *)subview).renderer;
+        [renderer resume];
+      }
+    }
+  }
   CameraIdleEvent{mapView.centerCoordinate.latitude,
                   mapView.centerCoordinate.longitude, mapView.zoomLevel,
                   static_cast<bool>(wasDragging)}
@@ -442,25 +563,16 @@ using namespace luggmaps::events;
                                    reuseIdentifier:nil];
   annotationView.canShowCallout = YES;
   annotationView.displayPriority = MKFeatureDisplayPriorityRequired;
-  annotationView.collisionMode = MKAnnotationViewCollisionModeNone;
-
-  UIView *iconView = markerView.iconView;
-  [iconView removeFromSuperview];
-  [annotationView addSubview:iconView];
+  annotationView.layer.zPosition = markerView.zIndex;
+  annotationView.zPriority = markerView.zIndex;
 
-  // Set frame and centerOffset based on iconView
-  CGRect frame = iconView.frame;
-  if (frame.size.width > 0 && frame.size.height > 0) {
-    annotationView.frame =
-        CGRectMake(0, 0, frame.size.width, frame.size.height);
-    iconView.frame = CGRectMake(0, 0, frame.size.width, frame.size.height);
-
-    CGPoint anchor = markerView.anchor;
-    annotationView.centerOffset =
-        CGPointMake(frame.size.width * (anchor.x - 0.5),
-                    -frame.size.height * (anchor.y - 0.5));
+  if (!markerView.rasterize) {
+    UIView *iconView = markerView.iconView;
+    [iconView removeFromSuperview];
+    [annotationView addSubview:iconView];
   }
 
+  [self applyMarkerStyle:markerView annotationView:annotationView];
   markerAnnotation.annotationView = annotationView;
 
   return annotationView;
@@ -482,6 +594,7 @@ using namespace luggmaps::events;
       if (colors.count > 1) {
         renderer.strokeColors = colors;
       }
+      renderer.animatedOptions = polylineView.animatedOptions;
       renderer.animated = polylineView.animated;
       polylineView.renderer = renderer;
       return renderer;
@@ -504,16 +617,18 @@ using namespace luggmaps::events;
     return;
   }
 
+  double targetZoom = zoom > 0 ? zoom : _mapView.zoomLevel;
+
   if (duration < 0) {
     [self setCameraWithLatitude:latitude
                       longitude:longitude
-                           zoom:zoom
+                           zoom:targetZoom
                        animated:YES];
   } else if (duration > 0) {
     CLLocationCoordinate2D center =
         CLLocationCoordinate2DMake(latitude, longitude);
     MKCoordinateRegion region = [_mapView regionForCenterCoordinate:center
-                                                          zoomLevel:zoom];
+                                                          zoomLevel:targetZoom];
     [UIView animateWithDuration:duration / 1000.0
                      animations:^{
                        [self->_mapView setRegion:region animated:NO];
@@ -521,7 +636,7 @@ using namespace luggmaps::events;
   } else {
     [self setCameraWithLatitude:latitude
                       longitude:longitude
-                           zoom:zoom
+                           zoom:targetZoom
                        animated:NO];
   }
 }