react-native-maps 1.21.0-alpha.14 → 1.21.0-alpha.140

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

@@ -4,161 +4,227 @@ import android.content.Context;
 
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.MapBuilder;
+import com.google.android.gms.maps.model.ButtCap;
 import com.google.android.gms.maps.model.Cap;
 import com.google.android.gms.maps.model.Dash;
 import com.google.android.gms.maps.model.Dot;
 import com.google.android.gms.maps.model.Gap;
+import com.google.android.gms.maps.model.JointType;
 import com.google.android.gms.maps.model.LatLng;
 import com.google.android.gms.maps.model.PatternItem;
 import com.google.android.gms.maps.model.Polyline;
 import com.google.android.gms.maps.model.PolylineOptions;
 import com.google.android.gms.maps.model.RoundCap;
+import com.google.android.gms.maps.model.SquareCap;
+import com.google.android.gms.maps.model.StrokeStyle;
+import com.google.android.gms.maps.model.StyleSpan;
 import com.google.maps.android.collections.PolylineManager;
+import com.rnmaps.fabric.event.OnPressEvent;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 public class MapPolyline extends MapFeature {
 
-  private PolylineOptions polylineOptions;
-  private Polyline polyline;
-
-  private List<LatLng> coordinates;
-  private int color;
-  private float width;
-  private boolean tappable;
-  private boolean geodesic;
-  private float zIndex;
-  private Cap lineCap = new RoundCap();
-  private ReadableArray patternValues;
-  private List<PatternItem> pattern;
-
-  public MapPolyline(Context context) {
-    super(context);
-  }
-
-  public void setCoordinates(ReadableArray coordinates) {
-    this.coordinates = new ArrayList<>(coordinates.size());
-    for (int i = 0; i < coordinates.size(); i++) {
-      ReadableMap coordinate = coordinates.getMap(i);
-      this.coordinates.add(i,
-          new LatLng(coordinate.getDouble("latitude"), coordinate.getDouble("longitude")));
-    }
-    if (polyline != null) {
-      polyline.setPoints(this.coordinates);
-    }
-  }
-
-  public void setColor(int color) {
-    this.color = color;
-    if (polyline != null) {
-      polyline.setColor(color);
-    }
-  }
-
-  public void setWidth(float width) {
-    this.width = width;
-    if (polyline != null) {
-      polyline.setWidth(width);
-    }
-  }
-
-  public void setZIndex(float zIndex) {
-    this.zIndex = zIndex;
-    if (polyline != null) {
-      polyline.setZIndex(zIndex);
-    }
-  }
-
-  public void setTappable(boolean tapabble) {
-    this.tappable = tapabble;
-    if (polyline != null) {
-      polyline.setClickable(tappable);
-    }
-  }
-
-  public void setGeodesic(boolean geodesic) {
-    this.geodesic = geodesic;
-    if (polyline != null) {
-      polyline.setGeodesic(geodesic);
-    }
-  }
-
-  public void setLineCap(Cap cap) {
-    this.lineCap = cap;
-    if (polyline != null) {
-      polyline.setStartCap(cap);
-      polyline.setEndCap(cap);
-    }
-    this.applyPattern();
-  }
-
-  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;
-        boolean isLineCapRound = this.lineCap instanceof RoundCap;
-        if(isLineCapRound) {
-          patternItem = new Dot();
-        }else {
-          patternItem = new Dash(patternValue);
-        }
-        this.pattern.add(patternItem);
-      }
-    }
-    if(polyline != null) {
-      polyline.setPattern(this.pattern);
-    }
-  }
-
-  public PolylineOptions getPolylineOptions() {
-    if (polylineOptions == null) {
-      polylineOptions = createPolylineOptions();
-    }
-    return polylineOptions;
-  }
-
-  private PolylineOptions createPolylineOptions() {
-    PolylineOptions options = new PolylineOptions();
-    options.addAll(coordinates);
-    options.color(color);
-    options.width(width);
-    options.geodesic(geodesic);
-    options.zIndex(zIndex);
-    options.startCap(lineCap);
-    options.endCap(lineCap);
-    options.pattern(this.pattern);
-    return options;
-  }
-
-  @Override
-  public Object getFeature() {
-    return polyline;
-  }
-
-  @Override
-  public void addToMap(Object collection) {
-    PolylineManager.Collection polylineCollection = (PolylineManager.Collection) collection;
-    polyline = polylineCollection.addPolyline(getPolylineOptions());
-    polyline.setClickable(this.tappable);
-  }
-
-  @Override
-  public void removeFromMap(Object collection) {
-    PolylineManager.Collection polylineCollection = (PolylineManager.Collection) collection;
-    polylineCollection.remove(polyline);
-  }
+    private PolylineOptions polylineOptions;
+    private Polyline polyline;
+
+    private List<LatLng> coordinates;
+    private int color;
+    private float width;
+    private boolean tappable;
+    private boolean geodesic;
+    private float zIndex;
+    private Cap lineCap = new RoundCap();
+    private ReadableArray patternValues;
+    private List<PatternItem> pattern;
+
+    public MapPolyline(Context context) {
+        super(context);
+    }
+
+    public void setCoordinates(ReadableArray coordinates) {
+        this.coordinates = new ArrayList<>(coordinates.size());
+        for (int i = 0; i < coordinates.size(); i++) {
+            ReadableMap coordinate = coordinates.getMap(i);
+            this.coordinates.add(i,
+                    new LatLng(coordinate.getDouble("latitude"), coordinate.getDouble("longitude")));
+        }
+        if (polyline != null) {
+            polyline.setPoints(this.coordinates);
+        }
+    }
+
+    public void setColor(int color) {
+        this.color = color;
+        if (polyline != null) {
+            polyline.setColor(color);
+        }
+    }
+
+    public void setStrokeColors(ReadableArray strokeColors) {
+        List<StyleSpan> spans = new ArrayList<>();
+        for (int i = 0; i < strokeColors.size(); i++) {
+            StrokeStyle stroke;
+
+            if (i == 0) {
+                stroke = StrokeStyle.colorBuilder(strokeColors.getInt(i)).build();
+            } else {
+                stroke = StrokeStyle.gradientBuilder(strokeColors.getInt(i - 1), strokeColors.getInt(i)).build();
+            }
+            spans.add(new StyleSpan(stroke));
+        }
+
+        polyline.setSpans(spans);
+    }
+
+    public void setWidth(float width) {
+        this.width = width;
+        if (polyline != null) {
+            polyline.setWidth(width);
+        }
+    }
+
+    public void setZIndex(float zIndex) {
+        this.zIndex = zIndex;
+        if (polyline != null) {
+            polyline.setZIndex(zIndex);
+        }
+    }
+
+    public void setTappable(boolean tapabble) {
+        this.tappable = tapabble;
+        if (polyline != null) {
+            polyline.setClickable(tappable);
+        }
+    }
+
+    public void setGeodesic(boolean geodesic) {
+        this.geodesic = geodesic;
+        if (polyline != null) {
+            polyline.setGeodesic(geodesic);
+        }
+    }
+
+    public void setLineCap(Cap cap) {
+        this.lineCap = cap;
+        if (polyline != null) {
+            polyline.setStartCap(cap);
+            polyline.setEndCap(cap);
+        }
+        this.applyPattern();
+    }
+
+    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;
+                boolean isLineCapRound = this.lineCap instanceof RoundCap;
+                if (isLineCapRound) {
+                    patternItem = new Dot();
+                } else {
+                    patternItem = new Dash(patternValue);
+                }
+                this.pattern.add(patternItem);
+            }
+        }
+        if (polyline != null) {
+            polyline.setPattern(this.pattern);
+        }
+    }
+
+    public PolylineOptions getPolylineOptions() {
+        if (polylineOptions == null) {
+            polylineOptions = createPolylineOptions();
+        }
+        return polylineOptions;
+    }
+
+    private PolylineOptions createPolylineOptions() {
+        PolylineOptions options = new PolylineOptions();
+        options.addAll(coordinates);
+        options.color(color);
+        options.width(width);
+        options.geodesic(geodesic);
+        options.zIndex(zIndex);
+        options.startCap(lineCap);
+        options.endCap(lineCap);
+        options.pattern(this.pattern);
+        return options;
+    }
+
+    @Override
+    public Object getFeature() {
+        return polyline;
+    }
+
+    @Override
+    public void addToMap(Object collection) {
+        PolylineManager.Collection polylineCollection = (PolylineManager.Collection) collection;
+        polyline = polylineCollection.addPolyline(getPolylineOptions());
+        polyline.setClickable(this.tappable);
+    }
+
+    @Override
+    public void removeFromMap(Object collection) {
+        PolylineManager.Collection polylineCollection = (PolylineManager.Collection) collection;
+        polylineCollection.remove(polyline);
+    }
+
+    public void setLineCap(String lineCap) {
+        Cap cap;
+        switch (lineCap) {
+            case "round":
+                cap = new RoundCap();
+                break;
+            case "square":
+                cap = new SquareCap();
+                break;
+            case "butt":
+            default:
+                cap = new ButtCap();
+                break;
+        }
+        setLineCap(cap);
+    }
+
+    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 void setLineJoin(String lineJoin) {
+        int type;
+        switch (lineJoin) {
+            case "round":
+                type = JointType.ROUND;
+                break;
+            case "bevel":
+                type = JointType.BEVEL;
+                break;
+            case "miter":
+            default:
+                type = JointType.DEFAULT;
+                break;
+        }
+        if (polyline != null) {
+            polyline.setJointType(type);
+        }
+    }
 }

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

@@ -74,22 +74,7 @@ public class MapPolylineManager extends ViewGroupManager<MapPolyline> {
 
   @ReactProp(name = "lineCap")
   public void setlineCap(MapPolyline view, String lineCap) {
-    Cap cap = null;
-    switch (lineCap) {
-      case "butt":
-        cap = new ButtCap();
-        break;
-      case "round":
-        cap = new RoundCap();
-        break;
-      case "square":
-        cap = new SquareCap();
-        break;
-      default:
-        cap = new RoundCap();
-        break;
-    }
-    view.setLineCap(cap);
+      view.setLineCap(lineCap);
   }
 
   @ReactProp(name = "lineDashPattern")

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

@@ -18,14 +18,14 @@ public class MapUrlTile extends MapFeature {
 
   protected String urlTemplate;
   protected float zIndex;
-  protected float maximumZ;
-  protected float maximumNativeZ = 100;
-  protected float minimumZ;
+  protected int maximumZ;
+  protected int maximumNativeZ = 100;
+  protected int minimumZ;
   protected boolean flipY = false;
-  protected float tileSize = 256;
+  protected int tileSize = 256;
   protected boolean doubleTileSize = false;
   protected String tileCachePath;
-  protected float tileCacheMaxAge;
+  protected int tileCacheMaxAge;
   protected boolean offlineMode = false;
   protected float opacity = 1;
   protected Context context;
@@ -53,20 +53,20 @@ public class MapUrlTile extends MapFeature {
     }
   }
 
-  public void setMaximumZ(float maximumZ) {
+  public void setMaximumZ(int maximumZ) {
     this.maximumZ = maximumZ;
     if (tileProvider != null) {
-      tileProvider.setMaximumZ((int)maximumZ);
+      tileProvider.setMaximumZ(maximumZ);
     }
     if (tileOverlay != null) {
       tileOverlay.clearTileCache();
     }
   }
 
-  public void setMaximumNativeZ(float maximumNativeZ) {
+  public void setMaximumNativeZ(int maximumNativeZ) {
     this.maximumNativeZ = maximumNativeZ;
     if (tileProvider != null) {
-      tileProvider.setMaximumNativeZ((int)maximumNativeZ);
+      tileProvider.setMaximumNativeZ(maximumNativeZ);
     }
     setCustomTileProviderMode();
     if (tileOverlay != null) {
@@ -74,10 +74,10 @@ public class MapUrlTile extends MapFeature {
     }
   }
 
-  public void setMinimumZ(float minimumZ) {
+  public void setMinimumZ(int minimumZ) {
     this.minimumZ = minimumZ;
     if (tileProvider != null) {
-      tileProvider.setMinimumZ((int)minimumZ);
+      tileProvider.setMinimumZ(minimumZ);
     }
     if (tileOverlay != null) {
       tileOverlay.clearTileCache();
@@ -105,10 +105,10 @@ public class MapUrlTile extends MapFeature {
     }
   }
 
-  public void setTileSize(float tileSize) {
+  public void setTileSize(int tileSize) {
     this.tileSize = tileSize;
     if (tileProvider != null) {
-      tileProvider.setTileSize((int)tileSize);
+      tileProvider.setTileSize(tileSize);
     }
     if (tileOverlay != null) {
       tileOverlay.clearTileCache();
@@ -136,10 +136,10 @@ public class MapUrlTile extends MapFeature {
     }
   }
 
-  public void setTileCacheMaxAge(float tileCacheMaxAge) {
+  public void setTileCacheMaxAge(int tileCacheMaxAge) {
     this.tileCacheMaxAge = tileCacheMaxAge;
     if (tileProvider != null) {
-      tileProvider.setTileCacheMaxAge((int)tileCacheMaxAge);
+      tileProvider.setTileCacheMaxAge(tileCacheMaxAge);
     }
     if (tileOverlay != null) {
       tileOverlay.clearTileCache();
@@ -176,7 +176,7 @@ public class MapUrlTile extends MapFeature {
     if (tileProvider != null) {
       tileProvider.setCustomMode();
     }
-  } 
+  }
 
   protected TileOverlayOptions createTileOverlayOptions() {
     Log.d("urlTile ", "creating TileProvider");
@@ -184,8 +184,8 @@ public class MapUrlTile extends MapFeature {
     options.zIndex(zIndex);
     options.transparency(1 - this.opacity);
     this.tileProvider = new MapTileProvider((int)this.tileSize, this.doubleTileSize, this.urlTemplate,
-      (int)this.maximumZ, (int)this.maximumNativeZ, (int)this.minimumZ, this.flipY, this.tileCachePath, 
-      (int)this.tileCacheMaxAge, this.offlineMode, this.context, this.customTileProviderNeeded);
+      this.maximumZ, this.maximumNativeZ, this.minimumZ, this.flipY, this.tileCachePath,
+      this.tileCacheMaxAge, this.offlineMode, this.context, this.customTileProviderNeeded);
     options.tileProvider(this.tileProvider);
     return options;
   }

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

@@ -13,10 +13,6 @@ public class MapUrlTileManager extends ViewGroupManager<MapUrlTile> {
 
   public MapUrlTileManager(ReactApplicationContext reactContext) {
     super();
-    DisplayMetrics metrics = new DisplayMetrics();
-    ((WindowManager) reactContext.getSystemService(Context.WINDOW_SERVICE))
-        .getDefaultDisplay()
-        .getRealMetrics(metrics);
   }
 
   @Override
@@ -39,18 +35,18 @@ public class MapUrlTileManager extends ViewGroupManager<MapUrlTile> {
     view.setZIndex(zIndex);
   }
 
-  @ReactProp(name = "minimumZ", defaultFloat = 0.0f)
-  public void setMinimumZ(MapUrlTile view, float minimumZ) {
+  @ReactProp(name = "minimumZ", defaultInt = 0)
+  public void setMinimumZ(MapUrlTile view, int minimumZ) {
     view.setMinimumZ(minimumZ);
   }
 
-  @ReactProp(name = "maximumZ", defaultFloat = 100.0f)
-  public void setMaximumZ(MapUrlTile view, float maximumZ) {
+  @ReactProp(name = "maximumZ", defaultInt = 100)
+  public void setMaximumZ(MapUrlTile view, int maximumZ) {
     view.setMaximumZ(maximumZ);
   }
 
-  @ReactProp(name = "maximumNativeZ", defaultFloat = 100.0f)
-  public void setMaximumNativeZ(MapUrlTile view, float maximumNativeZ) {
+  @ReactProp(name = "maximumNativeZ", defaultInt = 100)
+  public void setMaximumNativeZ(MapUrlTile view, int maximumNativeZ) {
     view.setMaximumNativeZ(maximumNativeZ);
   }
 
@@ -59,8 +55,8 @@ public class MapUrlTileManager extends ViewGroupManager<MapUrlTile> {
     view.setFlipY(flipY);
   }
 
-  @ReactProp(name = "tileSize", defaultFloat = 256.0f)
-  public void setTileSize(MapUrlTile view, float tileSize) {
+  @ReactProp(name = "tileSize", defaultInt = 256)
+  public void setTileSize(MapUrlTile view, int tileSize) {
     view.setTileSize(tileSize);
   }
 
@@ -74,8 +70,8 @@ public class MapUrlTileManager extends ViewGroupManager<MapUrlTile> {
     view.setTileCachePath(tileCachePath);
   }
 
-  @ReactProp(name = "tileCacheMaxAge", defaultFloat = 0.0f)
-  public void setTileCacheMaxAge(MapUrlTile view, float tileCacheMaxAge) {
+  @ReactProp(name = "tileCacheMaxAge", defaultInt = 0)
+  public void setTileCacheMaxAge(MapUrlTile view, int tileCacheMaxAge) {
     view.setTileCacheMaxAge(tileCacheMaxAge);
   }