@lugg/maps 1.0.0-beta.0 → 1.0.0-beta.10

package/ios/core/GMSPolylineAnimator.m

@@ -2,6 +2,7 @@
 #import <QuartzCore/QuartzCore.h>
 
 static const NSUInteger kMaxAnimationSpans = 16;
+static const NSUInteger kMaxGradientSpans = 512;
 
 @interface GMSDisplayLinkProxy : NSObject
 @property(nonatomic, weak) id target;
@@ -272,12 +273,14 @@ static const NSUInteger kMaxAnimationSpans = 16;
 - (NSArray<GMSStyleSpan *> *)createGradientSpans {
   NSMutableArray<GMSStyleSpan *> *spans = [NSMutableArray array];
   NSUInteger segmentCount = self.coordinates.count - 1;
+  NSUInteger spanCount = MIN(segmentCount, kMaxGradientSpans);
+  double segmentsPerSpan = (double)segmentCount / spanCount;
 
-  for (NSUInteger i = 0; i < segmentCount; i++) {
-    CGFloat position = (CGFloat)i / (CGFloat)segmentCount;
+  for (NSUInteger i = 0; i < spanCount; i++) {
+    CGFloat position = ((CGFloat)i + 0.5) / spanCount;
     UIColor *color = [self colorAtGradientPosition:position];
     GMSStrokeStyle *style = [GMSStrokeStyle solidColor:color];
-    [spans addObject:[GMSStyleSpan spanWithStyle:style]];
+    [spans addObject:[GMSStyleSpan spanWithStyle:style segments:segmentsPerSpan]];
   }
 
   return spans;

package/ios/core/GoogleMapProvider.mm

@@ -1,28 +1,48 @@
 #import "GoogleMapProvider.h"
+
+using facebook::react::LuggMapViewInsetAdjustment;
+using facebook::react::LuggMapViewMapType;
+using facebook::react::LuggMapViewPoiFilterMode;
+using facebook::react::LuggMapViewTheme;
+
+#import "../LuggCalloutView.h"
+#import "../LuggCircleView.h"
+#import "../LuggGroundOverlayView.h"
 #import "../LuggMarkerView.h"
 #import "../LuggPolygonView.h"
 #import "../LuggPolylineView.h"
+#import "../LuggTileOverlayView.h"
 #import "GMSPolylineAnimator.h"
 #import "PolylineAnimatorBase.h"
 
 static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
 @interface GoogleMapProvider () <
-    LuggMarkerViewDelegate, LuggPolylineViewDelegate, LuggPolygonViewDelegate>
+    LuggMarkerViewDelegate, LuggCalloutViewDelegate, LuggPolylineViewDelegate,
+    LuggPolygonViewDelegate, LuggCircleViewDelegate,
+    LuggGroundOverlayViewDelegate, LuggTileOverlayViewDelegate>
 @end
 
 @implementation GoogleMapProvider {
+  UIView *_wrapperView;
   GMSMapView *_mapView;
   BOOL _isMapReady;
   BOOL _isDragging;
-  NSInteger _theme;
+  LuggMapViewTheme _theme;
   UIEdgeInsets _edgeInsets;
   NSMutableArray<LuggMarkerView *> *_pendingMarkerViews;
   NSMutableArray<LuggPolylineView *> *_pendingPolylineViews;
   NSMutableArray<LuggPolygonView *> *_pendingPolygonViews;
+  NSMutableArray<LuggCircleView *> *_pendingCircleViews;
+  NSMutableArray<LuggGroundOverlayView *> *_pendingGroundOverlayViews;
+  NSMutableArray<LuggTileOverlayView *> *_pendingTileOverlayViews;
   NSMapTable<LuggPolylineView *, GMSPolylineAnimator *> *_polylineAnimators;
   NSMapTable<GMSPolygon *, LuggPolygonView *> *_polygonToViewMap;
+  NSMapTable<GMSCircle *, LuggCircleView *> *_circleToViewMap;
   NSMapTable<GMSMarker *, LuggMarkerView *> *_markerToViewMap;
+  NSMapTable<GMSGroundOverlay *, LuggGroundOverlayView *>
+      *_groundOverlayToViewMap;
+  LuggMarkerView *_activeNonBubbledMarker;
 
   // Edge insets animation
   CADisplayLink *_edgeInsetsDisplayLink;
@@ -41,9 +61,14 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
     _pendingMarkerViews = [NSMutableArray array];
     _pendingPolylineViews = [NSMutableArray array];
     _pendingPolygonViews = [NSMutableArray array];
+    _pendingCircleViews = [NSMutableArray array];
+    _pendingGroundOverlayViews = [NSMutableArray array];
+    _pendingTileOverlayViews = [NSMutableArray array];
     _polylineAnimators = [NSMapTable weakToStrongObjectsMapTable];
     _polygonToViewMap = [NSMapTable strongToWeakObjectsMapTable];
+    _circleToViewMap = [NSMapTable strongToWeakObjectsMapTable];
     _markerToViewMap = [NSMapTable strongToWeakObjectsMapTable];
+    _groundOverlayToViewMap = [NSMapTable strongToWeakObjectsMapTable];
   }
   return self;
 }
@@ -88,6 +113,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   _mapView.paddingAdjustmentBehavior =
       kGMSMapViewPaddingAdjustmentBehaviorNever;
 
+  _wrapperView = wrapperView;
   [wrapperView addSubview:_mapView];
 
   [self applyTheme];
@@ -96,6 +122,9 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [self processPendingMarkers];
   [self processPendingPolylines];
   [self processPendingPolygons];
+  [self processPendingCircles];
+  [self processPendingGroundOverlays];
+  [self processPendingTileOverlays];
 
   [_delegate mapProviderDidReady];
 }
@@ -105,9 +134,14 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [_pendingMarkerViews removeAllObjects];
   [_pendingPolylineViews removeAllObjects];
   [_pendingPolygonViews removeAllObjects];
+  [_pendingCircleViews removeAllObjects];
+  [_pendingGroundOverlayViews removeAllObjects];
+  [_pendingTileOverlayViews removeAllObjects];
   [_polylineAnimators removeAllObjects];
   [_polygonToViewMap removeAllObjects];
+  [_circleToViewMap removeAllObjects];
   [_markerToViewMap removeAllObjects];
+  [_groundOverlayToViewMap removeAllObjects];
   [_mapView clear];
   [_mapView removeFromSuperview];
   _mapView = nil;
@@ -136,7 +170,43 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   _mapView.myLocationEnabled = enabled;
 }
 
-- (void)setTheme:(NSInteger)theme {
+- (void)setInsetAdjustment:(LuggMapViewInsetAdjustment)insetAdjustment {
+  _mapView.paddingAdjustmentBehavior =
+      (insetAdjustment == LuggMapViewInsetAdjustment::Automatic)
+          ? kGMSMapViewPaddingAdjustmentBehaviorAlways
+          : kGMSMapViewPaddingAdjustmentBehaviorNever;
+}
+
+- (void)setPoiEnabled:(BOOL)enabled {
+}
+
+- (void)setPoiFilterMode:(LuggMapViewPoiFilterMode)mode {
+}
+
+- (void)setPoiFilterCategories:(NSArray<NSString *> *)categories {
+}
+
+- (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;
+  }
+}
+
+- (void)setTheme:(LuggMapViewTheme)theme {
   _theme = theme;
   [self applyTheme];
 }
@@ -146,13 +216,13 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
     return;
 
   switch (_theme) {
-  case 1: // Dark
+  case LuggMapViewTheme::Dark:
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleDark;
     break;
-  case 0: // Light
+  case LuggMapViewTheme::Light:
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
     break;
-  default: // System
+  default:
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleUnspecified;
     break;
   }
@@ -248,6 +318,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
                             longitude:position.target.longitude
                                  zoom:position.zoom
                               gesture:_isDragging];
+  [self positionNonBubbledCallout];
 }
 
 - (void)mapView:(GMSMapView *)mapView
@@ -267,6 +338,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
 - (void)mapView:(GMSMapView *)mapView
     didTapAtCoordinate:(CLLocationCoordinate2D)coordinate {
+  [self dismissNonBubbledCallout];
   CGPoint point = [mapView.projection pointForCoordinate:coordinate];
   [_delegate mapProviderDidPress:coordinate.latitude
                        longitude:coordinate.longitude
@@ -284,22 +356,55 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 }
 
 - (void)mapView:(GMSMapView *)mapView didTapOverlay:(GMSOverlay *)overlay {
-  if (![overlay isKindOfClass:[GMSPolygon class]])
-    return;
-
-  GMSPolygon *polygon = (GMSPolygon *)overlay;
-  LuggPolygonView *polygonView = [_polygonToViewMap objectForKey:polygon];
-  if (!polygonView || !polygonView.tappable)
-    return;
-
-  [polygonView emitPressEvent];
+  if ([overlay isKindOfClass:[GMSPolygon class]]) {
+    GMSPolygon *polygon = (GMSPolygon *)overlay;
+    LuggPolygonView *polygonView = [_polygonToViewMap objectForKey:polygon];
+    if (polygonView && polygonView.tappable) {
+      [polygonView emitPressEvent];
+    }
+  } else if ([overlay isKindOfClass:[GMSCircle class]]) {
+    GMSCircle *circle = (GMSCircle *)overlay;
+    LuggCircleView *circleView = [_circleToViewMap objectForKey:circle];
+    if (circleView && circleView.tappable) {
+      [circleView emitPressEvent];
+    }
+  } else if ([overlay isKindOfClass:[GMSGroundOverlay class]]) {
+    GMSGroundOverlay *groundOverlay = (GMSGroundOverlay *)overlay;
+    LuggGroundOverlayView *groundOverlayView =
+        [_groundOverlayToViewMap objectForKey:groundOverlay];
+    if (groundOverlayView && groundOverlayView.tappable) {
+      [groundOverlayView emitPressEvent];
+    }
+  }
 }
 
 - (BOOL)mapView:(GMSMapView *)mapView didTapMarker:(GMSMarker *)marker {
+  [self dismissNonBubbledCallout];
+
   LuggMarkerView *markerView = [_markerToViewMap objectForKey:marker];
   if (markerView) {
     CGPoint point = [_mapView.projection pointForCoordinate:marker.position];
     [markerView emitPressEventWithPoint:point];
+
+    LuggCalloutView *calloutView = markerView.calloutView;
+    if (calloutView && calloutView.hasCustomContent) {
+      if (markerView.centerOnPress) {
+        [mapView animateToLocation:marker.position];
+      }
+
+      mapView.selectedMarker = marker;
+
+      if (!calloutView.bubbled) {
+        [self showNonBubbledCallout:markerView];
+      }
+
+      return YES;
+    }
+
+    if (!markerView.centerOnPress) {
+      mapView.selectedMarker = marker;
+      return YES;
+    }
   }
   return NO;
 }
@@ -332,6 +437,129 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   }
 }
 
+- (UIView *)rasterizedCalloutView:(LuggCalloutView *)calloutView {
+  UIView *contentView = calloutView.contentView;
+  [contentView layoutIfNeeded];
+
+  CGSize size = contentView.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];
+  UIImage *image =
+      [renderer imageWithActions:^(UIGraphicsImageRendererContext *context) {
+        [contentView.layer renderInContext:context.CGContext];
+      }];
+
+  return [[UIImageView alloc] initWithImage:image];
+}
+
+- (UIView *)mapView:(GMSMapView *)mapView markerInfoWindow:(GMSMarker *)marker {
+  // Non-bubbled callouts are rendered as live views, not info windows
+  return nil;
+}
+
+- (UIView *)mapView:(GMSMapView *)mapView
+    markerInfoContents:(GMSMarker *)marker {
+  LuggMarkerView *markerView = [_markerToViewMap objectForKey:marker];
+  if (!markerView || !markerView.calloutView ||
+      !markerView.calloutView.hasCustomContent)
+    return nil;
+
+  if (markerView.calloutView.bubbled) {
+    return [self rasterizedCalloutView:markerView.calloutView];
+  }
+
+  return nil;
+}
+
+- (void)showNonBubbledCallout:(LuggMarkerView *)markerView {
+  [self dismissNonBubbledCallout];
+  _mapView.selectedMarker = nil;
+
+  LuggCalloutView *calloutView = markerView.calloutView;
+  UIView *contentView = calloutView.contentView;
+  [contentView removeFromSuperview];
+
+  contentView.userInteractionEnabled = YES;
+  contentView.hidden = YES;
+  calloutView.delegate = self;
+  [_wrapperView addSubview:contentView];
+
+  _activeNonBubbledMarker = markerView;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self positionNonBubbledCallout];
+    contentView.hidden = NO;
+  });
+}
+
+- (void)calloutViewDidUpdate:(LuggCalloutView *)calloutView {
+  [self positionNonBubbledCallout];
+}
+
+- (void)dismissNonBubbledCallout {
+  if (!_activeNonBubbledMarker)
+    return;
+
+  LuggCalloutView *calloutView = _activeNonBubbledMarker.calloutView;
+  calloutView.delegate = nil;
+  [calloutView.contentView removeFromSuperview];
+  _activeNonBubbledMarker = nil;
+}
+
+- (void)positionNonBubbledCallout {
+  if (!_activeNonBubbledMarker)
+    return;
+
+  LuggCalloutView *calloutView = _activeNonBubbledMarker.calloutView;
+  UIView *contentView = calloutView.contentView;
+  CGSize contentSize = contentView.bounds.size;
+  if (contentSize.width <= 0 || contentSize.height <= 0)
+    return;
+
+  CGPoint offset = calloutView.offset;
+  CGPoint point = [_mapView.projection
+      pointForCoordinate:_activeNonBubbledMarker.coordinate];
+
+  UIView *iconView = _activeNonBubbledMarker.iconView;
+  CGFloat markerHeight =
+      iconView.bounds.size.height * _activeNonBubbledMarker.scale;
+
+  contentView.center =
+      CGPointMake(point.x + offset.x,
+                  point.y - markerHeight * _activeNonBubbledMarker.anchor.y -
+                      contentSize.height / 2.0 + offset.y);
+}
+
+- (void)showCalloutForMarkerView:(LuggMarkerView *)markerView {
+  LuggCalloutView *calloutView = markerView.calloutView;
+  if (calloutView && calloutView.hasCustomContent) {
+    [self dismissNonBubbledCallout];
+    GMSMarker *marker = (GMSMarker *)markerView.marker;
+    if (calloutView.bubbled) {
+      _mapView.selectedMarker = marker;
+    } else {
+      [self showNonBubbledCallout:markerView];
+    }
+    return;
+  }
+
+  if (markerView.title.length > 0) {
+    _mapView.selectedMarker = (GMSMarker *)markerView.marker;
+  }
+}
+
+- (void)hideCalloutForMarkerView:(LuggMarkerView *)markerView {
+  [self dismissNonBubbledCallout];
+  if (_mapView.selectedMarker == markerView.marker) {
+    _mapView.selectedMarker = nil;
+  }
+}
+
 #pragma mark - MarkerViewDelegate
 
 - (void)markerViewDidLayout:(LuggMarkerView *)markerView {
@@ -354,6 +582,24 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [self syncPolygonView:polygonView];
 }
 
+#pragma mark - CircleViewDelegate
+
+- (void)circleViewDidUpdate:(LuggCircleView *)circleView {
+  [self syncCircleView:circleView];
+}
+
+#pragma mark - GroundOverlayViewDelegate
+
+- (void)groundOverlayViewDidUpdate:(LuggGroundOverlayView *)groundOverlayView {
+  [self syncGroundOverlayView:groundOverlayView];
+}
+
+#pragma mark - TileOverlayViewDelegate
+
+- (void)tileOverlayViewDidUpdate:(LuggTileOverlayView *)tileOverlayView {
+  [self syncTileOverlayView:tileOverlayView];
+}
+
 #pragma mark - Marker Management
 
 - (void)addMarkerView:(LuggMarkerView *)markerView {
@@ -387,8 +633,10 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
   GMSAdvancedMarker *marker = (GMSAdvancedMarker *)markerView.marker;
   marker.position = markerView.coordinate;
-  marker.title = markerView.title;
-  marker.snippet = markerView.markerDescription;
+  marker.title = markerView.title.length > 0 ? markerView.title : nil;
+  marker.snippet = markerView.markerDescription.length > 0
+                       ? markerView.markerDescription
+                       : nil;
   marker.zIndex = (int)markerView.zIndex;
   marker.draggable = markerView.draggable;
   [self applyMarkerStyle:markerView marker:marker];
@@ -410,8 +658,10 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
   GMSAdvancedMarker *marker = [[GMSAdvancedMarker alloc] init];
   marker.position = markerView.coordinate;
-  marker.title = markerView.title;
-  marker.snippet = markerView.markerDescription;
+  marker.title = markerView.title.length > 0 ? markerView.title : nil;
+  marker.snippet = markerView.markerDescription.length > 0
+                       ? markerView.markerDescription
+                       : nil;
   marker.zIndex = (int)markerView.zIndex;
   marker.draggable = markerView.draggable;
 
@@ -614,6 +864,243 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [_polygonToViewMap setObject:polygonView forKey:polygon];
 }
 
+#pragma mark - Circle Management
+
+- (void)addCircleView:(LuggCircleView *)circleView {
+  circleView.delegate = self;
+  [self syncCircleView:circleView];
+}
+
+- (void)removeCircleView:(LuggCircleView *)circleView {
+  GMSCircle *circle = (GMSCircle *)circleView.circle;
+  if (circle) {
+    [_circleToViewMap removeObjectForKey:circle];
+    circle.map = nil;
+    circleView.circle = nil;
+  }
+}
+
+- (void)syncCircleView:(LuggCircleView *)circleView {
+  if (!_mapView) {
+    if (![_pendingCircleViews containsObject:circleView]) {
+      [_pendingCircleViews addObject:circleView];
+    }
+    return;
+  }
+
+  if (!circleView.circle) {
+    [self addCircleViewToMap:circleView];
+    return;
+  }
+
+  GMSCircle *circle = (GMSCircle *)circleView.circle;
+  circle.position = circleView.center;
+  circle.radius = circleView.radius;
+  circle.fillColor = circleView.fillColor;
+  circle.strokeColor = circleView.strokeColor;
+  circle.strokeWidth = circleView.strokeWidth;
+  circle.zIndex = (int)circleView.zIndex;
+  circle.tappable = circleView.tappable;
+}
+
+- (void)processPendingCircles {
+  if (!_mapView)
+    return;
+
+  for (LuggCircleView *circleView in _pendingCircleViews) {
+    [self addCircleViewToMap:circleView];
+  }
+  [_pendingCircleViews removeAllObjects];
+}
+
+- (void)addCircleViewToMap:(LuggCircleView *)circleView {
+  if (!_mapView)
+    return;
+
+  GMSCircle *circle = [GMSCircle circleWithPosition:circleView.center
+                                             radius:circleView.radius];
+  circle.fillColor = circleView.fillColor;
+  circle.strokeColor = circleView.strokeColor;
+  circle.strokeWidth = circleView.strokeWidth;
+  circle.zIndex = (int)circleView.zIndex;
+  circle.tappable = circleView.tappable;
+  circle.map = _mapView;
+  circleView.circle = circle;
+  [_circleToViewMap setObject:circleView forKey:circle];
+}
+
+#pragma mark - Ground Overlay Management
+
+- (void)addGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  groundOverlayView.delegate = self;
+  [self syncGroundOverlayView:groundOverlayView];
+}
+
+- (void)removeGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  groundOverlayView.delegate = nil;
+  GMSGroundOverlay *overlay = (GMSGroundOverlay *)groundOverlayView.overlay;
+  if (overlay) {
+    [_groundOverlayToViewMap removeObjectForKey:overlay];
+    overlay.map = nil;
+    groundOverlayView.overlay = nil;
+  }
+}
+
+- (void)syncGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  if (!_mapView) {
+    if (![_pendingGroundOverlayViews containsObject:groundOverlayView]) {
+      [_pendingGroundOverlayViews addObject:groundOverlayView];
+    }
+    return;
+  }
+
+  NSString *imageUri = groundOverlayView.imageUri;
+  if (imageUri.length == 0)
+    return;
+
+  // Remove old overlay
+  GMSGroundOverlay *oldOverlay = (GMSGroundOverlay *)groundOverlayView.overlay;
+  if (oldOverlay) {
+    [_groundOverlayToViewMap removeObjectForKey:oldOverlay];
+    oldOverlay.map = nil;
+    groundOverlayView.overlay = nil;
+  }
+
+  // Load image and create overlay
+  NSURL *url = [NSURL URLWithString:imageUri];
+  if (!url)
+    return;
+
+  __weak __typeof(self) weakSelf = self;
+  __weak LuggGroundOverlayView *weakOverlayView = groundOverlayView;
+  dispatch_async(
+      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
+        NSData *data = [NSData dataWithContentsOfURL:url];
+        UIImage *image = data ? [UIImage imageWithData:data] : nil;
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [weakSelf addGroundOverlayToMap:weakOverlayView image:image];
+        });
+      });
+}
+
+- (void)addGroundOverlayToMap:(LuggGroundOverlayView *)groundOverlayView
+                        image:(UIImage *)image {
+  if (!_mapView || !groundOverlayView || !image)
+    return;
+
+  GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc]
+      initWithCoordinate:groundOverlayView.southwest
+              coordinate:groundOverlayView.northeast];
+
+  GMSGroundOverlay *overlay = [GMSGroundOverlay groundOverlayWithBounds:bounds
+                                                                   icon:image];
+  overlay.opacity = groundOverlayView.opacity;
+  overlay.bearing = groundOverlayView.bearing;
+  overlay.zIndex = (int)groundOverlayView.zIndex;
+  overlay.tappable = groundOverlayView.tappable;
+  overlay.map = _mapView;
+
+  groundOverlayView.overlay = overlay;
+  [_groundOverlayToViewMap setObject:groundOverlayView forKey:overlay];
+}
+
+- (void)processPendingGroundOverlays {
+  if (!_mapView)
+    return;
+
+  for (LuggGroundOverlayView *view in _pendingGroundOverlayViews) {
+    [self syncGroundOverlayView:view];
+  }
+  [_pendingGroundOverlayViews removeAllObjects];
+}
+
+#pragma mark - Tile Overlay Management
+
+- (void)addTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  tileOverlayView.delegate = self;
+  [self syncTileOverlayView:tileOverlayView];
+}
+
+- (void)removeTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  tileOverlayView.delegate = nil;
+  GMSTileLayer *tileLayer = (GMSTileLayer *)tileOverlayView.overlay;
+  if (tileLayer) {
+    tileLayer.map = nil;
+    tileOverlayView.overlay = nil;
+  }
+}
+
+- (void)syncTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  if (!_mapView) {
+    if (![_pendingTileOverlayViews containsObject:tileOverlayView]) {
+      [_pendingTileOverlayViews addObject:tileOverlayView];
+    }
+    return;
+  }
+
+  NSString *urlTemplate = tileOverlayView.urlTemplate;
+  if (urlTemplate.length == 0)
+    return;
+
+  // Remove old tile layer
+  GMSTileLayer *oldLayer = (GMSTileLayer *)tileOverlayView.overlay;
+  if (oldLayer) {
+    oldLayer.map = nil;
+    tileOverlayView.overlay = nil;
+  }
+
+  BOOL hasBounds = tileOverlayView.hasBounds;
+  CLLocationCoordinate2D sw = tileOverlayView.southwest;
+  CLLocationCoordinate2D ne = tileOverlayView.northeast;
+
+  GMSTileURLConstructor constructor = ^NSURL *(NSUInteger x, NSUInteger y,
+                                               NSUInteger zoom) {
+    if (hasBounds) {
+      double n = pow(2.0, zoom);
+      double tileSW_lat =
+          180.0 / M_PI * atan(sinh(M_PI * (1 - 2.0 * (y + 1) / n)));
+      double tileNE_lat = 180.0 / M_PI * atan(sinh(M_PI * (1 - 2.0 * y / n)));
+      double tileSW_lng = x / n * 360.0 - 180.0;
+      double tileNE_lng = (x + 1) / n * 360.0 - 180.0;
+
+      if (tileNE_lat < sw.latitude || tileSW_lat > ne.latitude ||
+          tileNE_lng < sw.longitude || tileSW_lng > ne.longitude) {
+        return nil;
+      }
+    }
+
+    NSString *urlString =
+        [urlTemplate stringByReplacingOccurrencesOfString:@"{x}"
+                                               withString:[@(x) stringValue]];
+    urlString =
+        [urlString stringByReplacingOccurrencesOfString:@"{y}"
+                                             withString:[@(y) stringValue]];
+    urlString =
+        [urlString stringByReplacingOccurrencesOfString:@"{z}"
+                                             withString:[@(zoom) stringValue]];
+    return [NSURL URLWithString:urlString];
+  };
+
+  GMSURLTileLayer *tileLayer =
+      [GMSURLTileLayer tileLayerWithURLConstructor:constructor];
+  tileLayer.tileSize = tileOverlayView.tileSize;
+  tileLayer.opacity = tileOverlayView.opacity;
+  tileLayer.zIndex = (int)tileOverlayView.zIndex;
+  tileLayer.map = _mapView;
+
+  tileOverlayView.overlay = tileLayer;
+}
+
+- (void)processPendingTileOverlays {
+  if (!_mapView)
+    return;
+
+  for (LuggTileOverlayView *view in _pendingTileOverlayViews) {
+    [self syncTileOverlayView:view];
+  }
+  [_pendingTileOverlayViews removeAllObjects];
+}
+
 #pragma mark - Lifecycle
 
 - (void)pauseAnimations {

package/ios/core/LuggAnnotationView.h

@@ -0,0 +1,12 @@
+#import <MapKit/MapKit.h>
+
+@interface LuggAnnotationView : MKAnnotationView
+@end
+
+@interface LuggMarkerAnnotationView : MKMarkerAnnotationView
+@end
+
+// Shared hit-test helpers for annotation views with subviews outside bounds
+BOOL LuggAnnotationPointInside(UIView *self, CGPoint point, UIEvent *event);
+UIView *_Nullable LuggAnnotationHitTest(UIView *self, CGPoint point,
+                                        UIEvent *event);