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

package/ios/core/GoogleMapProvider.mm

@@ -1,16 +1,59 @@
 #import "GoogleMapProvider.h"
+
+using facebook::react::LuggMapViewInsetAdjustment;
+using facebook::react::LuggMapViewMapType;
+using facebook::react::LuggMapViewPoiFilterMode;
+using facebook::react::LuggMapViewTheme;
+
 #import "../LuggCalloutView.h"
+#import "../LuggCircleView.h"
+#import "../LuggGroundOverlayView.h"
 #import "../LuggMarkerView.h"
 #import "../LuggPolygonView.h"
 #import "../LuggPolylineView.h"
+#import "../LuggTileOverlayView.h"
 #import "GMSPolylineAnimator.h"
 #import "PolylineAnimatorBase.h"
 
 static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
+GMSMapID *LuggGMSMapIDFromString(NSString *_Nullable mapId) {
+  if (mapId.length == 0 || [mapId isEqualToString:kDemoMapId]) {
+    return [GMSMapID demoMapID];
+  }
+  return [GMSMapID mapIDWithIdentifier:mapId];
+}
+
+GMSMapViewType
+LuggGMSMapTypeFromMapType(facebook::react::LuggMapViewMapType mapType) {
+  switch (mapType) {
+  case LuggMapViewMapType::Satellite:
+    return kGMSTypeSatellite;
+  case LuggMapViewMapType::Terrain:
+    return kGMSTypeTerrain;
+  case LuggMapViewMapType::Hybrid:
+    return kGMSTypeHybrid;
+  default:
+    return kGMSTypeNormal;
+  }
+}
+
+UIUserInterfaceStyle
+LuggInterfaceStyleFromTheme(facebook::react::LuggMapViewTheme theme) {
+  switch (theme) {
+  case LuggMapViewTheme::Dark:
+    return UIUserInterfaceStyleDark;
+  case LuggMapViewTheme::Light:
+    return UIUserInterfaceStyleLight;
+  default:
+    return UIUserInterfaceStyleUnspecified;
+  }
+}
+
 @interface GoogleMapProvider () <
     LuggMarkerViewDelegate, LuggCalloutViewDelegate, LuggPolylineViewDelegate,
-    LuggPolygonViewDelegate>
+    LuggPolygonViewDelegate, LuggCircleViewDelegate,
+    LuggGroundOverlayViewDelegate, LuggTileOverlayViewDelegate>
 @end
 
 @implementation GoogleMapProvider {
@@ -18,14 +61,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
@@ -37,6 +86,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 }
 
 @synthesize delegate = _delegate;
+@synthesize staticMode = _staticMode;
 
 - (instancetype)init {
   if (self = [super init]) {
@@ -45,9 +95,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;
 }
@@ -68,13 +123,6 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   if (_mapView)
     return;
 
-  GMSMapID *gmsMapId;
-  if ([_mapId isEqualToString:kDemoMapId] || _mapId.length == 0) {
-    gmsMapId = [GMSMapID demoMapID];
-  } else {
-    gmsMapId = [GMSMapID mapIDWithIdentifier:_mapId];
-  }
-
   GMSCameraPosition *camera =
       [GMSCameraPosition cameraWithLatitude:coordinate.latitude
                                   longitude:coordinate.longitude
@@ -83,7 +131,7 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
   options.frame = wrapperView.bounds;
   options.camera = camera;
-  options.mapID = gmsMapId;
+  options.mapID = LuggGMSMapIDFromString(_mapId);
 
   _mapView = [[GMSMapView alloc] initWithOptions:options];
   _mapView.autoresizingMask =
@@ -101,6 +149,9 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [self processPendingMarkers];
   [self processPendingPolylines];
   [self processPendingPolygons];
+  [self processPendingCircles];
+  [self processPendingGroundOverlays];
+  [self processPendingTileOverlays];
 
   [_delegate mapProviderDidReady];
 }
@@ -110,13 +161,26 @@ 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];
-  [_mapView clear];
+  [_groundOverlayToViewMap removeAllObjects];
+  [self destroyMapView];
+  _isMapReady = NO;
+}
+
+- (void)destroyMapView {
+  if (!_mapView)
+    return;
+
+  _mapView.delegate = nil;
   [_mapView removeFromSuperview];
+  [_mapView clear];
   _mapView = nil;
-  _isMapReady = NO;
 }
 
 #pragma mark - Props
@@ -137,30 +201,41 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   _mapView.settings.tiltGestures = enabled;
 }
 
+- (void)setCompassEnabled:(BOOL)enabled {
+  _mapView.settings.compassButton = enabled;
+}
+
 - (void)setUserLocationEnabled:(BOOL)enabled {
   _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 {
+  _mapView.mapType = LuggGMSMapTypeFromMapType(mapType);
+}
+
+- (void)setTheme:(LuggMapViewTheme)theme {
   _theme = theme;
   [self applyTheme];
 }
 
 - (void)applyTheme {
-  if (!_mapView)
-    return;
-
-  switch (_theme) {
-  case 1: // Dark
-    _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleDark;
-    break;
-  case 0: // Light
-    _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
-    break;
-  default: // System
-    _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleUnspecified;
-    break;
-  }
+  _mapView.overrideUserInterfaceStyle = LuggInterfaceStyleFromTheme(_theme);
 }
 
 - (void)setMinZoom:(double)minZoom {
@@ -291,15 +366,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 {
@@ -312,15 +398,21 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
     LuggCalloutView *calloutView = markerView.calloutView;
     if (calloutView && calloutView.hasCustomContent) {
-      [mapView animateToLocation:marker.position];
-
-      dispatch_async(dispatch_get_main_queue(), ^{
-        if (calloutView.bubbled) {
-          mapView.selectedMarker = marker;
-        } else {
-          [self showNonBubbledCallout:markerView];
-        }
-      });
+      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;
     }
   }
@@ -439,13 +531,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
@@ -470,6 +592,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 {
@@ -734,6 +874,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 {
@@ -758,9 +1135,11 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
     return;
 
   float targetZoom = zoom > 0 ? (float)zoom : _mapView.camera.zoom;
-  GMSCameraPosition *camera = [GMSCameraPosition cameraWithLatitude:latitude
-                                                          longitude:longitude
-                                                               zoom:targetZoom];
+  GMSCameraPosition *camera = [GMSCameraPosition
+      cameraWithTarget:CLLocationCoordinate2DMake(latitude, longitude)
+                  zoom:targetZoom
+               bearing:_mapView.camera.bearing
+          viewingAngle:_mapView.camera.viewingAngle];
   if (duration < 0) {
     [_mapView animateToCameraPosition:camera];
   } else if (duration > 0) {

package/ios/core/GoogleStaticMapProvider.h

@@ -0,0 +1,21 @@
+#import "StaticMapProviderBase.h"
+#import <GoogleMaps/GoogleMaps.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * Static Google map. The Google Maps SDK has no async snapshotter, so the
+ * base map briefly warms up on a live, tiles-only GMSMapView inserted below
+ * the overlays, then is swapped with a rendered image and the map view is
+ * pooled for reuse. Markers and shapes are overlay views (shared with
+ * Apple static maps) that reveal with the base map, so the warmup map
+ * never renders its own markers. Warmup cost scales with how many static
+ * maps mount at once - bound that with list props (windowSize etc.).
+ */
+@interface GoogleStaticMapProvider : StaticMapProviderBase <GMSMapViewDelegate>
+
+@property(nonatomic, copy, nullable) NSString *mapId;
+
+@end
+
+NS_ASSUME_NONNULL_END