@lugg/maps 1.0.0-beta.1 → 1.0.0-beta.11

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,8 +1,17 @@
 #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"
 
@@ -10,7 +19,8 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
 @interface GoogleMapProvider () <
     LuggMarkerViewDelegate, LuggCalloutViewDelegate, LuggPolylineViewDelegate,
-    LuggPolygonViewDelegate>
+    LuggPolygonViewDelegate, LuggCircleViewDelegate,
+    LuggGroundOverlayViewDelegate, LuggTileOverlayViewDelegate>
 @end
 
 @implementation GoogleMapProvider {
@@ -18,14 +28,20 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   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
@@ -45,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;
 }
@@ -101,6 +122,9 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [self processPendingMarkers];
   [self processPendingPolylines];
   [self processPendingPolygons];
+  [self processPendingCircles];
+  [self processPendingGroundOverlays];
+  [self processPendingTileOverlays];
 
   [_delegate mapProviderDidReady];
 }
@@ -110,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;
@@ -141,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];
 }
@@ -151,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;
   }
@@ -291,15 +356,26 @@ 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 {
@@ -311,9 +387,22 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
     [markerView emitPressEventWithPoint:point];
 
     LuggCalloutView *calloutView = markerView.calloutView;
-    if (calloutView && !calloutView.bubbled && calloutView.hasCustomContent) {
-      [mapView animateToLocation:marker.position];
-      [self showNonBubbledCallout:markerView];
+    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;
     }
   }
@@ -397,11 +486,15 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [contentView removeFromSuperview];
 
   contentView.userInteractionEnabled = YES;
+  contentView.hidden = YES;
   calloutView.delegate = self;
   [_wrapperView addSubview:contentView];
 
   _activeNonBubbledMarker = markerView;
-  [self positionNonBubbledCallout];
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self positionNonBubbledCallout];
+    contentView.hidden = NO;
+  });
 }
 
 - (void)calloutViewDidUpdate:(LuggCalloutView *)calloutView {
@@ -428,13 +521,43 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   if (contentSize.width <= 0 || contentSize.height <= 0)
     return;
 
-  CGPoint anchor = calloutView.anchor;
+  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 + contentSize.width * (0.5 - anchor.x),
-                  point.y + contentSize.height * (0.5 - anchor.y));
+      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
@@ -459,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 {
@@ -723,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/MapProviderDelegate.h

@@ -1,11 +1,15 @@
 #import <CoreLocation/CoreLocation.h>
 #import <UIKit/UIKit.h>
+#import <react/renderer/components/RNMapsSpec/Props.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
 @class LuggMarkerView;
 @class LuggPolylineView;
 @class LuggPolygonView;
+@class LuggCircleView;
+@class LuggGroundOverlayView;
+@class LuggTileOverlayView;
 
 @protocol MapProviderDelegate <NSObject>
 - (void)mapProviderDidReady;
@@ -38,12 +42,15 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)destroy;
 
 // Props
+- (void)setInsetAdjustment:
+    (facebook::react::LuggMapViewInsetAdjustment)insetAdjustment;
 - (void)setZoomEnabled:(BOOL)enabled;
 - (void)setScrollEnabled:(BOOL)enabled;
 - (void)setRotateEnabled:(BOOL)enabled;
 - (void)setPitchEnabled:(BOOL)enabled;
 - (void)setUserLocationEnabled:(BOOL)enabled;
-- (void)setTheme:(NSInteger)theme;
+- (void)setMapType:(facebook::react::LuggMapViewMapType)mapType;
+- (void)setTheme:(facebook::react::LuggMapViewTheme)theme;
 - (void)setMinZoom:(double)minZoom;
 - (void)setMaxZoom:(double)maxZoom;
 - (void)setEdgeInsets:(UIEdgeInsets)edgeInsets
@@ -51,6 +58,9 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)setEdgeInsets:(UIEdgeInsets)edgeInsets
         oldEdgeInsets:(UIEdgeInsets)oldEdgeInsets
              duration:(double)duration;
+- (void)setPoiEnabled:(BOOL)enabled;
+- (void)setPoiFilterMode:(facebook::react::LuggMapViewPoiFilterMode)mode;
+- (void)setPoiFilterCategories:(NSArray<NSString *> *)categories;
 
 // Children
 - (void)addMarkerView:(LuggMarkerView *)markerView;
@@ -62,6 +72,15 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)addPolygonView:(LuggPolygonView *)polygonView;
 - (void)removePolygonView:(LuggPolygonView *)polygonView;
 - (void)syncPolygonView:(LuggPolygonView *)polygonView;
+- (void)addCircleView:(LuggCircleView *)circleView;
+- (void)removeCircleView:(LuggCircleView *)circleView;
+- (void)syncCircleView:(LuggCircleView *)circleView;
+- (void)addGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView;
+- (void)removeGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView;
+- (void)syncGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView;
+- (void)addTileOverlayView:(LuggTileOverlayView *)tileOverlayView;
+- (void)removeTileOverlayView:(LuggTileOverlayView *)tileOverlayView;
+- (void)syncTileOverlayView:(LuggTileOverlayView *)tileOverlayView;
 
 // Lifecycle
 - (void)pauseAnimations;

package/ios/events/CirclePressEvent.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct CirclePressEvent {
+  template <typename Emitter>
+  static void emit(const facebook::react::SharedEventEmitter &eventEmitter) {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnCirclePress event;
+    emitter->onCirclePress(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps

package/ios/events/GroundOverlayPressEvent.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct GroundOverlayPressEvent {
+  template <typename Emitter>
+  static void emit(const facebook::react::SharedEventEmitter &eventEmitter) {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnGroundOverlayPress event;
+    emitter->onGroundOverlayPress(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps

package/ios/events/TileOverlayPressEvent.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct TileOverlayPressEvent {
+  template <typename Emitter>
+  static void emit(const facebook::react::SharedEventEmitter &eventEmitter) {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnTileOverlayPress event;
+    emitter->onTileOverlayPress(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps