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

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

@@ -0,0 +1,262 @@
+package com.rnmaps.maps;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.Handler;
+import android.os.Looper;
+
+import com.facebook.common.references.CloseableReference;
+import com.facebook.datasource.BaseDataSubscriber;
+import com.facebook.datasource.DataSource;
+import com.facebook.datasource.DataSubscriber;
+import com.facebook.drawee.backends.pipeline.Fresco;
+import com.facebook.drawee.drawable.ScalingUtils;
+import com.facebook.drawee.generic.GenericDraweeHierarchy;
+import com.facebook.drawee.generic.GenericDraweeHierarchyBuilder;
+import com.facebook.imagepipeline.core.ImagePipeline;
+import com.facebook.imagepipeline.image.CloseableBitmap;
+import com.facebook.imagepipeline.image.CloseableImage;
+import com.facebook.imagepipeline.request.ImageRequest;
+import com.facebook.imagepipeline.request.ImageRequestBuilder;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.common.MapBuilder;
+import com.google.android.gms.common.images.ImageManager;
+import com.google.android.gms.maps.model.BitmapDescriptor;
+import com.google.android.gms.maps.model.BitmapDescriptorFactory;
+import com.google.android.gms.maps.model.GroundOverlay;
+import com.google.android.gms.maps.model.GroundOverlayOptions;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.LatLngBounds;
+import com.google.maps.android.collections.GroundOverlayManager;
+import com.rnmaps.fabric.event.OnPressEvent;
+
+import java.util.Map;
+import java.util.concurrent.Executors;
+
+public class MapOverlay extends MapFeature {
+
+
+    private String imageUri;
+
+    private GroundOverlayOptions groundOverlayOptions;
+    private GroundOverlay groundOverlay;
+    private LatLngBounds bounds;
+    private float bearing;
+    private BitmapDescriptor bitmapDescriptor;
+    private boolean tappable;
+    private float zIndex;
+    private float transparency;
+
+    private DataSource<CloseableReference<CloseableImage>> dataSource;
+
+    private GroundOverlayManager.Collection groundOverlayCollection;
+
+    private ImageManager.OnImageLoadedListener imageLoadedListener;
+
+
+    public MapOverlay(Context context) {
+        super(context);
+        transparency = 1;
+    }
+
+    private GenericDraweeHierarchy createDraweeHierarchy() {
+        return new GenericDraweeHierarchyBuilder(getResources())
+                .setActualImageScaleType(ScalingUtils.ScaleType.FIT_CENTER)
+                .setFadeDuration(0)
+                .build();
+    }
+
+
+
+    public void setBounds(LatLngBounds bounds) {
+        this.bounds = bounds;
+        if (this.groundOverlay != null) {
+            this.groundOverlay.setPositionFromBounds(this.bounds);
+        }
+    }
+
+    public void setBearing(float bearing) {
+        this.bearing = bearing;
+        if (this.groundOverlay != null) {
+            this.groundOverlay.setBearing(bearing);
+        }
+    }
+
+    public void setZIndex(float zIndex) {
+        this.zIndex = zIndex;
+        if (this.groundOverlay != null) {
+            this.groundOverlay.setZIndex(zIndex);
+        }
+    }
+
+    public void setTransparency(float transparency) {
+        this.transparency = transparency;
+        if (groundOverlay != null) {
+            groundOverlay.setTransparency(transparency);
+        }
+    }
+
+
+    public void setImage(String uri) {
+        boolean shouldLoadImage = true;
+
+        this.imageUri = uri;
+        if (!shouldLoadImage) {
+            return;
+        }
+
+        if (uri == null) {
+            bitmapDescriptor = null;
+        } else if (uri.startsWith("http://") || uri.startsWith("https://") ||
+                uri.startsWith("file://") || uri.startsWith("asset://") || uri.startsWith("data:")) {
+
+            ImageRequest imageRequest = ImageRequestBuilder
+                    .newBuilderWithSource(Uri.parse(uri))
+                    .build();
+
+            ImagePipeline imagePipeline = Fresco.getImagePipeline();
+            dataSource = imagePipeline.fetchDecodedImage(imageRequest, this);
+
+            DataSubscriber<CloseableReference<CloseableImage>> subscriber = new BaseDataSubscriber<CloseableReference<CloseableImage>>() {
+                @Override
+                protected void onNewResultImpl(DataSource<CloseableReference<CloseableImage>> dataSource) {
+                    if (!dataSource.isFinished()) {
+                        return;
+                    }
+
+                    CloseableReference<CloseableImage> imageReference = dataSource.getResult();
+                    if (imageReference != null) {
+                        try {
+                            CloseableImage closeableImage = imageReference.get();
+                            if (closeableImage instanceof CloseableBitmap) {
+                                Bitmap bitmap = ((CloseableBitmap) closeableImage).getUnderlyingBitmap();
+                                if (bitmap != null) {
+                                    bitmapDescriptor = BitmapDescriptorFactory.fromBitmap(bitmap);
+                                }
+                            }
+                        } finally {
+                            CloseableReference.closeSafely(imageReference);
+                        }
+                        new Handler(Looper.getMainLooper()).post(() -> update());
+                    }
+                }
+
+                @Override
+                protected void onFailureImpl(DataSource<CloseableReference<CloseableImage>> dataSource) {
+                    // Handle failure
+                }
+            };
+
+            dataSource.subscribe(subscriber, Executors.newSingleThreadExecutor());
+
+        } else {
+            bitmapDescriptor = getBitmapDescriptorByName(uri);
+        }
+    }
+
+
+    private BitmapDescriptor getBitmapDescriptorByName(String name) {
+        return BitmapDescriptorFactory.fromResource(getDrawableResourceByName(name));
+    }
+
+    private int getDrawableResourceByName(String name) {
+        return getResources().getIdentifier(
+                name,
+                "drawable",
+                getContext().getPackageName());
+    }
+
+    public void setTappable(boolean tapabble) {
+        this.tappable = tapabble;
+        if (groundOverlay != null) {
+            groundOverlay.setClickable(tappable);
+        }
+    }
+
+    public static Map<String, Object> getExportedCustomBubblingEventTypeConstants() {
+        MapBuilder.Builder<String, Object> builder = MapBuilder.builder();
+        builder.put(OnPressEvent.EVENT_NAME, MapBuilder.of("registrationName", OnPressEvent.EVENT_NAME));
+        return builder.build();
+    }
+
+    public GroundOverlayOptions getGroundOverlayOptions() {
+        if (this.groundOverlayOptions == null) {
+            this.groundOverlayOptions = createGroundOverlayOptions();
+        }
+        return this.groundOverlayOptions;
+    }
+
+    private GroundOverlayOptions createGroundOverlayOptions() {
+        if (this.groundOverlayOptions != null) {
+            return this.groundOverlayOptions;
+        }
+        GroundOverlayOptions options = new GroundOverlayOptions();
+        if (this.bitmapDescriptor != null) {
+            options.image(bitmapDescriptor);
+        } else {
+            // add stub image to be able to instantiate the overlay
+            // and store a reference to it in MapView
+            options.image(BitmapDescriptorFactory.defaultMarker());
+            // hide overlay until real image gets added
+            options.visible(false);
+        }
+        options.positionFromBounds(bounds);
+        options.zIndex(zIndex);
+        options.bearing(bearing);
+//        options.transparency(transparency);
+        return options;
+    }
+
+    @Override
+    public Object getFeature() {
+        return groundOverlay;
+    }
+
+    @Override
+    public void addToMap(Object collection) {
+        GroundOverlayManager.Collection groundOverlayCollection = (GroundOverlayManager.Collection) collection;
+        GroundOverlayOptions groundOverlayOptions = getGroundOverlayOptions();
+        if (groundOverlayOptions != null) {
+            groundOverlay = groundOverlayCollection.addGroundOverlay(groundOverlayOptions);
+            groundOverlay.setClickable(this.tappable);
+        } else {
+            this.groundOverlayCollection = groundOverlayCollection;
+        }
+    }
+
+    @Override
+    public void removeFromMap(Object collection) {
+        if (groundOverlay != null) {
+            GroundOverlayManager.Collection groundOverlayCollection = (GroundOverlayManager.Collection) collection;
+            groundOverlayCollection.remove(groundOverlay);
+            groundOverlay = null;
+            groundOverlayOptions = null;
+        }
+        groundOverlayCollection = null;
+    }
+
+    public void update() {
+        this.groundOverlay = getGroundOverlay();
+        if (this.groundOverlay != null) {
+            this.groundOverlay.setVisible(true);
+            this.groundOverlay.setImage(this.bitmapDescriptor);
+            //          this.groundOverlay.setTransparency(this.transparency);
+            this.groundOverlay.setClickable(this.tappable);
+        }
+    }
+
+    private GroundOverlay getGroundOverlay() {
+        if (this.groundOverlay != null) {
+            return this.groundOverlay;
+        }
+        if (this.groundOverlayCollection == null) {
+            return null;
+        }
+        GroundOverlayOptions groundOverlayOptions = getGroundOverlayOptions();
+        if (groundOverlayOptions != null) {
+            return this.groundOverlayCollection.addGroundOverlay(groundOverlayOptions);
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,97 @@
+package com.rnmaps.maps;
+
+import android.content.Context;
+import android.util.DisplayMetrics;
+import android.view.WindowManager;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.LatLngBounds;
+
+import java.util.Map;
+
+public class MapOverlayManager extends ViewGroupManager<MapOverlay> {
+
+  public MapOverlayManager(ReactApplicationContext reactContext) {
+    super();
+    DisplayMetrics metrics = new DisplayMetrics();
+    ((WindowManager) reactContext.getSystemService(Context.WINDOW_SERVICE))
+        .getDefaultDisplay()
+        .getRealMetrics(metrics);
+  }
+
+  @Override
+  public String getName() {
+    return "AIRMapOverlay";
+  }
+
+  @Override
+  public MapOverlay createViewInstance(ThemedReactContext context) {
+    return new MapOverlay(context);
+  }
+
+  @ReactProp(name = "bounds")
+  public void setBounds(MapOverlay view, ReadableArray bounds) {
+    view.setBounds(fixBoundsIfNecessary(bounds));
+  }
+
+  // seems like apple users north west, south east
+  // google uses north east, south west
+  private static LatLngBounds fixBoundsIfNecessary(ReadableArray bounds) {
+    double lat1 = bounds.getArray(0).getDouble(0);
+    double lon1 = bounds.getArray(0).getDouble(1);
+    double lat2 = bounds.getArray(1).getDouble(0);
+    double lon2 = bounds.getArray(1).getDouble(1);
+
+// Ensure lat1/lon1 is the SW corner and lat2/lon2 is the NE corner
+    double southLat = Math.min(lat1, lat2);
+    double northLat = Math.max(lat1, lat2);
+    double westLon = Math.min(lon1, lon2);
+    double eastLon = Math.max(lon1, lon2);
+
+// Create corrected LatLngs
+    LatLng sw = new LatLng(southLat, westLon);
+    LatLng ne = new LatLng(northLat, eastLon);
+    return new LatLngBounds(sw, ne);
+  }
+
+  @ReactProp(name = "bearing")
+  public void setBearing(MapOverlay view, float bearing){
+    view.setBearing(bearing);
+  }
+
+  @ReactProp(name = "zIndex", defaultFloat = 1.0f)
+  public void setZIndex(MapOverlay view, float zIndex) {
+    view.setZIndex(zIndex);
+  }
+
+  @ReactProp(name = "opacity", defaultFloat = 1.0f)
+  public void setOpacity(MapOverlay view, float opacity) {
+    view.setTransparency(1 - opacity);
+  }
+
+  @ReactProp(name = "image")
+  public void setImage(MapOverlay view, @Nullable String source) {
+    view.setImage(source);
+  }
+
+  @ReactProp(name = "tappable", defaultBoolean = false)
+  public void setTappable(MapOverlay view, boolean tapabble) {
+    view.setTappable(tapabble);
+  }
+
+  @Override
+  @Nullable
+  public Map getExportedCustomDirectEventTypeConstants() {
+    return MapBuilder.of(
+        "onPress", MapBuilder.of("registrationName", "onPress")
+    );
+  }
+}

package/android/src/main/java/com/{airbnb/android/react/maps/AirMapPolygon.java → rnmaps/maps/MapPolygon.java}

@@ -1,18 +1,30 @@
-package com.airbnb.android.react.maps;
+package com.rnmaps.maps;
 
 import android.content.Context;
+import android.graphics.Color;
 
+import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
-import com.google.android.gms.maps.GoogleMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.google.android.gms.maps.model.Dash;
+import com.google.android.gms.maps.model.Gap;
 import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.PatternItem;
 import com.google.android.gms.maps.model.Polygon;
 import com.google.android.gms.maps.model.PolygonOptions;
+import com.google.maps.android.collections.PolygonManager;
+import com.rnmaps.fabric.event.OnPressEvent;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
-public class AirMapPolygon extends AirMapFeature {
+public class MapPolygon extends MapFeature {
 
   private PolygonOptions polygonOptions;
   private Polygon polygon;
@@ -25,11 +37,34 @@ public class AirMapPolygon extends AirMapFeature {
   private boolean geodesic;
   private boolean tappable;
   private float zIndex;
+  private ReadableArray patternValues;
+  private List<PatternItem> pattern;
 
-  public AirMapPolygon(Context context) {
+  public MapPolygon(Context context) {
     super(context);
+    strokeWidth = 10;
   }
 
+    public static Map<String, Object> getExportedCustomBubblingEventTypeConstants() {
+      MapBuilder.Builder<String, Object> builder = MapBuilder.builder();
+      builder.put(OnPressEvent.EVENT_NAME, MapBuilder.of("registrationName", OnPressEvent.EVENT_NAME));
+      return builder.build();
+    }
+
+  public  <T extends Event> void dispatchEvent(WritableMap payload, MapView.EventCreator<T> creator, ReactContext reactContext) {
+
+    // Get the event dispatcher
+    EventDispatcher eventDispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, getId());
+
+    // If there is a dispatcher, create and dispatch the event
+    if (eventDispatcher != null) {
+      int surfaceId = UIManagerHelper.getSurfaceId(reactContext);
+      T event = creator.create(surfaceId, getId(), payload);
+      eventDispatcher.dispatchEvent(event);
+    }
+  }
+
+
   public void setCoordinates(ReadableArray coordinates) {
     // it's kind of a bummer that we can't run map() or anything on the ReadableArray
     this.coordinates = new ArrayList<>(coordinates.size());
@@ -117,6 +152,32 @@ public class AirMapPolygon extends AirMapFeature {
     }
   }
 
+  public void setLineDashPattern(ReadableArray patternValues) {
+    this.patternValues = patternValues;
+    this.applyPattern();
+  }
+
+  private void applyPattern() {
+    if(patternValues == null) {
+      return;
+    }
+    this.pattern = new ArrayList<>(patternValues.size());
+    for (int i = 0; i < patternValues.size(); i++) {
+      float patternValue = (float) patternValues.getDouble(i);
+      boolean isGap = i % 2 != 0;
+      if(isGap) {
+        this.pattern.add(new Gap(patternValue));
+      }else {
+        PatternItem patternItem;
+        patternItem = new Dash(patternValue);
+        this.pattern.add(patternItem);
+      }
+    }
+    if(polygon != null) {
+      polygon.setStrokePattern(this.pattern);
+    }
+  }
+
   public PolygonOptions getPolygonOptions() {
     if (polygonOptions == null) {
       polygonOptions = createPolygonOptions();
@@ -132,6 +193,8 @@ public class AirMapPolygon extends AirMapFeature {
     options.strokeWidth(strokeWidth);
     options.geodesic(geodesic);
     options.zIndex(zIndex);
+    options.strokePattern(this.pattern);
+    options.clickable(this.tappable);
 
     if (this.holes != null) {
       for (int i = 0; i < holes.size(); i++) {
@@ -148,13 +211,14 @@ public class AirMapPolygon extends AirMapFeature {
   }
 
   @Override
-  public void addToMap(GoogleMap map) {
-    polygon = map.addPolygon(getPolygonOptions());
-    polygon.setClickable(this.tappable);
+  public void addToMap(Object collection) {
+    PolygonManager.Collection polygonCollection = (PolygonManager.Collection) collection;
+    polygon = polygonCollection.addPolygon(getPolygonOptions());
   }
 
   @Override
-  public void removeFromMap(GoogleMap map) {
-    polygon.remove();
+  public void removeFromMap(Object collection) {
+    PolygonManager.Collection polygonCollection = (PolygonManager.Collection) collection;
+    polygonCollection.remove(polygon);
   }
 }

package/android/src/main/java/com/{airbnb/android/react/maps/AirMapPolygonManager.java → rnmaps/maps/MapPolygonManager.java}

@@ -1,8 +1,7 @@
-package com.airbnb.android.react.maps;
+package com.rnmaps.maps;
 
 import android.content.Context;
 import android.graphics.Color;
-import android.os.Build;
 import android.util.DisplayMetrics;
 import android.view.WindowManager;
 
@@ -17,19 +16,15 @@ import com.facebook.react.uimanager.annotations.ReactProp;
 
 import java.util.Map;
 
-public class AirMapPolygonManager extends ViewGroupManager<AirMapPolygon> {
+public class MapPolygonManager extends ViewGroupManager<MapPolygon> {
   private final DisplayMetrics metrics;
 
-  public AirMapPolygonManager(ReactApplicationContext reactContext) {
+  public MapPolygonManager(ReactApplicationContext reactContext) {
     super();
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
-      metrics = new DisplayMetrics();
-      ((WindowManager) reactContext.getSystemService(Context.WINDOW_SERVICE))
-          .getDefaultDisplay()
-          .getRealMetrics(metrics);
-    } else {
-      metrics = reactContext.getResources().getDisplayMetrics();
-    }
+    metrics = new DisplayMetrics();
+    ((WindowManager) reactContext.getSystemService(Context.WINDOW_SERVICE))
+        .getDefaultDisplay()
+        .getRealMetrics(metrics);
   }
 
   @Override
@@ -38,51 +33,56 @@ public class AirMapPolygonManager extends ViewGroupManager<AirMapPolygon> {
   }
 
   @Override
-  public AirMapPolygon createViewInstance(ThemedReactContext context) {
-    return new AirMapPolygon(context);
+  public MapPolygon createViewInstance(ThemedReactContext context) {
+    return new MapPolygon(context);
   }
 
   @ReactProp(name = "coordinates")
-  public void setCoordinate(AirMapPolygon view, ReadableArray coordinates) {
+  public void setCoordinate(MapPolygon view, ReadableArray coordinates) {
     view.setCoordinates(coordinates);
   }
 
   @ReactProp(name = "holes")
-  public  void setHoles(AirMapPolygon view, ReadableArray holes) {
+  public  void setHoles(MapPolygon view, ReadableArray holes) {
     view.setHoles(holes);
   }
 
   @ReactProp(name = "strokeWidth", defaultFloat = 1f)
-  public void setStrokeWidth(AirMapPolygon view, float widthInPoints) {
+  public void setStrokeWidth(MapPolygon view, float widthInPoints) {
     float widthInScreenPx = metrics.density * widthInPoints; // done for parity with iOS
     view.setStrokeWidth(widthInScreenPx);
   }
 
   @ReactProp(name = "fillColor", defaultInt = Color.RED, customType = "Color")
-  public void setFillColor(AirMapPolygon view, int color) {
+  public void setFillColor(MapPolygon view, int color) {
     view.setFillColor(color);
   }
 
   @ReactProp(name = "strokeColor", defaultInt = Color.RED, customType = "Color")
-  public void setStrokeColor(AirMapPolygon view, int color) {
+  public void setStrokeColor(MapPolygon view, int color) {
     view.setStrokeColor(color);
   }
 
   @ReactProp(name = "tappable", defaultBoolean = false)
-  public void setTappable(AirMapPolygon view, boolean tapabble) {
+  public void setTappable(MapPolygon view, boolean tapabble) {
     view.setTappable(tapabble);
   }
 
   @ReactProp(name = "geodesic", defaultBoolean = false)
-  public void setGeodesic(AirMapPolygon view, boolean geodesic) {
+  public void setGeodesic(MapPolygon view, boolean geodesic) {
     view.setGeodesic(geodesic);
   }
 
   @ReactProp(name = "zIndex", defaultFloat = 1.0f)
-  public void setZIndex(AirMapPolygon view, float zIndex) {
+  public void setZIndex(MapPolygon view, float zIndex) {
     view.setZIndex(zIndex);
   }
 
+  @ReactProp(name = "lineDashPattern")
+  public void setLineDashPattern(MapPolygon view, ReadableArray patternValues) {
+      view.setLineDashPattern(patternValues);
+  }
+
   @Override
   @Nullable
   public Map getExportedCustomDirectEventTypeConstants() {