react-native-maps 1.21.0-alpha.1 → 1.21.0-alpha.11

package/android/build.gradle

@@ -17,16 +17,31 @@ buildscript {
   }
 }
 
-apply plugin: 'com.android.library'
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  if (major == 7 && minor >= 3) {
+    return true
+  }
+
+  return major >= 8
+}
 
 def isNewArchitectureEnabled() {
   return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
 }
 
+apply plugin: 'com.android.library'
+if (isNewArchitectureEnabled()) {
+  apply plugin: 'com.facebook.react'
+}
+apply plugin: 'kotlin-android'
+
 android {
-  namespace "com.rnmaps.maps"
-  def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
-  if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
+  if (supportsNamespace()) {
     namespace "com.rnmaps.maps"
   }
 

package/android/src/main/java/com/rnmaps/fabric/NativeAirMapsModule.java

@@ -0,0 +1,51 @@
+package com.rnmaps.fabric;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+
+public class NativeAirMapsModule extends NativeAirMapsModuleSpec {
+    public NativeAirMapsModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public void getCamera(double tag, Promise promise) {
+
+    }
+
+    @Override
+    public void getMarkersFrames(double tag, boolean onlyVisible, Promise promise) {
+
+    }
+
+    @Override
+    public void getMapBoundaries(double tag, Promise promise) {
+
+    }
+
+    @Override
+    public void takeSnapshot(double tag, ReadableMap config, Promise promise) {
+
+    }
+
+    @Override
+    public void getAddressFromCoordinates(double tag, ReadableMap coordinate, Promise promise) {
+
+    }
+
+    @Override
+    public void getPointForCoordinate(double tag, ReadableMap coordinate, Promise promise) {
+
+    }
+
+    @Override
+    public void getCoordinateForPoint(double tag, ReadableMap point, Promise promise) {
+
+    }
+}

package/android/src/main/java/com/rnmaps/maps/MapAirModulePackage.java

@@ -0,0 +1,46 @@
+package com.rnmaps.maps;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.rnmaps.fabric.NativeAirMapsModule;
+import com.rnmaps.fabric.NativeAirMapsModuleSpec;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class MapAirModulePackage extends TurboReactPackage {
+
+    @Override
+    public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+        if (name.equals(NativeAirMapsModuleSpec.NAME)) {
+            return new NativeAirMapsModule(reactContext);
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return new ReactModuleInfoProvider() {
+            @NonNull
+            @Override
+            public Map<String, ReactModuleInfo> getReactModuleInfos() {
+                Map<String, ReactModuleInfo> map = new HashMap<>();
+                map.put(NativeAirMapsModuleSpec.NAME, new ReactModuleInfo(
+                        NativeAirMapsModuleSpec.NAME,       // name
+                        NativeAirMapsModuleSpec.NAME,       // className
+                        false, // canOverrideExistingModule
+                        false, // needsEagerInit
+                        false, // isCXXModule
+                        true   // isTurboModule
+                ));
+                return map;
+            }
+        };
+    }
+}

package/ios/AirGoogleMaps/AIRGMSMarker.h

@@ -12,7 +12,7 @@
 
 @class AIRGoogleMapMarker;
 
-@interface AIRGMSMarker : GMSMarker
+@interface AIRGMSMarker : GMSAdvancedMarker
 @property (nonatomic, strong) NSString *identifier;
 @property (nonatomic, weak) AIRGoogleMapMarker *fakeMarker;
 @property (nonatomic, copy) RCTBubblingEventBlock onPress;

package/ios/AirGoogleMaps/AIRGoogleMap.h

@@ -13,9 +13,10 @@
 #import <GoogleMaps/GoogleMaps.h>
 #import <MapKit/MapKit.h>
 #import "AIRGMSMarker.h"
-#import "RCTConvert+AirMap.h"
+#import "RNMapsAirModuleDelegate.h"
+#import "AIRGoogleMapCoordinate.h"
 
-@interface AIRGoogleMap : GMSMapView
+@interface AIRGoogleMap : GMSMapView <RNMapsAirModuleDelegate>
 
 // TODO: don't use MK region?
 @property (nonatomic, weak) RCTBridge *bridge;
@@ -66,6 +67,7 @@
 @property (nonatomic, assign) BOOL showsIndoorLevelPicker;
 @property (nonatomic, assign) NSString *kmlSrc;
 
+- (BOOL) isReady;
 - (void)didPrepareMap;
 - (void)mapViewDidFinishTileRendering;
 - (BOOL)didTapMarker:(GMSMarker *)marker;
@@ -84,6 +86,10 @@
 
 - (NSDictionary*) getMarkersFramesWithOnlyVisible:(BOOL)onlyVisible;
 - (instancetype)initWithMapId:(NSString *)mapId initialCamera:(GMSCameraPosition*) camera backgroundColor:(UIColor *) backgroundColor andZoomTapEnabled:(BOOL)zoomTapEnabled;
+-(void) fitToSuppliedMarkers:(NSArray*) markers withEdgePadding:(NSDictionary*) edgePadding animated:(BOOL)animated;
+-(void) fitToCoordinates:(NSArray<AIRGoogleMapCoordinate *> *) coordinates withEdgePadding:(NSDictionary*) edgePadding animated:(BOOL)animated;
+-(void) fitToElementsWithEdgePadding:(nonnull NSDictionary *)edgePadding
+             animated:(BOOL)animated;
 @end
 
 #endif

package/ios/AirGoogleMaps/AIRGoogleMap.m

@@ -17,11 +17,12 @@
 #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
@@ -86,7 +87,7 @@ id regionAsJSON(MKCoordinateRegion region) {
         [options setCamera:camera];
     }
     self = [super initWithOptions:options];
- 
+
     if (self) {
     _reactSubviews = [NSMutableArray new];
     _markers = [NSMutableArray array];
@@ -145,6 +146,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 {
@@ -579,11 +666,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 ];
 }
 
@@ -610,7 +697,7 @@ id regionAsJSON(MKCoordinateRegion region) {
     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"]);
     }
@@ -618,7 +705,7 @@ id regionAsJSON(MKCoordinateRegion region) {
     if (airMarker && self.onMarkerDeselect) {
         self.onMarkerDeselect([fakeAirMarker makeEventData:@"marker-deselect"]);
     }
-    
+
     if (selectedMarker && selectedMarker.onSelect) {
         selectedMarker.onSelect([fakeSelectedMarker makeEventData:@"marker-select"]);
     }
@@ -665,6 +752,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 callback:(RCTPromiseResolveBlock) callback
+{
+    /* 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"];
+    NSString *filePath = [config objectForKey:@"filePath"];
+
+    
+    // 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];
+        callback(filePath);
+    } else if ([result isEqualToString:@"base64"]) {
+          callback([data base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithCarriageReturn]);
+    }
+  
+  UIGraphicsEndImageContext();
+}
+
 #pragma mark - Utils
 
 - (CGRect) frameForMarker:(AIRGoogleMapMarker*) mrkView {
@@ -1034,7 +1178,7 @@ id regionAsJSON(MKCoordinateRegion region) {
 }
 // do nothing, passed as options on initialization
 - (void)setLoadingBackgroundColor:(UIColor *)loadingBackgroundColor {
-    
+
 }
 
 

package/ios/AirGoogleMaps/AIRGoogleMapCircle.h

@@ -7,7 +7,6 @@
 #ifdef HAVE_GOOGLE_MAPS
 
 #import <GoogleMaps/GoogleMaps.h>
-#import "AIRMapCoordinate.h"
 
 @interface AIRGoogleMapCircle : UIView
 

package/ios/AirGoogleMaps/AIRGoogleMapCoordinate.h

@@ -0,0 +1,13 @@
+//
+// Created by Leland Richardson on 12/27/15.
+// Copyright (c) 2015 Facebook. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <MapKit/MapKit.h>
+
+@interface AIRGoogleMapCoordinate : NSObject
+
+@property (nonatomic, assign) CLLocationCoordinate2D coordinate;
+
+@end

package/ios/AirGoogleMaps/AIRGoogleMapCoordinate.m

@@ -0,0 +1,10 @@
+//
+// Created by Leland Richardson on 12/27/15.
+// Copyright (c) 2015 Facebook. All rights reserved.
+//
+
+#import "AIRGoogleMapCoordinate.h"
+
+
+@implementation AIRGoogleMapCoordinate
+@end

package/ios/AirGoogleMaps/AIRGoogleMapManager.h

@@ -9,8 +9,15 @@
 
 #import <React/RCTViewManager.h>
 
+@class GMSCameraPosition;
+
 @interface AIRGoogleMapManager : RCTViewManager
 
+@property (nonatomic, strong) NSString* googleMapId;
+@property (nonatomic) BOOL zoomTapEnabled;
+@property (nonatomic, strong) UIColor* backgroundColor;
+@property (nonatomic, strong) GMSCameraPosition* camera;
+
 @property (nonatomic, strong) NSDictionary *initialProps;
 
 @property (nonatomic) BOOL isGesture;

package/ios/AirGoogleMaps/AIRGoogleMapManager.m

@@ -19,14 +19,9 @@
 #import <React/UIView+React.h>
 #import "RCTConvert+GMSMapViewType.h"
 #import "AIRGoogleMap.h"
-#import "AIRMapMarker.h"
-#import "AIRMapPolyline.h"
-#import "AIRMapPolygon.h"
-#import "AIRMapCircle.h"
-#import "SMCalloutView.h"
 #import "AIRGoogleMapMarker.h"
-#import "RCTConvert+AirMap.h"
-
+#import "AIRGoogleMapCoordinate.h"
+#import "RCTConvert+GMSMapViewType.h"
 #import <MapKit/MapKit.h>
 #import <QuartzCore/QuartzCore.h>
 
@@ -45,26 +40,22 @@ RCT_EXPORT_MODULE()
 
 - (UIView *)view
 {
-  NSString* googleMapId  = nil;
-  BOOL zoomTapEnabled = YES;
-  UIColor* backgroundColor = nil;
-  GMSCameraPosition* camera = nil;
 
   if (self.initialProps){
       if (self.initialProps[@"googleMapId"]){
-          googleMapId  = self.initialProps[@"googleMapId"];
+          _googleMapId  = self.initialProps[@"googleMapId"];
       }
       if (self.initialProps[@"zoomTapEnabled"]){
-          zoomTapEnabled = self.initialProps[@"zoomTapEnabled"];
+          _zoomTapEnabled = self.initialProps[@"zoomTapEnabled"];
       }
       if (self.initialProps[@"loadingBackgroundColor"]){
-          backgroundColor = [RCTConvert UIColor:self.initialProps[@"loadingBackgroundColor"]];
+          _backgroundColor = [RCTConvert UIColor:self.initialProps[@"loadingBackgroundColor"]];
       }
       if (self.initialProps[@"initialCamera"]){
-          camera = [RCTConvert GMSCameraPositionWithDefaults:self.initialProps[@"initialCamera"] existingCamera:nil];
+          _camera = [RCTConvert GMSCameraPositionWithDefaults:self.initialProps[@"initialCamera"] existingCamera:nil];
       }
   }
-  AIRGoogleMap *map = [[AIRGoogleMap alloc] initWithMapId:googleMapId initialCamera:camera backgroundColor:backgroundColor andZoomTapEnabled:zoomTapEnabled];
+  AIRGoogleMap *map = [[AIRGoogleMap alloc] initWithMapId:self.googleMapId initialCamera:self.camera backgroundColor:self.backgroundColor andZoomTapEnabled:self.zoomTapEnabled];
   map.bridge = self.bridge;
   map.delegate = self;
   map.isAccessibilityElement = NO;
@@ -217,32 +208,8 @@ RCT_EXPORT_METHOD(fitToElements:(nonnull NSNumber *)reactTag
     if (![view isKindOfClass:[AIRGoogleMap class]]) {
       RCTLogError(@"Invalid view returned from registry, expecting AIRGoogleMap, got: %@", view);
     } else {
-      AIRGoogleMap *mapView = (AIRGoogleMap *)view;
-
-      CLLocationCoordinate2D myLocation = ((AIRGoogleMapMarker *)(mapView.markers.firstObject)).realMarker.position;
-      GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc] initWithCoordinate:myLocation coordinate:myLocation];
-
-      for (AIRGoogleMapMarker *marker in mapView.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) {
-        [mapView animateWithCameraUpdate: cameraUpdate];
-      } else {
-        [mapView moveCamera: cameraUpdate];
-      }
+        AIRGoogleMap *mapView = (AIRGoogleMap *)view;
+        [mapView fitToElementsWithEdgePadding:edgePadding animated:animated];
     }
   }];
 }
@@ -257,40 +224,14 @@ RCT_EXPORT_METHOD(fitToSuppliedMarkers:(nonnull NSNumber *)reactTag
     if (![view isKindOfClass:[AIRGoogleMap class]]) {
       RCTLogError(@"Invalid view returned from registry, expecting AIRGoogleMap, got: %@", view);
     } else {
-      AIRGoogleMap *mapView = (AIRGoogleMap *)view;
-
-      NSPredicate *filterMarkers = [NSPredicate predicateWithBlock:^BOOL(id evaluatedObject, NSDictionary *bindings) {
-        AIRGoogleMapMarker *marker = (AIRGoogleMapMarker *)evaluatedObject;
-        return [marker isKindOfClass:[AIRGoogleMapMarker class]] && [markers containsObject:marker.identifier];
-      }];
-
-      NSArray *filteredMarkers = [mapView.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) {
-        [mapView animateWithCameraUpdate:cameraUpdate
-         ];
-      } else {
-        [mapView moveCamera: cameraUpdate];
-      }
+        AIRGoogleMap *mapView = (AIRGoogleMap *)view;
+        [mapView fitToSuppliedMarkers:markers withEdgePadding:edgePadding animated:animated];
     }
   }];
 }
 
 RCT_EXPORT_METHOD(fitToCoordinates:(nonnull NSNumber *)reactTag
-                  coordinates:(nonnull NSArray<AIRMapCoordinate *> *)coordinates
+                  coordinates:(nonnull NSArray<AIRGoogleMapCoordinate *> *)coordinates
                   edgePadding:(nonnull NSDictionary *)edgePadding
                   animated:(BOOL)animated)
 {
@@ -300,26 +241,7 @@ RCT_EXPORT_METHOD(fitToCoordinates:(nonnull NSNumber *)reactTag
       RCTLogError(@"Invalid view returned from registry, expecting AIRGoogleMap, got: %@", view);
     } else {
       AIRGoogleMap *mapView = (AIRGoogleMap *)view;
-
-      CLLocationCoordinate2D myLocation = coordinates.firstObject.coordinate;
-      GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc] initWithCoordinate:myLocation coordinate:myLocation];
-
-      for (AIRMapCoordinate *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) {
-        [mapView animateWithCameraUpdate: cameraUpdate];
-      } else {
-        [mapView moveCamera: cameraUpdate];
-      }
+        [mapView fitToCoordinates:coordinates withEdgePadding:edgePadding animated:animated];
     }
   }];
 }
@@ -331,7 +253,7 @@ RCT_EXPORT_METHOD(takeSnapshot:(nonnull NSNumber *)reactTag
                   format:(nonnull NSString *)format
                   quality:(nonnull NSNumber *)quality
                   result:(nonnull NSString *)result
-                  withCallback:(RCTResponseSenderBlock)callback)
+                  withCallback:(RCTPromiseResolveBlock)callback)
 {
   NSTimeInterval timeStamp = [[NSDate date] timeIntervalSince1970];
   NSString *pathComponent = [NSString stringWithFormat:@"Documents/snapshot-%.20lf.%@", timeStamp, format];
@@ -342,7 +264,17 @@ RCT_EXPORT_METHOD(takeSnapshot:(nonnull NSNumber *)reactTag
     if (![view isKindOfClass:[AIRGoogleMap class]]) {
         RCTLogError(@"Invalid view returned from registry, expecting AIRMap, got: %@", view);
     } else {
-      AIRGoogleMap *mapView = (AIRGoogleMap *)view;
+        AIRGoogleMap *mapView = (AIRGoogleMap *)view;
+        NSMutableDictionary* config = [NSMutableDictionary new];
+        
+        [mapView takeSnapshotWithConfig:config callback:callback];
+        
+        [config setObject:width forKey:@"width"];
+        [config setObject:height forKey:@"height"];
+        [config setObject:format forKey:@"format"];
+        [config setObject:quality forKey:@"quality"];
+        [config setObject:result forKey:@"result"];
+        [config setObject:filePath forKey:@"filePath"];
 
       // TODO: currently we are ignoring width, height, region
 
@@ -388,13 +320,7 @@ RCT_EXPORT_METHOD(pointForCoordinate:(nonnull NSNumber *)reactTag
       RCTLogError(@"Invalid view returned from registry, expecting AIRMap, got: %@", view);
     } else {
       AIRGoogleMap *mapView = (AIRGoogleMap *)view;
-
-      CGPoint touchPoint = [mapView.projection pointForCoordinate:coord];
-
-      resolve(@{
-                @"x": @(touchPoint.x),
-                @"y": @(touchPoint.y),
-                });
+        resolve([mapView getPointForCoordinates:coord]);
     }
   }];
 }
@@ -415,13 +341,7 @@ RCT_EXPORT_METHOD(coordinateForPoint:(nonnull NSNumber *)reactTag
       RCTLogError(@"Invalid view returned from registry, expecting AIRMap, got: %@", view);
     } else {
       AIRGoogleMap *mapView = (AIRGoogleMap *)view;
-
-      CLLocationCoordinate2D coordinate = [mapView.projection coordinateForPoint:pt];
-
-      resolve(@{
-                @"latitude": @(coordinate.latitude),
-                @"longitude": @(coordinate.longitude),
-                });
+        resolve([view getCoordinatesForPoint:pt]);
     }
   }];
 }
@@ -451,18 +371,7 @@ RCT_EXPORT_METHOD(getMapBoundaries:(nonnull NSNumber *)reactTag
     if (![view isKindOfClass:[AIRGoogleMap class]]) {
       RCTLogError(@"Invalid view returned from registry, expecting AIRGoogleMap, got: %@", view);
     } else {
-        NSArray *boundingBox = [view getMapBoundaries];
-
-        resolve(@{
-          @"northEast" : @{
-            @"longitude" : boundingBox[0][0],
-            @"latitude" : boundingBox[0][1]
-          },
-          @"southWest" : @{
-            @"longitude" : boundingBox[1][0],
-            @"latitude" : boundingBox[1][1]
-          }
-        });
+        resolve([view getMapBoundaries]);
     }
   }];
 }

package/ios/AirGoogleMaps/AIRGoogleMapMarkerManager.m

@@ -11,7 +11,6 @@
 #import "AIRGoogleMapMarker.h"
 #import <MapKit/MapKit.h>
 #import <React/RCTUIManager.h>
-#import "RCTConvert+AirMap.h"
 
 @implementation AIRGoogleMapMarkerManager