react-native-maps 2.0.0-beta.5 → 2.0.0-beta.7

package/ios/{AirGoogleMaps/AIRGoogleMapURLTileManager.m → GoogleMaps/RNMGoogleMapUrlTileManager.m}

@@ -1,24 +1,24 @@
 //
-//  AIRGoogleMapURLTileManager.m
+//  RNMGoogleMapURLTileManager.m
 //  Created by Nick Italiano on 11/5/16.
 //
 
 #ifdef HAVE_GOOGLE_MAPS
 
-#import "AIRGoogleMapUrlTileManager.h"
-#import "AIRGoogleMapUrlTile.h"
+#import "RNMGoogleMapUrlTileManager.h"
+#import "RNMGoogleMapUrlTile.h"
 
-@interface AIRGoogleMapUrlTileManager()
+@interface RNMGoogleMapUrlTileManager()
 
 @end
 
-@implementation AIRGoogleMapUrlTileManager
+@implementation RNMGoogleMapUrlTileManager
 
-RCT_EXPORT_MODULE()
+RCT_EXPORT_MODULE(RNMGoogleMapUrlTile)
 
 - (UIView *)view
 {
-  AIRGoogleMapUrlTile *tileLayer = [AIRGoogleMapUrlTile new];
+  RNMGoogleMapUrlTile *tileLayer = [RNMGoogleMapUrlTile new];
   return tileLayer;
 }
 

package/ios/GoogleMaps/RNMGoogleMapViewModule.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RNMGoogleMapViewModule : NSObject <RCTBridgeModule>
+
+@end

package/ios/GoogleMaps/RNMGoogleMapViewModule.m

@@ -0,0 +1,380 @@
+#import "RNMGoogleMapViewModule.h"
+#import "RNMGoogleMap.h"
+#import "RNMGoogleMapMarker.h"
+#import "RNMMapCoordinate.h"
+#import "RCTConvert+GMSMapViewType.h"
+#import <React/RCTUIManager.h>
+#import <React/RCTUIManagerUtils.h>
+
+@implementation RNMGoogleMapViewModule
+
+@synthesize bridge = _bridge;
+
+- (dispatch_queue_t)methodQueue
+{
+    return RCTGetUIManagerQueue();
+}
+
+RCT_EXPORT_MODULE();
+
+RCT_EXPORT_METHOD(getCamera:(nonnull NSNumber *)reactTag
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RNMGoogleMap class]]) {
+            reject(@"Invalid argument", [NSString stringWithFormat:@"Invalid view returned from registry, expecting RNMGoogleMap, got: %@", view], NULL);
+        } else {
+            RNMGoogleMap *mapView = (RNMGoogleMap *)view;
+            resolve(@{
+                @"center": @{
+                    @"latitude": @(mapView.camera.target.latitude),
+                    @"longitude": @(mapView.camera.target.longitude),
+                },
+                @"pitch": @(mapView.camera.viewingAngle),
+                @"heading": @(mapView.camera.bearing),
+                @"zoom": @(mapView.camera.zoom),
+            });
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(takeSnapshot:(nonnull NSNumber *)reactTag
+                  config:(NSDictionary *)config
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    NSString *format = config[@"format"];
+    NSNumber *quality = config[@"quality"];
+    NSString *result = config[@"result"];
+    NSTimeInterval timeStamp = [[NSDate date] timeIntervalSince1970];
+    NSString *pathComponent = [NSString stringWithFormat:@"Documents/snapshot-%.20lf.%@", timeStamp, format];
+    NSString *filePath = [NSHomeDirectory() stringByAppendingPathComponent: pathComponent];
+    
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RNMGoogleMap class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RNMMap, got: %@", view);
+        } else {
+            RNMGoogleMap *mapView = (RNMGoogleMap *)view;
+            
+            // TODO: currently we are ignoring width, height, region
+            
+            UIGraphicsBeginImageContextWithOptions(mapView.frame.size, YES, 0.0f);
+            [mapView.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];
+                resolve(filePath);
+            }
+            else if ([result isEqualToString:@"base64"]) {
+                NSString *base64 = [data base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithCarriageReturn];
+                resolve(base64);
+            }
+        }
+        UIGraphicsEndImageContext();
+    }];
+}
+
+RCT_EXPORT_METHOD(pointForCoordinate:(nonnull NSNumber *)reactTag
+                  coordinate:(NSDictionary *)coordinate
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    CLLocationCoordinate2D coord =
+    CLLocationCoordinate2DMake(
+                               [coordinate[@"latitude"] doubleValue],
+                               [coordinate[@"longitude"] doubleValue]
+                               );
+    
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RNMGoogleMap class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RNMMap, got: %@", view);
+        } else {
+            RNMGoogleMap *mapView = (RNMGoogleMap *)view;
+            
+            CGPoint touchPoint = [mapView.projection pointForCoordinate:coord];
+            
+            resolve(@{
+                @"x": @(touchPoint.x),
+                @"y": @(touchPoint.y),
+            });
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(coordinateForPoint:(nonnull NSNumber *)reactTag
+                  point:(NSDictionary *)point
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    CGPoint pt = CGPointMake(
+                             [point[@"x"] doubleValue],
+                             [point[@"y"] doubleValue]
+                             );
+    
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RNMGoogleMap class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RNMMap, got: %@", view);
+        } else {
+            RNMGoogleMap *mapView = (RNMGoogleMap *)view;
+            
+            CLLocationCoordinate2D coordinate = [mapView.projection coordinateForPoint:pt];
+            
+            resolve(@{
+                @"latitude": @(coordinate.latitude),
+                @"longitude": @(coordinate.longitude),
+            });
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(getMarkersFrames:(nonnull NSNumber *)reactTag
+                  onlyVisible:(BOOL)onlyVisible
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RNMGoogleMap class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RNMMap, got: %@", view);
+        } else {
+            RNMGoogleMap *mapView = (RNMGoogleMap *)view;
+            resolve([mapView getMarkersFramesWithOnlyVisible:onlyVisible]);
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(getMapBoundaries:(nonnull NSNumber *)reactTag
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RNMGoogleMap class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RNMGoogleMap, 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]
+                }
+            });
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(animateToRegion:(nonnull NSNumber *)reactTag
+                withRegion:(NSDictionary *)region
+                withDuration:(CGFloat)duration
+                resolver: (RCTPromiseResolveBlock)resolve
+                rejecter:(RCTPromiseRejectBlock)reject)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RNMGoogleMap class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RNMGoogleMap, got: %@", view);
+    } else {
+      RNMGoogleMap *mapView = (RNMGoogleMap *)view;
+      MKCoordinateRegion mkRegion = [RCTConvert MKCoordinateRegion:region];
+      GMSCameraPosition *camera = [RNMGoogleMap makeGMSCameraPositionFromMap:mapView andMKCoordinateRegion:mkRegion];
+      // Core Animation must be used to control the animation's duration
+      // See http://stackoverflow.com/a/15663039/171744
+      [CATransaction begin];
+      [CATransaction setCompletionBlock:^{
+        resolve(nil);
+      }];
+      [CATransaction setAnimationDuration:duration/1000];
+      [mapView animateToCameraPosition:camera];
+      [CATransaction commit];
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(animateCamera:(nonnull NSNumber *)reactTag
+                  withCamera:(id)json
+                  withDuration:(CGFloat)duration
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+        id view = viewRegistry[reactTag];
+        if (![view isKindOfClass:[RNMGoogleMap class]]) {
+            RCTLogError(@"Invalid view returned from registry, expecting RNMGoogleMap, got: %@", view);
+        } else {
+            RNMGoogleMap *mapView = (RNMGoogleMap *)view;
+            GMSCameraPosition *camera = [RCTConvert GMSCameraPositionWithDefaults:json existingCamera:[mapView camera]];
+
+            [CATransaction begin];
+            [CATransaction setCompletionBlock:^{
+                resolve(nil);
+            }];
+            [CATransaction setAnimationDuration:duration/1000];
+            [mapView animateToCameraPosition:camera];
+            [CATransaction commit];
+        }
+    }];
+}
+
+RCT_EXPORT_METHOD(fitToElements:(nonnull NSNumber *)reactTag
+                  edgePadding:(nonnull NSDictionary *)edgePadding
+                  withDuration:(CGFloat)duration
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RNMGoogleMap class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RNMGoogleMap, got: %@", view);
+    } else {
+      RNMGoogleMap *mapView = (RNMGoogleMap *)view;
+
+      CLLocationCoordinate2D myLocation = ((RNMGoogleMapMarker *)(mapView.markers.firstObject)).realMarker.position;
+      GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc] initWithCoordinate:myLocation coordinate:myLocation];
+
+      for (RNMGoogleMapMarker *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 (duration > 0.0f) {
+        [CATransaction begin];
+        [CATransaction setCompletionBlock:^{
+            resolve(nil);
+        }];
+        [CATransaction setAnimationDuration:duration/1000];
+        [mapView animateWithCameraUpdate:cameraUpdate];
+        [CATransaction commit];
+      } else {
+        [mapView moveCamera:cameraUpdate];
+        resolve(nil);
+      }
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(fitToSuppliedMarkers:(nonnull NSNumber *)reactTag
+                  markers:(nonnull NSArray *)markers
+                  edgePadding:(nonnull NSDictionary *)edgePadding
+                  withDuration:(CGFloat)duration
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RNMGoogleMap class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RNMGoogleMap, got: %@", view);
+    } else {
+      RNMGoogleMap *mapView = (RNMGoogleMap *)view;
+
+      NSPredicate *filterMarkers = [NSPredicate predicateWithBlock:^BOOL(id evaluatedObject, NSDictionary *bindings) {
+        RNMGoogleMapMarker *marker = (RNMGoogleMapMarker *)evaluatedObject;
+        return [marker isKindOfClass:[RNMGoogleMapMarker class]] && [markers containsObject:marker.identifier];
+      }];
+
+      NSArray *filteredMarkers = [mapView.markers filteredArrayUsingPredicate:filterMarkers];
+
+      CLLocationCoordinate2D myLocation = ((RNMGoogleMapMarker *)(filteredMarkers.firstObject)).realMarker.position;
+      GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc] initWithCoordinate:myLocation coordinate:myLocation];
+
+      for (RNMGoogleMapMarker *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 (duration > 0.0f) {
+        [CATransaction begin];
+        [CATransaction setCompletionBlock:^{
+            resolve(nil);
+        }];
+        [CATransaction setAnimationDuration:duration/1000];
+        [mapView animateWithCameraUpdate:cameraUpdate];
+        [CATransaction commit];
+      } else {
+        [mapView moveCamera:cameraUpdate];
+        resolve(nil);
+      }
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(fitToCoordinates:(nonnull NSNumber *)reactTag
+                  coordinates:(nonnull NSArray<RNMMapCoordinate *> *)coordinates
+                  edgePadding:(nonnull NSDictionary *)edgePadding
+                  withDuration:(CGFloat)duration
+                  resolver: (RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  [self.bridge.uiManager addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    id view = viewRegistry[reactTag];
+    if (![view isKindOfClass:[RNMGoogleMap class]]) {
+      RCTLogError(@"Invalid view returned from registry, expecting RNMGoogleMap, got: %@", view);
+    } else {
+      RNMGoogleMap *mapView = (RNMGoogleMap *)view;
+
+      CLLocationCoordinate2D myLocation = coordinates.firstObject.coordinate;
+      GMSCoordinateBounds *bounds = [[GMSCoordinateBounds alloc] initWithCoordinate:myLocation coordinate:myLocation];
+
+      for (RNMMapCoordinate *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 (duration > 0.0f) {
+        [CATransaction begin];
+        [CATransaction setCompletionBlock:^{
+            resolve(nil);
+        }];
+        [CATransaction setAnimationDuration:duration/1000];
+        [mapView animateWithCameraUpdate:cameraUpdate];
+        [CATransaction commit];
+      } else {
+        [mapView moveCamera: cameraUpdate];
+        resolve(nil);
+      }
+    }
+  }];
+}
+
+@end

package/ios/{AirGoogleMaps/AIRGoogleMapWMSTile.h → GoogleMaps/RNMGoogleMapWMSTile.h}

@@ -1,6 +1,6 @@
 //
-//  AIRGoogleMapWMSTile.h
-//  AirMaps
+//  RNMGoogleMapWMSTile.h
+//  RNMaps
 //
 //  Created by nizam on 10/28/18.
 //  Copyright © 2018. All rights reserved.
@@ -18,7 +18,7 @@
 @property (nonatomic, assign) NSInteger minimumZ;
 @end
 
-@interface AIRGoogleMapWMSTile : UIView
+@interface RNMGoogleMapWMSTile : UIView
 @property (nonatomic, strong) WMSTileOverlay *tileLayer;
 @property (nonatomic, assign) NSString *urlTemplate;
 @property (nonatomic, assign) int zIndex;

package/ios/{AirGoogleMaps/AIRGoogleMapWMSTile.m → GoogleMaps/RNMGoogleMapWMSTile.m}

@@ -1,6 +1,6 @@
 //
-//  AIRGoogleMapWMSTile.m
-//  AirMaps
+//  RNMGoogleMapWMSTile.m
+//  RNMaps
 //
 //  Created by nizam on 10/28/18.
 //  Copyright © 2018. All rights reserved.
@@ -8,9 +8,9 @@
 
 #ifdef HAVE_GOOGLE_MAPS
 
-#import "AIRGoogleMapWMSTile.h"
+#import "RNMGoogleMapWMSTile.h"
 
-@implementation AIRGoogleMapWMSTile
+@implementation RNMGoogleMapWMSTile
 
 -(id) init
 {

package/ios/{AirGoogleMaps/AIRGoogleMapWMSTileManager.h → GoogleMaps/RNMGoogleMapWMSTileManager.h}

@@ -1,6 +1,6 @@
 //
-//  AIRGoogleMapWMSTileManager.h
-//  AirMaps
+//  RNMGoogleMapWMSTileManager.h
+//  RNMaps
 //
 //  Created by nizam on 10/28/18.
 //  Copyright © 2018. All rights reserved.
@@ -11,7 +11,7 @@
 #import <Foundation/Foundation.h>
 #import <React/RCTViewManager.h>
 
-@interface AIRGoogleMapWMSTileManager : RCTViewManager
+@interface RNMGoogleMapWMSTileManager : RCTViewManager
 @end
 
 #endif

package/ios/{AirGoogleMaps/AIRGoogleMapWMSTileManager.m → GoogleMaps/RNMGoogleMapWMSTileManager.m}

@@ -1,6 +1,6 @@
 //
-//  AIRGoogleMapWMSTileManager.m
-//  AirMaps
+//  RNMGoogleMapWMSTileManager.m
+//  RNMaps
 //
 //  Created by nizam on 10/28/18.
 //  Copyright © 2018. All rights reserved.
@@ -8,20 +8,20 @@
 
 #ifdef HAVE_GOOGLE_MAPS
 
-#import "AIRGoogleMapWMSTileManager.h"
-#import "AIRGoogleMapWMSTile.h"
+#import "RNMGoogleMapWMSTileManager.h"
+#import "RNMGoogleMapWMSTile.h"
 
-@interface AIRGoogleMapWMSTileManager()
+@interface RNMGoogleMapWMSTileManager()
 
 @end
 
-@implementation AIRGoogleMapWMSTileManager
+@implementation RNMGoogleMapWMSTileManager
 
-RCT_EXPORT_MODULE()
+RCT_EXPORT_MODULE(RNMGoogleMapWMSTile)
 
 - (UIView *)view
 {
-    AIRGoogleMapWMSTile *tileLayer = [AIRGoogleMapWMSTile new];
+    RNMGoogleMapWMSTile *tileLayer = [RNMGoogleMapWMSTile new];
     return tileLayer;
 }
 

package/ios/{AirMaps → Maps}/Callout/SMCalloutView.h

@@ -176,11 +176,11 @@ extern NSTimeInterval const kSMCalloutViewRepositionDelayForUIScrollView;
 - (void)calloutViewClicked:(SMCalloutView *)calloutView;
 
 /**
- Called when the callout view detects that it will be outside the constrained view when it appears, 
- or if the target rect was already outside the constrained view. You can implement this selector 
+ Called when the callout view detects that it will be outside the constrained view when it appears,
+ or if the target rect was already outside the constrained view. You can implement this selector
  to respond to this situation by repositioning your content first in order to make everything visible.
- The @c CGSize passed is the calculated offset necessary to make everything visible (plus a nice margin). 
- It expects you to return the amount of time you need to reposition things so the popup can be delayed. 
+ The @c CGSize passed is the calculated offset necessary to make everything visible (plus a nice margin).
+ It expects you to return the amount of time you need to reposition things so the popup can be delayed.
  Typically you would return @c kSMCalloutViewRepositionDelayForUIScrollView if you're repositioning by calling @c [UIScrollView @c setContentOffset:animated:].
  
  @param calloutView the @c SMCalloutView to reposition

package/ios/{AirMaps/RCTConvert+AirMap.h → Maps/RCTConvert+RNMMap.h}

@@ -7,7 +7,7 @@
 #import <MapKit/MapKit.h>
 #import <React/RCTConvert.h>
 
-@interface RCTConvert (AirMap)
+@interface RCTConvert (RNMMap)
 
 + (MKCoordinateSpan)MKCoordinateSpan:(id)json;
 + (MKCoordinateRegion)MKCoordinateRegion:(id)json;

package/ios/{AirMaps/RCTConvert+AirMap.m → Maps/RCTConvert+RNMMap.m}

@@ -3,12 +3,12 @@
 // Copyright (c) 2015 Facebook. All rights reserved.
 //
 
-#import "RCTConvert+AirMap.h"
+#import "RCTConvert+RNMMap.h"
 
 #import <React/RCTConvert+CoreLocation.h>
-#import "AIRMapCoordinate.h"
+#import "RNMMapCoordinate.h"
 
-@implementation RCTConvert (AirMap)
+@implementation RCTConvert (RNMMap)
 
 + (MKCoordinateSpan)MKCoordinateSpan:(id)json
 {
@@ -71,18 +71,18 @@ RCT_ENUM_CONVERTER(MKMapType, (@{
 // around a `CLLocationCoordinate2D`, since I was unable to figure out
 // how to handle an array of structs like CLLocationCoordinate2D. Would love
 // to get rid of this if someone can show me how...
-+ (AIRMapCoordinate *)AIRMapCoordinate:(id)json
++ (RNMMapCoordinate *)RNMMapCoordinate:(id)json
 {
-    AIRMapCoordinate *coord = [AIRMapCoordinate new];
+    RNMMapCoordinate *coord = [RNMMapCoordinate new];
     coord.coordinate = [self CLLocationCoordinate2D:json];
     return coord;
 }
 
-RCT_ARRAY_CONVERTER(AIRMapCoordinate)
+RCT_ARRAY_CONVERTER(RNMMapCoordinate)
 
-+ (NSArray<NSArray<AIRMapCoordinate *> *> *)AIRMapCoordinateArrayArray:(id)json
++ (NSArray<NSArray<RNMMapCoordinate *> *> *)RNMMapCoordinateArrayArray:(id)json
 {
-    return RCTConvertArrayValue(@selector(AIRMapCoordinateArray:), json);
+    return RCTConvertArrayValue(@selector(RNMMapCoordinateArray:), json);
 }
 
 @end

package/ios/{AirMaps/AIRMap.h → Maps/RNMMap.h}

@@ -12,16 +12,16 @@
 
 #import <React/RCTComponent.h>
 #import "SMCalloutView.h"
-#import "RCTConvert+AirMap.h"
-#import "AIRMapCalloutSubview.h"
+#import "RCTConvert+RNMMap.h"
+#import "RNMMapCalloutSubview.h"
 
-@class AIRMapMarker;
+@class RNMMapMarker;
 
-extern const NSTimeInterval AIRMapRegionChangeObserveInterval;
-extern const CGFloat AIRMapZoomBoundBuffer;
-extern const NSInteger AIRMapMaxZoomLevel;
+extern const NSTimeInterval RNMMapRegionChangeObserveInterval;
+extern const CGFloat RNMMapZoomBoundBuffer;
+extern const NSInteger RNMMapMaxZoomLevel;
 
-@interface AIRMap: MKMapView<SMCalloutViewDelegate>
+@interface RNMMap: MKMapView<SMCalloutViewDelegate>
 
 @property (nonatomic, strong) SMCalloutView *calloutView;
 @property (nonatomic, strong) UIImageView *cacheImageView;
@@ -73,7 +73,7 @@ extern const NSInteger AIRMapMaxZoomLevel;
 - (void)finishLoading;
 - (NSArray *)getMapBoundaries;
 
-- (AIRMapMarker*) markerAtPoint:(CGPoint)point;
+- (RNMMapMarker*) markerAtPoint:(CGPoint)point;
 - (NSDictionary*) getMarkersFramesWithOnlyVisible:(BOOL)onlyVisible;
 
 @end