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

package/ios/core/AppleMapProvider.mm

@@ -1,8 +1,11 @@
 #import "AppleMapProvider.h"
 #import "../LuggCalloutView.h"
+#import "../LuggCircleView.h"
+#import "../LuggGroundOverlayView.h"
 #import "../LuggMarkerView.h"
 #import "../LuggPolygonView.h"
 #import "../LuggPolylineView.h"
+#import "../LuggTileOverlayView.h"
 #import "../extensions/MKMapView+Zoom.h"
 #import "LuggAnnotationView.h"
 #import "MKPolylineAnimator.h"
@@ -19,12 +22,90 @@
 @implementation AppleMarkerAnnotation
 @end
 
+@interface GroundImageOverlay : NSObject <MKOverlay>
+@property(nonatomic, assign) CLLocationCoordinate2D coordinate;
+@property(nonatomic, assign) MKMapRect boundingMapRect;
+@property(nonatomic, strong) UIImage *image;
+@property(nonatomic, assign) CGFloat opacity;
+@end
+
+@implementation GroundImageOverlay
+@end
+
+@interface BoundedTileOverlay : MKTileOverlay
+@property(nonatomic, assign) CLLocationCoordinate2D southwest;
+@property(nonatomic, assign) CLLocationCoordinate2D northeast;
+@end
+
+@implementation BoundedTileOverlay
+
+static double tileToLat(NSInteger y, NSInteger z) {
+  double n = M_PI - 2.0 * M_PI * y / pow(2.0, z);
+  return 180.0 / M_PI * atan(0.5 * (exp(n) - exp(-n)));
+}
+
+static double tileToLng(NSInteger x, NSInteger z) {
+  return x / pow(2.0, z) * 360.0 - 180.0;
+}
+
+- (void)loadTileAtPath:(MKTileOverlayPath)path
+                result:(void (^)(NSData *_Nullable, NSError *_Nullable))result {
+  double tileSW_lat = tileToLat(path.y + 1, path.z);
+  double tileNE_lat = tileToLat(path.y, path.z);
+  double tileSW_lng = tileToLng(path.x, path.z);
+  double tileNE_lng = tileToLng(path.x + 1, path.z);
+
+  if (tileNE_lat < self.southwest.latitude ||
+      tileSW_lat > self.northeast.latitude ||
+      tileNE_lng < self.southwest.longitude ||
+      tileSW_lng > self.northeast.longitude) {
+    result(nil, nil);
+    return;
+  }
+
+  [super loadTileAtPath:path result:result];
+}
+
+@end
+
+@interface GroundImageOverlayRenderer : MKOverlayRenderer
+@property(nonatomic, strong) UIImage *image;
+@property(nonatomic, assign) CGFloat overlayOpacity;
+@end
+
+@implementation GroundImageOverlayRenderer
+
+- (void)drawMapRect:(MKMapRect)mapRect
+          zoomScale:(MKZoomScale)zoomScale
+          inContext:(CGContextRef)context {
+  MKMapRect overlayRect = self.overlay.boundingMapRect;
+  CGRect drawRect = [self rectForMapRect:overlayRect];
+
+  CGContextSaveGState(context);
+  CGContextSetAlpha(context, self.overlayOpacity);
+
+  // Flip the context for UIImage drawing
+  CGContextTranslateCTM(context, drawRect.origin.x,
+                        drawRect.origin.y + drawRect.size.height);
+  CGContextScaleCTM(context, 1.0, -1.0);
+
+  CGRect imageRect =
+      CGRectMake(0, 0, drawRect.size.width, drawRect.size.height);
+  CGContextDrawImage(context, imageRect, self.image.CGImage);
+
+  CGContextRestoreGState(context);
+}
+
+@end
+
 @implementation LuggAppleMapViewContent
 @end
 
 @interface AppleMapProvider () <
     LuggMarkerViewDelegate, LuggCalloutViewDelegate, LuggPolylineViewDelegate,
-    LuggPolygonViewDelegate, UIGestureRecognizerDelegate>
+    LuggPolygonViewDelegate, LuggCircleViewDelegate,
+    LuggGroundOverlayViewDelegate, LuggTileOverlayViewDelegate,
+    UIGestureRecognizerDelegate>
 @end
 
 @implementation AppleMapProvider {
@@ -36,6 +117,10 @@
   double _maxZoom;
   NSMapTable<id<MKOverlay>, LuggPolylineView *> *_overlayToPolylineMap;
   NSMapTable<id<MKOverlay>, LuggPolygonView *> *_overlayToPolygonMap;
+  NSMapTable<id<MKOverlay>, LuggCircleView *> *_overlayToCircleMap;
+  NSMapTable<id<MKOverlay>, LuggGroundOverlayView *>
+      *_overlayToGroundOverlayMap;
+  NSMapTable<id<MKOverlay>, LuggTileOverlayView *> *_overlayToTileOverlayMap;
   UITapGestureRecognizer *_tapGesture;
   UILongPressGestureRecognizer *_longPressGesture;
   LuggMarkerView *_activeNonBubbledMarker;
@@ -54,6 +139,9 @@
   if (self = [super init]) {
     _overlayToPolylineMap = [NSMapTable strongToWeakObjectsMapTable];
     _overlayToPolygonMap = [NSMapTable strongToWeakObjectsMapTable];
+    _overlayToCircleMap = [NSMapTable strongToWeakObjectsMapTable];
+    _overlayToGroundOverlayMap = [NSMapTable strongToWeakObjectsMapTable];
+    _overlayToTileOverlayMap = [NSMapTable strongToWeakObjectsMapTable];
   }
   return self;
 }
@@ -315,6 +403,55 @@
   return nil;
 }
 
+- (LuggCircleView *)hitTestCircleAtPoint:(CGPoint)point {
+  CLLocationCoordinate2D tapCoordinate = [_mapView convertPoint:point
+                                           toCoordinateFromView:_mapView];
+  CLLocation *tapLocation =
+      [[CLLocation alloc] initWithLatitude:tapCoordinate.latitude
+                                 longitude:tapCoordinate.longitude];
+
+  NSArray<id<MKOverlay>> *overlays = _mapView.overlays;
+  for (NSInteger i = overlays.count - 1; i >= 0; i--) {
+    id<MKOverlay> overlay = overlays[i];
+    if (![overlay isKindOfClass:[MKCircle class]])
+      continue;
+
+    LuggCircleView *circleView = [_overlayToCircleMap objectForKey:overlay];
+    if (!circleView || !circleView.tappable)
+      continue;
+
+    CLLocation *center =
+        [[CLLocation alloc] initWithLatitude:circleView.center.latitude
+                                   longitude:circleView.center.longitude];
+    CLLocationDistance distance = [tapLocation distanceFromLocation:center];
+    if (distance <= circleView.radius)
+      return circleView;
+  }
+  return nil;
+}
+
+- (LuggGroundOverlayView *)hitTestGroundOverlayAtPoint:(CGPoint)point {
+  CLLocationCoordinate2D tapCoordinate = [_mapView convertPoint:point
+                                           toCoordinateFromView:_mapView];
+
+  NSArray<id<MKOverlay>> *overlays = _mapView.overlays;
+  for (NSInteger i = overlays.count - 1; i >= 0; i--) {
+    id<MKOverlay> overlay = overlays[i];
+    if (![overlay isKindOfClass:[GroundImageOverlay class]])
+      continue;
+
+    LuggGroundOverlayView *view =
+        [_overlayToGroundOverlayMap objectForKey:overlay];
+    if (!view || !view.tappable)
+      continue;
+
+    MKMapPoint mapPoint = MKMapPointForCoordinate(tapCoordinate);
+    if (MKMapRectContainsPoint(overlay.boundingMapRect, mapPoint))
+      return view;
+  }
+  return nil;
+}
+
 - (BOOL)hitTestAnnotationAtPoint:(CGPoint)point {
   for (id<MKAnnotation> annotation in _mapView.annotations) {
     MKAnnotationView *view = [_mapView viewForAnnotation:annotation];
@@ -349,6 +486,19 @@
   if ([self hitTestAnnotationAtPoint:point])
     return;
 
+  LuggGroundOverlayView *groundOverlayView =
+      [self hitTestGroundOverlayAtPoint:point];
+  if (groundOverlayView) {
+    [groundOverlayView emitPressEvent];
+    return;
+  }
+
+  LuggCircleView *circleView = [self hitTestCircleAtPoint:point];
+  if (circleView) {
+    [circleView emitPressEvent];
+    return;
+  }
+
   LuggPolygonView *polygonView = [self hitTestPolygonAtPoint:point];
   if (polygonView) {
     [polygonView emitPressEvent];
@@ -526,6 +676,37 @@
     return renderer;
   }
 
+  if ([overlay isKindOfClass:[MKCircle class]]) {
+    LuggCircleView *circleView = [_overlayToCircleMap objectForKey:overlay];
+    MKCircle *circle = (MKCircle *)overlay;
+
+    MKCircleRenderer *renderer =
+        [[MKCircleRenderer alloc] initWithCircle:circle];
+    if (circleView) {
+      renderer.fillColor = circleView.fillColor;
+      renderer.strokeColor = circleView.strokeColor;
+      renderer.lineWidth = circleView.strokeWidth;
+      circleView.renderer = renderer;
+    }
+    return renderer;
+  }
+
+  if ([overlay isKindOfClass:[GroundImageOverlay class]]) {
+    GroundImageOverlay *groundOverlay = (GroundImageOverlay *)overlay;
+    GroundImageOverlayRenderer *renderer =
+        [[GroundImageOverlayRenderer alloc] initWithOverlay:overlay];
+    renderer.image = groundOverlay.image;
+    renderer.overlayOpacity = groundOverlay.opacity;
+    return renderer;
+  }
+
+  if ([overlay isKindOfClass:[MKTileOverlay class]]) {
+    MKTileOverlay *tileOverlay = (MKTileOverlay *)overlay;
+    MKTileOverlayRenderer *renderer =
+        [[MKTileOverlayRenderer alloc] initWithTileOverlay:tileOverlay];
+    return renderer;
+  }
+
   return nil;
 }
 
@@ -587,10 +768,7 @@
   }
 
   _activeNonBubbledMarker = markerView;
-  dispatch_async(dispatch_get_main_queue(), ^{
-    [self positionNonBubbledCallout];
-    contentView.hidden = NO;
-  });
+  [self positionNonBubbledCallout];
 }
 
 - (void)calloutViewDidUpdate:(LuggCalloutView *)calloutView {
@@ -616,8 +794,7 @@
   if (annotationView && contentView.superview == annotationView) {
     CGPoint center = CGPointMake(annotationView.bounds.size.width / 2.0 +
                                      contentSize.width * (0.5 - anchor.x),
-                                 annotationView.bounds.size.height / 2.0 +
-                                     contentSize.height * (0.5 - anchor.y));
+                                 contentSize.height * (0.5 - anchor.y));
     contentView.center = center;
   } else {
     CGPoint point =
@@ -627,6 +804,8 @@
         CGPointMake(point.x + contentSize.width * (0.5 - anchor.x),
                     point.y + contentSize.height * (0.5 - anchor.y));
   }
+
+  contentView.hidden = NO;
 }
 
 - (void)dismissNonBubbledCallout {
@@ -766,6 +945,24 @@
   [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 {
@@ -1089,6 +1286,196 @@
   return [interiorPolygons copy];
 }
 
+#pragma mark - Circle Management
+
+- (void)addCircleView:(LuggCircleView *)circleView {
+  circleView.delegate = self;
+  [self addCircleOverlayToMap:circleView];
+}
+
+- (void)removeCircleView:(LuggCircleView *)circleView {
+  circleView.delegate = nil;
+  MKCircle *circle = (MKCircle *)circleView.circle;
+  if (circle) {
+    [_overlayToCircleMap removeObjectForKey:circle];
+    [_mapView removeOverlay:circle];
+    circleView.circle = nil;
+  }
+}
+
+- (void)syncCircleView:(LuggCircleView *)circleView {
+  if (!_mapView)
+    return;
+
+  MKCircle *oldCircle = (MKCircle *)circleView.circle;
+
+  MKCircle *newCircle = [MKCircle circleWithCenterCoordinate:circleView.center
+                                                      radius:circleView.radius];
+
+  circleView.circle = newCircle;
+  [_overlayToCircleMap setObject:circleView forKey:newCircle];
+
+  MKCircleRenderer *renderer = (MKCircleRenderer *)circleView.renderer;
+  if (renderer && oldCircle) {
+    [_overlayToCircleMap removeObjectForKey:oldCircle];
+    [_mapView removeOverlay:oldCircle];
+    [self insertOverlay:newCircle withZIndex:circleView.zIndex];
+    circleView.renderer = nil;
+    return;
+  }
+
+  if (oldCircle) {
+    [_overlayToCircleMap removeObjectForKey:oldCircle];
+    [_mapView removeOverlay:oldCircle];
+  }
+  [self insertOverlay:newCircle withZIndex:circleView.zIndex];
+}
+
+- (void)addCircleOverlayToMap:(LuggCircleView *)circleView {
+  if (!_mapView)
+    return;
+
+  MKCircle *circle = [MKCircle circleWithCenterCoordinate:circleView.center
+                                                   radius:circleView.radius];
+
+  circleView.circle = circle;
+  [_overlayToCircleMap setObject:circleView forKey:circle];
+  [self insertOverlay:circle withZIndex:circleView.zIndex];
+}
+
+#pragma mark - Ground Overlay Management
+
+- (void)addGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  groundOverlayView.delegate = self;
+  [self syncGroundOverlayView:groundOverlayView];
+}
+
+- (void)removeGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  groundOverlayView.delegate = nil;
+  GroundImageOverlay *overlay = (GroundImageOverlay *)groundOverlayView.overlay;
+  if (overlay) {
+    [_overlayToGroundOverlayMap removeObjectForKey:overlay];
+    [_mapView removeOverlay:overlay];
+    groundOverlayView.overlay = nil;
+  }
+}
+
+- (void)syncGroundOverlayView:(LuggGroundOverlayView *)groundOverlayView {
+  if (!_mapView)
+    return;
+
+  NSString *imageUri = groundOverlayView.imageUri;
+  if (imageUri.length == 0)
+    return;
+
+  // Remove old overlay
+  GroundImageOverlay *oldOverlay =
+      (GroundImageOverlay *)groundOverlayView.overlay;
+  if (oldOverlay) {
+    [_overlayToGroundOverlayMap removeObjectForKey:oldOverlay];
+    [_mapView removeOverlay:oldOverlay];
+    groundOverlayView.overlay = nil;
+  }
+
+  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;
+
+  MKMapPoint sw = MKMapPointForCoordinate(groundOverlayView.southwest);
+  MKMapPoint ne = MKMapPointForCoordinate(groundOverlayView.northeast);
+
+  MKMapRect mapRect = MKMapRectMake(MIN(sw.x, ne.x), MIN(sw.y, ne.y),
+                                    fabs(ne.x - sw.x), fabs(ne.y - sw.y));
+
+  CLLocationCoordinate2D center =
+      CLLocationCoordinate2DMake((groundOverlayView.northeast.latitude +
+                                  groundOverlayView.southwest.latitude) /
+                                     2.0,
+                                 (groundOverlayView.northeast.longitude +
+                                  groundOverlayView.southwest.longitude) /
+                                     2.0);
+
+  GroundImageOverlay *overlay = [[GroundImageOverlay alloc] init];
+  overlay.coordinate = center;
+  overlay.boundingMapRect = mapRect;
+  overlay.image = image;
+  overlay.opacity = groundOverlayView.opacity;
+
+  groundOverlayView.overlay = overlay;
+  [_overlayToGroundOverlayMap setObject:groundOverlayView forKey:overlay];
+  [self insertOverlay:overlay withZIndex:groundOverlayView.zIndex];
+}
+
+#pragma mark - Tile Overlay Management
+
+- (void)addTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  tileOverlayView.delegate = self;
+  [self syncTileOverlayView:tileOverlayView];
+}
+
+- (void)removeTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  tileOverlayView.delegate = nil;
+  MKTileOverlay *overlay = (MKTileOverlay *)tileOverlayView.overlay;
+  if (overlay) {
+    [_overlayToTileOverlayMap removeObjectForKey:overlay];
+    [_mapView removeOverlay:overlay];
+    tileOverlayView.overlay = nil;
+  }
+}
+
+- (void)syncTileOverlayView:(LuggTileOverlayView *)tileOverlayView {
+  if (!_mapView)
+    return;
+
+  NSString *urlTemplate = tileOverlayView.urlTemplate;
+  if (urlTemplate.length == 0)
+    return;
+
+  // Remove old overlay
+  MKTileOverlay *oldOverlay = (MKTileOverlay *)tileOverlayView.overlay;
+  if (oldOverlay) {
+    [_overlayToTileOverlayMap removeObjectForKey:oldOverlay];
+    [_mapView removeOverlay:oldOverlay];
+    tileOverlayView.overlay = nil;
+  }
+
+  MKTileOverlay *tileOverlay;
+  if (tileOverlayView.hasBounds) {
+    BoundedTileOverlay *bounded =
+        [[BoundedTileOverlay alloc] initWithURLTemplate:urlTemplate];
+    bounded.southwest = tileOverlayView.southwest;
+    bounded.northeast = tileOverlayView.northeast;
+    tileOverlay = bounded;
+  } else {
+    tileOverlay = [[MKTileOverlay alloc] initWithURLTemplate:urlTemplate];
+  }
+
+  tileOverlay.tileSize =
+      CGSizeMake(tileOverlayView.tileSize, tileOverlayView.tileSize);
+  tileOverlay.canReplaceMapContent = NO;
+
+  tileOverlayView.overlay = tileOverlay;
+  [_overlayToTileOverlayMap setObject:tileOverlayView forKey:tileOverlay];
+  [_mapView addOverlay:tileOverlay level:MKOverlayLevelAboveRoads];
+}
+
 - (void)insertOverlay:(id<MKOverlay>)overlay withZIndex:(NSInteger)zIndex {
   if (zIndex == 0) {
     [_mapView addOverlay:overlay];
@@ -1104,10 +1491,18 @@
         [_overlayToPolylineMap objectForKey:overlays[i]];
     LuggPolygonView *existingPolygonView =
         [_overlayToPolygonMap objectForKey:overlays[i]];
+    LuggCircleView *existingCircleView =
+        [_overlayToCircleMap objectForKey:overlays[i]];
+    LuggGroundOverlayView *existingGroundOverlayView =
+        [_overlayToGroundOverlayMap objectForKey:overlays[i]];
     if (existingPolylineView) {
       existingZIndex = existingPolylineView.zIndex;
     } else if (existingPolygonView) {
       existingZIndex = existingPolygonView.zIndex;
+    } else if (existingCircleView) {
+      existingZIndex = existingCircleView.zIndex;
+    } else if (existingGroundOverlayView) {
+      existingZIndex = existingGroundOverlayView.zIndex;
     } else {
       continue;
     }