@lugg/maps 0.2.0-alpha.22 → 0.2.0-alpha.24

package/ios/core/GMSPolylineAnimator.m

@@ -1,6 +1,8 @@
 #import "GMSPolylineAnimator.h"
 #import <QuartzCore/QuartzCore.h>
 
+static const NSUInteger kMaxAnimationSpans = 16;
+
 @interface GMSDisplayLinkProxy : NSObject
 @property(nonatomic, weak) id target;
 @property(nonatomic, assign) SEL selector;
@@ -245,12 +247,22 @@
   }
 
   NSUInteger pathCount = path.count;
-  for (NSUInteger i = 0; i < pathCount - 1; i++) {
-    CGFloat segMidDist = tailDist + visibleLength * ((CGFloat)i + 0.5) / (CGFloat)(pathCount - 1);
-    CGFloat gradientPos = (segMidDist - tailDist) / visibleLength;
+  NSUInteger segmentCount = pathCount - 1;
+
+  if (self.strokeColors.count <= 1) {
+    _polyline.path = path;
+    _polyline.strokeColor = self.strokeColors.firstObject ?: [UIColor blackColor];
+    return;
+  }
+
+  NSUInteger spanCount = MIN(segmentCount, kMaxAnimationSpans);
+  double segmentsPerSpan = (double)segmentCount / spanCount;
+
+  for (NSUInteger i = 0; i < spanCount; i++) {
+    CGFloat gradientPos = ((CGFloat)i + 0.5) / spanCount;
     UIColor *color = [self colorAtGradientPosition:gradientPos];
     GMSStrokeStyle *style = [GMSStrokeStyle solidColor:color];
-    [spans addObject:[GMSStyleSpan spanWithStyle:style]];
+    [spans addObject:[GMSStyleSpan spanWithStyle:style segments:segmentsPerSpan]];
   }
 
   _polyline.path = path;

package/ios/core/GoogleMapProvider.h

@@ -0,0 +1,13 @@
+#import "MapProviderDelegate.h"
+#import <GoogleMaps/GoogleMaps.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface GoogleMapProvider : NSObject <MapProvider, GMSMapViewDelegate>
+
+@property(nonatomic, copy, nullable) NSString *mapId;
+@property(nonatomic, readonly, nullable) GMSMapView *mapView;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/{LuggGoogleMapView.mm → core/GoogleMapProvider.mm}

@@ -1,137 +1,53 @@
-#import "LuggGoogleMapView.h"
-#import "LuggMarkerView.h"
-#import "LuggPolylineView.h"
-#import "core/GMSPolylineAnimator.h"
-#import "core/PolylineAnimatorBase.h"
-#import "events/CameraIdleEvent.h"
-#import "events/CameraMoveEvent.h"
-#import "events/ReadyEvent.h"
-
-#import <react/renderer/components/RNMapsSpec/ComponentDescriptors.h>
-#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
-#import <react/renderer/components/RNMapsSpec/Props.h>
-#import <react/renderer/components/RNMapsSpec/RCTComponentViewHelpers.h>
-
-#import "RCTFabricComponentsPlugins.h"
-
-using namespace facebook::react;
-using namespace luggmaps::events;
-
-#import "LuggMapWrapperView.h"
+#import "GoogleMapProvider.h"
+#import "../LuggMarkerView.h"
+#import "../LuggPolylineView.h"
+#import "GMSPolylineAnimator.h"
+#import "PolylineAnimatorBase.h"
 
 static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
-@interface LuggGoogleMapView () <RCTLuggGoogleMapViewViewProtocol,
-                                 GMSMapViewDelegate, LuggMarkerViewDelegate,
+@interface GoogleMapProvider () <LuggMarkerViewDelegate,
                                  LuggPolylineViewDelegate>
 @end
 
-@implementation LuggGoogleMapView {
+@implementation GoogleMapProvider {
   GMSMapView *_mapView;
-  LuggMapWrapperView *_mapWrapperView;
   BOOL _isMapReady;
   BOOL _isDragging;
-  NSString *_mapId;
+  NSString *_theme;
   NSMutableArray<LuggMarkerView *> *_pendingMarkerViews;
   NSMutableArray<LuggPolylineView *> *_pendingPolylineViews;
   NSMapTable<LuggPolylineView *, GMSPolylineAnimator *> *_polylineAnimators;
 }
 
-+ (ComponentDescriptorProvider)componentDescriptorProvider {
-  return concreteComponentDescriptorProvider<
-      LuggGoogleMapViewComponentDescriptor>();
-}
-
-- (instancetype)initWithFrame:(CGRect)frame {
-  if (self = [super initWithFrame:frame]) {
-    static const auto defaultProps =
-        std::make_shared<const LuggGoogleMapViewProps>();
-    _props = defaultProps;
+@synthesize delegate = _delegate;
 
+- (instancetype)init {
+  if (self = [super init]) {
     _isMapReady = NO;
     _mapId = kDemoMapId;
     _pendingMarkerViews = [NSMutableArray array];
     _pendingPolylineViews = [NSMutableArray array];
     _polylineAnimators = [NSMapTable weakToStrongObjectsMapTable];
   }
-
   return self;
 }
 
-#pragma mark - View Lifecycle
-
-- (void)mountChildComponentView:
-            (UIView<RCTComponentViewProtocol> *)childComponentView
-                          index:(NSInteger)index {
-  [super mountChildComponentView:childComponentView index:index];
-
-  if ([childComponentView isKindOfClass:[LuggMapWrapperView class]]) {
-    _mapWrapperView = (LuggMapWrapperView *)childComponentView;
-  } else if ([childComponentView isKindOfClass:[LuggMarkerView class]]) {
-    LuggMarkerView *markerView = (LuggMarkerView *)childComponentView;
-    markerView.delegate = self;
-    [self syncMarkerView:markerView caller:@"mountChildComponentView"];
-  } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
-    LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
-    polylineView.delegate = self;
-    [self syncPolylineView:polylineView];
-  }
+- (BOOL)isMapReady {
+  return _isMapReady;
 }
 
-- (void)unmountChildComponentView:
-            (UIView<RCTComponentViewProtocol> *)childComponentView
-                            index:(NSInteger)index {
-  if ([childComponentView isKindOfClass:[LuggMarkerView class]]) {
-    LuggMarkerView *markerView = (LuggMarkerView *)childComponentView;
-    GMSAdvancedMarker *marker = (GMSAdvancedMarker *)markerView.marker;
-    if (marker) {
-      marker.iconView = nil;
-      marker.map = nil;
-      markerView.marker = nil;
-    }
-    [markerView resetIconViewTransform];
-  } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
-    LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
-    [_polylineAnimators removeObjectForKey:polylineView];
-    GMSPolyline *polyline = (GMSPolyline *)polylineView.polyline;
-    if (polyline) {
-      polyline.map = nil;
-      polylineView.polyline = nil;
-    }
-  }
-
-  [super unmountChildComponentView:childComponentView index:index];
-}
-
-- (void)didMoveToWindow {
-  [super didMoveToWindow];
-  if (self.window && !_mapView && _mapWrapperView) {
-    [self initializeMap];
-  }
-}
-
-- (void)prepareForRecycle {
-  [super prepareForRecycle];
-
-  [_pendingMarkerViews removeAllObjects];
-  [_pendingPolylineViews removeAllObjects];
-  [_polylineAnimators removeAllObjects];
-  [_mapView clear];
-  [_mapView removeFromSuperview];
-  _mapView = nil;
-  _mapWrapperView = nil;
-  _isMapReady = NO;
+- (GMSMapView *)mapView {
+  return _mapView;
 }
 
-#pragma mark - Map Initialization
+#pragma mark - MapProvider
 
-- (void)initializeMap {
-  if (_mapView || !_mapWrapperView) {
+- (void)initializeMapInView:(UIView *)wrapperView
+          initialCoordinate:(CLLocationCoordinate2D)coordinate
+                initialZoom:(double)zoom {
+  if (_mapView)
     return;
-  }
-
-  const auto &viewProps =
-      *std::static_pointer_cast<LuggGoogleMapViewProps const>(_props);
 
   GMSMapID *gmsMapId;
   if ([_mapId isEqualToString:kDemoMapId] || _mapId.length == 0) {
@@ -140,13 +56,13 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
     gmsMapId = [GMSMapID mapIDWithIdentifier:_mapId];
   }
 
-  GMSCameraPosition *camera = [GMSCameraPosition
-      cameraWithLatitude:viewProps.initialCoordinate.latitude
-               longitude:viewProps.initialCoordinate.longitude
-                    zoom:viewProps.initialZoom];
+  GMSCameraPosition *camera =
+      [GMSCameraPosition cameraWithLatitude:coordinate.latitude
+                                  longitude:coordinate.longitude
+                                       zoom:zoom];
 
   GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
-  options.frame = _mapWrapperView.bounds;
+  options.frame = wrapperView.bounds;
   options.camera = camera;
   options.mapID = gmsMapId;
 
@@ -156,42 +72,84 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   _mapView.delegate = self;
   _mapView.paddingAdjustmentBehavior =
       kGMSMapViewPaddingAdjustmentBehaviorNever;
-  _mapView.settings.zoomGestures = viewProps.zoomEnabled;
-  _mapView.settings.scrollGestures = viewProps.scrollEnabled;
-  _mapView.settings.rotateGestures = viewProps.rotateEnabled;
-  _mapView.settings.tiltGestures = viewProps.pitchEnabled;
-  _mapView.myLocationEnabled = viewProps.userLocationEnabled;
 
-  if (viewProps.theme == LuggGoogleMapViewTheme::Dark) {
+  [wrapperView addSubview:_mapView];
+
+  [self applyTheme];
+
+  _isMapReady = YES;
+  [self processPendingMarkers];
+  [self processPendingPolylines];
+
+  [_delegate mapProviderDidReady];
+}
+
+- (void)destroy {
+  [_pendingMarkerViews removeAllObjects];
+  [_pendingPolylineViews removeAllObjects];
+  [_polylineAnimators removeAllObjects];
+  [_mapView clear];
+  [_mapView removeFromSuperview];
+  _mapView = nil;
+  _isMapReady = NO;
+}
+
+#pragma mark - Props
+
+- (void)setZoomEnabled:(BOOL)enabled {
+  _mapView.settings.zoomGestures = enabled;
+}
+
+- (void)setScrollEnabled:(BOOL)enabled {
+  _mapView.settings.scrollGestures = enabled;
+}
+
+- (void)setRotateEnabled:(BOOL)enabled {
+  _mapView.settings.rotateGestures = enabled;
+}
+
+- (void)setPitchEnabled:(BOOL)enabled {
+  _mapView.settings.tiltGestures = enabled;
+}
+
+- (void)setUserLocationEnabled:(BOOL)enabled {
+  _mapView.myLocationEnabled = enabled;
+}
+
+- (void)setTheme:(NSString *)theme {
+  _theme = [theme copy];
+  [self applyTheme];
+}
+
+- (void)applyTheme {
+  if (!_mapView)
+    return;
+
+  if ([_theme isEqualToString:@"dark"]) {
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleDark;
-  } else if (viewProps.theme == LuggGoogleMapViewTheme::Light) {
+  } else if ([_theme isEqualToString:@"light"]) {
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
   } else {
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleUnspecified;
   }
+}
 
-  if (viewProps.minZoom > 0) {
-    [_mapView setMinZoom:(float)viewProps.minZoom maxZoom:_mapView.maxZoom];
-  }
-  if (viewProps.maxZoom > 0) {
-    [_mapView setMinZoom:_mapView.minZoom maxZoom:(float)viewProps.maxZoom];
-  }
-
-  _mapView.padding =
-      UIEdgeInsetsMake(viewProps.padding.top, viewProps.padding.left,
-                       viewProps.padding.bottom, viewProps.padding.right);
-
-  [_mapWrapperView addSubview:_mapView];
-
-  _isMapReady = YES;
-  [self processPendingMarkers];
-  [self processPendingPolylines];
+- (void)setMinZoom:(double)minZoom {
+  if (!_mapView)
+    return;
+  float min = minZoom > 0 ? (float)minZoom : _mapView.minZoom;
+  [_mapView setMinZoom:min maxZoom:_mapView.maxZoom];
+}
 
-  ReadyEvent::emit<LuggGoogleMapViewEventEmitter>(_eventEmitter);
+- (void)setMaxZoom:(double)maxZoom {
+  if (!_mapView)
+    return;
+  float max = maxZoom > 0 ? (float)maxZoom : _mapView.maxZoom;
+  [_mapView setMinZoom:_mapView.minZoom maxZoom:max];
 }
 
-- (GMSMapView *)mapView {
-  return _mapView;
+- (void)setPadding:(UIEdgeInsets)padding oldPadding:(UIEdgeInsets)oldPadding {
+  _mapView.padding = padding;
 }
 
 #pragma mark - GMSMapViewDelegate
@@ -207,9 +165,10 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
 - (void)mapView:(GMSMapView *)mapView
     didChangeCameraPosition:(GMSCameraPosition *)position {
-  CameraMoveEvent{position.target.latitude, position.target.longitude,
-                  position.zoom, _isDragging}
-      .emit<LuggGoogleMapViewEventEmitter>(_eventEmitter);
+  [_delegate mapProviderDidMoveCamera:position.target.latitude
+                            longitude:position.target.longitude
+                                 zoom:position.zoom
+                              gesture:_isDragging];
 }
 
 - (void)mapView:(GMSMapView *)mapView
@@ -221,59 +180,46 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
       [animator resume];
     }
   }
-  CameraIdleEvent{position.target.latitude, position.target.longitude,
-                  position.zoom, static_cast<bool>(wasDragging)}
-      .emit<LuggGoogleMapViewEventEmitter>(_eventEmitter);
-}
-
-#pragma mark - PolylineViewDelegate
-
-- (void)polylineViewDidUpdate:(LuggPolylineView *)polylineView {
-  [self syncPolylineView:polylineView];
+  [_delegate mapProviderDidIdleCamera:position.target.latitude
+                            longitude:position.target.longitude
+                                 zoom:position.zoom
+                              gesture:wasDragging];
 }
 
 #pragma mark - MarkerViewDelegate
 
 - (void)markerViewDidLayout:(LuggMarkerView *)markerView {
-  [self syncMarkerView:markerView caller:@"markerViewDidLayout"];
+  [self syncMarkerView:markerView];
 }
 
 - (void)markerViewDidUpdate:(LuggMarkerView *)markerView {
-  [self syncMarkerView:markerView caller:@"markerViewDidUpdate"];
+  [self syncMarkerView:markerView];
+}
+
+#pragma mark - PolylineViewDelegate
+
+- (void)polylineViewDidUpdate:(LuggPolylineView *)polylineView {
+  [self syncPolylineView:polylineView];
 }
 
 #pragma mark - Marker Management
 
-- (void)applyMarkerStyle:(LuggMarkerView *)markerView
-                  marker:(GMSAdvancedMarker *)marker {
-  if (markerView.hasCustomView) {
-    if (markerView.rasterize) {
-      marker.iconView = nil;
-      marker.icon = [markerView createScaledIconImage];
-      marker.rotation = markerView.rotate;
-    } else {
-      UIView *iconView = markerView.iconView;
-      if (marker.iconView != iconView) {
-        [iconView removeFromSuperview];
-        marker.iconView = iconView;
-      }
-      CGFloat scale = markerView.scale;
-      CGFloat radians = markerView.rotate * M_PI / 180.0;
-      iconView.transform =
-          CGAffineTransformConcat(CGAffineTransformMakeScale(scale, scale),
-                                  CGAffineTransformMakeRotation(radians));
-      marker.rotation = 0;
-    }
-    marker.groundAnchor = markerView.anchor;
-  } else {
+- (void)addMarkerView:(LuggMarkerView *)markerView {
+  markerView.delegate = self;
+  [self syncMarkerView:markerView];
+}
+
+- (void)removeMarkerView:(LuggMarkerView *)markerView {
+  GMSAdvancedMarker *marker = (GMSAdvancedMarker *)markerView.marker;
+  if (marker) {
     marker.iconView = nil;
-    marker.icon = nil;
-    marker.rotation = markerView.rotate;
-    marker.groundAnchor = CGPointMake(0.5, 1);
+    marker.map = nil;
+    markerView.marker = nil;
   }
+  [markerView resetIconViewTransform];
 }
 
-- (void)syncMarkerView:(LuggMarkerView *)markerView caller:(NSString *)caller {
+- (void)syncMarkerView:(LuggMarkerView *)markerView {
   if (!_mapView) {
     if (![_pendingMarkerViews containsObject:markerView]) {
       [_pendingMarkerViews addObject:markerView];
@@ -295,9 +241,8 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 }
 
 - (void)processPendingMarkers {
-  if (!_mapView) {
+  if (!_mapView)
     return;
-  }
 
   for (LuggMarkerView *markerView in _pendingMarkerViews) {
     [self addMarkerViewToMap:markerView];
@@ -306,10 +251,8 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 }
 
 - (void)addMarkerViewToMap:(LuggMarkerView *)markerView {
-  if (!_mapView) {
-    RCTLogWarn(@"Lugg: addMarkerViewToMap called without a map");
+  if (!_mapView)
     return;
-  }
 
   GMSAdvancedMarker *marker = [[GMSAdvancedMarker alloc] init];
   marker.position = markerView.coordinate;
@@ -323,8 +266,51 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   markerView.marker = marker;
 }
 
+- (void)applyMarkerStyle:(LuggMarkerView *)markerView
+                  marker:(GMSAdvancedMarker *)marker {
+  if (markerView.hasCustomView) {
+    if (markerView.rasterize) {
+      marker.iconView = nil;
+      marker.icon = [markerView createScaledIconImage];
+      marker.rotation = markerView.rotate;
+    } else {
+      UIView *iconView = markerView.iconView;
+      if (marker.iconView != iconView) {
+        [iconView removeFromSuperview];
+        marker.iconView = iconView;
+      }
+      CGFloat scale = markerView.scale;
+      CGFloat radians = markerView.rotate * M_PI / 180.0;
+      iconView.transform =
+          CGAffineTransformConcat(CGAffineTransformMakeScale(scale, scale),
+                                  CGAffineTransformMakeRotation(radians));
+      marker.rotation = 0;
+    }
+    marker.groundAnchor = markerView.anchor;
+  } else {
+    marker.iconView = nil;
+    marker.icon = nil;
+    marker.rotation = markerView.rotate;
+    marker.groundAnchor = CGPointMake(0.5, 1);
+  }
+}
+
 #pragma mark - Polyline Management
 
+- (void)addPolylineView:(LuggPolylineView *)polylineView {
+  polylineView.delegate = self;
+  [self syncPolylineView:polylineView];
+}
+
+- (void)removePolylineView:(LuggPolylineView *)polylineView {
+  [_polylineAnimators removeObjectForKey:polylineView];
+  GMSPolyline *polyline = (GMSPolyline *)polylineView.polyline;
+  if (polyline) {
+    polyline.map = nil;
+    polylineView.polyline = nil;
+  }
+}
+
 - (void)syncPolylineView:(LuggPolylineView *)polylineView {
   if (!_mapView) {
     if (![_pendingPolylineViews containsObject:polylineView]) {
@@ -354,9 +340,8 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 }
 
 - (void)processPendingPolylines {
-  if (!_mapView) {
+  if (!_mapView)
     return;
-  }
 
   for (LuggPolylineView *polylineView in _pendingPolylineViews) {
     [self addPolylineViewToMap:polylineView];
@@ -365,9 +350,8 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 }
 
 - (void)addPolylineViewToMap:(LuggPolylineView *)polylineView {
-  if (!_mapView) {
+  if (!_mapView)
     return;
-  }
 
   GMSPolyline *polyline = [GMSPolyline polylineWithPath:[GMSMutablePath path]];
   polyline.strokeWidth = polylineView.strokeWidth;
@@ -386,52 +370,18 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   [_polylineAnimators setObject:animator forKey:polylineView];
 }
 
-#pragma mark - Property Setters
-
-- (void)updateProps:(Props::Shared const &)props
-           oldProps:(Props::Shared const &)oldProps {
-  const auto &oldViewProps =
-      *std::static_pointer_cast<LuggGoogleMapViewProps const>(oldProps);
-  const auto &newViewProps =
-      *std::static_pointer_cast<LuggGoogleMapViewProps const>(props);
+#pragma mark - Lifecycle
 
-  if (_mapView == nil) {
-    NSString *newMapId =
-        [NSString stringWithUTF8String:newViewProps.mapId.c_str()];
-    if (newMapId.length > 0) {
-      _mapId = newMapId;
-    }
+- (void)pauseAnimations {
+  for (GMSPolylineAnimator *animator in _polylineAnimators.objectEnumerator) {
+    [animator pause];
   }
+}
 
-  if (_mapView) {
-    _mapView.settings.zoomGestures = newViewProps.zoomEnabled;
-    _mapView.settings.scrollGestures = newViewProps.scrollEnabled;
-    _mapView.settings.rotateGestures = newViewProps.rotateEnabled;
-    _mapView.settings.tiltGestures = newViewProps.pitchEnabled;
-    _mapView.myLocationEnabled = newViewProps.userLocationEnabled;
-
-    if (oldViewProps.theme != newViewProps.theme) {
-      if (newViewProps.theme == LuggGoogleMapViewTheme::Dark) {
-        _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleDark;
-      } else if (newViewProps.theme == LuggGoogleMapViewTheme::Light) {
-        _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
-      } else {
-        _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleUnspecified;
-      }
-    }
-
-    _mapView.padding = UIEdgeInsetsMake(
-        newViewProps.padding.top, newViewProps.padding.left,
-        newViewProps.padding.bottom, newViewProps.padding.right);
-
-    float minZoom = newViewProps.minZoom > 0 ? (float)newViewProps.minZoom
-                                             : _mapView.minZoom;
-    float maxZoom = newViewProps.maxZoom > 0 ? (float)newViewProps.maxZoom
-                                             : _mapView.maxZoom;
-    [_mapView setMinZoom:minZoom maxZoom:maxZoom];
+- (void)resumeAnimations {
+  for (GMSPolylineAnimator *animator in _polylineAnimators.objectEnumerator) {
+    [animator resume];
   }
-
-  [super updateProps:props oldProps:oldProps];
 }
 
 #pragma mark - Commands
@@ -440,9 +390,8 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
          longitude:(double)longitude
               zoom:(double)zoom
           duration:(double)duration {
-  if (!_mapView) {
+  if (!_mapView)
     return;
-  }
 
   float targetZoom = zoom > 0 ? (float)zoom : _mapView.camera.zoom;
   GMSCameraPosition *camera = [GMSCameraPosition cameraWithLatitude:latitude
@@ -466,9 +415,8 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
          paddingBottom:(double)paddingBottom
           paddingRight:(double)paddingRight
               duration:(double)duration {
-  if (!_mapView || coordinates.count == 0) {
+  if (!_mapView || coordinates.count == 0)
     return;
-  }
 
   GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc] init];
   for (NSDictionary *coord in coordinates) {
@@ -494,12 +442,4 @@ static NSString *const kDemoMapId = @"DEMO_MAP_ID";
   }
 }
 
-- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
-  RCTLuggGoogleMapViewHandleCommand(self, commandName, args);
-}
-
-Class<RCTComponentViewProtocol> LuggGoogleMapViewCls(void) {
-  return LuggGoogleMapView.class;
-}
-
 @end

package/ios/core/MapProviderDelegate.h

@@ -0,0 +1,68 @@
+#import <CoreLocation/CoreLocation.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LuggMarkerView;
+@class LuggPolylineView;
+
+@protocol MapProviderDelegate <NSObject>
+- (void)mapProviderDidReady;
+- (void)mapProviderDidMoveCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture;
+- (void)mapProviderDidIdleCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture;
+@end
+
+@protocol MapProvider <NSObject>
+
+@property(nonatomic, weak, nullable) id<MapProviderDelegate> delegate;
+@property(nonatomic, readonly) BOOL isMapReady;
+
+- (void)initializeMapInView:(UIView *)wrapperView
+          initialCoordinate:(CLLocationCoordinate2D)coordinate
+                initialZoom:(double)zoom;
+- (void)destroy;
+
+// Props
+- (void)setZoomEnabled:(BOOL)enabled;
+- (void)setScrollEnabled:(BOOL)enabled;
+- (void)setRotateEnabled:(BOOL)enabled;
+- (void)setPitchEnabled:(BOOL)enabled;
+- (void)setUserLocationEnabled:(BOOL)enabled;
+- (void)setTheme:(NSString *)theme;
+- (void)setMinZoom:(double)minZoom;
+- (void)setMaxZoom:(double)maxZoom;
+- (void)setPadding:(UIEdgeInsets)padding oldPadding:(UIEdgeInsets)oldPadding;
+
+// Children
+- (void)addMarkerView:(LuggMarkerView *)markerView;
+- (void)removeMarkerView:(LuggMarkerView *)markerView;
+- (void)syncMarkerView:(LuggMarkerView *)markerView;
+- (void)addPolylineView:(LuggPolylineView *)polylineView;
+- (void)removePolylineView:(LuggPolylineView *)polylineView;
+- (void)syncPolylineView:(LuggPolylineView *)polylineView;
+
+// Lifecycle
+- (void)pauseAnimations;
+- (void)resumeAnimations;
+
+// Commands
+- (void)moveCamera:(double)latitude
+         longitude:(double)longitude
+              zoom:(double)zoom
+          duration:(double)duration;
+- (void)fitCoordinates:(NSArray *)coordinates
+            paddingTop:(double)paddingTop
+           paddingLeft:(double)paddingLeft
+         paddingBottom:(double)paddingBottom
+          paddingRight:(double)paddingRight
+              duration:(double)duration;
+
+@end
+
+NS_ASSUME_NONNULL_END