@lugg/maps 1.0.0-beta.2 → 1.0.0-beta.20

package/ios/core/AppleMapProvider.mm

@@ -1,8 +1,17 @@
 #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"
@@ -19,12 +28,90 @@
 @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, LuggCalloutViewDelegate, LuggPolylineViewDelegate,
-    LuggPolygonViewDelegate, UIGestureRecognizerDelegate>
+    LuggPolygonViewDelegate, LuggCircleViewDelegate,
+    LuggGroundOverlayViewDelegate, LuggTileOverlayViewDelegate,
+    UIGestureRecognizerDelegate>
 @end
 
 @implementation AppleMapProvider {
@@ -36,24 +123,40 @@
   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;
+@synthesize staticMode = _staticMode;
 
 - (instancetype)init {
   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;
 }
@@ -80,6 +183,10 @@
   _mapView.delegate = self;
   _mapView.insetsLayoutMarginsFromSafeArea = NO;
 
+  if (_staticMode) {
+    _mapView.userInteractionEnabled = NO;
+  }
+
   [self applyZoomRange];
 
   _tapGesture =
@@ -110,6 +217,11 @@
 }
 
 - (void)destroy {
+  [self destroyMapView];
+  _isMapReady = NO;
+}
+
+- (void)destroyMapView {
   [self dismissNonBubbledCallout];
   [self stopEdgeInsetsAnimation];
   if (_tapGesture) {
@@ -120,9 +232,9 @@
     [_mapView removeGestureRecognizer:_longPressGesture];
     _longPressGesture = nil;
   }
+  _mapView.delegate = nil;
   [_mapView removeFromSuperview];
   _mapView = nil;
-  _isMapReady = NO;
 }
 
 #pragma mark - Props
@@ -143,19 +255,191 @@
   _mapView.pitchEnabled = enabled;
 }
 
+- (void)setCompassEnabled:(BOOL)enabled {
+  _mapView.showsCompass = enabled;
+}
+
 - (void)setUserLocationEnabled:(BOOL)enabled {
   _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];
+}
+
+MKPointOfInterestFilter *_Nullable LuggPointOfInterestFilter(
+    BOOL poiEnabled, LuggMapViewPoiFilterMode filterMode,
+    NSArray<NSString *> *filterCategories) {
+  if (!poiEnabled) {
+    return MKPointOfInterestFilter.filterExcludingAllCategories;
+  }
+  if (filterCategories.count > 0) {
+    NSMutableArray<MKPointOfInterestCategory> *categories =
+        [NSMutableArray array];
+    for (NSString *name in filterCategories) {
+      MKPointOfInterestCategory category = poiCategoryFromString(name);
+      if (category) {
+        [categories addObject:category];
+      }
+    }
+    if (categories.count > 0) {
+      if (filterMode == LuggMapViewPoiFilterMode::Excluding) {
+        return [[MKPointOfInterestFilter alloc]
+            initExcludingCategories:categories];
+      }
+      return
+          [[MKPointOfInterestFilter alloc] initIncludingCategories:categories];
+    }
+  }
+  return nil;
+}
+
+- (void)applyPoiFilter {
+  _mapView.pointOfInterestFilter = LuggPointOfInterestFilter(
+      _poiEnabled, _poiFilterMode, _poiFilterCategories);
+}
+
+- (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];
+}
+
+MKMapType LuggMKMapTypeFromMapType(LuggMapViewMapType mapType) {
+  switch (mapType) {
+  case LuggMapViewMapType::Satellite:
+    return MKMapTypeSatellite;
+  case LuggMapViewMapType::Terrain:
+    return MKMapTypeStandard;
+  case LuggMapViewMapType::Hybrid:
+    return MKMapTypeHybrid;
+  case LuggMapViewMapType::MutedStandard:
+    return MKMapTypeMutedStandard;
+  default:
+    return MKMapTypeStandard;
+  }
+}
+
+- (void)setMapType:(LuggMapViewMapType)mapType {
+  _mapView.mapType = LuggMKMapTypeFromMapType(mapType);
+}
+
+- (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;
   }
@@ -182,6 +466,7 @@
   CGFloat deltaY = newOffsetY - oldOffsetY;
 
   _mapView.layoutMargins = edgeInsets;
+  _edgeInsetsCurrent = edgeInsets;
 
   if (deltaX != 0 || deltaY != 0) {
     CLLocationCoordinate2D currentCenter = _mapView.centerCoordinate;
@@ -232,7 +517,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];
@@ -315,6 +600,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];
@@ -349,6 +683,19 @@
   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];
@@ -501,7 +848,8 @@
         renderer.strokeColors = colors;
       }
       renderer.animatedOptions = polylineView.animatedOptions;
-      renderer.animated = polylineView.animated;
+      // Static maps snapshot an arbitrary frame; render the full polyline
+      renderer.animated = polylineView.animated && !_staticMode;
       polylineView.renderer = renderer;
       return renderer;
     }
@@ -526,6 +874,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;
 }
 
@@ -538,10 +917,6 @@
   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];
@@ -587,10 +962,7 @@
   }
 
   _activeNonBubbledMarker = markerView;
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [self positionNonBubbledCallout];
-    contentView.hidden = NO;
-  });
+  [self positionNonBubbledCallout];
 }
 
 - (void)calloutViewDidUpdate:(LuggCalloutView *)calloutView {
@@ -607,26 +979,26 @@
   if (contentSize.width <= 0 || contentSize.height <= 0)
     return;
 
-  CGPoint anchor = calloutView.anchor;
+  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 +
-                                     contentSize.width * (0.5 - anchor.x),
-                                 annotationView.bounds.size.height / 2.0 +
-                                     contentSize.height * (0.5 - anchor.y));
+    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 + contentSize.width * (0.5 - anchor.x),
-                    point.y + contentSize.height * (0.5 - anchor.y));
+    contentView.center = CGPointMake(
+        point.x + offset.x, point.y - contentSize.height / 2.0 + offset.y);
   }
+
+  contentView.hidden = NO;
 }
 
 - (void)dismissNonBubbledCallout {
@@ -697,7 +1069,17 @@
   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];
+      }
+    }
   }
 }
 
@@ -722,6 +1104,42 @@
       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];
+  }
+}
+
 #pragma mark - MarkerViewDelegate
 
 - (void)markerViewDidLayout:(LuggMarkerView *)markerView {
@@ -766,6 +1184,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 {
@@ -942,7 +1378,7 @@
     renderer.strokeColors =
         polylineView.strokeColors.count > 1 ? polylineView.strokeColors : nil;
     renderer.animatedOptions = polylineView.animatedOptions;
-    renderer.animated = polylineView.animated;
+    renderer.animated = polylineView.animated && !_staticMode;
     return;
   }
 
@@ -1089,6 +1525,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];
@@ -1104,10 +1730,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;
     }
@@ -1157,11 +1791,11 @@
   } else if (duration > 0) {
     CLLocationCoordinate2D center =
         CLLocationCoordinate2DMake(latitude, longitude);
-    MKCoordinateRegion region = [_mapView regionForCenterCoordinate:center
-                                                          zoomLevel:targetZoom];
+    MKMapCamera *camera = [_mapView cameraForCenterCoordinate:center
+                                                    zoomLevel:targetZoom];
     [UIView animateWithDuration:duration / 1000.0
                      animations:^{
-                       [self->_mapView setRegion:region animated:NO];
+                       [self->_mapView setCamera:camera animated:NO];
                      }];
   } else {
     [_mapView