@lugg/maps 0.2.0-alpha.9 → 1.0.0-beta.1

package/ios/LuggMapView.mm

@@ -0,0 +1,343 @@
+#import "LuggMapView.h"
+#import "LuggMapWrapperView.h"
+#import "LuggMarkerView.h"
+#import "LuggPolygonView.h"
+#import "LuggPolylineView.h"
+#import "core/AppleMapProvider.h"
+#import "core/GoogleMapProvider.h"
+#import "core/MapProviderDelegate.h"
+#import "events/CameraIdleEvent.h"
+#import "events/CameraMoveEvent.h"
+#import "events/LongPressEvent.h"
+#import "events/PressEvent.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;
+
+@interface LuggMapView () <RCTLuggMapViewViewProtocol, MapProviderDelegate>
+@end
+
+@implementation LuggMapView {
+  id<MapProvider> _provider;
+  LuggMapWrapperView *_mapWrapperView;
+  LuggMapViewProvider _providerType;
+  NSString *_mapId;
+  BOOL _initialized;
+  // Cached props to apply after content creation
+  BOOL _zoomEnabled;
+  BOOL _scrollEnabled;
+  BOOL _rotateEnabled;
+  BOOL _pitchEnabled;
+  BOOL _userLocationEnabled;
+  LuggMapViewTheme _theme;
+  double _minZoom;
+  double _maxZoom;
+  UIEdgeInsets _edgeInsets;
+  UIEdgeInsets _oldEdgeInsets;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<LuggMapViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const LuggMapViewProps>();
+    _props = defaultProps;
+
+    _initialized = NO;
+    _mapId = @"";
+    _providerType = LuggMapViewProvider::Google;
+    _zoomEnabled = YES;
+    _scrollEnabled = YES;
+    _rotateEnabled = YES;
+    _pitchEnabled = YES;
+    _userLocationEnabled = NO;
+    _theme = LuggMapViewTheme::System;
+    _edgeInsets = UIEdgeInsetsZero;
+  }
+  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;
+    if (_provider) {
+      [_provider addMarkerView:markerView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
+    LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
+    if (_provider) {
+      [_provider addPolylineView:polylineView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggPolygonView class]]) {
+    LuggPolygonView *polygonView = (LuggPolygonView *)childComponentView;
+    if (_provider) {
+      [_provider addPolygonView:polygonView];
+    }
+  }
+}
+
+- (void)unmountChildComponentView:
+            (UIView<RCTComponentViewProtocol> *)childComponentView
+                            index:(NSInteger)index {
+  if ([childComponentView isKindOfClass:[LuggMarkerView class]]) {
+    LuggMarkerView *markerView = (LuggMarkerView *)childComponentView;
+    if (_provider) {
+      [_provider removeMarkerView:markerView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggPolylineView class]]) {
+    LuggPolylineView *polylineView = (LuggPolylineView *)childComponentView;
+    if (_provider) {
+      [_provider removePolylineView:polylineView];
+    }
+  } else if ([childComponentView isKindOfClass:[LuggPolygonView class]]) {
+    LuggPolygonView *polygonView = (LuggPolygonView *)childComponentView;
+    if (_provider) {
+      [_provider removePolygonView:polygonView];
+    }
+  }
+
+  [super unmountChildComponentView:childComponentView index:index];
+}
+
+- (void)didMoveToWindow {
+  [super didMoveToWindow];
+  if (self.window) {
+    if (!_provider && _mapWrapperView) {
+      [self initializeProvider];
+    }
+    [_provider resumeAnimations];
+  } else {
+    [_provider pauseAnimations];
+  }
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+
+  [_provider destroy];
+  _provider = nil;
+  _mapWrapperView = nil;
+  _initialized = NO;
+}
+
+#pragma mark - Provider Initialization
+
+- (void)initializeProvider {
+  if (_provider || !_mapWrapperView)
+    return;
+
+  const auto &viewProps =
+      *std::static_pointer_cast<LuggMapViewProps const>(_props);
+
+  if (_providerType == LuggMapViewProvider::Apple) {
+    _provider = [[AppleMapProvider alloc] init];
+  } else {
+    GoogleMapProvider *google = [[GoogleMapProvider alloc] init];
+    google.mapId = _mapId;
+    _provider = google;
+  }
+
+  _provider.delegate = self;
+
+  CLLocationCoordinate2D coordinate =
+      CLLocationCoordinate2DMake(viewProps.initialCoordinate.latitude,
+                                 viewProps.initialCoordinate.longitude);
+
+  [_provider initializeMapInView:_mapWrapperView
+               initialCoordinate:coordinate
+                     initialZoom:viewProps.initialZoom];
+
+  // Apply cached props after map view is created
+  [self applyProps];
+  [_provider setEdgeInsets:_edgeInsets oldEdgeInsets:UIEdgeInsetsZero];
+
+  _initialized = YES;
+
+  // Flush any children that were mounted before content was created
+  for (UIView *subview in self.subviews) {
+    if ([subview isKindOfClass:[LuggMarkerView class]]) {
+      [_provider addMarkerView:(LuggMarkerView *)subview];
+    } else if ([subview isKindOfClass:[LuggPolylineView class]]) {
+      [_provider addPolylineView:(LuggPolylineView *)subview];
+    } else if ([subview isKindOfClass:[LuggPolygonView class]]) {
+      [_provider addPolygonView:(LuggPolygonView *)subview];
+    }
+  }
+}
+
+#pragma mark - MapProviderDelegate
+
+- (void)mapProviderDidReady {
+  ReadyEvent::emit<LuggMapViewEventEmitter>(_eventEmitter);
+}
+
+- (void)mapProviderDidMoveCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture {
+  CameraMoveEvent{latitude, longitude, zoom, static_cast<bool>(gesture)}
+      .emit<LuggMapViewEventEmitter>(_eventEmitter);
+}
+
+- (void)mapProviderDidIdleCamera:(double)latitude
+                       longitude:(double)longitude
+                            zoom:(double)zoom
+                         gesture:(BOOL)gesture {
+  CameraIdleEvent{latitude, longitude, zoom, static_cast<bool>(gesture)}
+      .emit<LuggMapViewEventEmitter>(_eventEmitter);
+}
+
+- (void)mapProviderDidPress:(double)latitude
+                  longitude:(double)longitude
+                          x:(double)x
+                          y:(double)y {
+  PressEvent{latitude, longitude, x, y}.emit<LuggMapViewEventEmitter>(
+      _eventEmitter);
+}
+
+- (void)mapProviderDidLongPress:(double)latitude
+                      longitude:(double)longitude
+                              x:(double)x
+                              y:(double)y {
+  LongPressEvent{latitude, longitude, x, y}.emit<LuggMapViewEventEmitter>(
+      _eventEmitter);
+}
+
+#pragma mark - Property Setters
+
+- (void)applyProps {
+  [_provider setZoomEnabled:_zoomEnabled];
+  [_provider setScrollEnabled:_scrollEnabled];
+  [_provider setRotateEnabled:_rotateEnabled];
+  [_provider setPitchEnabled:_pitchEnabled];
+  [_provider setUserLocationEnabled:_userLocationEnabled];
+  [_provider setTheme:(NSInteger)_theme];
+  [_provider setMinZoom:_minZoom];
+  [_provider setMaxZoom:_maxZoom];
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  const auto &newViewProps =
+      *std::static_pointer_cast<LuggMapViewProps const>(props);
+  const auto &prevViewProps =
+      *std::static_pointer_cast<LuggMapViewProps const>(_props);
+
+  _providerType = newViewProps.provider;
+
+  NSString *newMapId =
+      [NSString stringWithUTF8String:newViewProps.mapId.c_str()];
+  if (newMapId.length > 0) {
+    _mapId = newMapId;
+  }
+
+  if (newViewProps.zoomEnabled != prevViewProps.zoomEnabled) {
+    _zoomEnabled = newViewProps.zoomEnabled;
+    [_provider setZoomEnabled:_zoomEnabled];
+  }
+  if (newViewProps.scrollEnabled != prevViewProps.scrollEnabled) {
+    _scrollEnabled = newViewProps.scrollEnabled;
+    [_provider setScrollEnabled:_scrollEnabled];
+  }
+  if (newViewProps.rotateEnabled != prevViewProps.rotateEnabled) {
+    _rotateEnabled = newViewProps.rotateEnabled;
+    [_provider setRotateEnabled:_rotateEnabled];
+  }
+  if (newViewProps.pitchEnabled != prevViewProps.pitchEnabled) {
+    _pitchEnabled = newViewProps.pitchEnabled;
+    [_provider setPitchEnabled:_pitchEnabled];
+  }
+  if (newViewProps.userLocationEnabled != prevViewProps.userLocationEnabled) {
+    _userLocationEnabled = newViewProps.userLocationEnabled;
+    [_provider setUserLocationEnabled:_userLocationEnabled];
+  }
+  if (newViewProps.minZoom != prevViewProps.minZoom) {
+    _minZoom = newViewProps.minZoom;
+    [_provider setMinZoom:_minZoom];
+  }
+  if (newViewProps.maxZoom != prevViewProps.maxZoom) {
+    _maxZoom = newViewProps.maxZoom;
+    [_provider setMaxZoom:_maxZoom];
+  }
+  if (newViewProps.theme != prevViewProps.theme) {
+    _theme = newViewProps.theme;
+    [_provider setTheme:(NSInteger)_theme];
+  }
+
+  UIEdgeInsets newEdgeInsets = UIEdgeInsetsMake(
+      newViewProps.edgeInsets.top, newViewProps.edgeInsets.left,
+      newViewProps.edgeInsets.bottom, newViewProps.edgeInsets.right);
+  if (!UIEdgeInsetsEqualToEdgeInsets(newEdgeInsets, _edgeInsets)) {
+    _oldEdgeInsets = _edgeInsets;
+    _edgeInsets = newEdgeInsets;
+    [_provider setEdgeInsets:_edgeInsets oldEdgeInsets:_oldEdgeInsets];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
+#pragma mark - Commands
+
+- (void)moveCamera:(double)latitude
+         longitude:(double)longitude
+              zoom:(double)zoom
+          duration:(double)duration {
+  [_provider moveCamera:latitude
+              longitude:longitude
+                   zoom:zoom
+               duration:duration];
+}
+
+- (void)fitCoordinates:(NSArray *)coordinates
+         edgeInsetsTop:(double)edgeInsetsTop
+        edgeInsetsLeft:(double)edgeInsetsLeft
+      edgeInsetsBottom:(double)edgeInsetsBottom
+       edgeInsetsRight:(double)edgeInsetsRight
+              duration:(double)duration {
+  [_provider fitCoordinates:coordinates
+              edgeInsetsTop:edgeInsetsTop
+             edgeInsetsLeft:edgeInsetsLeft
+           edgeInsetsBottom:edgeInsetsBottom
+            edgeInsetsRight:edgeInsetsRight
+                   duration:duration];
+}
+
+- (void)setEdgeInsets:(double)top
+                 left:(double)left
+               bottom:(double)bottom
+                right:(double)right
+             duration:(double)duration {
+  UIEdgeInsets oldInsets = _edgeInsets;
+  _edgeInsets = UIEdgeInsetsMake(top, left, bottom, right);
+  [_provider setEdgeInsets:_edgeInsets
+             oldEdgeInsets:oldInsets
+                  duration:duration];
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args {
+  RCTLuggMapViewHandleCommand(self, commandName, args);
+}
+
+Class<RCTComponentViewProtocol> LuggMapViewCls(void) {
+  return LuggMapView.class;
+}
+
+@end

package/ios/LuggMarkerView.h

@@ -5,6 +5,7 @@
 NS_ASSUME_NONNULL_BEGIN
 
 @class LuggMarkerView;
+@class LuggCalloutView;
 
 @protocol LuggMarkerViewDelegate <NSObject>
 @optional
@@ -20,12 +21,26 @@ NS_ASSUME_NONNULL_BEGIN
 @property(nonatomic, readonly, nullable) NSString *markerDescription;
 @property(nonatomic, readonly) CGPoint anchor;
 @property(nonatomic, readonly) NSInteger zIndex;
+@property(nonatomic, readonly) CLLocationDegrees rotate;
+@property(nonatomic, readonly) CGFloat scale;
+@property(nonatomic, readonly) BOOL rasterize;
+@property(nonatomic, readonly) BOOL draggable;
 @property(nonatomic, readonly) BOOL hasCustomView;
 @property(nonatomic, readonly) BOOL didLayout;
 @property(nonatomic, readonly) UIView *iconView;
+@property(nonatomic, readonly, nullable) LuggCalloutView *calloutView;
 @property(nonatomic, weak, nullable) id<LuggMarkerViewDelegate> delegate;
 @property(nonatomic, strong, nullable) NSObject *marker;
 
+- (nullable UIImage *)createIconImage;
+- (nullable UIImage *)createScaledIconImage;
+- (void)resetIconViewTransform;
+- (void)emitPressEventWithPoint:(CGPoint)point;
+- (void)emitDragStartEventWithPoint:(CGPoint)point;
+- (void)emitDragChangeEventWithPoint:(CGPoint)point;
+- (void)emitDragEndEventWithPoint:(CGPoint)point;
+- (void)updateCoordinate:(CLLocationCoordinate2D)coordinate;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/LuggMarkerView.mm

@@ -1,4 +1,7 @@
 #import "LuggMarkerView.h"
+#import "LuggCalloutView.h"
+#import "events/MarkerDragEvent.h"
+#import "events/MarkerPressEvent.h"
 
 #import <react/renderer/components/RNMapsSpec/ComponentDescriptors.h>
 #import <react/renderer/components/RNMapsSpec/EventEmitters.h>
@@ -8,6 +11,7 @@
 #import "RCTFabricComponentsPlugins.h"
 
 using namespace facebook::react;
+using namespace luggmaps::events;
 
 @interface LuggMarkerView () <RCTLuggMarkerViewViewProtocol>
 @end
@@ -19,8 +23,13 @@ using namespace facebook::react;
   NSString *_markerDescription;
   CGPoint _anchor;
   NSInteger _zIndex;
+  CLLocationDegrees _rotate;
+  CGFloat _scale;
+  BOOL _rasterize;
+  BOOL _draggable;
   BOOL _didLayout;
   UIView *_iconView;
+  LuggCalloutView *_calloutView;
 }
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
@@ -37,6 +46,9 @@ using namespace facebook::react;
     _coordinate = CLLocationCoordinate2DMake(0, 0);
     _anchor = CGPointMake(0.5, 1.0);
     _zIndex = 0;
+    _rotate = 0;
+    _scale = 1;
+    _rasterize = YES;
     _didLayout = NO;
 
     _iconView = [[UIView alloc] init];
@@ -63,6 +75,10 @@ using namespace facebook::react;
       [NSString stringWithUTF8String:newViewProps.description.c_str()];
   _anchor = CGPointMake(newViewProps.anchor.x, newViewProps.anchor.y);
   _zIndex = newViewProps.zIndex.value_or(0);
+  _rotate = newViewProps.rotate;
+  _scale = newViewProps.scale;
+  _rasterize = newViewProps.rasterize;
+  _draggable = newViewProps.draggable;
 }
 
 - (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
@@ -78,14 +94,22 @@ using namespace facebook::react;
 - (void)mountChildComponentView:
             (UIView<RCTComponentViewProtocol> *)childComponentView
                           index:(NSInteger)index {
-  [_iconView insertSubview:childComponentView atIndex:index];
+  if ([childComponentView isKindOfClass:[LuggCalloutView class]]) {
+    _calloutView = (LuggCalloutView *)childComponentView;
+  } else {
+    [_iconView insertSubview:childComponentView atIndex:index];
+  }
   _didLayout = NO;
 }
 
 - (void)unmountChildComponentView:
             (UIView<RCTComponentViewProtocol> *)childComponentView
                             index:(NSInteger)index {
-  [childComponentView removeFromSuperview];
+  if ([childComponentView isKindOfClass:[LuggCalloutView class]]) {
+    _calloutView = nil;
+  } else {
+    [childComponentView removeFromSuperview];
+  }
   _didLayout = NO;
 }
 
@@ -138,6 +162,22 @@ using namespace facebook::react;
   return _zIndex;
 }
 
+- (CLLocationDegrees)rotate {
+  return _rotate;
+}
+
+- (CGFloat)scale {
+  return _scale;
+}
+
+- (BOOL)rasterize {
+  return _rasterize;
+}
+
+- (BOOL)draggable {
+  return _draggable;
+}
+
 - (BOOL)hasCustomView {
   return _iconView.subviews.count > 0;
 }
@@ -150,11 +190,105 @@ using namespace facebook::react;
   return _iconView;
 }
 
+- (LuggCalloutView *)calloutView {
+  return _calloutView;
+}
+
+- (UIImage *)createIconImage {
+  CGSize size = _iconView.bounds.size;
+  if (size.width <= 0 || size.height <= 0) {
+    return nil;
+  }
+
+  UIGraphicsImageRendererFormat *format =
+      [UIGraphicsImageRendererFormat defaultFormat];
+  format.scale = [UIScreen mainScreen].scale;
+  UIGraphicsImageRenderer *renderer =
+      [[UIGraphicsImageRenderer alloc] initWithSize:size format:format];
+
+  return [renderer imageWithActions:^(UIGraphicsImageRendererContext *context) {
+    [self->_iconView.layer renderInContext:context.CGContext];
+  }];
+}
+
+- (UIImage *)createScaledIconImage {
+  CGSize size = _iconView.bounds.size;
+  if (size.width <= 0 || size.height <= 0) {
+    return nil;
+  }
+
+  CGSize scaledSize = CGSizeMake(size.width * _scale, size.height * _scale);
+
+  UIGraphicsImageRendererFormat *format =
+      [UIGraphicsImageRendererFormat defaultFormat];
+  format.scale = [UIScreen mainScreen].scale;
+  UIGraphicsImageRenderer *renderer =
+      [[UIGraphicsImageRenderer alloc] initWithSize:scaledSize format:format];
+
+  return [renderer imageWithActions:^(UIGraphicsImageRendererContext *context) {
+    CGContextScaleCTM(context.CGContext, self->_scale, self->_scale);
+    [self->_iconView.layer renderInContext:context.CGContext];
+  }];
+}
+
+- (void)emitPressEventWithPoint:(CGPoint)point {
+  MarkerPressEvent event{
+      .latitude = _coordinate.latitude,
+      .longitude = _coordinate.longitude,
+      .x = point.x,
+      .y = point.y,
+  };
+  event.emit<LuggMarkerViewEventEmitter>(_eventEmitter);
+}
+
+- (void)emitDragStartEventWithPoint:(CGPoint)point {
+  MarkerDragStartEvent event{
+      .latitude = _coordinate.latitude,
+      .longitude = _coordinate.longitude,
+      .x = point.x,
+      .y = point.y,
+  };
+  event.emit<LuggMarkerViewEventEmitter>(_eventEmitter);
+}
+
+- (void)emitDragChangeEventWithPoint:(CGPoint)point {
+  MarkerDragChangeEvent event{
+      .latitude = _coordinate.latitude,
+      .longitude = _coordinate.longitude,
+      .x = point.x,
+      .y = point.y,
+  };
+  event.emit<LuggMarkerViewEventEmitter>(_eventEmitter);
+}
+
+- (void)emitDragEndEventWithPoint:(CGPoint)point {
+  MarkerDragEndEvent event{
+      .latitude = _coordinate.latitude,
+      .longitude = _coordinate.longitude,
+      .x = point.x,
+      .y = point.y,
+  };
+  event.emit<LuggMarkerViewEventEmitter>(_eventEmitter);
+}
+
+- (void)updateCoordinate:(CLLocationCoordinate2D)coordinate {
+  _coordinate = coordinate;
+}
+
+- (void)resetIconViewTransform {
+  _iconView.transform = CGAffineTransformIdentity;
+  _iconView.layer.anchorPoint = CGPointMake(0.5, 0.5);
+  _iconView.frame = CGRectMake(0, 0, _iconView.bounds.size.width,
+                               _iconView.bounds.size.height);
+}
+
 - (void)prepareForRecycle {
   [super prepareForRecycle];
   _didLayout = NO;
+  _calloutView = nil;
   self.marker = nil;
   self.delegate = nil;
+  [self resetIconViewTransform];
   for (UIView *subview in _iconView.subviews) {
     [subview removeFromSuperview];
   }

package/ios/LuggPolygonView.h

@@ -0,0 +1,31 @@
+#import <CoreLocation/CoreLocation.h>
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LuggPolygonView;
+
+@protocol LuggPolygonViewDelegate <NSObject>
+@optional
+- (void)polygonViewDidUpdate:(LuggPolygonView *)polygonView;
+@end
+
+@interface LuggPolygonView : RCTViewComponentView
+
+@property(nonatomic, readonly) NSArray<CLLocation *> *coordinates;
+@property(nonatomic, readonly) NSArray<NSArray<CLLocation *> *> *holes;
+@property(nonatomic, readonly) UIColor *strokeColor;
+@property(nonatomic, readonly) UIColor *fillColor;
+@property(nonatomic, readonly) CGFloat strokeWidth;
+@property(nonatomic, readonly) NSInteger zIndex;
+@property(nonatomic, readonly) BOOL tappable;
+@property(nonatomic, weak, nullable) id<LuggPolygonViewDelegate> delegate;
+@property(nonatomic, strong, nullable) NSObject *polygon;
+@property(nonatomic, weak, nullable) NSObject *renderer;
+
+- (void)emitPressEvent;
+
+@end
+
+NS_ASSUME_NONNULL_END