react-native-maps 0.29.4 → 0.30.2

package/lib/android/src/main/java/com/airbnb/android/react/maps/AirMapTileWorker.java

@@ -0,0 +1,122 @@
+package com.airbnb.android.react.maps;
+
+import android.content.Context;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.work.Worker;
+import androidx.work.WorkerParameters;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+ 
+public class AirMapTileWorker extends Worker {
+	private static final int BUFFER_SIZE = 16 * 1024;
+
+	public AirMapTileWorker(
+			@NonNull Context context,
+			@NonNull WorkerParameters params) {
+			super(context, params);
+	}
+
+	@Override
+	public Result doWork() {
+		byte[] image = null;
+		URL url = null;
+    String fileName = getInputData().getString("filename");
+
+    try {
+      int tileCacheMaxAge = getInputData().getInt("maxAge", 0);
+      if (tileCacheMaxAge >= 0) {
+        File file = new File(fileName);
+	    	long lastModified = file.lastModified();
+        long now = System.currentTimeMillis();
+        if ((now - lastModified) / 1000 < tileCacheMaxAge) return Result.failure();
+      }
+    } catch (Error e) {
+      return Result.failure();
+    }
+
+		try {
+      url = new URL(getInputData().getString("url"));
+    } catch (MalformedURLException e) {
+      throw new AssertionError(e);
+    }
+
+		image = fetchTile(url);
+		if (image != null) {
+			boolean success = writeTileImage(image, fileName);
+			if (!success) {
+				return Result.failure();
+			}
+    } else {
+			return Result.retry();
+		}
+
+		// Indicate whether the work finished successfully with the Result
+    Log.d("urlTile", "Worker fetched " + fileName);
+		return Result.success();
+	}
+
+	private byte[] fetchTile(URL url) {
+      ByteArrayOutputStream buffer = null;
+      InputStream in = null;
+
+      try {
+        in = url.openStream();
+        buffer = new ByteArrayOutputStream();
+
+        int nRead;
+        byte[] data = new byte[BUFFER_SIZE];
+
+        while ((nRead = in.read(data, 0, BUFFER_SIZE)) != -1) {
+          buffer.write(data, 0, nRead);
+        }
+        buffer.flush();
+
+        return buffer.toByteArray();
+      } catch (IOException e) {
+        e.printStackTrace();
+        return null;
+      } catch (OutOfMemoryError e) {
+        e.printStackTrace();
+        return null;
+      } finally {
+        if (in != null) try { in.close(); } catch (Exception ignored) {}
+        if (buffer != null) try { buffer.close(); } catch (Exception ignored) {}
+      }
+    }
+
+	private boolean writeTileImage(byte[] image, String fileName) {
+      OutputStream out = null;
+      if (fileName == null) {
+        return false;
+      }
+
+      try {
+        File file = new File(fileName);
+        file.getParentFile().mkdirs();
+        out = new FileOutputStream(file);
+        out.write(image);
+
+        return true;
+      } catch (IOException e) {
+        e.printStackTrace();
+        return false;
+      } catch (OutOfMemoryError e) {
+        e.printStackTrace();
+        return false;
+      } finally {
+        if (out != null) try { out.close(); } catch (Exception ignored) {}
+      }
+  }
+}

package/lib/android/src/main/java/com/airbnb/android/react/maps/AirMapUrlTile.java

@@ -1,71 +1,39 @@
 package com.airbnb.android.react.maps;
 
+import android.util.Log;
+
 import android.content.Context;
 
 import com.google.android.gms.maps.GoogleMap;
 import com.google.android.gms.maps.model.TileOverlay;
 import com.google.android.gms.maps.model.TileOverlayOptions;
-import com.google.android.gms.maps.model.UrlTileProvider;
 
 import java.net.MalformedURLException;
 import java.net.URL;
 
 public class AirMapUrlTile extends AirMapFeature {
-
-  class AIRMapUrlTileProvider extends UrlTileProvider {
-    private String urlTemplate;
-
-    public AIRMapUrlTileProvider(int width, int height, String urlTemplate) {
-      super(width, height);
-      this.urlTemplate = urlTemplate;
-    }
-
-    @Override
-    public synchronized URL getTileUrl(int x, int y, int zoom) {
-
-      if (AirMapUrlTile.this.flipY == true) {
-        y = (1 << zoom) - y - 1;
-      }
-
-      String s = this.urlTemplate
-          .replace("{x}", Integer.toString(x))
-          .replace("{y}", Integer.toString(y))
-          .replace("{z}", Integer.toString(zoom));
-      URL url = null;
-
-      if(AirMapUrlTile.this.maximumZ > 0 && zoom > maximumZ) {
-        return url;
-      }
-
-      if(AirMapUrlTile.this.minimumZ > 0 && zoom < minimumZ) {
-        return url;
-      }
-
-      try {
-        url = new URL(s);
-      } catch (MalformedURLException e) {
-        throw new AssertionError(e);
-      }
-      return url;
-    }
-
-    public void setUrlTemplate(String urlTemplate) {
-      this.urlTemplate = urlTemplate;
-    }
-  }
-
-  private TileOverlayOptions tileOverlayOptions;
-  private TileOverlay tileOverlay;
-  private AIRMapUrlTileProvider tileProvider;
-
-  private String urlTemplate;
-  private float zIndex;
-  private float maximumZ;
-  private float minimumZ;
-  private boolean flipY;
+  protected TileOverlayOptions tileOverlayOptions;
+  protected TileOverlay tileOverlay;
+  protected AirMapTileProvider tileProvider;
+
+  protected String urlTemplate;
+  protected float zIndex;
+  protected float maximumZ;
+  protected float maximumNativeZ = 100;
+  protected float minimumZ;
+  protected boolean flipY = false;
+  protected float tileSize = 256;
+  protected boolean doubleTileSize = false;
+  protected String tileCachePath;
+  protected float tileCacheMaxAge;
+  protected boolean offlineMode = false;
+  protected float opacity = 1;
+  protected Context context;
+  protected boolean customTileProviderNeeded = false;
 
   public AirMapUrlTile(Context context) {
     super(context);
+    this.context = context;
   }
 
   public void setUrlTemplate(String urlTemplate) {
@@ -87,6 +55,20 @@ public class AirMapUrlTile extends AirMapFeature {
 
   public void setMaximumZ(float maximumZ) {
     this.maximumZ = maximumZ;
+    if (tileProvider != null) {
+      tileProvider.setMaximumZ((int)maximumZ);
+    }
+    if (tileOverlay != null) {
+      tileOverlay.clearTileCache();
+    }
+  }
+
+  public void setMaximumNativeZ(float maximumNativeZ) {
+    this.maximumNativeZ = maximumNativeZ;
+    if (tileProvider != null) {
+      tileProvider.setMaximumNativeZ((int)maximumNativeZ);
+    }
+    setCustomTileProviderMode();
     if (tileOverlay != null) {
       tileOverlay.clearTileCache();
     }
@@ -94,6 +76,9 @@ public class AirMapUrlTile extends AirMapFeature {
 
   public void setMinimumZ(float minimumZ) {
     this.minimumZ = minimumZ;
+    if (tileProvider != null) {
+      tileProvider.setMinimumZ((int)minimumZ);
+    }
     if (tileOverlay != null) {
       tileOverlay.clearTileCache();
     }
@@ -101,11 +86,83 @@ public class AirMapUrlTile extends AirMapFeature {
 
   public void setFlipY(boolean flipY) {
     this.flipY = flipY;
+    if (tileProvider != null) {
+      tileProvider.setFlipY((boolean)flipY);
+    }
     if (tileOverlay != null) {
       tileOverlay.clearTileCache();
     }
   }
 
+  public void setDoubleTileSize(boolean doubleTileSize) {
+    this.doubleTileSize = doubleTileSize;
+    if (tileProvider != null) {
+      tileProvider.setDoubleTileSize((boolean)doubleTileSize);
+    }
+    setCustomTileProviderMode();
+    if (tileOverlay != null) {
+      tileOverlay.clearTileCache();
+    }
+  }
+
+  public void setTileSize(float tileSize) {
+    this.tileSize = tileSize;
+    if (tileProvider != null) {
+      tileProvider.setTileSize((int)tileSize);
+    }
+    if (tileOverlay != null) {
+      tileOverlay.clearTileCache();
+    }
+  }
+
+  public void setTileCachePath(String tileCachePath) {
+    if (tileCachePath == null || tileCachePath.isEmpty()) return;
+    
+    try {
+      URL url = new URL(tileCachePath);
+      this.tileCachePath = url.getPath();
+    } catch (MalformedURLException e) {
+      this.tileCachePath = tileCachePath;
+    } catch (Exception e) {
+      return;
+    }
+
+    if (tileProvider != null) {
+      tileProvider.setTileCachePath(tileCachePath);
+    }
+    setCustomTileProviderMode();
+    if (tileOverlay != null) {
+      tileOverlay.clearTileCache();
+    }
+  }
+
+  public void setTileCacheMaxAge(float tileCacheMaxAge) {
+    this.tileCacheMaxAge = tileCacheMaxAge;
+    if (tileProvider != null) {
+      tileProvider.setTileCacheMaxAge((int)tileCacheMaxAge);
+    }
+    if (tileOverlay != null) {
+      tileOverlay.clearTileCache();
+    }
+  }
+
+  public void setOfflineMode(boolean offlineMode) {
+    this.offlineMode = offlineMode;
+    if (tileProvider != null) {
+      tileProvider.setOfflineMode((boolean)offlineMode);
+    }
+    if (tileOverlay != null) {
+      tileOverlay.clearTileCache();
+    }
+  }
+
+  public void setOpacity(float opacity) {
+    this.opacity = opacity;
+    if (tileOverlay != null) {
+        tileOverlay.setTransparency(1 - opacity);
+    }
+  }
+
   public TileOverlayOptions getTileOverlayOptions() {
     if (tileOverlayOptions == null) {
       tileOverlayOptions = createTileOverlayOptions();
@@ -113,10 +170,22 @@ public class AirMapUrlTile extends AirMapFeature {
     return tileOverlayOptions;
   }
 
-  private TileOverlayOptions createTileOverlayOptions() {
+  protected void setCustomTileProviderMode() {
+    Log.d("urlTile ", "creating new mode TileProvider");
+    this.customTileProviderNeeded = true;
+    if (tileProvider != null) {
+      tileProvider.setCustomMode();
+    }
+  } 
+
+  protected TileOverlayOptions createTileOverlayOptions() {
+    Log.d("urlTile ", "creating TileProvider");
     TileOverlayOptions options = new TileOverlayOptions();
     options.zIndex(zIndex);
-    this.tileProvider = new AIRMapUrlTileProvider(256, 256, this.urlTemplate);
+    options.transparency(1 - this.opacity);
+    this.tileProvider = new AirMapTileProvider((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);
     options.tileProvider(this.tileProvider);
     return options;
   }

package/lib/android/src/main/java/com/airbnb/android/react/maps/AirMapUrlTileManager.java

@@ -55,9 +55,43 @@ public class AirMapUrlTileManager extends ViewGroupManager<AirMapUrlTile> {
     view.setMaximumZ(maximumZ);
   }
 
+  @ReactProp(name = "maximumNativeZ", defaultFloat = 100.0f)
+  public void setMaximumNativeZ(AirMapUrlTile view, float maximumNativeZ) {
+    view.setMaximumNativeZ(maximumNativeZ);
+  }
+
   @ReactProp(name = "flipY", defaultBoolean = false)
   public void setFlipY(AirMapUrlTile view, boolean flipY) {
     view.setFlipY(flipY);
   }
 
+  @ReactProp(name = "tileSize", defaultFloat = 256.0f)
+  public void setTileSize(AirMapUrlTile view, float tileSize) {
+    view.setTileSize(tileSize);
+  }
+
+  @ReactProp(name = "doubleTileSize", defaultBoolean = false)
+  public void setDoubleTileSize(AirMapUrlTile view, boolean doubleTileSize) {
+    view.setDoubleTileSize(doubleTileSize);
+  }
+
+  @ReactProp(name = "tileCachePath")
+  public void setTileCachePath(AirMapUrlTile view, String tileCachePath) {
+    view.setTileCachePath(tileCachePath);
+  }
+
+  @ReactProp(name = "tileCacheMaxAge", defaultFloat = 0.0f)
+  public void setTileCacheMaxAge(AirMapUrlTile view, float tileCacheMaxAge) {
+    view.setTileCacheMaxAge(tileCacheMaxAge);
+  }
+
+  @ReactProp(name = "offlineMode", defaultBoolean = false)
+  public void setOfflineMode(AirMapUrlTile view, boolean offlineMode) {
+    view.setOfflineMode(offlineMode);
+  }
+
+  @ReactProp(name = "opacity", defaultFloat = 1.0f)
+  public void setOpacity(AirMapUrlTile view, float opacity) {
+    view.setOpacity(opacity);
+  }
 }

package/lib/android/src/main/java/com/airbnb/android/react/maps/AirMapView.java

@@ -116,6 +116,7 @@ public class AirMapView extends MapView implements GoogleMap.InfoWindowAdapter,
   private FusedLocationSource fusedLocationSource;
 
   private ViewAttacherGroup attacherGroup;
+  private LatLng tapLocation;
 
   private static boolean contextHasBug(Context context) {
     return context == null ||
@@ -276,7 +277,7 @@ public class AirMapView extends MapView implements GoogleMap.InfoWindowAdapter,
     map.setOnPolygonClickListener(new GoogleMap.OnPolygonClickListener() {
       @Override
       public void onPolygonClick(Polygon polygon) {
-        WritableMap event = makeClickEventData(polygon.getPoints().get(0));
+        WritableMap event = makeClickEventData(tapLocation);
         event.putString("action", "polygon-press");
         manager.pushEvent(context, polygonMap.get(polygon), "onPress", event);
       }
@@ -1008,6 +1009,10 @@ public class AirMapView extends MapView implements GoogleMap.InfoWindowAdapter,
   public boolean dispatchTouchEvent(MotionEvent ev) {
     gestureDetector.onTouchEvent(ev);
 
+    int X = (int)ev.getX();          
+    int Y = (int)ev.getY();
+    tapLocation = map.getProjection().fromScreenLocation(new Point(X,Y));
+
     int action = MotionEventCompat.getActionMasked(ev);
 
     switch (action) {

package/lib/android/src/main/java/com/airbnb/android/react/maps/AirMapWMSTile.java

@@ -2,6 +2,8 @@ package com.airbnb.android.react.maps;
 
 import android.content.Context;
 
+import android.util.Log;
+
 import com.google.android.gms.maps.GoogleMap;
 import com.google.android.gms.maps.model.TileOverlay;
 import com.google.android.gms.maps.model.TileOverlayOptions;
@@ -10,38 +12,42 @@ import com.google.android.gms.maps.model.UrlTileProvider;
 import java.net.MalformedURLException;
 import java.net.URL;
 
-public class AirMapWMSTile extends AirMapFeature {
+public class AirMapWMSTile extends AirMapUrlTile {
   private static final double[] mapBound = {-20037508.34789244, 20037508.34789244};
   private static final double FULL = 20037508.34789244 * 2;
 
-    class AIRMapGSUrlTileProvider extends UrlTileProvider {
+  class AIRMapGSUrlTileProvider extends AirMapTileProvider {
+
+    class AIRMapWMSTileProvider extends UrlTileProvider {
     private String urlTemplate;
-    private int width;
-    private int height;
-    public AIRMapGSUrlTileProvider(int width, int height, String urlTemplate) {
+    private int tileSize;
+
+    public AIRMapWMSTileProvider(int width, int height, String urlTemplate) {
       super(width, height);
       this.urlTemplate = urlTemplate;
-      this.width = width;
-      this.height = height;
+      this.tileSize = width;
     }
 
     @Override
-    public synchronized URL getTileUrl(int x, int y, int zoom) {
+    public URL getTileUrl(int x, int y, int zoom) {
       if(AirMapWMSTile.this.maximumZ > 0 && zoom > maximumZ) {
           return null;
       }
+
       if(AirMapWMSTile.this.minimumZ > 0 && zoom < minimumZ) {
           return null;
       }
+
       double[] bb = getBoundingBox(x, y, zoom);
       String s = this.urlTemplate
           .replace("{minX}", Double.toString(bb[0]))
           .replace("{minY}", Double.toString(bb[1]))
           .replace("{maxX}", Double.toString(bb[2]))
           .replace("{maxY}", Double.toString(bb[3]))
-          .replace("{width}", Integer.toString(width))
-          .replace("{height}", Integer.toString(height));
+          .replace("{width}", Integer.toString(this.tileSize))
+          .replace("{height}", Integer.toString(this.tileSize));
       URL url = null;
+
       try {
         url = new URL(s);
       } catch (MalformedURLException e) {
@@ -65,92 +71,30 @@ public class AirMapWMSTile extends AirMapFeature {
     }
   }
 
-  private TileOverlayOptions tileOverlayOptions;
-  private TileOverlay tileOverlay;
-  private AIRMapGSUrlTileProvider tileProvider;
-
-  private String urlTemplate;
-  private float zIndex;
-  private float maximumZ;
-  private float minimumZ;
-  private int tileSize;
-  private float opacity;
-
-  public AirMapWMSTile(Context context) {
-    super(context);
-  }
-
-  public void setUrlTemplate(String urlTemplate) {
-    this.urlTemplate = urlTemplate;
-    if (tileProvider != null) {
-      tileProvider.setUrlTemplate(urlTemplate);
-    }
-    if (tileOverlay != null) {
-      tileOverlay.clearTileCache();
-    }
-  }
-
-  public void setZIndex(float zIndex) {
-    this.zIndex = zIndex;
-    if (tileOverlay != null) {
-      tileOverlay.setZIndex(zIndex);
-    }
-  }
-
-  public void setMaximumZ(float maximumZ) {
-    this.maximumZ = maximumZ;
-    if (tileOverlay != null) {
-      tileOverlay.clearTileCache();
+  public AIRMapGSUrlTileProvider(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);
     }
   }
 
-  public void setMinimumZ(float minimumZ) {
-    this.minimumZ = minimumZ;
-    if (tileOverlay != null) {
-      tileOverlay.clearTileCache();
-    }
-  }
-  public void setTileSize(int tileSize) {
-    this.tileSize = tileSize;
-    if (tileOverlay != null) {
-      tileOverlay.clearTileCache();
-    }
-  }
-  public void setOpacity(float opacity) {
-    this.opacity = opacity;
-    if (tileOverlay != null) {
-        tileOverlay.setTransparency(1-opacity);
-    }
-  }
+  private AIRMapGSUrlTileProvider tileProvider;
 
-  public TileOverlayOptions getTileOverlayOptions() {
-    if (tileOverlayOptions == null) {
-      tileOverlayOptions = createTileOverlayOptions();
-    }
-    return tileOverlayOptions;
+  public AirMapWMSTile(Context context) {
+    super(context);
   }
 
-  private TileOverlayOptions createTileOverlayOptions() {
+  @Override
+  protected TileOverlayOptions createTileOverlayOptions() {
     TileOverlayOptions options = new TileOverlayOptions();
     options.zIndex(zIndex);
-    options.transparency(1-opacity);
-    this.tileProvider = new AIRMapGSUrlTileProvider(this.tileSize, this.tileSize, this.urlTemplate);
+    options.transparency(1 - this.opacity);
+    this.tileProvider = new AIRMapGSUrlTileProvider((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(this.tileProvider);
     return options;
   }
-
-  @Override
-  public Object getFeature() {
-    return tileOverlay;
-  }
-
-  @Override
-  public void addToMap(GoogleMap map) {
-    this.tileOverlay = map.addTileOverlay(getTileOverlayOptions());
-  }
-
-  @Override
-  public void removeFromMap(GoogleMap map) {
-    tileOverlay.remove();
-  }
 }

package/lib/android/src/main/java/com/airbnb/android/react/maps/AirMapWMSTileManager.java

@@ -55,11 +55,31 @@ public class AirMapWMSTileManager extends ViewGroupManager<AirMapWMSTile> {
     view.setMaximumZ(maximumZ);
   }
 
-  @ReactProp(name = "tileSize", defaultInt = 512)
-  public void setTileSize(AirMapWMSTile view, int tileSize) {
+  @ReactProp(name = "maximumNativeZ", defaultFloat = 100.0f)
+  public void setMaximumNativeZ(AirMapWMSTile view, float maximumNativeZ) {
+    view.setMaximumNativeZ(maximumNativeZ);
+  }
+
+  @ReactProp(name = "tileSize", defaultFloat = 256.0f)
+  public void setTileSize(AirMapWMSTile view, float tileSize) {
     view.setTileSize(tileSize);
   }
 
+  @ReactProp(name = "tileCachePath")
+  public void setTileCachePath(AirMapWMSTile view, String tileCachePath) {
+    view.setTileCachePath(tileCachePath);
+  }
+
+  @ReactProp(name = "tileCacheMaxAge", defaultFloat = 0.0f)
+  public void setTileCacheMaxAge(AirMapWMSTile view, float tileCacheMaxAge) {
+    view.setTileCacheMaxAge(tileCacheMaxAge);
+  }
+
+  @ReactProp(name = "offlineMode", defaultBoolean = false)
+  public void setOfflineMode(AirMapWMSTile view, boolean offlineMode) {
+    view.setOfflineMode(offlineMode);
+  }
+
   @ReactProp(name = "opacity", defaultFloat = 1.0f)
   public void setOpacity(AirMapWMSTile view, float opacity) {
     view.setOpacity(opacity);