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

package/ios/LuggGoogleMapView.mm

@@ -89,6 +89,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
       marker.map = nil;
       markerView.marker = nil;
     }
+    [markerView resetIconViewTransform];
   } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
     LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
     [_polylineAnimators removeObjectForKey:polylineView];
@@ -189,6 +190,11 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
 - (void)mapView:(GMSMapView *)mapView willMove:(BOOL)gesture {
   _isDragging = gesture;
+  if (_isDragging) {
+    for (GMSPolylineAnimator *animator in _polylineAnimators.objectEnumerator) {
+      [animator pause];
+    }
+  }
 }
 
 - (void)mapView:(GMSMapView *)mapView
@@ -202,6 +208,11 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
     idleAtCameraPosition:(GMSCameraPosition *)position {
   BOOL wasDragging = _isDragging;
   _isDragging = NO;
+  if (wasDragging) {
+    for (GMSPolylineAnimator *animator in _polylineAnimators.objectEnumerator) {
+      [animator resume];
+    }
+  }
   CameraIdleEvent{position.target.latitude, position.target.longitude,
                   position.zoom, static_cast<bool>(wasDragging)}
       .emit<LuggGoogleMapViewEventEmitter>(_eventEmitter);
@@ -225,6 +236,35 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
 #pragma mark - Marker Management
 
+- (void)applyMarkerStyle:(LuggMarkerView *)markerView
+                  marker:(GMSAdvancedMarker *)marker {
+  if (markerView.hasCustomView) {
+    if (markerView.rasterize) {
+      marker.iconView = nil;
+      marker.icon = [markerView createScaledIconImage];
+      marker.rotation = markerView.rotate;
+    } else {
+      UIView *iconView = markerView.iconView;
+      if (marker.iconView != iconView) {
+        [iconView removeFromSuperview];
+        marker.iconView = iconView;
+      }
+      CGFloat scale = markerView.scale;
+      CGFloat radians = markerView.rotate * M_PI / 180.0;
+      iconView.transform =
+          CGAffineTransformConcat(CGAffineTransformMakeScale(scale, scale),
+                                  CGAffineTransformMakeRotation(radians));
+      marker.rotation = 0;
+    }
+    marker.groundAnchor = markerView.anchor;
+  } else {
+    marker.iconView = nil;
+    marker.icon = nil;
+    marker.rotation = markerView.rotate;
+    marker.groundAnchor = CGPointMake(0.5, 1);
+  }
+}
+
 - (void)syncMarkerView:(LuggMarkerView *)markerView caller:(NSString *)caller {
   if (!_mapView) {
     if (![_pendingMarkerViews containsObject:markerView]) {
@@ -242,15 +282,8 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   marker.position = markerView.coordinate;
   marker.title = markerView.title;
   marker.snippet = markerView.markerDescription;
-  marker.groundAnchor = markerView.anchor;
-
-  if (markerView.hasCustomView) {
-    UIView *iconView = markerView.iconView;
-    [iconView removeFromSuperview];
-    marker.iconView = iconView;
-  } else {
-    marker.iconView = nil;
-  }
+  marker.zIndex = (int)markerView.zIndex;
+  [self applyMarkerStyle:markerView marker:marker];
 }
 
 - (void)processPendingMarkers {
@@ -270,22 +303,15 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
     return;
   }
 
-  UIView *iconView = markerView.iconView;
-  [iconView removeFromSuperview];
-
   GMSAdvancedMarker *marker = [[GMSAdvancedMarker alloc] init];
   marker.position = markerView.coordinate;
   marker.title = markerView.title;
   marker.snippet = markerView.markerDescription;
-  marker.collisionBehavior = GMSCollisionBehaviorRequired;
+  marker.zIndex = (int)markerView.zIndex;
 
-  if (markerView.hasCustomView) {
-    marker.iconView = iconView;
-  }
+  [self applyMarkerStyle:markerView marker:marker];
 
-  marker.groundAnchor = markerView.anchor;
   marker.map = _mapView;
-
   markerView.marker = marker;
 }
 
@@ -306,12 +332,14 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
   GMSPolyline *polyline = (GMSPolyline *)polylineView.polyline;
   polyline.strokeWidth = polylineView.strokeWidth;
+  polyline.zIndex = (int)polylineView.zIndex;
 
   GMSPolylineAnimator *animator =
       [_polylineAnimators objectForKey:polylineView];
   if (animator) {
     animator.coordinates = polylineView.coordinates;
     animator.strokeColors = polylineView.strokeColors;
+    animator.animatedOptions = polylineView.animatedOptions;
     animator.animated = polylineView.animated;
     [animator update];
   }
@@ -335,6 +363,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
   GMSPolyline *polyline = [GMSPolyline polylineWithPath:[GMSMutablePath path]];
   polyline.strokeWidth = polylineView.strokeWidth;
+  polyline.zIndex = (int)polylineView.zIndex;
   polyline.map = _mapView;
   polylineView.polyline = polyline;
 
@@ -342,6 +371,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   animator.polyline = polyline;
   animator.coordinates = polylineView.coordinates;
   animator.strokeColors = polylineView.strokeColors;
+  animator.animatedOptions = polylineView.animatedOptions;
   animator.animated = polylineView.animated;
   [animator update];
 
@@ -393,10 +423,10 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
     return;
   }
 
-  GMSCameraPosition *camera =
-      [GMSCameraPosition cameraWithLatitude:latitude
-                                  longitude:longitude
-                                       zoom:(float)zoom];
+  float targetZoom = zoom > 0 ? (float)zoom : _mapView.camera.zoom;
+  GMSCameraPosition *camera = [GMSCameraPosition cameraWithLatitude:latitude
+                                                          longitude:longitude
+                                                               zoom:targetZoom];
   if (duration < 0) {
     [_mapView animateToCameraPosition:camera];
   } else if (duration > 0) {

package/ios/LuggMarkerView.h

@@ -14,16 +14,25 @@ NS_ASSUME_NONNULL_BEGIN
 
 @interface LuggMarkerView : RCTViewComponentView
 
+@property(nonatomic, readonly, nullable) NSString *name;
 @property(nonatomic, readonly) CLLocationCoordinate2D coordinate;
 @property(nonatomic, readonly, nullable) NSString *title;
 @property(nonatomic, readonly, nullable) NSString *markerDescription;
 @property(nonatomic, readonly) CGPoint anchor;
+@property(nonatomic, readonly) NSInteger zIndex;
+@property(nonatomic, readonly) CLLocationDegrees rotate;
+@property(nonatomic, readonly) CGFloat scale;
+@property(nonatomic, readonly) BOOL rasterize;
 @property(nonatomic, readonly) BOOL hasCustomView;
 @property(nonatomic, readonly) BOOL didLayout;
 @property(nonatomic, readonly) UIView *iconView;
 @property(nonatomic, weak, nullable) id<LuggMarkerViewDelegate> delegate;
 @property(nonatomic, strong, nullable) NSObject *marker;
 
+- (nullable UIImage *)createIconImage;
+- (nullable UIImage *)createScaledIconImage;
+- (void)resetIconViewTransform;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/LuggMarkerView.mm

@@ -13,10 +13,15 @@ using namespace facebook::react;
 @end
 
 @implementation LuggMarkerView {
+  NSString *_name;
   CLLocationCoordinate2D _coordinate;
   NSString *_title;
   NSString *_markerDescription;
   CGPoint _anchor;
+  NSInteger _zIndex;
+  CLLocationDegrees _rotate;
+  CGFloat _scale;
+  BOOL _rasterize;
   BOOL _didLayout;
   UIView *_iconView;
 }
@@ -34,6 +39,10 @@ using namespace facebook::react;
 
     _coordinate = CLLocationCoordinate2DMake(0, 0);
     _anchor = CGPointMake(0.5, 1.0);
+    _zIndex = 0;
+    _rotate = 0;
+    _scale = 1;
+    _rasterize = YES;
     _didLayout = NO;
 
     _iconView = [[UIView alloc] init];
@@ -52,12 +61,17 @@ using namespace facebook::react;
   const auto &newViewProps =
       *std::static_pointer_cast<LuggMarkerViewProps const>(props);
 
+  _name = [NSString stringWithUTF8String:newViewProps.name.c_str()];
   _coordinate = CLLocationCoordinate2DMake(newViewProps.coordinate.latitude,
                                            newViewProps.coordinate.longitude);
   _title = [NSString stringWithUTF8String:newViewProps.title.c_str()];
   _markerDescription =
       [NSString stringWithUTF8String:newViewProps.description.c_str()];
   _anchor = CGPointMake(newViewProps.anchor.x, newViewProps.anchor.y);
+  _zIndex = newViewProps.zIndex.value_or(0);
+  _rotate = newViewProps.rotate;
+  _scale = newViewProps.scale;
+  _rasterize = newViewProps.rasterize;
 }
 
 - (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
@@ -109,6 +123,10 @@ using namespace facebook::react;
   }
 }
 
+- (NSString *)name {
+  return _name;
+}
+
 - (CLLocationCoordinate2D)coordinate {
   return _coordinate;
 }
@@ -125,6 +143,22 @@ using namespace facebook::react;
   return _anchor;
 }
 
+- (NSInteger)zIndex {
+  return _zIndex;
+}
+
+- (CLLocationDegrees)rotate {
+  return _rotate;
+}
+
+- (CGFloat)scale {
+  return _scale;
+}
+
+- (BOOL)rasterize {
+  return _rasterize;
+}
+
 - (BOOL)hasCustomView {
   return _iconView.subviews.count > 0;
 }
@@ -137,11 +171,56 @@ using namespace facebook::react;
   return _iconView;
 }
 
+- (UIImage *)createIconImage {
+  CGSize size = _iconView.bounds.size;
+  if (size.width <= 0 || size.height <= 0) {
+    return nil;
+  }
+
+  UIGraphicsImageRendererFormat *format =
+      [UIGraphicsImageRendererFormat defaultFormat];
+  format.scale = [UIScreen mainScreen].scale;
+  UIGraphicsImageRenderer *renderer =
+      [[UIGraphicsImageRenderer alloc] initWithSize:size format:format];
+
+  return [renderer imageWithActions:^(UIGraphicsImageRendererContext *context) {
+    [self->_iconView.layer renderInContext:context.CGContext];
+  }];
+}
+
+- (UIImage *)createScaledIconImage {
+  CGSize size = _iconView.bounds.size;
+  if (size.width <= 0 || size.height <= 0) {
+    return nil;
+  }
+
+  CGSize scaledSize = CGSizeMake(size.width * _scale, size.height * _scale);
+
+  UIGraphicsImageRendererFormat *format =
+      [UIGraphicsImageRendererFormat defaultFormat];
+  format.scale = [UIScreen mainScreen].scale;
+  UIGraphicsImageRenderer *renderer =
+      [[UIGraphicsImageRenderer alloc] initWithSize:scaledSize format:format];
+
+  return [renderer imageWithActions:^(UIGraphicsImageRendererContext *context) {
+    CGContextScaleCTM(context.CGContext, self->_scale, self->_scale);
+    [self->_iconView.layer renderInContext:context.CGContext];
+  }];
+}
+
+- (void)resetIconViewTransform {
+  _iconView.transform = CGAffineTransformIdentity;
+  _iconView.layer.anchorPoint = CGPointMake(0.5, 0.5);
+  _iconView.frame = CGRectMake(0, 0, _iconView.bounds.size.width,
+                               _iconView.bounds.size.height);
+}
+
 - (void)prepareForRecycle {
   [super prepareForRecycle];
   _didLayout = NO;
   self.marker = nil;
   self.delegate = nil;
+  [self resetIconViewTransform];
   for (UIView *subview in _iconView.subviews) {
     [subview removeFromSuperview];
   }

package/ios/LuggPolylineView.h

@@ -1,3 +1,4 @@
+#import "core/PolylineAnimatorBase.h"
 #import <CoreLocation/CoreLocation.h>
 #import <React/RCTViewComponentView.h>
 #import <UIKit/UIKit.h>
@@ -16,7 +17,10 @@ NS_ASSUME_NONNULL_BEGIN
 @property(nonatomic, readonly) NSArray<CLLocation *> *coordinates;
 @property(nonatomic, readonly) NSArray<UIColor *> *strokeColors;
 @property(nonatomic, readonly) BOOL animated;
+@property(nonatomic, readonly, nullable)
+    PolylineAnimatedOptions *animatedOptions;
 @property(nonatomic, readonly) CGFloat strokeWidth;
+@property(nonatomic, readonly) NSInteger zIndex;
 @property(nonatomic, weak, nullable) id<LuggPolylineViewDelegate> delegate;
 @property(nonatomic, strong, nullable) NSObject *polyline;
 @property(nonatomic, weak, nullable) NSObject *renderer;

package/ios/LuggPolylineView.mm

@@ -17,7 +17,9 @@ using namespace facebook::react;
   NSArray<CLLocation *> *_coordinates;
   NSArray<UIColor *> *_strokeColors;
   BOOL _animated;
+  PolylineAnimatedOptions *_animatedOptions;
   CGFloat _strokeWidth;
+  NSInteger _zIndex;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -72,7 +74,20 @@ using namespace facebook::react;
 
   _animated = newViewProps.animated;
 
+  const auto &opts = newViewProps.animatedOptions;
+  PolylineAnimatedOptions *options = [[PolylineAnimatedOptions alloc] init];
+  options.duration = opts.duration > 0 ? opts.duration : 2150;
+  options.trailLength = (opts.trailLength > 0 && opts.trailLength <= 1.0)
+                            ? opts.trailLength
+                            : 1.0;
+  options.delay = opts.delay;
+  options.easing = !opts.easing.empty()
+                       ? [NSString stringWithUTF8String:opts.easing.c_str()]
+                       : @"linear";
+  _animatedOptions = options;
+
   _strokeWidth = newViewProps.strokeWidth > 0 ? newViewProps.strokeWidth : 1.0;
+  _zIndex = newViewProps.zIndex.value_or(0);
 }
 
 - (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
@@ -97,10 +112,18 @@ using namespace facebook::react;
   return _animated;
 }
 
+- (PolylineAnimatedOptions *)animatedOptions {
+  return _animatedOptions;
+}
+
 - (CGFloat)strokeWidth {
   return _strokeWidth;
 }
 
+- (NSInteger)zIndex {
+  return _zIndex;
+}
+
 - (void)prepareForRecycle {
   [super prepareForRecycle];
   self.polyline = nil;

package/ios/core/GMSPolylineAnimator.h

@@ -5,7 +5,10 @@
 
 @property(nonatomic, weak) GMSPolyline *polyline;
 @property(nonatomic, assign) BOOL animated;
+@property(nonatomic, strong) PolylineAnimatedOptions *animatedOptions;
 
 - (void)update;
+- (void)pause;
+- (void)resume;
 
 @end

package/ios/core/GMSPolylineAnimator.m

@@ -1,15 +1,53 @@
 #import "GMSPolylineAnimator.h"
 #import <QuartzCore/QuartzCore.h>
 
+@interface GMSDisplayLinkProxy : NSObject
+@property(nonatomic, weak) id target;
+@property(nonatomic, assign) SEL selector;
+@end
+
+@implementation GMSDisplayLinkProxy
+- (instancetype)initWithTarget:(id)target selector:(SEL)selector {
+  if (self = [super init]) {
+    _target = target;
+    _selector = selector;
+  }
+  return self;
+}
+- (void)tick:(CADisplayLink *)displayLink {
+  if (_target) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+    [_target performSelector:_selector withObject:displayLink];
+#pragma clang diagnostic pop
+  } else {
+    [displayLink invalidate];
+  }
+}
+@end
+
 @implementation GMSPolylineAnimator {
   CADisplayLink *_displayLink;
+  GMSDisplayLinkProxy *_displayLinkProxy;
   CGFloat _animationProgress;
+  CGFloat _delayRemaining;
+  NSArray<NSNumber *> *_cumulativeDistances;
+  CGFloat _totalLength;
 }
 
+@synthesize animatedOptions = _animatedOptions;
+
 - (void)dealloc {
   [self stopAnimation];
 }
 
+- (void)setCoordinates:(NSArray<CLLocation *> *)coordinates {
+  [super setCoordinates:coordinates];
+  if (_animated && _displayLink) {
+    [self computeCumulativeDistances];
+  }
+}
+
 - (void)setAnimated:(BOOL)animated {
   if (_animated == animated) {
     return;
@@ -24,26 +62,74 @@
   }
 }
 
+- (void)setAnimatedOptions:(PolylineAnimatedOptions *)animatedOptions {
+  _animatedOptions = animatedOptions ?: [PolylineAnimatedOptions defaultOptions];
+  if (_animated && _displayLink) {
+    [self stopAnimation];
+    [self startAnimation];
+  }
+}
+
 - (void)startAnimation {
   if (_displayLink) {
     return;
   }
+  [self computeCumulativeDistances];
   _animationProgress = 0;
-  _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(animationTick:)];
+  _delayRemaining = self.animatedOptions.delay / 1000.0;
+  _displayLinkProxy = [[GMSDisplayLinkProxy alloc] initWithTarget:self selector:@selector(animationTick:)];
+  _displayLink = [CADisplayLink displayLinkWithTarget:_displayLinkProxy selector:@selector(tick:)];
   [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
 }
 
+- (void)computeCumulativeDistances {
+  NSMutableArray<NSNumber *> *distances = [NSMutableArray array];
+  CGFloat total = 0;
+  [distances addObject:@(0)];
+
+  for (NSUInteger i = 1; i < self.coordinates.count; i++) {
+    CLLocation *prev = self.coordinates[i - 1];
+    CLLocation *curr = self.coordinates[i];
+    total += [prev distanceFromLocation:curr];
+    [distances addObject:@(total)];
+  }
+
+  _cumulativeDistances = [distances copy];
+  _totalLength = total;
+}
+
 - (void)stopAnimation {
   [_displayLink invalidate];
   _displayLink = nil;
+  _displayLinkProxy = nil;
+}
+
+- (void)pause {
+  _displayLink.paused = YES;
+}
+
+- (void)resume {
+  _displayLink.paused = NO;
 }
 
 - (void)animationTick:(CADisplayLink *)displayLink {
-  CGFloat speed = displayLink.duration / 1.75;
+  if (_delayRemaining > 0) {
+    _delayRemaining -= displayLink.duration;
+    return;
+  }
+
+  CGFloat duration = self.animatedOptions.duration / 1000.0;
+  if (duration <= 0) duration = 2.15;
+
+  CGFloat trailLength = MAX(0.01, MIN(1.0, self.animatedOptions.trailLength));
+  CGFloat maxProgress = (trailLength < 1.0) ? 1.0 : 2.15;
+
+  CGFloat speed = displayLink.duration / duration;
   _animationProgress += speed;
 
-  if (_animationProgress >= 2.15) {
+  if (_animationProgress >= maxProgress) {
     _animationProgress = 0;
+    _delayRemaining = self.animatedOptions.delay / 1000.0;
   }
 
   [self updateAnimatedPolyline];
@@ -71,63 +157,100 @@
   }
 }
 
+- (NSUInteger)indexForDistance:(CGFloat)distance {
+  NSUInteger left = 0;
+  NSUInteger right = _cumulativeDistances.count - 1;
+
+  while (left < right) {
+    NSUInteger mid = (left + right + 1) / 2;
+    if (_cumulativeDistances[mid].doubleValue <= distance) {
+      left = mid;
+    } else {
+      right = mid - 1;
+    }
+  }
+
+  return MIN(left, _cumulativeDistances.count - 2);
+}
+
+- (CLLocationCoordinate2D)coordinateAtDistance:(CGFloat)distance {
+  if (distance <= 0) {
+    return self.coordinates.firstObject.coordinate;
+  }
+  if (distance >= _totalLength) {
+    return self.coordinates.lastObject.coordinate;
+  }
+
+  NSUInteger idx = [self indexForDistance:distance];
+  CGFloat segStart = _cumulativeDistances[idx].doubleValue;
+  CGFloat segEnd = _cumulativeDistances[idx + 1].doubleValue;
+  CGFloat segLength = segEnd - segStart;
+
+  CGFloat t = (segLength > 0) ? (distance - segStart) / segLength : 0;
+  CLLocationCoordinate2D c1 = self.coordinates[idx].coordinate;
+  CLLocationCoordinate2D c2 = self.coordinates[idx + 1].coordinate;
+
+  return CLLocationCoordinate2DMake(c1.latitude + (c2.latitude - c1.latitude) * t,
+                                    c1.longitude + (c2.longitude - c1.longitude) * t);
+}
+
 - (void)updateAnimatedPolyline {
-  if (!_polyline || self.coordinates.count < 2) {
+  if (!_polyline || self.coordinates.count < 2 || _totalLength <= 0) {
     return;
   }
 
-  NSUInteger segmentCount = self.coordinates.count - 1;
-  CGFloat progress = MIN(_animationProgress, 2.0);
-  CGFloat headPos, tailPos;
+  CGFloat trailLength = MAX(0.01, MIN(1.0, self.animatedOptions.trailLength));
+  CGFloat maxProgress = (trailLength < 1.0) ? 1.0 : 2.0;
+  CGFloat progress = MIN(_animationProgress, maxProgress);
+  CGFloat easedProgress = [self applyEasing:progress / maxProgress] * maxProgress;
+
+  CGFloat headDist, tailDist;
 
-  if (progress <= 1.0) {
-    tailPos = 0;
-    headPos = progress * segmentCount;
+  if (trailLength < 1.0) {
+    headDist = easedProgress * _totalLength;
+    tailDist = MAX(0, headDist - _totalLength * trailLength);
+  } else if (easedProgress <= 1.0) {
+    tailDist = 0;
+    headDist = easedProgress * _totalLength;
   } else {
-    CGFloat shrinkProgress = progress - 1.0;
-    tailPos = shrinkProgress * segmentCount;
-    headPos = segmentCount;
+    CGFloat shrinkProgress = easedProgress - 1.0;
+    tailDist = shrinkProgress * _totalLength;
+    headDist = _totalLength;
   }
 
-  if (headPos <= tailPos) {
+  if (headDist <= tailDist) {
     _polyline.path = [GMSMutablePath path];
     return;
   }
 
-  NSUInteger startIndex = (NSUInteger)floor(tailPos);
-  NSUInteger endIndex = (NSUInteger)ceil(headPos);
-  CGFloat visibleLength = headPos - tailPos;
+  CGFloat visibleLength = headDist - tailDist;
+  NSUInteger startIndex = [self indexForDistance:tailDist];
+  NSUInteger endIndex = [self indexForDistance:headDist];
 
   GMSMutablePath *path = [GMSMutablePath path];
   NSMutableArray<GMSStyleSpan *> *spans = [NSMutableArray array];
 
-  for (NSUInteger i = startIndex; i <= endIndex && i < self.coordinates.count; i++) {
-    CLLocationCoordinate2D coord = self.coordinates[i].coordinate;
-
-    if (i == startIndex && tailPos > (CGFloat)startIndex) {
-      CGFloat t = tailPos - (CGFloat)startIndex;
-      CLLocationCoordinate2D nextCoord = self.coordinates[i + 1].coordinate;
-      coord.latitude = coord.latitude + (nextCoord.latitude - coord.latitude) * t;
-      coord.longitude = coord.longitude + (nextCoord.longitude - coord.longitude) * t;
-    }
+  CLLocationCoordinate2D startCoord = [self coordinateAtDistance:tailDist];
+  [path addCoordinate:startCoord];
 
-    if (i == endIndex && headPos < (CGFloat)endIndex && i > 0) {
-      CGFloat t = headPos - (CGFloat)(endIndex - 1);
-      CLLocationCoordinate2D prevCoord = self.coordinates[i - 1].coordinate;
-      coord.latitude = prevCoord.latitude + (coord.latitude - prevCoord.latitude) * t;
-      coord.longitude = prevCoord.longitude + (coord.longitude - prevCoord.longitude) * t;
-    }
+  for (NSUInteger i = startIndex + 1; i <= endIndex; i++) {
+    [path addCoordinate:self.coordinates[i].coordinate];
+  }
 
-    [path addCoordinate:coord];
+  CLLocationCoordinate2D endCoord = [self coordinateAtDistance:headDist];
+  CLLocationCoordinate2D lastAdded =
+      (endIndex < self.coordinates.count) ? self.coordinates[endIndex].coordinate : endCoord;
+  if (endCoord.latitude != lastAdded.latitude || endCoord.longitude != lastAdded.longitude) {
+    [path addCoordinate:endCoord];
+  }
 
-    if (i < endIndex && i < segmentCount) {
-      CGFloat segStartPos = MAX((CGFloat)i, tailPos);
-      CGFloat segEndPos = MIN((CGFloat)(i + 1), headPos);
-      CGFloat gradientMid = ((segStartPos + segEndPos) / 2.0 - tailPos) / visibleLength;
-      UIColor *color = [self colorAtGradientPosition:gradientMid];
-      GMSStrokeStyle *style = [GMSStrokeStyle solidColor:color];
-      [spans addObject:[GMSStyleSpan spanWithStyle:style]];
-    }
+  NSUInteger pathCount = path.count;
+  for (NSUInteger i = 0; i < pathCount - 1; i++) {
+    CGFloat segMidDist = tailDist + visibleLength * ((CGFloat)i + 0.5) / (CGFloat)(pathCount - 1);
+    CGFloat gradientPos = (segMidDist - tailDist) / visibleLength;
+    UIColor *color = [self colorAtGradientPosition:gradientPos];
+    GMSStrokeStyle *style = [GMSStrokeStyle solidColor:color];
+    [spans addObject:[GMSStyleSpan spanWithStyle:style]];
   }
 
   _polyline.path = path;

package/ios/core/MKPolylineAnimator.h

@@ -1,3 +1,4 @@
+#import "PolylineAnimatorBase.h"
 #import <MapKit/MapKit.h>
 
 @interface MKPolylineAnimator : MKOverlayPathRenderer
@@ -6,7 +7,10 @@
 
 @property(nonatomic, strong) NSArray<UIColor *> *strokeColors;
 @property(nonatomic, assign) BOOL animated;
+@property(nonatomic, strong) PolylineAnimatedOptions *animatedOptions;
 
 - (void)updatePolyline:(MKPolyline *)polyline;
+- (void)pause;
+- (void)resume;
 
 @end