@lugg/maps 1.0.0-beta.9 → 1.1.0

package/ios/core/GoogleMapProvider.mm

@@ -13,10 +13,44 @@ using facebook::react::LuggMapViewTheme;
 #import "../LuggPolylineView.h"
 #import "../LuggTileOverlayView.h"
 #import "GMSPolylineAnimator.h"
+#import "MapEdgeInsets.h"
 #import "PolylineAnimatorBase.h"
 
 static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
+GMSMapID *LuggGMSMapIDFromString(NSString *_Nullable mapId) {
+  if (mapId.length == 0 || [mapId isEqualToString:kDemoMapId]) {
+    return [GMSMapID demoMapID];
+  }
+  return [GMSMapID mapIDWithIdentifier:mapId];
+}
+
+GMSMapViewType
+LuggGMSMapTypeFromMapType(facebook::react::LuggMapViewMapType mapType) {
+  switch (mapType) {
+  case LuggMapViewMapType::Satellite:
+    return kGMSTypeSatellite;
+  case LuggMapViewMapType::Terrain:
+    return kGMSTypeTerrain;
+  case LuggMapViewMapType::Hybrid:
+    return kGMSTypeHybrid;
+  default:
+    return kGMSTypeNormal;
+  }
+}
+
+UIUserInterfaceStyle
+LuggInterfaceStyleFromTheme(facebook::react::LuggMapViewTheme theme) {
+  switch (theme) {
+  case LuggMapViewTheme::Dark:
+    return UIUserInterfaceStyleDark;
+  case LuggMapViewTheme::Light:
+    return UIUserInterfaceStyleLight;
+  default:
+    return UIUserInterfaceStyleUnspecified;
+  }
+}
+
 @interface GoogleMapProvider () <
     LuggMarkerViewDelegate, LuggCalloutViewDelegate, LuggPolylineViewDelegate,
     LuggPolygonViewDelegate, LuggCircleViewDelegate,
@@ -53,6 +87,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 }
 
 @synthesize delegate = _delegate;
+@synthesize staticMode = _staticMode;
 
 - (instancetype)init {
   if (self = [super init]) {
@@ -89,13 +124,6 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   if (_mapView)
     return;
 
-  GMSMapID *gmsMapId;
-  if ([_mapId isEqualToString:kDemoMapId] || _mapId.length == 0) {
-    gmsMapId = [GMSMapID demoMapID];
-  } else {
-    gmsMapId = [GMSMapID mapIDWithIdentifier:_mapId];
-  }
-
   GMSCameraPosition *camera =
       [GMSCameraPosition cameraWithLatitude:coordinate.latitude
                                   longitude:coordinate.longitude
@@ -104,7 +132,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
   options.frame = wrapperView.bounds;
   options.camera = camera;
-  options.mapID = gmsMapId;
+  options.mapID = LuggGMSMapIDFromString(_mapId);
 
   _mapView = [[GMSMapView alloc] initWithOptions:options];
   _mapView.autoresizingMask =
@@ -142,10 +170,26 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [_circleToViewMap removeAllObjects];
   [_markerToViewMap removeAllObjects];
   [_groundOverlayToViewMap removeAllObjects];
-  [_mapView clear];
+  [self destroyMapView];
+  _isMapReady = NO;
+}
+
+- (void)destroyMapView {
+  if (!_mapView)
+    return;
+
+  _mapView.delegate = nil;
   [_mapView removeFromSuperview];
+  [_mapView clear];
   _mapView = nil;
-  _isMapReady = NO;
+}
+
+- (CLLocationCoordinate2D)coordinate {
+  return _mapView.camera.target;
+}
+
+- (double)zoom {
+  return _mapView.camera.zoom;
 }
 
 #pragma mark - Props
@@ -166,6 +210,10 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   _mapView.settings.tiltGestures = enabled;
 }
 
+- (void)setCompassEnabled:(BOOL)enabled {
+  _mapView.settings.compassButton = enabled;
+}
+
 - (void)setUserLocationEnabled:(BOOL)enabled {
   _mapView.myLocationEnabled = enabled;
 }
@@ -187,23 +235,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 }
 
 - (void)setMapType:(LuggMapViewMapType)mapType {
-  if (!_mapView)
-    return;
-
-  switch (mapType) {
-  case LuggMapViewMapType::Satellite:
-    _mapView.mapType = kGMSTypeSatellite;
-    break;
-  case LuggMapViewMapType::Terrain:
-    _mapView.mapType = kGMSTypeTerrain;
-    break;
-  case LuggMapViewMapType::Hybrid:
-    _mapView.mapType = kGMSTypeHybrid;
-    break;
-  default:
-    _mapView.mapType = kGMSTypeNormal;
-    break;
-  }
+  _mapView.mapType = LuggGMSMapTypeFromMapType(mapType);
 }
 
 - (void)setTheme:(LuggMapViewTheme)theme {
@@ -212,20 +244,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 }
 
 - (void)applyTheme {
-  if (!_mapView)
-    return;
-
-  switch (_theme) {
-  case LuggMapViewTheme::Dark:
-    _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleDark;
-    break;
-  case LuggMapViewTheme::Light:
-    _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
-    break;
-  default:
-    _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleUnspecified;
-    break;
-  }
+  _mapView.overrideUserInterfaceStyle = LuggInterfaceStyleFromTheme(_theme);
 }
 
 - (void)setMinZoom:(double)minZoom {
@@ -278,16 +297,8 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   CFTimeInterval elapsed = CACurrentMediaTime() - _edgeInsetsAnimationStart;
   CGFloat progress = MIN(elapsed / _edgeInsetsAnimationDuration, 1.0);
 
-  // Ease out cubic
-  CGFloat t = 1.0 - (1.0 - progress) * (1.0 - progress) * (1.0 - progress);
-
-  UIEdgeInsets current = UIEdgeInsetsMake(
-      _edgeInsetsFrom.top + (_edgeInsetsTo.top - _edgeInsetsFrom.top) * t,
-      _edgeInsetsFrom.left + (_edgeInsetsTo.left - _edgeInsetsFrom.left) * t,
-      _edgeInsetsFrom.bottom +
-          (_edgeInsetsTo.bottom - _edgeInsetsFrom.bottom) * t,
-      _edgeInsetsFrom.right +
-          (_edgeInsetsTo.right - _edgeInsetsFrom.right) * t);
+  UIEdgeInsets current =
+      LuggMapInsetsAtProgress(_edgeInsetsFrom, _edgeInsetsTo, progress);
 
   _mapView.padding = current;
 
@@ -1125,9 +1136,11 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
     return;
 
   float targetZoom = zoom > 0 ? (float)zoom : _mapView.camera.zoom;
-  GMSCameraPosition *camera = [GMSCameraPosition cameraWithLatitude:latitude
-                                                          longitude:longitude
-                                                               zoom:targetZoom];
+  GMSCameraPosition *camera = [GMSCameraPosition
+      cameraWithTarget:CLLocationCoordinate2DMake(latitude, longitude)
+                  zoom:targetZoom
+               bearing:_mapView.camera.bearing
+          viewingAngle:_mapView.camera.viewingAngle];
   if (duration < 0) {
     [_mapView animateToCameraPosition:camera];
   } else if (duration > 0) {

package/ios/core/GoogleStaticMapProvider.h

@@ -0,0 +1,21 @@
+#import "StaticMapProviderBase.h"
+#import <GoogleMaps/GoogleMaps.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Static Google map. The Google Maps SDK has no async snapshotter, so the
+ * base map briefly warms up on a live, tiles-only GMSMapView inserted below
+ * the overlays, then is swapped with a rendered image and the map view is
+ * pooled for reuse. Markers and shapes are overlay views (shared with
+ * Apple static maps) that reveal with the base map, so the warmup map
+ * never renders its own markers. Warmup cost scales with how many static
+ * maps mount at once - bound that with list props (windowSize etc.).
+ */
+@interface GoogleStaticMapProvider : StaticMapProviderBase <GMSMapViewDelegate>
+
+@property(nonatomic, copy, nullable) NSString *mapId;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/core/GoogleStaticMapProvider.mm

@@ -0,0 +1,217 @@
+#import "GoogleStaticMapProvider.h"
+
+#import "../extensions/UIView+Snapshot.h"
+#import "GoogleMapProvider.h"
+
+// Static maps churn through GMSMapViews as list rows warm up, and both
+// creating one and tearing one down are expensive main-thread operations
+// (renderer setup/teardown). Detached map views are pooled and reused so a
+// warmup usually only costs a camera move plus tile load. Keyed by map ID,
+// which is fixed at GMSMapView creation.
+static const NSUInteger kStaticMapViewPoolCapacity = 6;
+
+static NSMutableDictionary<NSString *, NSMutableArray<GMSMapView *> *> *
+StaticMapViewPool(void) {
+  static NSMutableDictionary<NSString *, NSMutableArray<GMSMapView *> *> *pool;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    pool = [NSMutableDictionary dictionary];
+    [[NSNotificationCenter defaultCenter]
+        addObserverForName:UIApplicationDidReceiveMemoryWarningNotification
+                    object:nil
+                     queue:[NSOperationQueue mainQueue]
+                usingBlock:^(NSNotification *notification) {
+                  [pool removeAllObjects];
+                }];
+  });
+  return pool;
+}
+
+static GMSMapView *_Nullable DequeueStaticMapView(NSString *mapId) {
+  NSMutableArray<GMSMapView *> *views = StaticMapViewPool()[mapId];
+  GMSMapView *mapView = views.lastObject;
+  [views removeLastObject];
+  return mapView;
+}
+
+static void EnqueueStaticMapView(NSString *mapId, GMSMapView *mapView) {
+  NSMutableDictionary<NSString *, NSMutableArray<GMSMapView *> *> *pool =
+      StaticMapViewPool();
+  NSMutableArray<GMSMapView *> *views = pool[mapId];
+  if (!views) {
+    views = [NSMutableArray array];
+    pool[mapId] = views;
+  }
+  if (views.count >= kStaticMapViewPoolCapacity)
+    return;
+  [views addObject:mapView];
+}
+
+@implementation GoogleStaticMapProvider {
+  GMSMapView *_warmupMapView;
+  BOOL _snapshotReady;
+  BOOL _swapScheduled;
+}
+
+#pragma mark - StaticMapProviderBase
+
+- (MKMapRect)mapRectForSize:(CGSize)size {
+  // GMSMapView shows the world 256 * 2^zoom points wide, centered on the
+  // camera target - the same web mercator MKMapPoint uses, so overlays
+  // project onto the warmed-up tiles exactly
+  double zoom =
+      MAX(MIN(self.zoom, (double)kGMSMaxZoomLevel), (double)kGMSMinZoomLevel);
+  double mapPointsPerPoint = MKMapSizeWorld.width / (256.0 * pow(2.0, zoom));
+  double width = size.width * mapPointsPerPoint;
+  double height = size.height * mapPointsPerPoint;
+  MKMapPoint center = MKMapPointForCoordinate(self.coordinate);
+  return MKMapRectMake(center.x - width / 2, center.y - height / 2, width,
+                       height);
+}
+
+- (UIView *)newDefaultMarkerOverlayView {
+  return
+      [[UIImageView alloc] initWithImage:[GMSMarker markerImageWithColor:nil]];
+}
+
+// Inverse of mapRectForSize
+- (double)zoomForMapPointsPerPoint:(double)mapPointsPerPoint {
+  double zoom = log2(MKMapSizeWorld.width / (256.0 * mapPointsPerPoint));
+  return MAX(MIN(zoom, (double)kGMSMaxZoomLevel), (double)kGMSMinZoomLevel);
+}
+
+- (void)renderBaseMap {
+  if (_warmupMapView) {
+    // Retry a swap that couldn't run (e.g. view was off-window)
+    [self scheduleSwap];
+    return;
+  }
+  [self startWarmup];
+}
+
+- (void)cancelBaseRender {
+  [self destroyWarmupMapView];
+}
+
+#pragma mark - Warmup
+
+// "" resolves to the demo map ID (see LuggGMSMapIDFromString), so both
+// share a pool bucket
+- (NSString *)poolKey {
+  return self.mapId.length > 0 ? self.mapId : @"DEMO_MAP_ID";
+}
+
+- (void)startWarmup {
+  UIView *wrapperView = self.wrapperView;
+  if (!wrapperView)
+    return;
+
+  _snapshotReady = NO;
+
+  GMSMapView *mapView = DequeueStaticMapView([self poolKey]);
+  if (mapView) {
+    mapView.frame = wrapperView.bounds;
+    [mapView moveCamera:[GMSCameraUpdate setTarget:self.coordinate
+                                              zoom:(float)self.zoom]];
+  } else {
+    GMSCameraPosition *camera =
+        [GMSCameraPosition cameraWithLatitude:self.coordinate.latitude
+                                    longitude:self.coordinate.longitude
+                                         zoom:(float)self.zoom];
+
+    GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
+    options.frame = wrapperView.bounds;
+    options.camera = camera;
+    options.mapID = LuggGMSMapIDFromString(self.mapId);
+
+    mapView = [[GMSMapView alloc] initWithOptions:options];
+  }
+
+  mapView.autoresizingMask =
+      UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+  mapView.delegate = self;
+  mapView.userInteractionEnabled = NO;
+  mapView.preferredFrameRate = kGMSFrameRateConservative;
+  mapView.paddingAdjustmentBehavior = kGMSMapViewPaddingAdjustmentBehaviorNever;
+  // Frames the camera like the inset-shifted projection (and clears stale
+  // padding on pooled views)
+  mapView.padding = self.edgeInsets;
+  mapView.mapType = LuggGMSMapTypeFromMapType(self.mapType);
+  mapView.overrideUserInterfaceStyle = LuggInterfaceStyleFromTheme(self.theme);
+
+  _warmupMapView = mapView;
+  [wrapperView insertSubview:mapView atIndex:0];
+}
+
+- (void)destroyWarmupMapView {
+  if (!_warmupMapView)
+    return;
+  _warmupMapView.delegate = nil;
+  [_warmupMapView removeFromSuperview];
+  EnqueueStaticMapView([self poolKey], _warmupMapView);
+  _warmupMapView = nil;
+}
+
+// Once the map is stable, swap the live map with its image and release the
+// map view. The image render and map teardown are expensive, so they run
+// outside scroll tracking; the live map keeps displaying (and loading
+// tiles) until then.
+- (void)scheduleSwap {
+  if (_swapScheduled || !_warmupMapView || !_snapshotReady ||
+      !_warmupMapView.window)
+    return;
+
+  _swapScheduled = YES;
+  __weak GoogleStaticMapProvider *weakSelf = self;
+  [[NSRunLoop mainRunLoop] performInModes:@[ NSDefaultRunLoopMode ]
+                                    block:^{
+                                      GoogleStaticMapProvider *strongSelf =
+                                          weakSelf;
+                                      if (!strongSelf)
+                                        return;
+                                      strongSelf->_swapScheduled = NO;
+                                      [strongSelf performSwap];
+                                    }];
+}
+
+- (void)performSwap {
+  // Tiles can invalidate (or the view leave the window) between scheduling
+  // and this runloop pass; the next snapshotReady or resumeAnimations
+  // retries
+  if (!_warmupMapView || !_snapshotReady || !_warmupMapView.window)
+    return;
+
+  UIImageView *imageView = [_warmupMapView lugg_snapshotImageView];
+  if (!imageView)
+    return;
+
+  [self displayBaseImage:imageView.image fromCache:NO];
+  [self destroyWarmupMapView];
+}
+
+#pragma mark - GMSMapViewDelegate
+
+- (void)mapViewDidStartTileRendering:(GMSMapView *)mapView {
+  _snapshotReady = NO;
+}
+
+// Fires for tiles that failed permanently too, so it can't gate the swap:
+// capturing here cached blank tiles under the static key with no way to
+// recover. The visible warmup map has rendered what it can; show the
+// overlays now instead of waiting for the swap, which is deferred while
+// scrolling
+- (void)mapViewDidFinishTileRendering:(GMSMapView *)mapView {
+  [self revealOverlays];
+}
+
+// Stable per the SDK: tiles loaded, labels and overlays rendered. The only
+// signal that the render is complete, so the only one that captures and
+// caches. Without it (e.g. offline) the live map stays until the view
+// leaves the window, and a fresh warmup runs on return.
+- (void)mapViewSnapshotReady:(GMSMapView *)mapView {
+  _snapshotReady = YES;
+  [self revealOverlays];
+  [self scheduleSwap];
+}
+
+@end

package/ios/core/MKPolylineAnimator.m

@@ -35,8 +35,9 @@
   NSArray<NSNumber *> *_cumulativeDistances;
   CGFloat _totalLength;
   CGColorSpaceRef _colorSpace;
-  RGBAComponents *_colorCache;
-  NSUInteger _colorCacheCount;
+  // Immutable snapshot read by background draws; rebuilt (never mutated)
+  // on the main thread
+  NSData *_colorCacheData;
 }
 
 - (id)initWithPolyline:(MKPolyline *)polyline {
@@ -61,7 +62,6 @@
 
 - (void)dealloc {
   [self stopAnimation];
-  free(_colorCache);
   if (_colorSpace) {
     CGColorSpaceRelease(_colorSpace);
     _colorSpace = NULL;
@@ -123,20 +123,25 @@
   _displayLink.paused = NO;
 }
 
-- (NSUInteger)indexForDistance:(CGFloat)distance {
+- (NSUInteger)indexForDistance:(CGFloat)distance
+                   inDistances:(NSArray<NSNumber *> *)distances {
+  if (distances.count < 2) {
+    return 0;
+  }
+
   NSUInteger left = 0;
-  NSUInteger right = _cumulativeDistances.count - 1;
+  NSUInteger right = distances.count - 1;
 
   while (left < right) {
     NSUInteger mid = (left + right + 1) / 2;
-    if (_cumulativeDistances[mid].doubleValue <= distance) {
+    if (distances[mid].doubleValue <= distance) {
       left = mid;
     } else {
       right = mid - 1;
     }
   }
 
-  return MIN(left, _cumulativeDistances.count - 2);
+  return MIN(left, distances.count - 2);
 }
 
 - (CGFloat)applyEasing:(CGFloat)t {
@@ -208,44 +213,52 @@
 }
 
 - (void)rebuildColorCache {
-  free(_colorCache);
-  _colorCache = NULL;
-  _colorCacheCount = _strokeColors.count;
-  if (_colorCacheCount == 0) return;
-
-  _colorCache = (RGBAComponents *)malloc(sizeof(RGBAComponents) * _colorCacheCount);
-  for (NSUInteger i = 0; i < _colorCacheCount; i++) {
-    [_strokeColors[i] getRed:&_colorCache[i].r
-                       green:&_colorCache[i].g
-                        blue:&_colorCache[i].b
-                       alpha:&_colorCache[i].a];
+  NSUInteger count = _strokeColors.count;
+  if (count == 0) {
+    _colorCacheData = nil;
+    return;
+  }
+
+  NSMutableData *data =
+      [NSMutableData dataWithLength:sizeof(RGBAComponents) * count];
+  RGBAComponents *cache = (RGBAComponents *)data.mutableBytes;
+  for (NSUInteger i = 0; i < count; i++) {
+    [_strokeColors[i] getRed:&cache[i].r
+                       green:&cache[i].g
+                        blue:&cache[i].b
+                       alpha:&cache[i].a];
   }
+  _colorCacheData = data;
 }
 
 - (void)colorAtGradientPosition:(CGFloat)position rgba:(RGBAComponents *)out {
-  if (_colorCacheCount == 0) {
+  NSData *cacheData = _colorCacheData;
+  const RGBAComponents *cache = (const RGBAComponents *)cacheData.bytes;
+  NSUInteger count = cacheData.length / sizeof(RGBAComponents);
+
+  if (count == 0) {
     CGFloat r, g, b, a;
     [self.strokeColor getRed:&r green:&g blue:&b alpha:&a];
     *out = (RGBAComponents){r, g, b, a};
     return;
   }
-  if (_colorCacheCount == 1) {
-    *out = _colorCache[0];
+  if (count == 1) {
+    *out = cache[0];
     return;
   }
 
   position = MAX(0, MIN(1, position));
-  CGFloat scaledPos = position * (_colorCacheCount - 1);
+  CGFloat scaledPos = position * (count - 1);
   NSUInteger index = (NSUInteger)scaledPos;
   CGFloat t = scaledPos - index;
 
-  if (index >= _colorCacheCount - 1) {
-    *out = _colorCache[_colorCacheCount - 1];
+  if (index >= count - 1) {
+    *out = cache[count - 1];
     return;
   }
 
-  RGBAComponents c1 = _colorCache[index];
-  RGBAComponents c2 = _colorCache[index + 1];
+  RGBAComponents c1 = cache[index];
+  RGBAComponents c2 = cache[index + 1];
   out->r = c1.r + (c2.r - c1.r) * t;
   out->g = c1.g + (c2.g - c1.g) * t;
   out->b = c1.b + (c2.b - c1.b) * t;
@@ -272,13 +285,20 @@
   CGContextSetLineCap(context, self.lineCap);
   CGContextSetLineJoin(context, self.lineJoin);
 
-  NSUInteger segmentCount = _polyline.pointCount - 1;
-  if (segmentCount == 0) {
+  // drawMapRect: runs on MapKit's background render queues while
+  // updatePolyline: swaps these ivars on the main thread; snapshot them so
+  // one frame draws from a consistent pair
+  MKPolyline *polyline = _polyline;
+  NSArray<NSNumber *> *distances = _cumulativeDistances;
+  CGFloat totalLength = _totalLength;
+
+  if (polyline.pointCount < 2) {
     return;
   }
+  NSUInteger segmentCount = polyline.pointCount - 1;
 
   // Snake animation: grow from start, then shrink from start
-  if (_animated && _polyline.pointCount > 1 && _totalLength > 0) {
+  if (_animated && distances.count > 1 && totalLength > 0) {
     CGFloat trailLength = MAX(0.01, MIN(1.0, _animatedOptions.trailLength));
     CGFloat maxProgress = (trailLength < 1.0) ? 1.0 : 2.0;
     CGFloat progress = MIN(_animationProgress, maxProgress);
@@ -287,15 +307,15 @@
     CGFloat headDist, tailDist;
 
     if (trailLength < 1.0) {
-      headDist = easedProgress * _totalLength;
-      tailDist = MAX(0, headDist - _totalLength * trailLength);
+      headDist = easedProgress * totalLength;
+      tailDist = MAX(0, headDist - totalLength * trailLength);
     } else if (easedProgress <= 1.0) {
       tailDist = 0;
-      headDist = easedProgress * _totalLength;
+      headDist = easedProgress * totalLength;
     } else {
       CGFloat shrinkProgress = easedProgress - 1.0;
-      tailDist = shrinkProgress * _totalLength;
-      headDist = _totalLength;
+      tailDist = shrinkProgress * totalLength;
+      headDist = totalLength;
     }
 
     if (headDist <= tailDist) {
@@ -303,19 +323,23 @@
     }
 
     CGFloat visibleLength = headDist - tailDist;
-    NSUInteger startIndex = [self indexForDistance:tailDist];
-    NSUInteger endIndex = [self indexForDistance:headDist];
+    NSUInteger startIndex = [self indexForDistance:tailDist inDistances:distances];
+    NSUInteger endIndex = [self indexForDistance:headDist inDistances:distances];
+
+    // distances may lag behind the polyline (or vice versa) for a frame;
+    // never index past either
+    NSUInteger maxSegment = MIN(segmentCount, distances.count - 1);
 
-    for (NSUInteger i = startIndex; i <= endIndex && i < segmentCount; i++) {
-      CGFloat segStartDist = _cumulativeDistances[i].doubleValue;
-      CGFloat segEndDist = _cumulativeDistances[i + 1].doubleValue;
+    for (NSUInteger i = startIndex; i <= endIndex && i < maxSegment; i++) {
+      CGFloat segStartDist = distances[i].doubleValue;
+      CGFloat segEndDist = distances[i + 1].doubleValue;
 
       if (segEndDist <= tailDist || segStartDist >= headDist) {
         continue;
       }
 
-      CGPoint segStart = [self pointForMapPoint:_polyline.points[i]];
-      CGPoint segEnd = [self pointForMapPoint:_polyline.points[i + 1]];
+      CGPoint segStart = [self pointForMapPoint:polyline.points[i]];
+      CGPoint segEnd = [self pointForMapPoint:polyline.points[i + 1]];
 
       CGPoint drawStart = segStart;
       CGPoint drawEnd = segEnd;
@@ -368,8 +392,8 @@
   // Static gradient rendering
   if (_strokeColors && _strokeColors.count > 1) {
     for (NSUInteger i = 0; i < segmentCount; i++) {
-      CGPoint startPoint = [self pointForMapPoint:_polyline.points[i]];
-      CGPoint endPoint = [self pointForMapPoint:_polyline.points[i + 1]];
+      CGPoint startPoint = [self pointForMapPoint:polyline.points[i]];
+      CGPoint endPoint = [self pointForMapPoint:polyline.points[i + 1]];
 
       CGFloat gradientStart = (CGFloat)i / segmentCount;
       CGFloat gradientEnd = (CGFloat)(i + 1) / segmentCount;

package/ios/core/MapEdgeInsets.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#import <UIKit/UIKit.h>
+
+static inline CGPoint LuggMapInsetOffset(UIEdgeInsets insets) {
+  return CGPointMake((insets.left - insets.right) / 2.0,
+                     (insets.top - insets.bottom) / 2.0);
+}
+
+static inline UIEdgeInsets
+LuggMapInsetsAtProgress(UIEdgeInsets from, UIEdgeInsets to, CGFloat progress) {
+  // Ease out cubic
+  CGFloat t = 1.0 - (1.0 - progress) * (1.0 - progress) * (1.0 - progress);
+  return UIEdgeInsetsMake(from.top + (to.top - from.top) * t,
+                          from.left + (to.left - from.left) * t,
+                          from.bottom + (to.bottom - from.bottom) * t,
+                          from.right + (to.right - from.right) * t);
+}