react-native-maps 0.31.0 → 1.0.0-alpha.1

package/ios/AirGoogleMaps/{AIRGoogleMap.m → AIRGoogleMap.mm}

@@ -17,18 +17,20 @@
 #import "AIRGoogleMapUrlTile.h"
 #import "AIRGoogleMapWMSTile.h"
 #import "AIRGoogleMapOverlay.h"
+#import "AIRGoogleMapCoordinate.h"
 #import <GoogleMaps/GoogleMaps.h>
 #import <MapKit/MapKit.h>
 #import <React/UIView+React.h>
 #import <React/RCTBridge.h>
-#import "RCTConvert+AirMap.h"
+#import <React/RCTConvert.h>
 #import <objc/runtime.h>
 
+
 #ifdef HAVE_GOOGLE_MAPS_UTILS
-#import <Google-Maps-iOS-Utils/GMUKMLParser.h>
-#import <Google-Maps-iOS-Utils/GMUPlacemark.h>
-#import <Google-Maps-iOS-Utils/GMUPoint.h>
-#import <Google-Maps-iOS-Utils/GMUGeometryRenderer.h>
+#import "GMUKMLParser.h"
+#import "GMUPlacemark.h"
+#import "GMUPoint.h"
+#import "GMUGeometryRenderer.h"
 #define REQUIRES_GOOGLE_MAPS_UTILS(feature) do {} while (0)
 #else
 #define GMUKMLParser void
@@ -48,8 +50,12 @@ id regionAsJSON(MKCoordinateRegion region) {
            @"longitudeDelta": [NSNumber numberWithDouble:region.span.longitudeDelta],
            };
 }
-
-@interface AIRGoogleMap () <GMSIndoorDisplayDelegate>
+#if __has_include(<ReactNativeMaps/generated/RNMapsAirModuleDelegate.h>)
+#import <ReactNativeMaps/generated/RNMapsAirModuleDelegate.h>
+#else
+#import "RNMapsAirModuleDelegate.h"
+#endif
+@interface AIRGoogleMap () <GMSIndoorDisplayDelegate, RNMapsAirModuleDelegate>
 
 - (id)eventFromCoordinate:(CLLocationCoordinate2D)coordinate;
 
@@ -62,15 +68,33 @@ id regionAsJSON(MKCoordinateRegion region) {
   NSMutableArray<UIView *> *_reactSubviews;
   MKCoordinateRegion _initialRegion;
   MKCoordinateRegion _region;
-  BOOL _initialCameraSetOnLoad;
+  BOOL _initialRegionSet;
+  BOOL _initialCameraSet;
+  BOOL _didLayoutSubviews;
+  BOOL _didPrepareMap;
   BOOL _didCallOnMapReady;
-  BOOL _didMoveToWindow;
   BOOL _zoomTapEnabled;
+  BOOL _isAnimating;
+  NSString* _googleMapId;
 }
 
-- (instancetype)init
+- (instancetype)initWithMapId:(NSString *)mapId initialCamera:(GMSCameraPosition*) camera backgroundColor:(UIColor *) backgroundColor andZoomTapEnabled:(BOOL)zoomTapEnabled
 {
-  if ((self = [super init])) {
+    GMSMapViewOptions* options = [[GMSMapViewOptions alloc] init];
+
+    if (mapId){
+        GMSMapID *mapID = [GMSMapID mapIDWithIdentifier:mapId];
+        [options setMapID:mapID];
+    }
+    if (backgroundColor){
+        [options setBackgroundColor:backgroundColor];
+    }
+    if (camera){
+        [options setCamera:camera];
+    }
+    self = [super initWithOptions:options];
+
+    if (self) {
     _reactSubviews = [NSMutableArray new];
     _markers = [NSMutableArray array];
     _polygons = [NSMutableArray array];
@@ -80,13 +104,14 @@ id regionAsJSON(MKCoordinateRegion region) {
     _tiles = [NSMutableArray array];
     _overlays = [NSMutableArray array];
     _initialCamera = nil;
-    _cameraProp = nil;
     _initialRegion = MKCoordinateRegionMake(CLLocationCoordinate2DMake(0.0, 0.0), MKCoordinateSpanMake(0.0, 0.0));
     _region = MKCoordinateRegionMake(CLLocationCoordinate2DMake(0.0, 0.0), MKCoordinateSpanMake(0.0, 0.0));
-    _initialCameraSetOnLoad = false;
+    _initialRegionSet = false;
+    _initialCameraSet = false;
+    _didLayoutSubviews = false;
+    _didPrepareMap = false;
     _didCallOnMapReady = false;
-    _didMoveToWindow = false;
-    _zoomTapEnabled = YES;
+    _zoomTapEnabled = zoomTapEnabled;
 
     // Listen to the myLocation property of GMSMapView.
     [self addObserver:self
@@ -101,6 +126,10 @@ id regionAsJSON(MKCoordinateRegion region) {
   return self;
 }
 
+- (instancetype) init {
+  return [self initWithMapId:nil initialCamera:nil backgroundColor:nil andZoomTapEnabled:YES];
+}
+
 - (void)dealloc {
   [self removeObserver:self
             forKeyPath:@"myLocation"
@@ -123,6 +152,92 @@ id regionAsJSON(MKCoordinateRegion region) {
            };
 }
 
+- (BOOL) isReady {
+    return _didPrepareMap;
+}
+
+-(void) fitToCoordinates:(NSArray<AIRGoogleMapCoordinate *> *) coordinates withEdgePadding:(NSDictionary*) edgePadding animated:(BOOL)animated
+{
+    CLLocationCoordinate2D myLocation = coordinates.firstObject.coordinate;
+         GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc] initWithCoordinate:myLocation coordinate:myLocation];
+
+         for (AIRGoogleMapCoordinate *coordinate in coordinates)
+           bounds = [bounds includingCoordinate:coordinate.coordinate];
+
+         // Set Map viewport
+         CGFloat top = [RCTConvert CGFloat:edgePadding[@"top"]];
+         CGFloat right = [RCTConvert CGFloat:edgePadding[@"right"]];
+         CGFloat bottom = [RCTConvert CGFloat:edgePadding[@"bottom"]];
+         CGFloat left = [RCTConvert CGFloat:edgePadding[@"left"]];
+
+         GMSCameraUpdate *cameraUpdate = [GMSCameraUpdate fitBounds:bounds withEdgeInsets:UIEdgeInsetsMake(top, left, bottom, right)];
+
+         if (animated) {
+           [self animateWithCameraUpdate: cameraUpdate];
+         } else {
+           [self moveCamera: cameraUpdate];
+         }
+}
+
+-(void) fitToElementsWithEdgePadding:(nonnull NSDictionary *)edgePadding
+             animated:(BOOL)animated
+{
+    CLLocationCoordinate2D myLocation = ((AIRGoogleMapMarker *)(self.markers.firstObject)).realMarker.position;
+    GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc] initWithCoordinate:myLocation coordinate:myLocation];
+
+    for (AIRGoogleMapMarker *marker in self.markers)
+      bounds = [bounds includingCoordinate:marker.realMarker.position];
+
+      GMSCameraUpdate* cameraUpdate;
+
+      if ([edgePadding count] != 0) {
+          // Set Map viewport
+          CGFloat top = [RCTConvert CGFloat:edgePadding[@"top"]];
+          CGFloat right = [RCTConvert CGFloat:edgePadding[@"right"]];
+          CGFloat bottom = [RCTConvert CGFloat:edgePadding[@"bottom"]];
+          CGFloat left = [RCTConvert CGFloat:edgePadding[@"left"]];
+
+          cameraUpdate = [GMSCameraUpdate fitBounds:bounds withEdgeInsets:UIEdgeInsetsMake(top, left, bottom, right)];
+      } else {
+          cameraUpdate = [GMSCameraUpdate fitBounds:bounds withPadding:55.0f];
+      }
+    if (animated) {
+      [self animateWithCameraUpdate: cameraUpdate];
+    } else {
+      [self moveCamera: cameraUpdate];
+    }
+}
+
+- (void) fitToSuppliedMarkers:(NSArray*) markers withEdgePadding:(NSDictionary*) edgePadding animated:(BOOL)animated
+{
+    NSPredicate *filterMarkers = [NSPredicate predicateWithBlock:^BOOL(id evaluatedObject, NSDictionary *bindings) {
+      AIRGoogleMapMarker *marker = (AIRGoogleMapMarker *)evaluatedObject;
+      return [marker isKindOfClass:[AIRGoogleMapMarker class]] && [markers containsObject:marker.identifier];
+    }];
+
+    NSArray *filteredMarkers = [self.markers filteredArrayUsingPredicate:filterMarkers];
+
+    CLLocationCoordinate2D myLocation = ((AIRGoogleMapMarker *)(filteredMarkers.firstObject)).realMarker.position;
+    GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc] initWithCoordinate:myLocation coordinate:myLocation];
+
+    for (AIRGoogleMapMarker *marker in filteredMarkers)
+      bounds = [bounds includingCoordinate:marker.realMarker.position];
+
+    // Set Map viewport
+    CGFloat top = [RCTConvert CGFloat:edgePadding[@"top"]];
+    CGFloat right = [RCTConvert CGFloat:edgePadding[@"right"]];
+    CGFloat bottom = [RCTConvert CGFloat:edgePadding[@"bottom"]];
+    CGFloat left = [RCTConvert CGFloat:edgePadding[@"left"]];
+
+    GMSCameraUpdate* cameraUpdate = [GMSCameraUpdate fitBounds:bounds withEdgeInsets:UIEdgeInsetsMake(top, left, bottom, right)];
+    if (animated) {
+      [self animateWithCameraUpdate:cameraUpdate
+       ];
+    } else {
+      [self moveCamera: cameraUpdate];
+    }
+}
+
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
 - (void)insertReactSubview:(id<RCTComponent>)subview atIndex:(NSInteger)atIndex {
@@ -130,12 +245,17 @@ id regionAsJSON(MKCoordinateRegion region) {
   // This is where we intercept them and do the appropriate underlying mapview action.
   if ([subview isKindOfClass:[AIRGoogleMapMarker class]]) {
     AIRGoogleMapMarker *marker = (AIRGoogleMapMarker*)subview;
-    marker.realMarker.map = self;
+    [marker didInsertInMap:self];
     [self.markers addObject:marker];
   } else if ([subview isKindOfClass:[AIRGoogleMapPolygon class]]) {
     AIRGoogleMapPolygon *polygon = (AIRGoogleMapPolygon*)subview;
-    polygon.polygon.map = self;
+    [polygon didInsertInMap:self];
     [self.polygons addObject:polygon];
+
+  } else if ([NSStringFromClass([subview class]) isEqualToString:@"RNMapsGooglePolygonView"]){
+//      RNMapsGooglePolygonView *polygon = (RNMapsGooglePolygonView*)subview;
+//      [polygon didInsertInMap:self];
+      [self.polygons addObject:subview];
   } else if ([subview isKindOfClass:[AIRGoogleMapPolyline class]]) {
     AIRGoogleMapPolyline *polyline = (AIRGoogleMapPolyline*)subview;
     polyline.polyline.map = self;
@@ -180,7 +300,9 @@ id regionAsJSON(MKCoordinateRegion region) {
     AIRGoogleMapMarker *marker = (AIRGoogleMapMarker*)subview;
     marker.realMarker.map = nil;
     [self.markers removeObject:marker];
-  } else if ([subview isKindOfClass:[AIRGoogleMapPolygon class]]) {
+  } else if ([NSStringFromClass([subview class]) isEqualToString:@"RNMapsGooglePolygonView"]) {
+      [self.polygons removeObject:subview];
+   } else if ([subview isKindOfClass:[AIRGoogleMapPolygon class]]) {
     AIRGoogleMapPolygon *polygon = (AIRGoogleMapPolygon*)subview;
     polygon.polygon.map = nil;
     [self.polygons removeObject:polygon];
@@ -225,7 +347,7 @@ id regionAsJSON(MKCoordinateRegion region) {
 }
 #pragma clang diagnostic pop
 
-- (NSArray *)getMapBoundaries
+- (NSDictionary *)getMapBoundaries
 {
     GMSVisibleRegion visibleRegion = self.projection.visibleRegion;
     GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc] initWithRegion:visibleRegion];
@@ -233,69 +355,112 @@ id regionAsJSON(MKCoordinateRegion region) {
     CLLocationCoordinate2D northEast = bounds.northEast;
     CLLocationCoordinate2D southWest = bounds.southWest;
 
-    return @[
-        @[
-            [NSNumber numberWithDouble:northEast.longitude],
-            [NSNumber numberWithDouble:northEast.latitude]
-        ],
-        @[
-            [NSNumber numberWithDouble:southWest.longitude],
-            [NSNumber numberWithDouble:southWest.latitude]
-        ]
-    ];
-}
-
-- (void)didMoveToWindow {
-  if (_didMoveToWindow) return;
-  _didMoveToWindow = true;
+    return @{
+        @"northEast": @{
+            @"latitude": [NSNumber numberWithDouble:northEast.latitude],
+            @"longitude": [NSNumber numberWithDouble:northEast.longitude],
+                },
+        @"southWest": @{
+            @"latitude": [NSNumber numberWithDouble:southWest.latitude],
+            @"longitude": [NSNumber numberWithDouble:southWest.longitude],
+            },
+    };
+}
+
+- (NSDictionary *) getCameraDic {
+    GMSCameraPosition *camera = [self camera];
+    return @{
+        @"center": @{
+                @"latitude": @(camera.target.latitude),
+                @"longitude": @(camera.target.longitude),
+                },
+        @"pitch": @(camera.viewingAngle),
+        @"heading": @(camera.bearing),
+        @"zoom": @(camera.zoom),
+    };
+}
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  if(_didLayoutSubviews) return;
+  _didLayoutSubviews = true;
 
   if (_initialCamera != nil) {
     self.camera = _initialCamera;
+    _initialCameraSet = true;
   }
   else if (_initialRegion.span.latitudeDelta != 0.0 &&
       _initialRegion.span.longitudeDelta != 0.0) {
     self.camera = [AIRGoogleMap makeGMSCameraPositionFromMap:self andMKCoordinateRegion:_initialRegion];
+    _initialRegionSet = true;
   } else if (_region.span.latitudeDelta != 0.0 &&
       _region.span.longitudeDelta != 0.0) {
     self.camera = [AIRGoogleMap makeGMSCameraPositionFromMap:self andMKCoordinateRegion:_region];
   }
-
-  [super didMoveToWindow];
 }
 
 - (void)setInitialRegion:(MKCoordinateRegion)initialRegion {
-  if (_initialCameraSetOnLoad) return;
   _initialRegion = initialRegion;
-  _initialCameraSetOnLoad = _didMoveToWindow;
-  self.camera = [AIRGoogleMap makeGMSCameraPositionFromMap:self andMKCoordinateRegion:initialRegion];
+  if(!_initialRegionSet && _didLayoutSubviews){
+    self.camera = [AIRGoogleMap makeGMSCameraPositionFromMap:self andMKCoordinateRegion:initialRegion];
+    _initialRegionSet = true;
+  }
 }
 
 - (void)setInitialCamera:(GMSCameraPosition*)initialCamera {
-    if (_initialCameraSetOnLoad) return;
     _initialCamera = initialCamera;
-    _initialCameraSetOnLoad = _didMoveToWindow;
-    self.camera = initialCamera;
+    if(!_initialCameraSet && _didLayoutSubviews){
+      self.camera = initialCamera;
+      _initialCameraSet = true;
+    }
 }
 
 - (void)setRegion:(MKCoordinateRegion)region {
-  // TODO: The JS component is repeatedly setting region unnecessarily. We might want to deal with that in here.
+    if (_isAnimating || !CLLocationCoordinate2DIsValid(region.center)) return;
   _region = region;
-  self.camera = [AIRGoogleMap makeGMSCameraPositionFromMap:self  andMKCoordinateRegion:region];
+  if(_didLayoutSubviews) {
+    self.camera = [AIRGoogleMap makeGMSCameraPositionFromMap:self  andMKCoordinateRegion:region];
+  }
+}
+
+- (void) setGoogleMapId:(NSString *) googleMapId {
+    _googleMapId = googleMapId;
+}
+
+- (GMSCameraPosition *)cameraProp {
+    if(_didLayoutSubviews) {
+      return self.camera;
+    } else {
+      return _initialCamera;
+    }
 }
 
 - (void)setCameraProp:(GMSCameraPosition*)camera {
+    if (_isAnimating || !CLLocationCoordinate2DIsValid([camera target])) return;
     _initialCamera = camera;
-    self.camera = camera;
+    if(_didLayoutSubviews) {
+      self.camera = camera;
+    }
 }
 
+- (void)setOnMapReady:(RCTBubblingEventBlock)onMapReady {
+    _onMapReady = onMapReady;
+    if(!_didCallOnMapReady && _didPrepareMap) {
+      self.onMapReady(@{});
+      _didCallOnMapReady = true;
+    }
+}
 
 - (void)didPrepareMap {
-  UIView* mapView = [self valueForKey:@"mapView"]; //GMSVectorMapView
-  [self overrideGestureRecognizersForView:mapView];
+    if (!_didPrepareMap){
+        [self overrideGestureRecognizersForView];
+    }
 
-  if (_didCallOnMapReady) return;
-  _didCallOnMapReady = true;
-  if (self.onMapReady) self.onMapReady(@{});
+  if (!_didCallOnMapReady && self.onMapReady) {
+    self.onMapReady(@{});
+    _didCallOnMapReady = true;
+  }
+  _didPrepareMap = true;
 }
 
 - (void)mapViewDidFinishTileRendering {
@@ -318,6 +483,7 @@ id regionAsJSON(MKCoordinateRegion region) {
 
   // TODO: not sure why this is necessary
   [self setSelectedMarker:marker];
+
   return NO;
 }
 
@@ -351,13 +517,19 @@ id regionAsJSON(MKCoordinateRegion region) {
   self.onLongPress([self eventFromCoordinate:coordinate]);
 }
 
+- (void)willMove:(BOOL)gesture {
+    _isAnimating = YES;
+  id event = @{@"isGesture": [NSNumber numberWithBool:gesture]};
+  if (self.onRegionChangeStart) self.onRegionChangeStart(event);
+}
+
 - (void)didChangeCameraPosition:(GMSCameraPosition *)position isGesture:(BOOL)isGesture{
   id event = @{@"continuous": @YES,
                @"region": regionAsJSON([AIRGoogleMap makeGMSCameraPositionFromMap:self andGMSCameraPosition:position]),
                @"isGesture": [NSNumber numberWithBool:isGesture],
                };
 
-  if (self.onChange) self.onChange(event);
+  if (self.onRegionChange) self.onRegionChange(event);
 }
 
 - (void)didTapPOIWithPlaceID:(NSString *)placeID
@@ -379,7 +551,8 @@ id regionAsJSON(MKCoordinateRegion region) {
                @"region": regionAsJSON([AIRGoogleMap makeGMSCameraPositionFromMap:self andGMSCameraPosition:position]),
                @"isGesture": [NSNumber numberWithBool:isGesture],
                };
-  if (self.onChange) self.onChange(event);  // complete
+    if (self.onRegionChangeComplete) self.onRegionChangeComplete(event);  // complete
+    _isAnimating = NO;
 }
 
 - (void)setMapPadding:(UIEdgeInsets)mapPadding {
@@ -498,8 +671,7 @@ id regionAsJSON(MKCoordinateRegion region) {
   if (!style) {
     NSLog(@"The style definition could not be loaded: %@", error);
   }
-
-  self.mapStyle = style;
+    [self setMapStyle:style];
 }
 
 - (BOOL)showsCompass {
@@ -522,11 +694,11 @@ id regionAsJSON(MKCoordinateRegion region) {
   return self.settings.myLocationButton;
 }
 
-- (void)setMinZoomLevel:(CGFloat)minZoomLevel {
+- (void)setMinZoom:(CGFloat)minZoomLevel {
   [self setMinZoom:minZoomLevel maxZoom:self.maxZoom ];
 }
 
-- (void)setMaxZoomLevel:(CGFloat)maxZoomLevel {
+- (void)setMaxZoom:(CGFloat)maxZoomLevel {
   [self setMinZoom:self.minZoom maxZoom:maxZoomLevel ];
 }
 
@@ -546,6 +718,33 @@ id regionAsJSON(MKCoordinateRegion region) {
   return self.settings.indoorPicker;
 }
 
+-(void)setSelectedMarker:(AIRGMSMarker *)selectedMarker {
+  if (selectedMarker == self.selectedMarker) {
+    return;
+  }
+    AIRGMSMarker *airMarker = (AIRGMSMarker *) self.selectedMarker;
+    AIRGoogleMapMarker *fakeAirMarker = (AIRGoogleMapMarker *) airMarker.fakeMarker;
+    AIRGoogleMapMarker *fakeSelectedMarker = (AIRGoogleMapMarker *) selectedMarker.fakeMarker;
+
+    if (airMarker && airMarker.onDeselect) {
+        airMarker.onDeselect([fakeAirMarker makeEventData:@"marker-deselect"]);
+    }
+
+    if (airMarker && self.onMarkerDeselect) {
+        self.onMarkerDeselect([fakeAirMarker makeEventData:@"marker-deselect"]);
+    }
+
+    if (selectedMarker && selectedMarker.onSelect) {
+        selectedMarker.onSelect([fakeSelectedMarker makeEventData:@"marker-select"]);
+    }
+
+    if (selectedMarker && self.onMarkerSelect) {
+        self.onMarkerSelect([fakeSelectedMarker makeEventData:@"marker-select"]);
+    }
+
+  [super setSelectedMarker:selectedMarker];
+}
+
 + (MKCoordinateRegion) makeGMSCameraPositionFromMap:(GMSMapView *)map andGMSCameraPosition:(GMSCameraPosition *)position {
   // solution from here: http://stackoverflow.com/a/16587735/1102215
   GMSVisibleRegion visibleRegion = map.projection.visibleRegion;
@@ -581,6 +780,63 @@ id regionAsJSON(MKCoordinateRegion region) {
   return [map cameraForBounds:bounds insets:UIEdgeInsetsZero];
 }
 
+#pragma mark - RNMapsAirModuleDelegate
+
+- (NSDictionary *) getCoordinatesForPoint:(CGPoint)point
+{
+    CLLocationCoordinate2D coordinate = [self.projection coordinateForPoint:point];
+    return @{
+              @"latitude": @(coordinate.latitude),
+              @"longitude": @(coordinate.longitude),
+    };
+}
+
+- (NSDictionary *) getPointForCoordinates:(CLLocationCoordinate2D)location
+{
+    CGPoint touchPoint = [self.projection pointForCoordinate:location];
+    return @{
+        @"x": @(touchPoint.x),
+        @"y": @(touchPoint.y),
+    };
+}
+
+-(void) takeSnapshotWithConfig:(NSDictionary *)config success:(RCTPromiseResolveBlock)success error:(RCTPromiseRejectBlock)error {
+    /* unused
+    NSNumber *width = [config objectForKey:@"width"];
+    NSNumber *height = [config objectForKey:@"height"];
+    */
+    NSNumber *quality = [config objectForKey:@"quality"];
+
+    NSString *format = [config objectForKey:@"format"];
+    NSString *result = [config objectForKey:@"result"];
+    NSTimeInterval timeStamp = [[NSDate date] timeIntervalSince1970];
+    NSString *pathComponent = [NSString stringWithFormat:@"Documents/snapshot-%.20lf.%@", timeStamp, format];
+    NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent: pathComponent];
+
+    // TODO: currently we are ignoring width, height, region
+
+    UIGraphicsBeginImageContextWithOptions(self.frame.size, YES, 0.0f);
+    [self.layer renderInContext:UIGraphicsGetCurrentContext()];
+    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
+
+    NSData *data;
+    if ([format isEqualToString:@"png"]) {
+        data = UIImagePNGRepresentation(image);
+
+    } else if([format isEqualToString:@"jpg"]) {
+          data = UIImageJPEGRepresentation(image, quality.floatValue);
+    }
+
+    if ([result isEqualToString:@"file"]) {
+        [data writeToFile:filePath atomically:YES];
+        success(filePath);
+    } else if ([result isEqualToString:@"base64"]) {
+        success([data base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithCarriageReturn]);
+    }
+
+  UIGraphicsEndImageContext();
+}
+
 #pragma mark - Utils
 
 - (CGRect) frameForMarker:(AIRGoogleMapMarker*) mrkView {
@@ -652,8 +908,8 @@ id regionAsJSON(MKCoordinateRegion region) {
 
 #pragma mark - Overrides for Callout behavior
 
--(void)overrideGestureRecognizersForView:(UIView*)view {
-    NSArray* grs = view.gestureRecognizers;
+-(void)overrideGestureRecognizersForView {
+    NSArray* grs = self.gestureRecognizers;
     for (UIGestureRecognizer* gestureRecognizer in grs) {
         NSNumber* grHash = [NSNumber numberWithUnsignedInteger:gestureRecognizer.hash];
         if([self.origGestureRecognizersMeta objectForKey:grHash] != nil)
@@ -673,7 +929,7 @@ id regionAsJSON(MKCoordinateRegion region) {
                                             }];
         }
         if (isZoomTapGesture && self.zoomTapEnabled == NO) {
-            [view removeGestureRecognizer:gestureRecognizer];
+            [self removeGestureRecognizer:gestureRecognizer];
             continue;
         }
 
@@ -704,16 +960,19 @@ id regionAsJSON(MKCoordinateRegion region) {
     BOOL isTap = [gestureRecognizer isKindOfClass:[UITapGestureRecognizer class]] || [gestureRecognizer isMemberOfClass:[UITapGestureRecognizer class]];
     if (isTap) {
         BOOL isTapInsideBubble = NO;
-    CGPoint tapPoint = CGPointZero;
-    CGPoint tapPointInBubble = CGPointZero;
-
-    NSArray* touches = [gestureRecognizer valueForKey:@"touches"];
-    UITouch* oneTouch = [touches firstObject];
-    NSArray* delayedTouches = [gestureRecognizer valueForKey:@"delayedTouches"];
-    NSObject* delayedTouch = [delayedTouches firstObject]; //UIGestureDeleayedTouch
-    UITouch* tapTouch = [delayedTouch valueForKey:@"stateWhenDelayed"];
-    if (!tapTouch)
-        tapTouch = oneTouch;
+        CGPoint tapPoint = CGPointZero;
+        CGPoint tapPointInBubble = CGPointZero;
+
+        NSArray* touches = [gestureRecognizer valueForKey:@"touches"];
+        UITouch* oneTouch = [touches firstObject];
+        NSArray* delayedTouches = [gestureRecognizer valueForKey:@"delayedTouches"];
+        NSObject* delayedTouch = [delayedTouches firstObject]; //UIGestureDeleayedTouch
+        UITouch* tapTouch = [delayedTouch valueForKey:@"stateWhenDelayed"];
+
+        if (!tapTouch) {
+            tapTouch = oneTouch;
+        };
+
         tapPoint = [tapTouch locationInView:self];
         isTapInsideBubble = tapTouch != nil && CGRectContainsPoint(bubbleFrame, tapPoint);
         if (isTapInsideBubble) {
@@ -797,7 +1056,7 @@ id regionAsJSON(MKCoordinateRegion region) {
                     @"latitude": @(location.coordinate.latitude),
                     @"longitude": @(location.coordinate.longitude),
                     @"altitude": @(location.altitude),
-                    @"timestamp": @(location.timestamp.timeIntervalSinceReferenceDate * 1000),
+                    @"timestamp": @(location.timestamp.timeIntervalSince1970 * 1000),
                     @"accuracy": @(location.horizontalAccuracy),
                     @"altitudeAccuracy": @(location.verticalAccuracy),
                     @"speed": @(location.speed),
@@ -813,7 +1072,7 @@ id regionAsJSON(MKCoordinateRegion region) {
 }
 
 + (NSString *)GetIconUrl:(GMUPlacemark *) marker parser:(GMUKMLParser *) parser {
-#ifdef HAVE_GOOGLE_MAPS_UTILS
+#if HAVE_GOOGLE_MAPS_UTILS
   if (marker.style.styleID != nil) {
     for (GMUStyle *style in parser.styles) {
       if (style.styleID == marker.style.styleID) {
@@ -832,8 +1091,53 @@ id regionAsJSON(MKCoordinateRegion region) {
   return _kmlSrc;
 }
 
+- (void) setKMLData:(NSData *) urlData {
+    GMUKMLParser *parser = [[GMUKMLParser alloc] initWithData:urlData];
+    [parser parse];
+
+    NSUInteger index = 0;
+    NSMutableArray *markers = [[NSMutableArray alloc]init];
+
+    for (GMUPlacemark *place in parser.placemarks) {
+
+      CLLocationCoordinate2D location =((GMUPoint *) place.geometry).coordinate;
+
+      AIRGoogleMapMarker *marker = (AIRGoogleMapMarker *)[[AIRGoogleMapMarkerManager alloc] view];
+      if (!marker.bridge) {
+        marker.bridge = _bridge;
+      }
+      marker.identifier = place.title;
+      marker.coordinate = location;
+      marker.title = place.title;
+      marker.subtitle = place.snippet;
+      marker.pinColor = place.style.fillColor;
+      marker.imageSrc = [AIRGoogleMap GetIconUrl:place parser:parser];
+      marker.layer.backgroundColor = [UIColor clearColor].CGColor;
+      marker.layer.position = CGPointZero;
+
+      [self insertReactSubview:(UIView *) marker atIndex:index];
+
+      [markers addObject:@{@"id": marker.identifier,
+                           @"title": marker.title,
+                           @"description": marker.subtitle,
+                           @"coordinate": @{
+                               @"latitude": @(location.latitude),
+                               @"longitude": @(location.longitude)
+                               }
+                           }];
+
+      index++;
+    }
+
+    id event = @{@"markers": markers};
+    if (self.onKmlReady) self.onKmlReady(event);
+  #else
+      REQUIRES_GOOGLE_MAPS_UTILS();
+  #endif
+}
+
 - (void)setKmlSrc:(NSString *)kmlUrl {
-#ifdef HAVE_GOOGLE_MAPS_UTILS
+#if HAVE_GOOGLE_MAPS_UTILS
 
   _kmlSrc = kmlUrl;
 
@@ -841,53 +1145,28 @@ id regionAsJSON(MKCoordinateRegion region) {
   NSData *urlData = nil;
 
   if ([url isFileURL]) {
-    urlData = [NSData dataWithContentsOfURL:url];
+      [self setKMLData:[NSData dataWithContentsOfURL:url]];
   } else {
-    urlData = [[NSFileManager defaultManager] contentsAtPath:kmlUrl];
+      __weak AIRGoogleMap *weakSelf = self;
+
+      NSURLSession *session = [NSURLSession sharedSession];
+      NSURLSessionDataTask *dataTask = [session dataTaskWithURL:url
+                                              completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
+          if (error) {
+              NSLog(@"Error fetching data: %@", error.localizedDescription);
+              return;
+          } else {
+              dispatch_async(dispatch_get_main_queue(), ^{
+                  AIRGoogleMap *strongSelf = weakSelf;
+                  [strongSelf setKMLData:data];
+              });
+
+          }
+      }];
+      [dataTask resume];
   }
 
-  GMUKMLParser *parser = [[GMUKMLParser alloc] initWithData:urlData];
-  [parser parse];
 
-  NSUInteger index = 0;
-  NSMutableArray *markers = [[NSMutableArray alloc]init];
-
-  for (GMUPlacemark *place in parser.placemarks) {
-
-    CLLocationCoordinate2D location =((GMUPoint *) place.geometry).coordinate;
-
-    AIRGoogleMapMarker *marker = (AIRGoogleMapMarker *)[[AIRGoogleMapMarkerManager alloc] view];
-    if (!marker.bridge) {
-      marker.bridge = _bridge;
-    }
-    marker.identifier = place.title;
-    marker.coordinate = location;
-    marker.title = place.title;
-    marker.subtitle = place.snippet;
-    marker.pinColor = place.style.fillColor;
-    marker.imageSrc = [AIRGoogleMap GetIconUrl:place parser:parser];
-    marker.layer.backgroundColor = [UIColor clearColor].CGColor;
-    marker.layer.position = CGPointZero;
-
-    [self insertReactSubview:(UIView *) marker atIndex:index];
-
-    [markers addObject:@{@"id": marker.identifier,
-                         @"title": marker.title,
-                         @"description": marker.subtitle,
-                         @"coordinate": @{
-                             @"latitude": @(location.latitude),
-                             @"longitude": @(location.longitude)
-                             }
-                         }];
-
-    index++;
-  }
-
-  id event = @{@"markers": markers};
-  if (self.onKmlReady) self.onKmlReady(event);
-#else
-    REQUIRES_GOOGLE_MAPS_UTILS();
-#endif
 }
 
 
@@ -897,11 +1176,9 @@ id regionAsJSON(MKCoordinateRegion region) {
             return;
         }
         self.onIndoorBuildingFocused(@{
-            @"IndoorBuilding": @{
-                    @"activeLevelIndex": @0,
-                    @"underground": @false,
-                    @"levels": [[NSMutableArray alloc]init]
-            }
+            @"activeLevelIndex": @0,
+            @"underground": @false,
+            @"levels": [[NSMutableArray alloc]init]
         });
     }
     NSInteger i = 0;
@@ -918,11 +1195,9 @@ id regionAsJSON(MKCoordinateRegion region) {
         return;
     }
     self.onIndoorBuildingFocused(@{
-        @"IndoorBuilding": @{
-                @"activeLevelIndex": @(building.defaultLevelIndex),
-                @"underground": @(building.underground),
-                @"levels": arrayLevels
-        }
+            @"activeLevelIndex": @(building.defaultLevelIndex),
+            @"underground": @(building.underground),
+            @"levels": arrayLevels
     });
 }
 
@@ -938,13 +1213,15 @@ id regionAsJSON(MKCoordinateRegion region) {
         i++;
     }
     self.onIndoorLevelActivated(@{
-        @"IndoorLevel": @{
-                @"activeLevelIndex": @(i),
-                @"name": level.name,
-                @"shortName": level.shortName
-        }
+            @"activeLevelIndex": @(i),
+            @"name": level.name,
+            @"shortName": level.shortName
     });
 }
+// do nothing, passed as options on initialization
+- (void)setLoadingBackgroundColor:(UIColor *)loadingBackgroundColor {
+
+}
 
 
 @end