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

package/ios/{LuggAppleMapView.mm → core/AppleMapProvider.mm}

@@ -1,22 +1,8 @@
-#import "LuggAppleMapView.h"
-#import "LuggMapWrapperView.h"
-#import "LuggMarkerView.h"
-#import "LuggPolylineView.h"
-#import "core/MKPolylineAnimator.h"
-#import "events/CameraIdleEvent.h"
-#import "events/CameraMoveEvent.h"
-#import "events/ReadyEvent.h"
-#import "extensions/MKMapView+Zoom.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 "AppleMapProvider.h"
+#import "../LuggMarkerView.h"
+#import "../LuggPolylineView.h"
+#import "../extensions/MKMapView+Zoom.h"
+#import "MKPolylineAnimator.h"
 
 @interface AppleMarkerAnnotation : NSObject <MKAnnotation>
 @property(nonatomic, assign) CLLocationCoordinate2D coordinate;
@@ -32,14 +18,12 @@ using namespace luggmaps::events;
 @implementation LuggAppleMapViewContent
 @end
 
-@interface LuggAppleMapView () <RCTLuggAppleMapViewViewProtocol,
-                                MKMapViewDelegate, LuggMarkerViewDelegate,
+@interface AppleMapProvider () <LuggMarkerViewDelegate,
                                 LuggPolylineViewDelegate>
 @end
 
-@implementation LuggAppleMapView {
+@implementation AppleMapProvider {
   LuggAppleMapViewContent *_mapView;
-  LuggMapWrapperView *_mapWrapperView;
   BOOL _isMapReady;
   BOOL _isDragging;
   double _minZoom;
@@ -47,179 +31,122 @@ using namespace luggmaps::events;
   NSMapTable<id<MKOverlay>, LuggPolylineView *> *_overlayToPolylineMap;
 }
 
-+ (ComponentDescriptorProvider)componentDescriptorProvider {
-  return concreteComponentDescriptorProvider<
-      LuggAppleMapViewComponentDescriptor>();
-}
+@synthesize delegate = _delegate;
 
-- (instancetype)initWithFrame:(CGRect)frame {
-  if (self = [super initWithFrame:frame]) {
-    static const auto defaultProps =
-        std::make_shared<const LuggAppleMapViewProps>();
-    _props = defaultProps;
+- (instancetype)init {
+  if (self = [super init]) {
     _overlayToPolylineMap = [NSMapTable strongToWeakObjectsMapTable];
   }
-
   return self;
 }
 
-#pragma mark - View Lifecycle
+- (BOOL)isMapReady {
+  return _isMapReady;
+}
 
-- (void)mountChildComponentView:
-            (UIView<RCTComponentViewProtocol> *)childComponentView
-                          index:(NSInteger)index {
-  [super mountChildComponentView:childComponentView index:index];
+- (MKMapView *)mapView {
+  return _mapView;
+}
 
-  if ([childComponentView isKindOfClass:[LuggMapWrapperView class]]) {
-    _mapWrapperView = (LuggMapWrapperView *)childComponentView;
-  } else if ([childComponentView isKindOfClass:[LuggMarkerView class]]) {
-    LuggMarkerView *markerView = (LuggMarkerView *)childComponentView;
-    markerView.delegate = self;
+#pragma mark - MapProvider
 
-    AppleMarkerAnnotation *annotation = [[AppleMarkerAnnotation alloc] init];
-    annotation.markerView = markerView;
-    markerView.marker = annotation;
+- (void)initializeMapInView:(UIView *)wrapperView
+          initialCoordinate:(CLLocationCoordinate2D)coordinate
+                initialZoom:(double)zoom {
+  if (_mapView)
+    return;
 
-    if (_mapView) {
-      [_mapView addAnnotation:annotation];
-    }
+  _mapView = [[LuggAppleMapViewContent alloc] initWithFrame:wrapperView.bounds];
+  _mapView.autoresizingMask =
+      UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+  _mapView.delegate = self;
+  _mapView.insetsLayoutMarginsFromSafeArea = NO;
 
-    [self markerViewDidUpdate:markerView];
-  } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
-    LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
-    polylineView.delegate = self;
-    [self addPolylineViewToMap:polylineView];
-  }
-}
+  [self applyZoomRange];
 
-- (void)unmountChildComponentView:
-            (UIView<RCTComponentViewProtocol> *)childComponentView
-                            index:(NSInteger)index {
-  if ([childComponentView isKindOfClass:[LuggMarkerView class]]) {
-    LuggMarkerView *markerView = (LuggMarkerView *)childComponentView;
-    markerView.delegate = nil;
+  [wrapperView addSubview:_mapView];
 
-    AppleMarkerAnnotation *annotation =
-        (AppleMarkerAnnotation *)markerView.marker;
+  MKCoordinateRegion region = [_mapView regionForCenterCoordinate:coordinate
+                                                        zoomLevel:zoom];
+  [_mapView setRegion:region animated:NO];
 
-    if (annotation) {
-      annotation.annotationView.transform = CGAffineTransformIdentity;
-      annotation.markerView = nil;
-      annotation.annotationView = nil;
-      [_mapView removeAnnotation:annotation];
-      markerView.marker = nil;
-    }
-    [markerView resetIconViewTransform];
-  } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
-    LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
-    polylineView.delegate = nil;
-    MKPolyline *polyline = (MKPolyline *)polylineView.polyline;
-    if (polyline) {
-      [_overlayToPolylineMap removeObjectForKey:polyline];
-      [_mapView removeOverlay:polyline];
-      polylineView.polyline = nil;
-    }
-  }
+  _isMapReady = YES;
 
-  [super unmountChildComponentView:childComponentView index:index];
+  [_delegate mapProviderDidReady];
 }
 
-- (void)didMoveToWindow {
-  [super didMoveToWindow];
-  if (self.window && !_mapView && _mapWrapperView) {
-    [self initializeMap];
-  }
-}
-
-- (void)prepareForRecycle {
-  [super prepareForRecycle];
-
+- (void)destroy {
   [_mapView removeFromSuperview];
   _mapView = nil;
-  _mapWrapperView = nil;
   _isMapReady = NO;
 }
 
-#pragma mark - Map Initialization
+#pragma mark - Props
 
-- (void)initializeMap {
-  if (_mapView || !_mapWrapperView) {
-    return;
-  }
+- (void)setZoomEnabled:(BOOL)enabled {
+  _mapView.zoomEnabled = enabled;
+}
 
-  const auto &viewProps =
-      *std::static_pointer_cast<LuggAppleMapViewProps const>(_props);
+- (void)setScrollEnabled:(BOOL)enabled {
+  _mapView.scrollEnabled = enabled;
+}
 
-  _mapView =
-      [[LuggAppleMapViewContent alloc] initWithFrame:_mapWrapperView.bounds];
-  _mapView.autoresizingMask =
-      UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
-  _mapView.delegate = self;
-  _mapView.insetsLayoutMarginsFromSafeArea = NO;
-  _mapView.zoomEnabled = viewProps.zoomEnabled;
-  _mapView.scrollEnabled = viewProps.scrollEnabled;
-  _mapView.rotateEnabled = viewProps.rotateEnabled;
-  _mapView.pitchEnabled = viewProps.pitchEnabled;
-  _mapView.showsUserLocation = viewProps.userLocationEnabled;
+- (void)setRotateEnabled:(BOOL)enabled {
+  _mapView.rotateEnabled = enabled;
+}
 
-  if (viewProps.theme == LuggAppleMapViewTheme::Dark) {
+- (void)setPitchEnabled:(BOOL)enabled {
+  _mapView.pitchEnabled = enabled;
+}
+
+- (void)setUserLocationEnabled:(BOOL)enabled {
+  _mapView.showsUserLocation = enabled;
+}
+
+- (void)setTheme:(NSString *)theme {
+  if ([theme isEqualToString:@"dark"]) {
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleDark;
-  } else if (viewProps.theme == LuggAppleMapViewTheme::Light) {
+  } else if ([theme isEqualToString:@"light"]) {
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
   } else {
     _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleUnspecified;
   }
+}
 
-  _minZoom = viewProps.minZoom;
-  _maxZoom = viewProps.maxZoom;
+- (void)setMinZoom:(double)minZoom {
+  _minZoom = minZoom;
   [self applyZoomRange];
+}
 
-  _mapView.layoutMargins =
-      UIEdgeInsetsMake(viewProps.padding.top, viewProps.padding.left,
-                       viewProps.padding.bottom, viewProps.padding.right);
-
-  [_mapWrapperView addSubview:_mapView];
-
-  CLLocationCoordinate2D center =
-      CLLocationCoordinate2DMake(viewProps.initialCoordinate.latitude,
-                                 viewProps.initialCoordinate.longitude);
-  MKCoordinateRegion region =
-      [_mapView regionForCenterCoordinate:center
-                                zoomLevel:viewProps.initialZoom];
-  [_mapView setRegion:region animated:NO];
+- (void)setMaxZoom:(double)maxZoom {
+  _maxZoom = maxZoom;
+  [self applyZoomRange];
+}
 
-  // Add annotations for any markers that were mounted before map was ready
-  for (UIView *subview in self.subviews) {
-    if ([subview isKindOfClass:[LuggMarkerView class]]) {
-      LuggMarkerView *markerView = (LuggMarkerView *)subview;
-      AppleMarkerAnnotation *annotation =
-          (AppleMarkerAnnotation *)markerView.marker;
-      if (annotation) {
-        [_mapView addAnnotation:annotation];
-      }
-    } else if ([subview isKindOfClass:[LuggPolylineView class]]) {
-      LuggPolylineView *polylineView = (LuggPolylineView *)subview;
-      [self addPolylineViewToMap:polylineView];
-    }
-  }
+- (void)setPadding:(UIEdgeInsets)padding oldPadding:(UIEdgeInsets)oldPadding {
+  CGFloat oldOffsetX = (oldPadding.left - oldPadding.right) / 2.0;
+  CGFloat oldOffsetY = (oldPadding.top - oldPadding.bottom) / 2.0;
+  CGFloat newOffsetX = (padding.left - padding.right) / 2.0;
+  CGFloat newOffsetY = (padding.top - padding.bottom) / 2.0;
 
-  _isMapReady = YES;
+  CGFloat deltaX = newOffsetX - oldOffsetX;
+  CGFloat deltaY = newOffsetY - oldOffsetY;
 
-  ReadyEvent::emit<LuggAppleMapViewEventEmitter>(_eventEmitter);
-}
+  _mapView.layoutMargins = padding;
 
-- (void)setCameraWithLatitude:(double)latitude
-                    longitude:(double)longitude
-                         zoom:(double)zoom
-                     animated:(BOOL)animated {
-  CLLocationCoordinate2D center =
-      CLLocationCoordinate2DMake(latitude, longitude);
-  [_mapView setCenterCoordinate:center zoomLevel:zoom animated:animated];
+  if (deltaX != 0 || deltaY != 0) {
+    CLLocationCoordinate2D currentCenter = _mapView.centerCoordinate;
+    CGPoint centerPoint = [_mapView convertCoordinate:currentCenter
+                                        toPointToView:_mapView];
+    CGPoint newPoint =
+        CGPointMake(centerPoint.x - deltaX, centerPoint.y - deltaY);
+    CLLocationCoordinate2D newCenter = [_mapView convertPoint:newPoint
+                                         toCoordinateFromView:_mapView];
+    [_mapView setCenterCoordinate:newCenter animated:NO];
+  }
 }
 
 - (CLLocationDistance)cameraDistanceForZoomLevel:(double)zoomLevel {
-  // Approximate conversion: at zoom 0, altitude ~128M km
-  // Each zoom level halves the altitude
   return 128000000.0 / pow(2, zoomLevel);
 }
 
@@ -238,88 +165,189 @@ using namespace luggmaps::events;
   _mapView.cameraZoomRange = zoomRange;
 }
 
-- (MKMapView *)mapView {
-  return _mapView;
+#pragma mark - MKMapViewDelegate
+
+- (BOOL)isUserInteracting {
+  UIView *mapContainerView = _mapView.subviews.firstObject;
+  for (UIGestureRecognizer *gesture in mapContainerView.gestureRecognizers) {
+    if (gesture.state == UIGestureRecognizerStateBegan ||
+        gesture.state == UIGestureRecognizerStateChanged) {
+      return YES;
+    }
+  }
+  return NO;
 }
 
-#pragma mark - Property Setters
+- (void)mapView:(MKMapView *)mapView regionWillChangeAnimated:(BOOL)animated {
+  _isDragging = [self isUserInteracting];
+  if (_isDragging) {
+    for (LuggPolylineView *polylineView in _overlayToPolylineMap
+             .objectEnumerator) {
+      MKPolylineAnimator *renderer =
+          (MKPolylineAnimator *)polylineView.renderer;
+      [renderer pause];
+    }
+  }
+}
 
-- (void)updateProps:(Props::Shared const &)props
-           oldProps:(Props::Shared const &)oldProps {
-  const auto &oldViewProps =
-      *std::static_pointer_cast<LuggAppleMapViewProps const>(oldProps);
-  const auto &newViewProps =
-      *std::static_pointer_cast<LuggAppleMapViewProps const>(props);
+- (void)mapViewDidChangeVisibleRegion:(MKMapView *)mapView {
+  [_delegate mapProviderDidMoveCamera:mapView.centerCoordinate.latitude
+                            longitude:mapView.centerCoordinate.longitude
+                                 zoom:mapView.zoomLevel
+                              gesture:_isDragging];
+}
 
-  if (_mapView) {
-    _mapView.zoomEnabled = newViewProps.zoomEnabled;
-    _mapView.scrollEnabled = newViewProps.scrollEnabled;
-    _mapView.rotateEnabled = newViewProps.rotateEnabled;
-    _mapView.pitchEnabled = newViewProps.pitchEnabled;
-    _mapView.showsUserLocation = newViewProps.userLocationEnabled;
-
-    if (oldViewProps.theme != newViewProps.theme) {
-      if (newViewProps.theme == LuggAppleMapViewTheme::Dark) {
-        _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleDark;
-      } else if (newViewProps.theme == LuggAppleMapViewTheme::Light) {
-        _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleLight;
-      } else {
-        _mapView.overrideUserInterfaceStyle = UIUserInterfaceStyleUnspecified;
-      }
+- (void)mapView:(MKMapView *)mapView regionDidChangeAnimated:(BOOL)animated {
+  BOOL wasDragging = _isDragging;
+  _isDragging = NO;
+  if (wasDragging) {
+    for (LuggPolylineView *polylineView in _overlayToPolylineMap
+             .objectEnumerator) {
+      MKPolylineAnimator *renderer =
+          (MKPolylineAnimator *)polylineView.renderer;
+      [renderer resume];
     }
+  }
+  [_delegate mapProviderDidIdleCamera:mapView.centerCoordinate.latitude
+                            longitude:mapView.centerCoordinate.longitude
+                                 zoom:mapView.zoomLevel
+                              gesture:wasDragging];
+}
 
-    // Check if padding changed
-    BOOL paddingChanged =
-        oldViewProps.padding.top != newViewProps.padding.top ||
-        oldViewProps.padding.left != newViewProps.padding.left ||
-        oldViewProps.padding.bottom != newViewProps.padding.bottom ||
-        oldViewProps.padding.right != newViewProps.padding.right;
-
-    if (paddingChanged) {
-      // Calculate the offset difference to keep visual center stable
-      CGFloat oldOffsetX =
-          (oldViewProps.padding.left - oldViewProps.padding.right) / 2.0;
-      CGFloat oldOffsetY =
-          (oldViewProps.padding.top - oldViewProps.padding.bottom) / 2.0;
-      CGFloat newOffsetX =
-          (newViewProps.padding.left - newViewProps.padding.right) / 2.0;
-      CGFloat newOffsetY =
-          (newViewProps.padding.top - newViewProps.padding.bottom) / 2.0;
-
-      CGFloat deltaX = newOffsetX - oldOffsetX;
-      CGFloat deltaY = newOffsetY - oldOffsetY;
-
-      // Apply new padding first
-      _mapView.layoutMargins = UIEdgeInsetsMake(
-          newViewProps.padding.top, newViewProps.padding.left,
-          newViewProps.padding.bottom, newViewProps.padding.right);
-
-      // Convert pixel offset to coordinate offset
-      if (deltaX != 0 || deltaY != 0) {
-        CLLocationCoordinate2D currentCenter = _mapView.centerCoordinate;
-        CGPoint centerPoint = [_mapView convertCoordinate:currentCenter
-                                            toPointToView:_mapView];
-        CGPoint newPoint =
-            CGPointMake(centerPoint.x - deltaX, centerPoint.y - deltaY);
-        CLLocationCoordinate2D newCenter = [_mapView convertPoint:newPoint
-                                             toCoordinateFromView:_mapView];
-        [_mapView setCenterCoordinate:newCenter animated:NO];
+- (MKAnnotationView *)mapView:(MKMapView *)mapView
+            viewForAnnotation:(id<MKAnnotation>)annotation {
+  if (![annotation isKindOfClass:[AppleMarkerAnnotation class]]) {
+    return nil;
+  }
+
+  AppleMarkerAnnotation *markerAnnotation = (AppleMarkerAnnotation *)annotation;
+  LuggMarkerView *markerView = markerAnnotation.markerView;
+
+  if (!markerView || !markerView.hasCustomView) {
+    return nil;
+  }
+
+  MKAnnotationView *annotationView =
+      [[MKAnnotationView alloc] initWithAnnotation:annotation
+                                   reuseIdentifier:nil];
+  annotationView.canShowCallout = YES;
+  annotationView.displayPriority = MKFeatureDisplayPriorityRequired;
+  annotationView.layer.zPosition = markerView.zIndex;
+  annotationView.zPriority = markerView.zIndex;
+
+  if (!markerView.rasterize) {
+    UIView *iconView = markerView.iconView;
+    [iconView removeFromSuperview];
+    [annotationView addSubview:iconView];
+  }
+
+  [self applyMarkerStyle:markerView annotationView:annotationView];
+  markerAnnotation.annotationView = annotationView;
+
+  return annotationView;
+}
+
+- (MKOverlayRenderer *)mapView:(MKMapView *)mapView
+            rendererForOverlay:(id<MKOverlay>)overlay {
+  if ([overlay isKindOfClass:[MKPolyline class]]) {
+    LuggPolylineView *polylineView =
+        [_overlayToPolylineMap objectForKey:overlay];
+    MKPolyline *polyline = (MKPolyline *)overlay;
+
+    if (polylineView) {
+      NSArray<UIColor *> *colors = polylineView.strokeColors;
+
+      MKPolylineAnimator *renderer =
+          [[MKPolylineAnimator alloc] initWithPolyline:polyline];
+      renderer.lineWidth = polylineView.strokeWidth;
+      renderer.strokeColor = colors.firstObject;
+      if (colors.count > 1) {
+        renderer.strokeColors = colors;
       }
-    } else {
-      _mapView.layoutMargins = UIEdgeInsetsMake(
-          newViewProps.padding.top, newViewProps.padding.left,
-          newViewProps.padding.bottom, newViewProps.padding.right);
+      renderer.animatedOptions = polylineView.animatedOptions;
+      renderer.animated = polylineView.animated;
+      polylineView.renderer = renderer;
+      return renderer;
     }
 
-    _minZoom = newViewProps.minZoom;
-    _maxZoom = newViewProps.maxZoom;
-    [self applyZoomRange];
+    MKPolylineRenderer *renderer =
+        [[MKPolylineRenderer alloc] initWithPolyline:polyline];
+    return renderer;
   }
+  return nil;
+}
+
+#pragma mark - MarkerViewDelegate
+
+- (void)markerViewDidLayout:(LuggMarkerView *)markerView {
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)markerView.marker;
+  if (annotation) {
+    [self updateAnnotationViewFrame:annotation];
+  }
+}
+
+- (void)markerViewDidUpdate:(LuggMarkerView *)markerView {
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)markerView.marker;
+
+  if (!annotation)
+    return;
+
+  annotation.coordinate = markerView.coordinate;
+  annotation.title = markerView.title;
+  annotation.subtitle = markerView.markerDescription;
+
+  MKAnnotationView *annotationView = annotation.annotationView;
+  if (annotationView) {
+    annotationView.layer.zPosition = markerView.zIndex;
+    annotationView.zPriority = markerView.zIndex;
+  }
+
+  [self updateAnnotationViewFrame:annotation];
+}
+
+#pragma mark - PolylineViewDelegate
+
+- (void)polylineViewDidUpdate:(LuggPolylineView *)polylineView {
+  [self syncPolylineView:polylineView];
+}
+
+#pragma mark - Marker Management
+
+- (void)addMarkerView:(LuggMarkerView *)markerView {
+  markerView.delegate = self;
+
+  AppleMarkerAnnotation *annotation = [[AppleMarkerAnnotation alloc] init];
+  annotation.markerView = markerView;
+  markerView.marker = annotation;
+
+  if (_mapView) {
+    [_mapView addAnnotation:annotation];
+  }
+
+  [self markerViewDidUpdate:markerView];
+}
+
+- (void)removeMarkerView:(LuggMarkerView *)markerView {
+  markerView.delegate = nil;
 
-  [super updateProps:props oldProps:oldProps];
+  AppleMarkerAnnotation *annotation =
+      (AppleMarkerAnnotation *)markerView.marker;
+
+  if (annotation) {
+    annotation.annotationView.transform = CGAffineTransformIdentity;
+    annotation.markerView = nil;
+    annotation.annotationView = nil;
+    [_mapView removeAnnotation:annotation];
+    markerView.marker = nil;
+  }
+  [markerView resetIconViewTransform];
 }
 
-#pragma mark - Annotation Helpers
+- (void)syncMarkerView:(LuggMarkerView *)markerView {
+  [self markerViewDidUpdate:markerView];
+}
 
 - (void)applyMarkerStyle:(LuggMarkerView *)markerView
           annotationView:(MKAnnotationView *)annotationView {
@@ -357,55 +385,36 @@ using namespace luggmaps::events;
   MKAnnotationView *annotationView = annotation.annotationView;
   LuggMarkerView *markerView = annotation.markerView;
 
-  if (!annotationView || !markerView) {
+  if (!annotationView || !markerView)
     return;
-  }
 
   [self applyMarkerStyle:markerView annotationView:annotationView];
 }
 
-#pragma mark - PolylineViewDelegate
-
-- (void)polylineViewDidUpdate:(LuggPolylineView *)polylineView {
-  [self syncPolylineView:polylineView];
-}
-
 #pragma mark - Polyline Management
 
-- (void)addPolylineViewToMap:(LuggPolylineView *)polylineView {
-  if (!_mapView) {
-    return;
-  }
+- (void)addPolylineView:(LuggPolylineView *)polylineView {
+  polylineView.delegate = self;
+  [self addPolylineOverlayToMap:polylineView];
+}
 
-  NSArray<CLLocation *> *coordinates = polylineView.coordinates;
-  if (coordinates.count == 0) {
-    return;
+- (void)removePolylineView:(LuggPolylineView *)polylineView {
+  polylineView.delegate = nil;
+  MKPolyline *polyline = (MKPolyline *)polylineView.polyline;
+  if (polyline) {
+    [_overlayToPolylineMap removeObjectForKey:polyline];
+    [_mapView removeOverlay:polyline];
+    polylineView.polyline = nil;
   }
-
-  CLLocationCoordinate2D *coords = (CLLocationCoordinate2D *)malloc(
-      sizeof(CLLocationCoordinate2D) * coordinates.count);
-  for (NSUInteger i = 0; i < coordinates.count; i++) {
-    coords[i] = coordinates[i].coordinate;
-  }
-
-  MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords
-                                                       count:coordinates.count];
-  free(coords);
-
-  polylineView.polyline = polyline;
-  [_overlayToPolylineMap setObject:polylineView forKey:polyline];
-  [self insertOverlay:polyline withZIndex:polylineView.zIndex];
 }
 
 - (void)syncPolylineView:(LuggPolylineView *)polylineView {
-  if (!_mapView) {
+  if (!_mapView)
     return;
-  }
 
   MKPolylineAnimator *renderer = (MKPolylineAnimator *)polylineView.renderer;
   MKPolyline *oldPolyline = (MKPolyline *)polylineView.polyline;
 
-  // Build new polyline from coordinates
   NSArray<CLLocation *> *coordinates = polylineView.coordinates;
   if (coordinates.count == 0) {
     if (renderer) {
@@ -432,7 +441,6 @@ using namespace luggmaps::events;
   polylineView.polyline = newPolyline;
   [_overlayToPolylineMap setObject:polylineView forKey:newPolyline];
 
-  // If we have an existing renderer, update it in place
   if (renderer && oldPolyline) {
     [_overlayToPolylineMap removeObjectForKey:oldPolyline];
     [_mapView removeOverlay:oldPolyline];
@@ -447,7 +455,6 @@ using namespace luggmaps::events;
     return;
   }
 
-  // Otherwise do full add
   if (oldPolyline) {
     [_overlayToPolylineMap removeObjectForKey:oldPolyline];
     [_mapView removeOverlay:oldPolyline];
@@ -455,6 +462,29 @@ using namespace luggmaps::events;
   [self insertOverlay:newPolyline withZIndex:polylineView.zIndex];
 }
 
+- (void)addPolylineOverlayToMap:(LuggPolylineView *)polylineView {
+  if (!_mapView)
+    return;
+
+  NSArray<CLLocation *> *coordinates = polylineView.coordinates;
+  if (coordinates.count == 0)
+    return;
+
+  CLLocationCoordinate2D *coords = (CLLocationCoordinate2D *)malloc(
+      sizeof(CLLocationCoordinate2D) * coordinates.count);
+  for (NSUInteger i = 0; i < coordinates.count; i++) {
+    coords[i] = coordinates[i].coordinate;
+  }
+
+  MKPolyline *polyline = [MKPolyline polylineWithCoordinates:coords
+                                                       count:coordinates.count];
+  free(coords);
+
+  polylineView.polyline = polyline;
+  [_overlayToPolylineMap setObject:polylineView forKey:polyline];
+  [self insertOverlay:polyline withZIndex:polylineView.zIndex];
+}
+
 - (void)insertOverlay:(id<MKOverlay>)overlay withZIndex:(NSInteger)zIndex {
   if (zIndex == 0) {
     [_mapView addOverlay:overlay];
@@ -466,7 +496,7 @@ using namespace luggmaps::events;
 
   for (NSInteger i = 0; i < overlays.count; i++) {
     LuggPolylineView *existingPolylineView =
-        [self findPolylineViewForOverlay:overlays[i]];
+        [_overlayToPolylineMap objectForKey:overlays[i]];
     if (existingPolylineView && existingPolylineView.zIndex > zIndex) {
       insertIndex = i;
       break;
@@ -476,172 +506,40 @@ using namespace luggmaps::events;
   [_mapView insertOverlay:overlay atIndex:insertIndex];
 }
 
-- (LuggPolylineView *)findPolylineViewForOverlay:(id<MKOverlay>)overlay {
-  return [_overlayToPolylineMap objectForKey:overlay];
-}
+#pragma mark - Lifecycle
 
-#pragma mark - MarkerViewDelegate
-
-- (void)markerViewDidLayout:(LuggMarkerView *)markerView {
-  AppleMarkerAnnotation *annotation =
-      (AppleMarkerAnnotation *)markerView.marker;
-  if (annotation) {
-    [self updateAnnotationViewFrame:annotation];
+- (void)pauseAnimations {
+  for (LuggPolylineView *polylineView in _overlayToPolylineMap
+           .objectEnumerator) {
+    MKPolylineAnimator *renderer = (MKPolylineAnimator *)polylineView.renderer;
+    [renderer pause];
   }
 }
 
-- (void)markerViewDidUpdate:(LuggMarkerView *)markerView {
-  AppleMarkerAnnotation *annotation =
-      (AppleMarkerAnnotation *)markerView.marker;
-
-  if (!annotation) {
-    RCTLogWarn(@"markerViewDidUpdate called without annotation");
-    return;
-  }
-
-  annotation.coordinate = markerView.coordinate;
-  annotation.title = markerView.title;
-  annotation.subtitle = markerView.markerDescription;
-
-  MKAnnotationView *annotationView = annotation.annotationView;
-  if (annotationView) {
-    annotationView.layer.zPosition = markerView.zIndex;
-    annotationView.zPriority = markerView.zIndex;
-  }
-
-  [self updateAnnotationViewFrame:annotation];
-}
-
-#pragma mark - MKMapViewDelegate
-
-- (void)mapView:(MKMapView *)mapView regionWillChangeAnimated:(BOOL)animated {
-  _isDragging = [self isUserInteracting:mapView];
-  if (_isDragging) {
-    for (UIView *subview in self.subviews) {
-      if ([subview isKindOfClass:[LuggPolylineView class]]) {
-        MKPolylineAnimator *renderer =
-            (MKPolylineAnimator *)((LuggPolylineView *)subview).renderer;
-        [renderer pause];
-      }
-    }
+- (void)resumeAnimations {
+  for (LuggPolylineView *polylineView in _overlayToPolylineMap
+           .objectEnumerator) {
+    MKPolylineAnimator *renderer = (MKPolylineAnimator *)polylineView.renderer;
+    [renderer resume];
   }
 }
 
-- (BOOL)isUserInteracting:(MKMapView *)mapView {
-  UIView *mapContainerView = mapView.subviews.firstObject;
-  for (UIGestureRecognizer *gesture in mapContainerView.gestureRecognizers) {
-    if (gesture.state == UIGestureRecognizerStateBegan ||
-        gesture.state == UIGestureRecognizerStateChanged) {
-      return YES;
-    }
-  }
-  return NO;
-}
-
-- (void)mapViewDidChangeVisibleRegion:(MKMapView *)mapView {
-  CameraMoveEvent{mapView.centerCoordinate.latitude,
-                  mapView.centerCoordinate.longitude, mapView.zoomLevel,
-                  _isDragging}
-      .emit<LuggAppleMapViewEventEmitter>(_eventEmitter);
-}
-
-- (void)mapView:(MKMapView *)mapView regionDidChangeAnimated:(BOOL)animated {
-  BOOL wasDragging = _isDragging;
-  _isDragging = NO;
-  if (wasDragging) {
-    for (UIView *subview in self.subviews) {
-      if ([subview isKindOfClass:[LuggPolylineView class]]) {
-        MKPolylineAnimator *renderer =
-            (MKPolylineAnimator *)((LuggPolylineView *)subview).renderer;
-        [renderer resume];
-      }
-    }
-  }
-  CameraIdleEvent{mapView.centerCoordinate.latitude,
-                  mapView.centerCoordinate.longitude, mapView.zoomLevel,
-                  static_cast<bool>(wasDragging)}
-      .emit<LuggAppleMapViewEventEmitter>(_eventEmitter);
-}
-
-- (MKAnnotationView *)mapView:(MKMapView *)mapView
-            viewForAnnotation:(id<MKAnnotation>)annotation {
-  if (![annotation isKindOfClass:[AppleMarkerAnnotation class]]) {
-    return nil;
-  }
-
-  AppleMarkerAnnotation *markerAnnotation = (AppleMarkerAnnotation *)annotation;
-  LuggMarkerView *markerView = markerAnnotation.markerView;
-
-  if (!markerView || !markerView.hasCustomView) {
-    return nil;
-  }
-
-  MKAnnotationView *annotationView =
-      [[MKAnnotationView alloc] initWithAnnotation:annotation
-                                   reuseIdentifier:nil];
-  annotationView.canShowCallout = YES;
-  annotationView.displayPriority = MKFeatureDisplayPriorityRequired;
-  annotationView.layer.zPosition = markerView.zIndex;
-  annotationView.zPriority = markerView.zIndex;
-
-  if (!markerView.rasterize) {
-    UIView *iconView = markerView.iconView;
-    [iconView removeFromSuperview];
-    [annotationView addSubview:iconView];
-  }
-
-  [self applyMarkerStyle:markerView annotationView:annotationView];
-  markerAnnotation.annotationView = annotationView;
-
-  return annotationView;
-}
-
-- (MKOverlayRenderer *)mapView:(MKMapView *)mapView
-            rendererForOverlay:(id<MKOverlay>)overlay {
-  if ([overlay isKindOfClass:[MKPolyline class]]) {
-    LuggPolylineView *polylineView = [self findPolylineViewForOverlay:overlay];
-    MKPolyline *polyline = (MKPolyline *)overlay;
-
-    if (polylineView) {
-      NSArray<UIColor *> *colors = polylineView.strokeColors;
-
-      MKPolylineAnimator *renderer =
-          [[MKPolylineAnimator alloc] initWithPolyline:polyline];
-      renderer.lineWidth = polylineView.strokeWidth;
-      renderer.strokeColor = colors.firstObject;
-      if (colors.count > 1) {
-        renderer.strokeColors = colors;
-      }
-      renderer.animatedOptions = polylineView.animatedOptions;
-      renderer.animated = polylineView.animated;
-      polylineView.renderer = renderer;
-      return renderer;
-    }
-
-    MKPolylineRenderer *renderer =
-        [[MKPolylineRenderer alloc] initWithPolyline:polyline];
-    return renderer;
-  }
-  return nil;
-}
-
 #pragma mark - Commands
 
 - (void)moveCamera:(double)latitude
          longitude:(double)longitude
               zoom:(double)zoom
           duration:(double)duration {
-  if (!_mapView) {
+  if (!_mapView)
     return;
-  }
 
   double targetZoom = zoom > 0 ? zoom : _mapView.zoomLevel;
 
   if (duration < 0) {
-    [self setCameraWithLatitude:latitude
-                      longitude:longitude
-                           zoom:targetZoom
-                       animated:YES];
+    [_mapView
+        setCenterCoordinate:CLLocationCoordinate2DMake(latitude, longitude)
+                  zoomLevel:targetZoom
+                   animated:YES];
   } else if (duration > 0) {
     CLLocationCoordinate2D center =
         CLLocationCoordinate2DMake(latitude, longitude);
@@ -652,10 +550,10 @@ using namespace luggmaps::events;
                        [self->_mapView setRegion:region animated:NO];
                      }];
   } else {
-    [self setCameraWithLatitude:latitude
-                      longitude:longitude
-                           zoom:targetZoom
-                       animated:NO];
+    [_mapView
+        setCenterCoordinate:CLLocationCoordinate2DMake(latitude, longitude)
+                  zoomLevel:targetZoom
+                   animated:NO];
   }
 }
 
@@ -665,9 +563,8 @@ using namespace luggmaps::events;
          paddingBottom:(double)paddingBottom
           paddingRight:(double)paddingRight
               duration:(double)duration {
-  if (!_mapView || coordinates.count == 0) {
+  if (!_mapView || coordinates.count == 0)
     return;
-  }
 
   CLLocationCoordinate2D *coords = (CLLocationCoordinate2D *)malloc(
       sizeof(CLLocationCoordinate2D) * coordinates.count);
@@ -702,12 +599,4 @@ using namespace luggmaps::events;
   }
 }
 
-- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
-  RCTLuggAppleMapViewHandleCommand(self, commandName, args);
-}
-
-Class<RCTComponentViewProtocol> LuggAppleMapViewCls(void) {
-  return LuggAppleMapView.class;
-}
-
 @end