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

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

@@ -0,0 +1,598 @@
+package com.rnmaps.maps;
+
+import android.graphics.Bitmap;
+import android.graphics.Point;
+import android.location.Address;
+import android.location.Geocoder;
+import android.net.Uri;
+import android.util.Base64;
+import android.util.DisplayMetrics;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.uimanager.NativeViewHierarchyManager;
+import com.facebook.react.uimanager.UIBlock;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.google.android.gms.maps.CameraUpdate;
+import com.google.android.gms.maps.CameraUpdateFactory;
+import com.google.android.gms.maps.GoogleMap;
+import com.google.android.gms.maps.MapsInitializer;
+import com.google.android.gms.maps.OnMapsSdkInitializedCallback;
+import com.google.android.gms.maps.model.CameraPosition;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.LatLngBounds;
+import com.google.android.gms.maps.model.Marker;
+
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class MapViewModule extends ReactContextBaseJavaModule {
+
+  private final ReactApplicationContext context;
+
+  public MapViewModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    context = reactContext;
+  }
+
+  @Override
+  public String getName() {
+    return "RNMMapViewModule";
+  }
+
+  @Override
+  public Map<String, Object> getConstants() {
+    final Map<String, Object> constants = new HashMap<>();
+    constants.put("legalNotice", "This license information is displayed in Settings > Google > Open Source on any device running Google Play services.");
+    return constants;
+  }
+
+  public static void closeQuietly(Closeable closeable) {
+    if (closeable == null) return;
+    try {
+      closeable.close();
+    } catch (IOException ignored) {
+    }
+  }
+
+  @ReactMethod
+  public void takeSnapshot(final int tag, final ReadableMap options, final Promise promise) {
+    // Parse and verity options
+    final String format = options.hasKey("format") ? options.getString("format") : "png";
+    final Bitmap.CompressFormat compressFormat =
+            format.equals("png") ? Bitmap.CompressFormat.PNG :
+                    format.equals("jpg") ? Bitmap.CompressFormat.JPEG : null;
+    final double quality = options.hasKey("quality") ? options.getDouble("quality") : 1.0;
+    final DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
+    final Integer width =
+            options.hasKey("width") ? (int) (displayMetrics.density * options.getDouble("width")) : 0;
+    final Integer height =
+            options.hasKey("height") ? (int) (displayMetrics.density * options.getDouble("height")) : 0;
+    final String result = options.hasKey("result") ? options.getString("result") : "file";
+
+    // Add UI-block so we can get a valid reference to the map-view
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      public void execute(NativeViewHierarchyManager nvhm) {
+        MapView view = (MapView) nvhm.resolveView(tag);
+        if (view == null) {
+          promise.reject("RNMMapView not found");
+          return;
+        }
+        if (view.map == null) {
+          promise.reject("RNMMapView.map is not valid");
+          return;
+        }
+        view.map.snapshot(new GoogleMap.SnapshotReadyCallback() {
+          public void onSnapshotReady(@Nullable Bitmap snapshot) {
+
+            // Convert image to requested width/height if necessary
+            if (snapshot == null) {
+              promise.reject("Failed to generate bitmap, snapshot = null");
+              return;
+            }
+            if ((width != 0) && (height != 0) &&
+                    (width != snapshot.getWidth() || height != snapshot.getHeight())) {
+              snapshot = Bitmap.createScaledBitmap(snapshot, width, height, true);
+            }
+
+            // Save the snapshot to disk
+            if (result.equals("file")) {
+              File tempFile;
+              FileOutputStream outputStream;
+              try {
+                tempFile =
+                        File.createTempFile("RNMMapSnapshot", "." + format, context.getCacheDir());
+                outputStream = new FileOutputStream(tempFile);
+              } catch (Exception e) {
+                promise.reject(e);
+                return;
+              }
+              snapshot.compress(compressFormat, (int) (100.0 * quality), outputStream);
+              closeQuietly(outputStream);
+              String uri = Uri.fromFile(tempFile).toString();
+              promise.resolve(uri);
+            } else if (result.equals("base64")) {
+              ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+              snapshot.compress(compressFormat, (int) (100.0 * quality), outputStream);
+              closeQuietly(outputStream);
+              byte[] bytes = outputStream.toByteArray();
+              String data = Base64.encodeToString(bytes, Base64.NO_WRAP);
+              promise.resolve(data);
+            }
+          }
+        });
+      }
+    });
+  }
+
+  @ReactMethod
+  public void getCamera(final int tag, final Promise promise) {
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      @Override
+      public void execute(NativeViewHierarchyManager nvhm) {
+        MapView view = (MapView) nvhm.resolveView(tag);
+        if (view == null) {
+          promise.reject("RNMMapView not found");
+          return;
+        }
+        if (view.map == null) {
+          promise.reject("RNMMapView.map is not valid");
+          return;
+        }
+
+        CameraPosition position = view.map.getCameraPosition();
+
+        WritableMap centerJson = new WritableNativeMap();
+        centerJson.putDouble("latitude", position.target.latitude);
+        centerJson.putDouble("longitude", position.target.longitude);
+
+        WritableMap cameraJson = new WritableNativeMap();
+        cameraJson.putMap("center", centerJson);
+        cameraJson.putDouble("heading", (double) position.bearing);
+        cameraJson.putDouble("zoom", (double) position.zoom);
+        cameraJson.putDouble("pitch", (double) position.tilt);
+
+        promise.resolve(cameraJson);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void getAddressFromCoordinates(final int tag, final ReadableMap coordinate, final Promise promise) {
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      @Override
+      public void execute(NativeViewHierarchyManager nvhm) {
+        MapView view = (MapView) nvhm.resolveView(tag);
+        if (view == null) {
+          promise.reject("RNMMapView not found");
+          return;
+        }
+        if (view.map == null) {
+          promise.reject("RNMMapView.map is not valid");
+          return;
+        }
+        if (coordinate == null ||
+                !coordinate.hasKey("latitude") ||
+                !coordinate.hasKey("longitude")) {
+          promise.reject("Invalid coordinate format");
+          return;
+        }
+        Geocoder geocoder = new Geocoder(context);
+        try {
+          List<Address> list =
+                  geocoder.getFromLocation(coordinate.getDouble("latitude"), coordinate.getDouble("longitude"), 1);
+          if (list.isEmpty()) {
+            promise.reject("Can not get address location");
+            return;
+          }
+          Address address = list.get(0);
+
+          WritableMap addressJson = new WritableNativeMap();
+          addressJson.putString("name", address.getFeatureName());
+          addressJson.putString("locality", address.getLocality());
+          addressJson.putString("thoroughfare", address.getThoroughfare());
+          addressJson.putString("subThoroughfare", address.getSubThoroughfare());
+          addressJson.putString("subLocality", address.getSubLocality());
+          addressJson.putString("administrativeArea", address.getAdminArea());
+          addressJson.putString("subAdministrativeArea", address.getSubAdminArea());
+          addressJson.putString("postalCode", address.getPostalCode());
+          addressJson.putString("countryCode", address.getCountryCode());
+          addressJson.putString("country", address.getCountryName());
+
+          promise.resolve(addressJson);
+        } catch (IOException e) {
+          promise.reject("Can not get address location");
+        }
+      }
+    });
+  }
+
+  @ReactMethod
+  public void pointForCoordinate(final int tag, ReadableMap coordinate, final Promise promise) {
+    final double density = context.getResources().getDisplayMetrics().density;
+
+    final LatLng coord = new LatLng(
+            coordinate.hasKey("latitude") ? coordinate.getDouble("latitude") : 0.0,
+            coordinate.hasKey("longitude") ? coordinate.getDouble("longitude") : 0.0
+    );
+
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      @Override
+      public void execute(NativeViewHierarchyManager nvhm) {
+        MapView view = (MapView) nvhm.resolveView(tag);
+        if (view == null) {
+          promise.reject("RNMMapView not found");
+          return;
+        }
+        if (view.map == null) {
+          promise.reject("RNMMapView.map is not valid");
+          return;
+        }
+
+        Point pt = view.map.getProjection().toScreenLocation(coord);
+
+        WritableMap ptJson = new WritableNativeMap();
+        ptJson.putDouble("x", (double) pt.x / density);
+        ptJson.putDouble("y", (double) pt.y / density);
+
+        promise.resolve(ptJson);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void coordinateForPoint(final int tag, ReadableMap point, final Promise promise) {
+    final double density = context.getResources().getDisplayMetrics().density;
+
+    final Point pt = new Point(
+            point.hasKey("x") ? (int) (point.getDouble("x") * density) : 0,
+            point.hasKey("y") ? (int) (point.getDouble("y") * density) : 0
+    );
+
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      @Override
+      public void execute(NativeViewHierarchyManager nvhm) {
+        MapView view = (MapView) nvhm.resolveView(tag);
+        if (view == null) {
+          promise.reject("RNMMapView not found");
+          return;
+        }
+        if (view.map == null) {
+          promise.reject("RNMMapView.map is not valid");
+          return;
+        }
+
+        LatLng coord = view.map.getProjection().fromScreenLocation(pt);
+
+        WritableMap coordJson = new WritableNativeMap();
+        coordJson.putDouble("latitude", coord.latitude);
+        coordJson.putDouble("longitude", coord.longitude);
+
+        promise.resolve(coordJson);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void getMapBoundaries(final int tag, final Promise promise) {
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      @Override
+      public void execute(NativeViewHierarchyManager nvhm) {
+        MapView view = (MapView) nvhm.resolveView(tag);
+        if (view == null) {
+          promise.reject("RNMMapView not found");
+          return;
+        }
+        if (view.map == null) {
+          promise.reject("RNMMapView.map is not valid");
+          return;
+        }
+
+        double[][] boundaries = view.getMapBoundaries();
+
+        WritableMap coordinates = new WritableNativeMap();
+        WritableMap northEastHash = new WritableNativeMap();
+        WritableMap southWestHash = new WritableNativeMap();
+
+        northEastHash.putDouble("longitude", boundaries[0][0]);
+        northEastHash.putDouble("latitude", boundaries[0][1]);
+        southWestHash.putDouble("longitude", boundaries[1][0]);
+        southWestHash.putDouble("latitude", boundaries[1][1]);
+
+        coordinates.putMap("northEast", northEastHash);
+        coordinates.putMap("southWest", southWestHash);
+
+        promise.resolve(coordinates);
+      }
+    });
+  }
+
+  @ReactMethod
+  public void enableLatestRenderer(final Promise promise) {
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      @Override
+      public void execute(NativeViewHierarchyManager nvhm) {
+        MapsInitializer.initialize(context, MapsInitializer.Renderer.LATEST, new OnMapsSdkInitializedCallback() {
+          @Override
+          public void onMapsSdkInitialized(@NonNull MapsInitializer.Renderer renderer) {
+            Log.d("RNMMapRenderer", renderer.toString());
+            promise.resolve(renderer.toString());
+          }
+        });
+      }
+    });
+  }
+
+  @ReactMethod
+  public void animateToRegion(final int tag, ReadableMap region, int duration, final Promise promise) {
+    double lng = region.getDouble("longitude");
+    double lat = region.getDouble("latitude");
+    double lngDelta = region.getDouble("longitudeDelta");
+    double latDelta = region.getDouble("latitudeDelta");
+    LatLngBounds bounds = new LatLngBounds(
+            new LatLng(lat - latDelta / 2, lng - lngDelta / 2), // southwest
+            new LatLng(lat + latDelta / 2, lng + lngDelta / 2)  // northeast
+    );
+
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      @Override
+      public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
+        MapView view = (MapView) nativeViewHierarchyManager.resolveView(tag);
+        if (view == null) {
+          promise.reject("RNMMapView not found");
+          return;
+        }
+        if (view.map == null) {
+          promise.reject("RNMMapView.map is not valid");
+          return;
+        }
+        if (duration <= 0) {
+          view.map.moveCamera(CameraUpdateFactory.newLatLngBounds(bounds, 0));
+          promise.resolve(null);
+        } else {
+          view.map.animateCamera(CameraUpdateFactory.newLatLngBounds(bounds, 0), duration, new GoogleMap.CancelableCallback() {
+            @Override
+            public void onCancel() {
+              promise.resolve(null);
+            }
+
+            @Override
+            public void onFinish() {
+              promise.resolve(null);
+            }
+          });
+        }
+      }
+    });
+  }
+
+  @ReactMethod
+  public void animateCamera(final int tag, ReadableMap camera, int duration, final Promise promise) {
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      @Override
+      public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
+        MapView view = (MapView) nativeViewHierarchyManager.resolveView(tag);
+        if (view == null) {
+          promise.reject("RNMMapView not found");
+          return;
+        }
+        if (view.map == null) {
+          promise.reject("RNMMapView.map is not valid");
+          return;
+        }
+
+        CameraUpdate update = view.buildCameraUpdate(camera);
+
+        if (duration <= 0) {
+          view.map.moveCamera(update);
+          promise.resolve(null);
+        } else {
+          view.map.animateCamera(update, duration, new GoogleMap.CancelableCallback() {
+            @Override
+            public void onCancel() {
+              promise.resolve(null);
+            }
+
+            @Override
+            public void onFinish() {
+              promise.resolve(null);
+            }
+          });
+        }
+      }
+    });
+  }
+
+  @ReactMethod
+  public void fitToElements(final int tag, ReadableMap edgePadding, int duration, final Promise promise) {
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      @Override
+      public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
+        MapView view = (MapView) nativeViewHierarchyManager.resolveView(tag);
+        if (view == null) {
+          promise.reject("RNMMapView not found");
+          return;
+        }
+        if (view.map == null) {
+          promise.reject("RNMMapView.map is not valid");
+          return;
+        }
+        LatLngBounds.Builder builder = new LatLngBounds.Builder();
+
+        boolean addedPosition = false;
+
+        for (MapFeature feature : view.features) {
+          if (feature instanceof MapMarker) {
+            Marker marker = (Marker) feature.getFeature();
+            builder.include(marker.getPosition());
+            addedPosition = true;
+          }
+          // TODO(lmr): may want to include shapes / etc.
+        }
+        if (addedPosition) {
+          LatLngBounds bounds = builder.build();
+          CameraUpdate cu = CameraUpdateFactory.newLatLngBounds(bounds, view.baseMapPadding);
+
+          if (edgePadding != null) {
+            view.map.setPadding(edgePadding.getInt("left"), edgePadding.getInt("top"),
+                    edgePadding.getInt("right"), edgePadding.getInt("bottom"));
+          }
+
+          if (duration > 0) {
+            view.map.animateCamera(cu, duration, new GoogleMap.CancelableCallback() {
+              @Override
+              public void onCancel() {
+                promise.resolve(null);
+              }
+
+              @Override
+              public void onFinish() {
+                promise.resolve(null);
+              }
+            });
+          } else {
+            view.map.moveCamera(cu);
+            promise.resolve(null);
+          }
+        }
+      }
+    });
+
+  }
+
+  @ReactMethod
+  public void fitToSuppliedMarkers(final int tag, ReadableArray markersIds, ReadableMap edgePadding, int duration, final Promise promise) {
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      @Override
+      public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
+        MapView view = (MapView) nativeViewHierarchyManager.resolveView(tag);
+        if (view == null) {
+          promise.reject("RNMMapView not found");
+          return;
+        }
+        if (view.map == null) {
+          promise.reject("RNMMapView.map is not valid");
+          return;
+        }
+        LatLngBounds.Builder builder = new LatLngBounds.Builder();
+
+        String[] markerIDs = new String[markersIds.size()];
+        for (int i = 0; i < markersIds.size(); i++) {
+          markerIDs[i] = markersIds.getString(i);
+        }
+
+        boolean addedPosition = false;
+
+        List<String> markerIDList = Arrays.asList(markerIDs);
+
+        for (MapFeature feature : view.features) {
+          if (feature instanceof MapMarker) {
+            String identifier = ((MapMarker) feature).getIdentifier();
+            Marker marker = (Marker) feature.getFeature();
+            if (markerIDList.contains(identifier)) {
+              builder.include(marker.getPosition());
+              addedPosition = true;
+            }
+          }
+        }
+
+        if (addedPosition) {
+          LatLngBounds bounds = builder.build();
+          CameraUpdate cu = CameraUpdateFactory.newLatLngBounds(bounds, view.baseMapPadding);
+
+          if (edgePadding != null) {
+            view.map.setPadding(edgePadding.getInt("left"), edgePadding.getInt("top"),
+                    edgePadding.getInt("right"), edgePadding.getInt("bottom"));
+          }
+
+          if (duration > 0) {
+            view.map.animateCamera(cu, duration, new GoogleMap.CancelableCallback() {
+              @Override
+              public void onCancel() {
+                promise.resolve(null);
+              }
+
+              @Override
+              public void onFinish() {
+                promise.resolve(null);
+              }
+            });
+          } else {
+            view.map.moveCamera(cu);
+            promise.resolve(null);
+          }
+        }
+      }
+    });
+  }
+
+  @ReactMethod
+  public void fitToCoordinates(final int tag, ReadableArray coordinates, ReadableMap edgePadding, int duration, Promise promise) {
+    context.getNativeModule(UIManagerModule.class).addUIBlock(new UIBlock() {
+      @Override
+      public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
+        MapView view = (MapView) nativeViewHierarchyManager.resolveView(tag);
+        if (view == null) {
+          promise.reject("RNMMapView not found");
+          return;
+        }
+        if (view.map == null) {
+          promise.reject("RNMMapView.map is not valid");
+          return;
+        }
+
+        LatLngBounds.Builder builder = new LatLngBounds.Builder();
+
+        for (int i = 0; i < coordinates.size(); i++) {
+          ReadableMap latLng = coordinates.getMap(i);
+          double lat = latLng.getDouble("latitude");
+          double lng = latLng.getDouble("longitude");
+          builder.include(new LatLng(lat, lng));
+        }
+
+        LatLngBounds bounds = builder.build();
+        CameraUpdate cu = CameraUpdateFactory.newLatLngBounds(bounds, view.baseMapPadding);
+
+        if (edgePadding != null) {
+          view.appendMapPadding(edgePadding.getInt("left"), edgePadding.getInt("top"), edgePadding.getInt("right"), edgePadding.getInt("bottom"));
+        }
+
+        if (duration > 0) {
+          view.map.animateCamera(cu, duration, new GoogleMap.CancelableCallback() {
+            @Override
+            public void onCancel() {
+              promise.resolve(null);
+            }
+
+            @Override
+            public void onFinish() {
+              promise.resolve(null);
+            }
+          });
+        } else {
+          view.map.moveCamera(cu);
+          promise.resolve(null);
+        }
+        // Move the google logo to the default base padding value.
+        view.map.setPadding(view.baseLeftMapPadding, view.baseTopMapPadding, view.baseRightMapPadding, view.baseBottomMapPadding);
+      }
+    });
+  }
+}

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

@@ -12,13 +12,13 @@ public class MapWMSTile extends MapUrlTile {
   private static final double[] mapBound = {-20037508.34789244, 20037508.34789244};
   private static final double FULL = 20037508.34789244 * 2;
 
-  class AIRMapGSUrlTileProvider extends MapTileProvider {
+  class MapGSUrlTileProvider extends MapTileProvider {
 
-    class AIRMapWMSTileProvider extends UrlTileProvider {
+    class MapWMSTileProvider extends UrlTileProvider {
     private String urlTemplate;
     private final int tileSize;
 
-    public AIRMapWMSTileProvider(int width, int height, String urlTemplate) {
+    public MapWMSTileProvider(int width, int height, String urlTemplate) {
       super(width, height);
       this.urlTemplate = urlTemplate;
       this.tileSize = width;
@@ -67,12 +67,12 @@ public class MapWMSTile extends MapUrlTile {
     }
   }
 
-  public AIRMapGSUrlTileProvider(int tileSizet, String urlTemplate, 
+  public MapGSUrlTileProvider(int tileSizet, String urlTemplate, 
     int maximumZ, int maximumNativeZ, int minimumZ, String tileCachePath, 
     int tileCacheMaxAge, boolean offlineMode, Context context, boolean customMode) {
       super(tileSizet, false, urlTemplate, maximumZ, maximumNativeZ, minimumZ, false,
         tileCachePath, tileCacheMaxAge, offlineMode, context, customMode);
-      this.tileProvider = new AIRMapWMSTileProvider(tileSizet, tileSizet, urlTemplate);
+      this.tileProvider = new MapWMSTileProvider(tileSizet, tileSizet, urlTemplate);
     }
   }
 
@@ -85,7 +85,7 @@ public class MapWMSTile extends MapUrlTile {
     TileOverlayOptions options = new TileOverlayOptions();
     options.zIndex(zIndex);
     options.transparency(1 - this.opacity);
-    AIRMapGSUrlTileProvider tileProvider = new AIRMapGSUrlTileProvider((int) this.tileSize, this.urlTemplate,
+    MapGSUrlTileProvider tileProvider = new MapGSUrlTileProvider((int) this.tileSize, this.urlTemplate,
             (int) this.maximumZ, (int) this.maximumNativeZ, (int) this.minimumZ, this.tileCachePath,
             (int) this.tileCacheMaxAge, this.offlineMode, this.context, this.customTileProviderNeeded);
     options.tileProvider(tileProvider);

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

@@ -21,7 +21,7 @@ public class MapWMSTileManager extends ViewGroupManager<MapWMSTile> {
 
   @Override
   public String getName() {
-    return "AIRMapWMSTile";
+    return "RNMMapWMSTile";
   }
 
   @Override

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

@@ -14,7 +14,7 @@ public class MapsPackage implements ReactPackage {
   public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
     List<NativeModule> modules = new ArrayList<>();
 
-    modules.add(new MapModule(reactContext));
+    modules.add(new MapViewModule(reactContext));
 
     return modules;
   }

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

@@ -14,7 +14,7 @@ import com.facebook.react.uimanager.UIViewOperationQueue;
 import java.util.HashMap;
 import java.util.Map;
 
-// Custom LayoutShadowNode implementation used in conjunction with the AirMapManager
+// Custom LayoutShadowNode implementation used in conjunction with the RNMMapManager
 // which sends the width/height of the view after layout occurs.
 public class SizeReportingShadowNode extends LayoutShadowNode {
 

package/ios/{AirGoogleMaps/AIRDummyView.h → GoogleMaps/RNMDummyView.h}

@@ -1,6 +1,6 @@
 //
-//  AIRDummyView.h
-//  AirMapsExplorer
+//  RNMDummyView.h
+//  RNMaps
 //
 //  Created by Gil Birman on 10/4/16.
 //
@@ -10,7 +10,7 @@
 #import <UIKit/UIKit.h>
 
 
-@interface AIRDummyView : UIView
+@interface RNMDummyView : UIView
 @property (nonatomic, weak) UIView *view;
 - (instancetype)initWithView:(UIView*)view;
 @end