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

package/ios/core/AppleMapProvider.mm

@@ -1,8 +1,19 @@
 #import "AppleMapProvider.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 "../extensions/MKMapView+Zoom.h"
+#import "LuggAnnotationView.h"
 #import "MKPolylineAnimator.h"
 
 @interface AppleMarkerAnnotation : NSObject <MKAnnotation>
@@ -11,20 +22,100 @@
 @property(nonatomic, copy, nullable) NSString *subtitle;
 @property(nonatomic, strong) LuggMarkerView *markerView;
 @property(nonatomic, weak) MKAnnotationView *annotationView;
+@property(nonatomic, copy, nullable) dispatch_block_t pendingScaleAnimation;
 @end
 
 @implementation AppleMarkerAnnotation
 @end
 
+@interface GroundImageOverlay : NSObject <MKOverlay>
+@property(nonatomic, assign) CLLocationCoordinate2D coordinate;
+@property(nonatomic, assign) MKMapRect boundingMapRect;
+@property(nonatomic, strong) UIImage *image;
+@property(nonatomic, assign) CGFloat opacity;
+@end
+
+@implementation GroundImageOverlay
+@end
+
+@interface BoundedTileOverlay : MKTileOverlay
+@property(nonatomic, assign) CLLocationCoordinate2D southwest;
+@property(nonatomic, assign) CLLocationCoordinate2D northeast;
+@end
+
+@implementation BoundedTileOverlay
+
+static double tileToLat(NSInteger y, NSInteger z) {
+  double n = M_PI - 2.0 * M_PI * y / pow(2.0, z);
+  return 180.0 / M_PI * atan(0.5 * (exp(n) - exp(-n)));
+}
+
+static double tileToLng(NSInteger x, NSInteger z) {
+  return x / pow(2.0, z) * 360.0 - 180.0;
+}
+
+- (void)loadTileAtPath:(MKTileOverlayPath)path
+                result:(void (^)(NSData *_Nullable, NSError *_Nullable))result {
+  double tileSW_lat = tileToLat(path.y + 1, path.z);
+  double tileNE_lat = tileToLat(path.y, path.z);
+  double tileSW_lng = tileToLng(path.x, path.z);
+  double tileNE_lng = tileToLng(path.x + 1, path.z);
+
+  if (tileNE_lat < self.southwest.latitude ||
+      tileSW_lat > self.northeast.latitude ||
+      tileNE_lng < self.southwest.longitude ||
+      tileSW_lng > self.northeast.longitude) {
+    result(nil, nil);
+    return;
+  }
+
+  [super loadTileAtPath:path result:result];
+}
+
+@end
+
+@interface GroundImageOverlayRenderer : MKOverlayRenderer
+@property(nonatomic, strong) UIImage *image;
+@property(nonatomic, assign) CGFloat overlayOpacity;
+@end
+
+@implementation GroundImageOverlayRenderer
+
+- (void)drawMapRect:(MKMapRect)mapRect
+          zoomScale:(MKZoomScale)zoomScale
+          inContext:(CGContextRef)context {
+  MKMapRect overlayRect = self.overlay.boundingMapRect;
+  CGRect drawRect = [self rectForMapRect:overlayRect];
+
+  CGContextSaveGState(context);
+  CGContextSetAlpha(context, self.overlayOpacity);
+
+  // Flip the context for UIImage drawing
+  CGContextTranslateCTM(context, drawRect.origin.x,
+                        drawRect.origin.y + drawRect.size.height);
+  CGContextScaleCTM(context, 1.0, -1.0);
+
+  CGRect imageRect =
+      CGRectMake(0, 0, drawRect.size.width, drawRect.size.height);
+  CGContextDrawImage(context, imageRect, self.image.CGImage);
+
+  CGContextRestoreGState(context);
+}
+
+@end
+
 @implementation LuggAppleMapViewContent
 @end
 
 @interface AppleMapProvider () <
-    LuggMarkerViewDelegate, LuggPolylineViewDelegate, LuggPolygonViewDelegate,
+    LuggMarkerViewDelegate, LuggCalloutViewDelegate, LuggPolylineViewDelegate,
+    LuggPolygonViewDelegate, LuggCircleViewDelegate,
+    LuggGroundOverlayViewDelegate, LuggTileOverlayViewDelegate,
     UIGestureRecognizerDelegate>
 @end
 
 @implementation AppleMapProvider {
+  UIView *_wrapperView;
   LuggAppleMapViewContent *_mapView;
   BOOL _isMapReady;
   BOOL _isDragging;
@@ -32,14 +123,25 @@
   double _maxZoom;
   NSMapTable<id<MKOverlay>, LuggPolylineView *> *_overlayToPolylineMap;
   NSMapTable<id<MKOverlay>, LuggPolygonView *> *_overlayToPolygonMap;
+  NSMapTable<id<MKOverlay>, LuggCircleView *> *_overlayToCircleMap;
+  NSMapTable<id<MKOverlay>, LuggGroundOverlayView *>
+      *_overlayToGroundOverlayMap;
+  NSMapTable<id<MKOverlay>, LuggTileOverlayView *> *_overlayToTileOverlayMap;
   UITapGestureRecognizer *_tapGesture;
   UILongPressGestureRecognizer *_longPressGesture;
+  LuggMarkerView *_activeNonBubbledMarker;
+  BOOL _isReselectingAnnotation;
+  BOOL _isProgrammaticSelect;
   // Edge insets animation
   CADisplayLink *_edgeInsetsDisplayLink;
   UIEdgeInsets _edgeInsetsFrom;
   UIEdgeInsets _edgeInsetsTo;
+  UIEdgeInsets _edgeInsetsCurrent;
   CFTimeInterval _edgeInsetsAnimationStart;
   CFTimeInterval _edgeInsetsAnimationDuration;
+  BOOL _poiEnabled;
+  LuggMapViewPoiFilterMode _poiFilterMode;
+  NSArray<NSString *> *_poiFilterCategories;
 }
 
 @synthesize delegate = _delegate;
@@ -48,6 +150,12 @@
   if (self = [super init]) {
     _overlayToPolylineMap = [NSMapTable strongToWeakObjectsMapTable];
     _overlayToPolygonMap = [NSMapTable strongToWeakObjectsMapTable];
+    _overlayToCircleMap = [NSMapTable strongToWeakObjectsMapTable];
+    _overlayToGroundOverlayMap = [NSMapTable strongToWeakObjectsMapTable];
+    _overlayToTileOverlayMap = [NSMapTable strongToWeakObjectsMapTable];
+    _poiEnabled = YES;
+    _poiFilterMode = LuggMapViewPoiFilterMode::Including;
+    _poiFilterCategories = @[];
   }
   return self;
 }
@@ -91,6 +199,7 @@
 
   [_tapGesture requireGestureRecognizerToFail:_longPressGesture];
 
+  _wrapperView = wrapperView;
   [wrapperView addSubview:_mapView];
 
   MKCoordinateRegion region = [_mapView regionForCenterCoordinate:coordinate
@@ -103,6 +212,7 @@
 }
 
 - (void)destroy {
+  [self dismissNonBubbledCallout];
   [self stopEdgeInsetsAnimation];
   if (_tapGesture) {
     [_mapView removeGestureRecognizer:_tapGesture];
@@ -139,15 +249,181 @@
   _mapView.showsUserLocation = enabled;
 }
 
-- (void)setTheme:(NSInteger)theme {
+static MKPointOfInterestCategory poiCategoryFromString(NSString *string) {
+  static NSDictionary<NSString *, MKPointOfInterestCategory> *map;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    NSMutableDictionary<NSString *, MKPointOfInterestCategory> *m =
+        [NSMutableDictionary dictionaryWithDictionary:@{
+          @"airport" : MKPointOfInterestCategoryAirport,
+          @"amusement-park" : MKPointOfInterestCategoryAmusementPark,
+          @"aquarium" : MKPointOfInterestCategoryAquarium,
+          @"atm" : MKPointOfInterestCategoryATM,
+          @"bakery" : MKPointOfInterestCategoryBakery,
+          @"bank" : MKPointOfInterestCategoryBank,
+          @"beach" : MKPointOfInterestCategoryBeach,
+          @"brewery" : MKPointOfInterestCategoryBrewery,
+          @"cafe" : MKPointOfInterestCategoryCafe,
+          @"campground" : MKPointOfInterestCategoryCampground,
+          @"car-rental" : MKPointOfInterestCategoryCarRental,
+          @"ev-charger" : MKPointOfInterestCategoryEVCharger,
+          @"fire-station" : MKPointOfInterestCategoryFireStation,
+          @"fitness-center" : MKPointOfInterestCategoryFitnessCenter,
+          @"food-market" : MKPointOfInterestCategoryFoodMarket,
+          @"gas-station" : MKPointOfInterestCategoryGasStation,
+          @"hospital" : MKPointOfInterestCategoryHospital,
+          @"hotel" : MKPointOfInterestCategoryHotel,
+          @"laundry" : MKPointOfInterestCategoryLaundry,
+          @"library" : MKPointOfInterestCategoryLibrary,
+          @"marina" : MKPointOfInterestCategoryMarina,
+          @"movie-theater" : MKPointOfInterestCategoryMovieTheater,
+          @"museum" : MKPointOfInterestCategoryMuseum,
+          @"national-park" : MKPointOfInterestCategoryNationalPark,
+          @"nightlife" : MKPointOfInterestCategoryNightlife,
+          @"park" : MKPointOfInterestCategoryPark,
+          @"parking" : MKPointOfInterestCategoryParking,
+          @"pharmacy" : MKPointOfInterestCategoryPharmacy,
+          @"police" : MKPointOfInterestCategoryPolice,
+          @"post-office" : MKPointOfInterestCategoryPostOffice,
+          @"public-transport" : MKPointOfInterestCategoryPublicTransport,
+          @"restaurant" : MKPointOfInterestCategoryRestaurant,
+          @"restroom" : MKPointOfInterestCategoryRestroom,
+          @"school" : MKPointOfInterestCategorySchool,
+          @"stadium" : MKPointOfInterestCategoryStadium,
+          @"store" : MKPointOfInterestCategoryStore,
+          @"theater" : MKPointOfInterestCategoryTheater,
+          @"university" : MKPointOfInterestCategoryUniversity,
+          @"winery" : MKPointOfInterestCategoryWinery,
+          @"zoo" : MKPointOfInterestCategoryZoo,
+        }];
+    if (@available(iOS 18.0, *)) {
+      [m addEntriesFromDictionary:@{
+        @"animal-service" : MKPointOfInterestCategoryAnimalService,
+        @"automotive-repair" : MKPointOfInterestCategoryAutomotiveRepair,
+        @"baseball" : MKPointOfInterestCategoryBaseball,
+        @"basketball" : MKPointOfInterestCategoryBasketball,
+        @"beauty" : MKPointOfInterestCategoryBeauty,
+        @"bowling" : MKPointOfInterestCategoryBowling,
+        @"castle" : MKPointOfInterestCategoryCastle,
+        @"convention-center" : MKPointOfInterestCategoryConventionCenter,
+        @"distillery" : MKPointOfInterestCategoryDistillery,
+        @"fairground" : MKPointOfInterestCategoryFairground,
+        @"fishing" : MKPointOfInterestCategoryFishing,
+        @"fortress" : MKPointOfInterestCategoryFortress,
+        @"go-kart" : MKPointOfInterestCategoryGoKart,
+        @"golf" : MKPointOfInterestCategoryGolf,
+        @"hiking" : MKPointOfInterestCategoryHiking,
+        @"kayaking" : MKPointOfInterestCategoryKayaking,
+        @"landmark" : MKPointOfInterestCategoryLandmark,
+        @"mailbox" : MKPointOfInterestCategoryMailbox,
+        @"mini-golf" : MKPointOfInterestCategoryMiniGolf,
+        @"music-venue" : MKPointOfInterestCategoryMusicVenue,
+        @"national-monument" : MKPointOfInterestCategoryNationalMonument,
+        @"planetarium" : MKPointOfInterestCategoryPlanetarium,
+        @"rock-climbing" : MKPointOfInterestCategoryRockClimbing,
+        @"rv-park" : MKPointOfInterestCategoryRVPark,
+        @"skate-park" : MKPointOfInterestCategorySkatePark,
+        @"skating" : MKPointOfInterestCategorySkating,
+        @"skiing" : MKPointOfInterestCategorySkiing,
+        @"soccer" : MKPointOfInterestCategorySoccer,
+        @"spa" : MKPointOfInterestCategorySpa,
+        @"surfing" : MKPointOfInterestCategorySurfing,
+        @"swimming" : MKPointOfInterestCategorySwimming,
+        @"tennis" : MKPointOfInterestCategoryTennis,
+        @"volleyball" : MKPointOfInterestCategoryVolleyball,
+      }];
+    }
+    map = [m copy];
+  });
+  return map[string];
+}
+
+- (void)applyPoiFilter {
+  if (!_poiEnabled) {
+    _mapView.pointOfInterestFilter =
+        MKPointOfInterestFilter.filterExcludingAllCategories;
+    return;
+  }
+  if (_poiFilterCategories.count > 0) {
+    NSMutableArray<MKPointOfInterestCategory> *categories =
+        [NSMutableArray array];
+    for (NSString *name in _poiFilterCategories) {
+      MKPointOfInterestCategory category = poiCategoryFromString(name);
+      if (category) {
+        [categories addObject:category];
+      }
+    }
+    if (categories.count > 0) {
+      if (_poiFilterMode == LuggMapViewPoiFilterMode::Excluding) {
+        _mapView.pointOfInterestFilter = [[MKPointOfInterestFilter alloc]
+            initExcludingCategories:categories];
+      } else {
+        _mapView.pointOfInterestFilter = [[MKPointOfInterestFilter alloc]
+            initIncludingCategories:categories];
+      }
+      return;
+    }
+  }
+  _mapView.pointOfInterestFilter = nil;
+}
+
+- (void)setInsetAdjustment:(LuggMapViewInsetAdjustment)insetAdjustment {
+  BOOL automatic = (insetAdjustment == LuggMapViewInsetAdjustment::Automatic);
+  if (_mapView.insetsLayoutMarginsFromSafeArea == automatic)
+    return;
+
+  CLLocationCoordinate2D center = _mapView.centerCoordinate;
+  _mapView.insetsLayoutMarginsFromSafeArea = automatic;
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self->_mapView setCenterCoordinate:center animated:NO];
+  });
+}
+
+- (void)setPoiEnabled:(BOOL)enabled {
+  _poiEnabled = enabled;
+  [self applyPoiFilter];
+}
+
+- (void)setPoiFilterMode:(LuggMapViewPoiFilterMode)mode {
+  _poiFilterMode = mode;
+  [self applyPoiFilter];
+}
+
+- (void)setPoiFilterCategories:(NSArray<NSString *> *)categories {
+  _poiFilterCategories = categories;
+  [self applyPoiFilter];
+}
+
+- (void)setMapType:(LuggMapViewMapType)mapType {
+  switch (mapType) {
+  case LuggMapViewMapType::Satellite:
+    _mapView.mapType = MKMapTypeSatellite;
+    break;
+  case LuggMapViewMapType::Terrain:
+    _mapView.mapType = MKMapTypeStandard;
+    break;
+  case LuggMapViewMapType::Hybrid:
+    _mapView.mapType = MKMapTypeHybrid;
+    break;
+  case LuggMapViewMapType::MutedStandard:
+    _mapView.mapType = MKMapTypeMutedStandard;
+    break;
+  default:
+    _mapView.mapType = MKMapTypeStandard;
+    break;
+  }
+}
+
+- (void)setTheme:(LuggMapViewTheme)theme {
   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;
   }
@@ -174,6 +450,7 @@
   CGFloat deltaY = newOffsetY - oldOffsetY;
 
   _mapView.layoutMargins = edgeInsets;
+  _edgeInsetsCurrent = edgeInsets;
 
   if (deltaX != 0 || deltaY != 0) {
     CLLocationCoordinate2D currentCenter = _mapView.centerCoordinate;
@@ -224,7 +501,7 @@
       _edgeInsetsFrom.right +
           (_edgeInsetsTo.right - _edgeInsetsFrom.right) * t);
 
-  [self setEdgeInsets:current oldEdgeInsets:_mapView.layoutMargins];
+  [self setEdgeInsets:current oldEdgeInsets:_edgeInsetsCurrent];
 
   if (progress >= 1.0) {
     [self stopEdgeInsetsAnimation];
@@ -307,6 +584,55 @@
   return nil;
 }
 
+- (LuggCircleView *)hitTestCircleAtPoint:(CGPoint)point {
+  CLLocationCoordinate2D tapCoordinate = [_mapView convertPoint:point
+                                           toCoordinateFromView:_mapView];
+  CLLocation *tapLocation =
+      [[CLLocation alloc] initWithLatitude:tapCoordinate.latitude
+                                 longitude:tapCoordinate.longitude];
+
+  NSArray<id<MKOverlay>> *overlays = _mapView.overlays;
+  for (NSInteger i = overlays.count - 1; i >= 0; i--) {
+    id<MKOverlay> overlay = overlays[i];
+    if (![overlay isKindOfClass:[MKCircle class]])
+      continue;
+
+    LuggCircleView *circleView = [_overlayToCircleMap objectForKey:overlay];
+    if (!circleView || !circleView.tappable)
+      continue;
+
+    CLLocation *center =
+        [[CLLocation alloc] initWithLatitude:circleView.center.latitude
+                                   longitude:circleView.center.longitude];
+    CLLocationDistance distance = [tapLocation distanceFromLocation:center];
+    if (distance <= circleView.radius)
+      return circleView;
+  }
+  return nil;
+}
+
+- (LuggGroundOverlayView *)hitTestGroundOverlayAtPoint:(CGPoint)point {
+  CLLocationCoordinate2D tapCoordinate = [_mapView convertPoint:point
+                                           toCoordinateFromView:_mapView];
+
+  NSArray<id<MKOverlay>> *overlays = _mapView.overlays;
+  for (NSInteger i = overlays.count - 1; i >= 0; i--) {
+    id<MKOverlay> overlay = overlays[i];
+    if (![overlay isKindOfClass:[GroundImageOverlay class]])
+      continue;
+
+    LuggGroundOverlayView *view =
+        [_overlayToGroundOverlayMap objectForKey:overlay];
+    if (!view || !view.tappable)
+      continue;
+
+    MKMapPoint mapPoint = MKMapPointForCoordinate(tapCoordinate);
+    if (MKMapRectContainsPoint(overlay.boundingMapRect, mapPoint))
+      return view;
+  }
+  return nil;
+}
+
 - (BOOL)hitTestAnnotationAtPoint:(CGPoint)point {
   for (id<MKAnnotation> annotation in _mapView.annotations) {
     MKAnnotationView *view = [_mapView viewForAnnotation:annotation];
@@ -319,15 +645,41 @@
   return NO;
 }
 
+- (BOOL)hitTestCalloutAtPoint:(CGPoint)point {
+  if (!_activeNonBubbledMarker)
+    return NO;
+
+  UIView *contentView = _activeNonBubbledMarker.calloutView.contentView;
+  CGPoint local = [contentView convertPoint:point fromView:_mapView];
+  return [contentView pointInside:local withEvent:nil];
+}
+
 - (void)handleTap:(UITapGestureRecognizer *)gesture {
   if (gesture.state != UIGestureRecognizerStateEnded)
     return;
 
   CGPoint point = [gesture locationInView:_mapView];
+  if ([self hitTestCalloutAtPoint:point])
+    return;
+
+  [self dismissNonBubbledCallout];
 
   if ([self hitTestAnnotationAtPoint:point])
     return;
 
+  LuggGroundOverlayView *groundOverlayView =
+      [self hitTestGroundOverlayAtPoint:point];
+  if (groundOverlayView) {
+    [groundOverlayView emitPressEvent];
+    return;
+  }
+
+  LuggCircleView *circleView = [self hitTestCircleAtPoint:point];
+  if (circleView) {
+    [circleView emitPressEvent];
+    return;
+  }
+
   LuggPolygonView *polygonView = [self hitTestPolygonAtPoint:point];
   if (polygonView) {
     [polygonView emitPressEvent];
@@ -390,6 +742,7 @@
                             longitude:mapView.centerCoordinate.longitude
                                  zoom:mapView.zoomLevel
                               gesture:_isDragging];
+  [self positionNonBubbledCallout];
 }
 
 - (void)mapView:(MKMapView *)mapView regionDidChangeAnimated:(BOOL)animated {
@@ -423,22 +776,23 @@
   }
 
   if (!markerView.hasCustomView) {
-    MKMarkerAnnotationView *markerAnnotationView =
-        [[MKMarkerAnnotationView alloc] initWithAnnotation:annotation
-                                           reuseIdentifier:nil];
+    LuggMarkerAnnotationView *markerAnnotationView =
+        [[LuggMarkerAnnotationView alloc] initWithAnnotation:annotation
+                                             reuseIdentifier:nil];
     markerAnnotationView.canShowCallout = YES;
     markerAnnotationView.displayPriority = MKFeatureDisplayPriorityRequired;
     markerAnnotationView.layer.zPosition = markerView.zIndex;
     markerAnnotationView.zPriority = markerView.zIndex;
     markerAnnotationView.draggable = markerView.draggable;
+    [self applyCalloutView:markerView annotationView:markerAnnotationView];
     [self addCenterTapGesture:markerAnnotationView];
     markerAnnotation.annotationView = markerAnnotationView;
     return markerAnnotationView;
   }
 
-  MKAnnotationView *annotationView =
-      [[MKAnnotationView alloc] initWithAnnotation:annotation
-                                   reuseIdentifier:nil];
+  LuggAnnotationView *annotationView =
+      [[LuggAnnotationView alloc] initWithAnnotation:annotation
+                                     reuseIdentifier:nil];
   annotationView.canShowCallout = YES;
   annotationView.displayPriority = MKFeatureDisplayPriorityRequired;
   annotationView.layer.zPosition = markerView.zIndex;
@@ -446,6 +800,8 @@
   annotationView.draggable = markerView.draggable;
   [self addCenterTapGesture:annotationView];
 
+  [self applyCalloutView:markerView annotationView:annotationView];
+
   if (!markerView.rasterize) {
     UIView *iconView = markerView.iconView;
     [iconView removeFromSuperview];
@@ -501,6 +857,37 @@
     return renderer;
   }
 
+  if ([overlay isKindOfClass:[MKCircle class]]) {
+    LuggCircleView *circleView = [_overlayToCircleMap objectForKey:overlay];
+    MKCircle *circle = (MKCircle *)overlay;
+
+    MKCircleRenderer *renderer =
+        [[MKCircleRenderer alloc] initWithCircle:circle];
+    if (circleView) {
+      renderer.fillColor = circleView.fillColor;
+      renderer.strokeColor = circleView.strokeColor;
+      renderer.lineWidth = circleView.strokeWidth;
+      circleView.renderer = renderer;
+    }
+    return renderer;
+  }
+
+  if ([overlay isKindOfClass:[GroundImageOverlay class]]) {
+    GroundImageOverlay *groundOverlay = (GroundImageOverlay *)overlay;
+    GroundImageOverlayRenderer *renderer =
+        [[GroundImageOverlayRenderer alloc] initWithOverlay:overlay];
+    renderer.image = groundOverlay.image;
+    renderer.overlayOpacity = groundOverlay.opacity;
+    return renderer;
+  }
+
+  if ([overlay isKindOfClass:[MKTileOverlay class]]) {
+    MKTileOverlay *tileOverlay = (MKTileOverlay *)overlay;
+    MKTileOverlayRenderer *renderer =
+        [[MKTileOverlayRenderer alloc] initWithTileOverlay:tileOverlay];
+    return renderer;
+  }
+
   return nil;
 }
 
@@ -513,9 +900,104 @@
   LuggMarkerView *markerView = annotation.markerView;
 
   if (markerView) {
-    CGPoint point = [_mapView convertCoordinate:markerView.coordinate
-                                  toPointToView:_mapView];
-    [markerView emitPressEventWithPoint:point];
+    LuggCalloutView *calloutView = markerView.calloutView;
+    if (calloutView && !calloutView.bubbled && calloutView.hasCustomContent) {
+      [self showNonBubbledCallout:markerView];
+    }
+  }
+}
+
+- (void)mapView:(MKMapView *)mapView
+    didDeselectAnnotationView:(MKAnnotationView *)view {
+  if (![view.annotation isKindOfClass:[AppleMarkerAnnotation class]])
+    return;
+
+  AppleMarkerAnnotation *annotation = (AppleMarkerAnnotation *)view.annotation;
+  LuggMarkerView *markerView = annotation.markerView;
+
+  if (markerView && _activeNonBubbledMarker == markerView &&
+      !_isReselectingAnnotation) {
+    _isReselectingAnnotation = YES;
+    [_mapView selectAnnotation:annotation animated:NO];
+    _isReselectingAnnotation = NO;
+  }
+}
+
+- (void)showNonBubbledCallout:(LuggMarkerView *)markerView {
+  [self dismissNonBubbledCallout];
+
+  LuggCalloutView *calloutView = markerView.calloutView;
+  UIView *contentView = calloutView.contentView;
+  [contentView removeFromSuperview];
+
+  contentView.userInteractionEnabled = YES;
+  contentView.hidden = YES;
+  calloutView.delegate = self;
+
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)markerView.marker;
+  MKAnnotationView *annotationView = annotation.annotationView;
+  if (annotationView) {
+    annotationView.clipsToBounds = NO;
+    [annotationView addSubview:contentView];
+  } else {
+    [_wrapperView addSubview:contentView];
+  }
+
+  _activeNonBubbledMarker = markerView;
+  [self positionNonBubbledCallout];
+}
+
+- (void)calloutViewDidUpdate:(LuggCalloutView *)calloutView {
+  [self positionNonBubbledCallout];
+}
+
+- (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;
+
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)_activeNonBubbledMarker.marker;
+  MKAnnotationView *annotationView = annotation.annotationView;
+
+  if (annotationView && contentView.superview == annotationView) {
+    CGPoint center =
+        CGPointMake(annotationView.bounds.size.width / 2.0 + offset.x,
+                    -contentSize.height / 2.0 + offset.y);
+    contentView.center = center;
+  } else {
+    CGPoint point =
+        [_mapView convertCoordinate:_activeNonBubbledMarker.coordinate
+                      toPointToView:_wrapperView];
+    contentView.center = CGPointMake(
+        point.x + offset.x, point.y - contentSize.height / 2.0 + offset.y);
+  }
+
+  contentView.hidden = NO;
+}
+
+- (void)dismissNonBubbledCallout {
+  if (!_activeNonBubbledMarker)
+    return;
+
+  LuggMarkerView *markerView = _activeNonBubbledMarker;
+  _activeNonBubbledMarker = nil;
+
+  markerView.calloutView.delegate = nil;
+  [markerView.calloutView.contentView removeFromSuperview];
+
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)markerView.marker;
+  if (annotation) {
+    [_mapView deselectAnnotation:annotation animated:NO];
   }
 }
 
@@ -570,7 +1052,74 @@
   if ([view.annotation isKindOfClass:[AppleMarkerAnnotation class]]) {
     AppleMarkerAnnotation *annotation =
         (AppleMarkerAnnotation *)view.annotation;
-    [_mapView setCenterCoordinate:annotation.coordinate animated:YES];
+    LuggMarkerView *markerView = annotation.markerView;
+
+    if (markerView) {
+      CGPoint point = [_mapView convertCoordinate:markerView.coordinate
+                                    toPointToView:_mapView];
+      [markerView emitPressEventWithPoint:point];
+
+      if (markerView.centerOnPress) {
+        [_mapView setCenterCoordinate:annotation.coordinate animated:YES];
+      }
+    }
+  }
+}
+
+- (void)applyCalloutView:(LuggMarkerView *)markerView
+          annotationView:(MKAnnotationView *)annotationView {
+  LuggCalloutView *calloutView = markerView.calloutView;
+  if (!calloutView) {
+    annotationView.detailCalloutAccessoryView = nil;
+    annotationView.rightCalloutAccessoryView = nil;
+    return;
+  }
+
+  annotationView.rightCalloutAccessoryView = nil;
+
+  if (!calloutView.bubbled) {
+    annotationView.canShowCallout = NO;
+    annotationView.detailCalloutAccessoryView = nil;
+    return;
+  }
+
+  annotationView.detailCalloutAccessoryView =
+      calloutView.hasCustomContent ? calloutView.contentView : nil;
+}
+
+- (void)showCalloutForMarkerView:(LuggMarkerView *)markerView {
+  LuggCalloutView *calloutView = markerView.calloutView;
+  _isProgrammaticSelect = YES;
+
+  if (calloutView && calloutView.hasCustomContent) {
+    [self dismissNonBubbledCallout];
+    AppleMarkerAnnotation *annotation =
+        (AppleMarkerAnnotation *)markerView.marker;
+    if (!calloutView.bubbled) {
+      [self showNonBubbledCallout:markerView];
+    } else if (annotation) {
+      [_mapView selectAnnotation:annotation animated:YES];
+    }
+    _isProgrammaticSelect = NO;
+    return;
+  }
+
+  if (markerView.title.length > 0) {
+    AppleMarkerAnnotation *annotation =
+        (AppleMarkerAnnotation *)markerView.marker;
+    if (annotation) {
+      [_mapView selectAnnotation:annotation animated:YES];
+    }
+  }
+  _isProgrammaticSelect = NO;
+}
+
+- (void)hideCalloutForMarkerView:(LuggMarkerView *)markerView {
+  [self dismissNonBubbledCallout];
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)markerView.marker;
+  if (annotation) {
+    [_mapView deselectAnnotation:annotation animated:YES];
   }
 }
 
@@ -600,6 +1149,7 @@
     annotationView.draggable = markerView.draggable;
     annotationView.layer.zPosition = markerView.zIndex;
     annotationView.zPriority = markerView.zIndex;
+    [self applyCalloutView:markerView annotationView:annotationView];
   }
 
   [self updateAnnotationViewFrame:annotation];
@@ -617,6 +1167,24 @@
   [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 {
@@ -640,6 +1208,10 @@
       (AppleMarkerAnnotation *)markerView.marker;
 
   if (annotation) {
+    if (annotation.pendingScaleAnimation) {
+      dispatch_block_cancel(annotation.pendingScaleAnimation);
+      annotation.pendingScaleAnimation = nil;
+    }
     annotation.annotationView.transform = CGAffineTransformIdentity;
     annotation.markerView = nil;
     annotation.annotationView = nil;
@@ -658,31 +1230,65 @@
   annotationView.transform = CGAffineTransformIdentity;
 
   UIView *iconView = markerView.iconView;
-  CGRect frame = iconView.frame;
-  if (frame.size.width <= 0 || frame.size.height <= 0)
+  iconView.transform = CGAffineTransformIdentity;
+
+  // Clean up iconView from in-progress rasterize animation
+  if (markerView.rasterize && [iconView superview] == annotationView) {
+    [iconView removeFromSuperview];
+    iconView.layer.anchorPoint = CGPointMake(0.5, 0.5);
+  }
+
+  CGSize size = iconView.bounds.size;
+  if (size.width <= 0 || size.height <= 0)
     return;
 
   CGFloat scale = markerView.scale;
   CGPoint anchor = markerView.anchor;
+  CGFloat scaledWidth = size.width * scale;
+  CGFloat scaledHeight = size.height * scale;
 
-  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));
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)markerView.marker;
+
+  // Cancel any pending rasterize
+  if (annotation.pendingScaleAnimation) {
+    dispatch_block_cancel(annotation.pendingScaleAnimation);
+    annotation.pendingScaleAnimation = nil;
+  }
+
+  // Use live iconView during rapid updates (skip expensive rasterize per frame)
+  if (markerView.rasterize && [iconView superview] != annotationView) {
+    annotationView.image = nil;
+    [annotationView addSubview:iconView];
+  }
+
+  iconView.layer.anchorPoint = anchor;
+  iconView.bounds = CGRectMake(0, 0, size.width, size.height);
+  iconView.center =
+      CGPointMake(scaledWidth * anchor.x, scaledHeight * anchor.y);
+  iconView.transform = CGAffineTransformMakeScale(scale, scale);
+
+  annotationView.bounds = CGRectMake(0, 0, scaledWidth, scaledHeight);
+  annotationView.centerOffset = CGPointMake(scaledWidth * (0.5 - anchor.x),
+                                            scaledHeight * (0.5 - anchor.y));
   annotationView.transform =
       CGAffineTransformMakeRotation(markerView.rotate * M_PI / 180.0);
+
+  // Debounce: rasterize once updates settle
+  if (markerView.rasterize) {
+    dispatch_block_t rasterizeBlock =
+        dispatch_block_create((dispatch_block_flags_t)0, ^{
+          annotation.pendingScaleAnimation = nil;
+          annotationView.image = [markerView createScaledIconImage];
+          [iconView removeFromSuperview];
+          [markerView resetIconViewTransform];
+        });
+
+    annotation.pendingScaleAnimation = rasterizeBlock;
+    dispatch_after(
+        dispatch_time(DISPATCH_TIME_NOW, (int64_t)(150 * NSEC_PER_MSEC)),
+        dispatch_get_main_queue(), rasterizeBlock);
+  }
 }
 
 - (void)updateAnnotationViewFrame:(AppleMarkerAnnotation *)annotation {
@@ -902,6 +1508,196 @@
   return [interiorPolygons copy];
 }
 
+#pragma mark - Circle Management
+
+- (void)addCircleView:(LuggCircleView *)circleView {
+  circleView.delegate = self;
+  [self addCircleOverlayToMap:circleView];
+}
+
+- (void)removeCircleView:(LuggCircleView *)circleView {
+  circleView.delegate = nil;
+  MKCircle *circle = (MKCircle *)circleView.circle;
+  if (circle) {
+    [_overlayToCircleMap removeObjectForKey:circle];
+    [_mapView removeOverlay:circle];
+    circleView.circle = nil;
+  }
+}
+
+- (void)syncCircleView:(LuggCircleView *)circleView {
+  if (!_mapView)
+    return;
+
+  MKCircle *oldCircle = (MKCircle *)circleView.circle;
+
+  MKCircle *newCircle = [MKCircle circleWithCenterCoordinate:circleView.center
+                                                      radius:circleView.radius];
+
+  circleView.circle = newCircle;
+  [_overlayToCircleMap setObject:circleView forKey:newCircle];
+
+  MKCircleRenderer *renderer = (MKCircleRenderer *)circleView.renderer;
+  if (renderer && oldCircle) {
+    [_overlayToCircleMap removeObjectForKey:oldCircle];
+    [_mapView removeOverlay:oldCircle];
+    [self insertOverlay:newCircle withZIndex:circleView.zIndex];
+    circleView.renderer = nil;
+    return;
+  }
+
+  if (oldCircle) {
+    [_overlayToCircleMap removeObjectForKey:oldCircle];
+    [_mapView removeOverlay:oldCircle];
+  }
+  [self insertOverlay:newCircle withZIndex:circleView.zIndex];
+}
+
+- (void)addCircleOverlayToMap:(LuggCircleView *)circleView {
+  if (!_mapView)
+    return;
+
+  MKCircle *circle = [MKCircle circleWithCenterCoordinate:circleView.center
+                                                   radius:circleView.radius];
+
+  circleView.circle = circle;
+  [_overlayToCircleMap setObject:circleView forKey:circle];
+  [self insertOverlay:circle withZIndex:circleView.zIndex];
+}
+
+#pragma mark - Ground Overlay Management
+
+- (void)addGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  groundOverlayView.delegate = self;
+  [self syncGroundOverlayView:groundOverlayView];
+}
+
+- (void)removeGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  groundOverlayView.delegate = nil;
+  GroundImageOverlay *overlay = (GroundImageOverlay *)groundOverlayView.overlay;
+  if (overlay) {
+    [_overlayToGroundOverlayMap removeObjectForKey:overlay];
+    [_mapView removeOverlay:overlay];
+    groundOverlayView.overlay = nil;
+  }
+}
+
+- (void)syncGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  if (!_mapView)
+    return;
+
+  NSString *imageUri = groundOverlayView.imageUri;
+  if (imageUri.length == 0)
+    return;
+
+  // Remove old overlay
+  GroundImageOverlay *oldOverlay =
+      (GroundImageOverlay *)groundOverlayView.overlay;
+  if (oldOverlay) {
+    [_overlayToGroundOverlayMap removeObjectForKey:oldOverlay];
+    [_mapView removeOverlay:oldOverlay];
+    groundOverlayView.overlay = nil;
+  }
+
+  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;
+
+  MKMapPoint sw = MKMapPointForCoordinate(groundOverlayView.southwest);
+  MKMapPoint ne = MKMapPointForCoordinate(groundOverlayView.northeast);
+
+  MKMapRect mapRect = MKMapRectMake(MIN(sw.x, ne.x), MIN(sw.y, ne.y),
+                                    fabs(ne.x - sw.x), fabs(ne.y - sw.y));
+
+  CLLocationCoordinate2D center =
+      CLLocationCoordinate2DMake((groundOverlayView.northeast.latitude +
+                                  groundOverlayView.southwest.latitude) /
+                                     2.0,
+                                 (groundOverlayView.northeast.longitude +
+                                  groundOverlayView.southwest.longitude) /
+                                     2.0);
+
+  GroundImageOverlay *overlay = [[GroundImageOverlay alloc] init];
+  overlay.coordinate = center;
+  overlay.boundingMapRect = mapRect;
+  overlay.image = image;
+  overlay.opacity = groundOverlayView.opacity;
+
+  groundOverlayView.overlay = overlay;
+  [_overlayToGroundOverlayMap setObject:groundOverlayView forKey:overlay];
+  [self insertOverlay:overlay withZIndex:groundOverlayView.zIndex];
+}
+
+#pragma mark - Tile Overlay Management
+
+- (void)addTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  tileOverlayView.delegate = self;
+  [self syncTileOverlayView:tileOverlayView];
+}
+
+- (void)removeTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  tileOverlayView.delegate = nil;
+  MKTileOverlay *overlay = (MKTileOverlay *)tileOverlayView.overlay;
+  if (overlay) {
+    [_overlayToTileOverlayMap removeObjectForKey:overlay];
+    [_mapView removeOverlay:overlay];
+    tileOverlayView.overlay = nil;
+  }
+}
+
+- (void)syncTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  if (!_mapView)
+    return;
+
+  NSString *urlTemplate = tileOverlayView.urlTemplate;
+  if (urlTemplate.length == 0)
+    return;
+
+  // Remove old overlay
+  MKTileOverlay *oldOverlay = (MKTileOverlay *)tileOverlayView.overlay;
+  if (oldOverlay) {
+    [_overlayToTileOverlayMap removeObjectForKey:oldOverlay];
+    [_mapView removeOverlay:oldOverlay];
+    tileOverlayView.overlay = nil;
+  }
+
+  MKTileOverlay *tileOverlay;
+  if (tileOverlayView.hasBounds) {
+    BoundedTileOverlay *bounded =
+        [[BoundedTileOverlay alloc] initWithURLTemplate:urlTemplate];
+    bounded.southwest = tileOverlayView.southwest;
+    bounded.northeast = tileOverlayView.northeast;
+    tileOverlay = bounded;
+  } else {
+    tileOverlay = [[MKTileOverlay alloc] initWithURLTemplate:urlTemplate];
+  }
+
+  tileOverlay.tileSize =
+      CGSizeMake(tileOverlayView.tileSize, tileOverlayView.tileSize);
+  tileOverlay.canReplaceMapContent = NO;
+
+  tileOverlayView.overlay = tileOverlay;
+  [_overlayToTileOverlayMap setObject:tileOverlayView forKey:tileOverlay];
+  [_mapView addOverlay:tileOverlay level:MKOverlayLevelAboveRoads];
+}
+
 - (void)insertOverlay:(id<MKOverlay>)overlay withZIndex:(NSInteger)zIndex {
   if (zIndex == 0) {
     [_mapView addOverlay:overlay];
@@ -917,10 +1713,18 @@
         [_overlayToPolylineMap objectForKey:overlays[i]];
     LuggPolygonView *existingPolygonView =
         [_overlayToPolygonMap objectForKey:overlays[i]];
+    LuggCircleView *existingCircleView =
+        [_overlayToCircleMap objectForKey:overlays[i]];
+    LuggGroundOverlayView *existingGroundOverlayView =
+        [_overlayToGroundOverlayMap objectForKey:overlays[i]];
     if (existingPolylineView) {
       existingZIndex = existingPolylineView.zIndex;
     } else if (existingPolygonView) {
       existingZIndex = existingPolygonView.zIndex;
+    } else if (existingCircleView) {
+      existingZIndex = existingCircleView.zIndex;
+    } else if (existingGroundOverlayView) {
+      existingZIndex = existingGroundOverlayView.zIndex;
     } else {
       continue;
     }