@lugg/maps 1.0.0-beta.17 → 1.0.0-beta.19

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/MapProviderDelegate.h

@@ -13,6 +13,8 @@ NS_ASSUME_NONNULL_BEGIN
 
 @protocol MapProviderDelegate <NSObject>
 - (void)mapProviderDidReady;
+- (void)mapProviderDidFinishStaticSnapshot;
+- (void)mapProviderDidCaptureStaticImage:(UIImage *)image;
 - (void)mapProviderDidMoveCamera:(double)latitude
                        longitude:(double)longitude
                             zoom:(double)zoom
@@ -36,6 +38,10 @@ NS_ASSUME_NONNULL_BEGIN
 @property(nonatomic, weak, nullable) id<MapProviderDelegate> delegate;
 @property(nonatomic, readonly) BOOL isMapReady;
 
+// Non-interactive static map. Must be set before initializeMapInView.
+// Once fully rendered, the live map is replaced with a snapshot image.
+@property(nonatomic, assign) BOOL staticMode;
+
 - (void)initializeMapInView:(UIView *)wrapperView
           initialCoordinate:(CLLocationCoordinate2D)coordinate
                 initialZoom:(double)zoom;

package/ios/core/StaticMapProviderBase.h

@@ -0,0 +1,70 @@
+#import "MapProviderDelegate.h"
+#import <MapKit/MapKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Projects a coordinate into view points for a static map covering mapRect
+CGPoint LuggStaticPointForCoordinate(MKMapRect mapRect, CGSize size,
+                                     CLLocationCoordinate2D coordinate);
+
+/**
+ * Shared behavior for static (non-interactive) map providers - the iOS
+ * equivalent of Android's lite mode. The base map renders asynchronously
+ * (subclass-specific), so static maps keep loading while the user scrolls
+ * without blocking the main thread.
+ *
+ * Markers are live views positioned over the base map via a mercator
+ * projection (mirroring Android's live markers on lite maps), so async
+ * marker content (e.g. remote images) still updates when it loads.
+ * Polylines, polygons, circles and ground overlays are drawn into a
+ * single CoreGraphics overlay view. All overlays stay hidden over the
+ * placeholder and reveal together with the base map. Tile overlays are
+ * not supported.
+ */
+@interface StaticMapProviderBase : NSObject <MapProvider>
+
+/// Previously captured base map for the same cache key; when set, the base
+/// render is skipped and the image is shown immediately.
+@property(nonatomic, strong, nullable) UIImage *cachedBaseImage;
+
+// State for subclasses
+@property(nonatomic, readonly, nullable) UIView *wrapperView;
+@property(nonatomic, readonly) CLLocationCoordinate2D coordinate;
+@property(nonatomic, readonly) double zoom;
+@property(nonatomic, readonly) MKMapRect mapRect;
+@property(nonatomic, readonly) CGSize projectedSize;
+@property(nonatomic, readonly) UIEdgeInsets edgeInsets;
+@property(nonatomic, readonly) BOOL projectionReady;
+@property(nonatomic, readonly) facebook::react::LuggMapViewMapType mapType;
+@property(nonatomic, readonly) facebook::react::LuggMapViewTheme theme;
+
+/// Shows the base image below the overlays, emits the static snapshot
+/// delegate callbacks and marks the base render done.
+- (void)displayBaseImage:(UIImage *)image fromCache:(BOOL)fromCache;
+
+/// Shows the marker and shape overlays (idempotent). Called automatically
+/// when the base image displays; subclasses whose base map is already
+/// visible earlier (e.g. a live warmup map) can call it sooner.
+- (void)revealOverlays;
+
+#pragma mark - Subclass hooks
+
+/// The map rect the base render covers for the given view size; must match
+/// the SDK's camera framing so overlays align with the base map exactly.
+- (MKMapRect)mapRectForSize:(CGSize)size;
+
+/// Overlay view shown for markers without a custom child view.
+- (UIView *)newDefaultMarkerOverlayView;
+
+/// Starts rendering the base map for the current projection (guaranteed
+/// projectionReady, no cached image). Called after mount (once initial
+/// props have applied), after a resize, and from resumeAnimations to retry
+/// a failed or cancelled render (e.g. device back online).
+- (void)renderBaseMap;
+
+/// Cancels an in-flight base render (resize or teardown).
+- (void)cancelBaseRender;
+
+@end
+
+NS_ASSUME_NONNULL_END