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

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

@@ -0,0 +1,64 @@
+package com.rnmaps.maps;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.UIManager;
+import com.facebook.react.fabric.FabricUIManager;
+import com.facebook.react.fabric.interop.UIBlockViewResolver;
+import com.facebook.react.uimanager.common.UIManagerType;
+import com.facebook.react.uimanager.NativeViewHierarchyManager;
+import com.facebook.react.uimanager.UIBlock;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.UIManagerModule;
+
+import java.util.function.Function;
+
+public class MapUIBlock implements UIBlockInterface {
+    private int tag;
+    private Promise promise;
+    private ReactApplicationContext context;
+    private Function<MapView, Void> mapOperation;
+
+    public MapUIBlock(int tag, Promise promise, ReactApplicationContext context, Function<MapView, Void> mapOperation) {
+        this.tag = tag;
+        this.promise = promise;
+        this.context = context;
+        this.mapOperation = mapOperation;
+    }
+
+    @Override
+    public void execute(NativeViewHierarchyManager nvhm) {
+        executeImpl(nvhm, null);
+    }
+
+    @Override
+    public void execute(UIBlockViewResolver uiBlockViewResolver) {
+        executeImpl(null, uiBlockViewResolver);
+    }
+
+    private void executeImpl(NativeViewHierarchyManager nvhm, UIBlockViewResolver uiBlockViewResolver) {
+        MapView view = uiBlockViewResolver != null ? (MapView) uiBlockViewResolver.resolveView(tag) : (MapView) nvhm.resolveView(tag);
+        if (view == null) {
+            promise.reject("AirMapView not found");
+            return;
+        }
+        if (view.map == null) {
+            promise.reject("AirMapView.map is not valid");
+            return;
+        }
+
+        mapOperation.apply(view);
+    }
+
+    public void addToUIManager() {
+        if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+            UIManager uiManager = UIManagerHelper.getUIManager(context, UIManagerType.FABRIC);
+            ((FabricUIManager) uiManager).addUIBlock(this);
+        } else {
+            UIManagerModule uiManager = context.getNativeModule(UIManagerModule.class);
+            uiManager.addUIBlock(this);
+        }
+    }
+}
+
+interface UIBlockInterface extends UIBlock, com.facebook.react.fabric.interop.UIBlock  {}

package/android/src/main/java/com/{airbnb/android/react/maps/AirMapUrlTile.java → rnmaps/maps/MapUrlTile.java}

@@ -1,4 +1,4 @@
-package com.airbnb.android.react.maps;
+package com.rnmaps.maps;
 
 import android.util.Log;
 
@@ -11,27 +11,27 @@ import com.google.android.gms.maps.model.TileOverlayOptions;
 import java.net.MalformedURLException;
 import java.net.URL;
 
-public class AirMapUrlTile extends AirMapFeature {
+public class MapUrlTile extends MapFeature {
   protected TileOverlayOptions tileOverlayOptions;
   protected TileOverlay tileOverlay;
-  protected AirMapTileProvider tileProvider;
+  protected MapTileProvider tileProvider;
 
   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;
   protected boolean customTileProviderNeeded = false;
 
-  public AirMapUrlTile(Context context) {
+  public MapUrlTile(Context context) {
     super(context);
     this.context = context;
   }
@@ -53,20 +53,20 @@ public class AirMapUrlTile extends AirMapFeature {
     }
   }
 
-  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 AirMapUrlTile extends AirMapFeature {
     }
   }
 
-  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();
@@ -87,7 +87,7 @@ public class AirMapUrlTile extends AirMapFeature {
   public void setFlipY(boolean flipY) {
     this.flipY = flipY;
     if (tileProvider != null) {
-      tileProvider.setFlipY((boolean)flipY);
+      tileProvider.setFlipY(flipY);
     }
     if (tileOverlay != null) {
       tileOverlay.clearTileCache();
@@ -97,7 +97,7 @@ public class AirMapUrlTile extends AirMapFeature {
   public void setDoubleTileSize(boolean doubleTileSize) {
     this.doubleTileSize = doubleTileSize;
     if (tileProvider != null) {
-      tileProvider.setDoubleTileSize((boolean)doubleTileSize);
+      tileProvider.setDoubleTileSize(doubleTileSize);
     }
     setCustomTileProviderMode();
     if (tileOverlay != null) {
@@ -105,10 +105,10 @@ public class AirMapUrlTile extends AirMapFeature {
     }
   }
 
-  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 AirMapUrlTile extends AirMapFeature {
     }
   }
 
-  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();
@@ -149,7 +149,7 @@ public class AirMapUrlTile extends AirMapFeature {
   public void setOfflineMode(boolean offlineMode) {
     this.offlineMode = offlineMode;
     if (tileProvider != null) {
-      tileProvider.setOfflineMode((boolean)offlineMode);
+      tileProvider.setOfflineMode(offlineMode);
     }
     if (tileOverlay != null) {
       tileOverlay.clearTileCache();
@@ -176,16 +176,16 @@ public class AirMapUrlTile extends AirMapFeature {
     if (tileProvider != null) {
       tileProvider.setCustomMode();
     }
-  } 
+  }
 
   protected TileOverlayOptions createTileOverlayOptions() {
     Log.d("urlTile ", "creating TileProvider");
     TileOverlayOptions options = new TileOverlayOptions();
     options.zIndex(zIndex);
     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);
+    this.tileProvider = new MapTileProvider((int)this.tileSize, this.doubleTileSize, this.urlTemplate,
+      this.maximumZ, this.maximumNativeZ, this.minimumZ, this.flipY, this.tileCachePath,
+      this.tileCacheMaxAge, this.offlineMode, this.context, this.customTileProviderNeeded);
     options.tileProvider(this.tileProvider);
     return options;
   }
@@ -196,12 +196,12 @@ public class AirMapUrlTile extends AirMapFeature {
   }
 
   @Override
-  public void addToMap(GoogleMap map) {
-    this.tileOverlay = map.addTileOverlay(getTileOverlayOptions());
+  public void addToMap(Object map) {
+    this.tileOverlay = ((GoogleMap) map).addTileOverlay(getTileOverlayOptions());
   }
 
   @Override
-  public void removeFromMap(GoogleMap map) {
+  public void removeFromMap(Object map) {
     tileOverlay.remove();
   }
 }

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

@@ -0,0 +1,87 @@
+package com.rnmaps.maps;
+
+import android.content.Context;
+import android.util.DisplayMetrics;
+import android.view.WindowManager;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+public class MapUrlTileManager extends ViewGroupManager<MapUrlTile> {
+
+  public MapUrlTileManager(ReactApplicationContext reactContext) {
+    super();
+  }
+
+  @Override
+  public String getName() {
+    return "AIRMapUrlTile";
+  }
+
+  @Override
+  public MapUrlTile createViewInstance(ThemedReactContext context) {
+    return new MapUrlTile(context);
+  }
+
+  @ReactProp(name = "urlTemplate")
+  public void setUrlTemplate(MapUrlTile view, String urlTemplate) {
+    view.setUrlTemplate(urlTemplate);
+  }
+
+  @ReactProp(name = "zIndex", defaultFloat = -1.0f)
+  public void setZIndex(MapUrlTile view, float zIndex) {
+    view.setZIndex(zIndex);
+  }
+
+  @ReactProp(name = "minimumZ", defaultInt = 0)
+  public void setMinimumZ(MapUrlTile view, int minimumZ) {
+    view.setMinimumZ(minimumZ);
+  }
+
+  @ReactProp(name = "maximumZ", defaultInt = 100)
+  public void setMaximumZ(MapUrlTile view, int maximumZ) {
+    view.setMaximumZ(maximumZ);
+  }
+
+  @ReactProp(name = "maximumNativeZ", defaultInt = 100)
+  public void setMaximumNativeZ(MapUrlTile view, int maximumNativeZ) {
+    view.setMaximumNativeZ(maximumNativeZ);
+  }
+
+  @ReactProp(name = "flipY", defaultBoolean = false)
+  public void setFlipY(MapUrlTile view, boolean flipY) {
+    view.setFlipY(flipY);
+  }
+
+  @ReactProp(name = "tileSize", defaultInt = 256)
+  public void setTileSize(MapUrlTile view, int tileSize) {
+    view.setTileSize(tileSize);
+  }
+
+  @ReactProp(name = "doubleTileSize", defaultBoolean = false)
+  public void setDoubleTileSize(MapUrlTile view, boolean doubleTileSize) {
+    view.setDoubleTileSize(doubleTileSize);
+  }
+
+  @ReactProp(name = "tileCachePath")
+  public void setTileCachePath(MapUrlTile view, String tileCachePath) {
+    view.setTileCachePath(tileCachePath);
+  }
+
+  @ReactProp(name = "tileCacheMaxAge", defaultInt = 0)
+  public void setTileCacheMaxAge(MapUrlTile view, int tileCacheMaxAge) {
+    view.setTileCacheMaxAge(tileCacheMaxAge);
+  }
+
+  @ReactProp(name = "offlineMode", defaultBoolean = false)
+  public void setOfflineMode(MapUrlTile view, boolean offlineMode) {
+    view.setOfflineMode(offlineMode);
+  }
+
+  @ReactProp(name = "opacity", defaultFloat = 1.0f)
+  public void setOpacity(MapUrlTile view, float opacity) {
+    view.setOpacity(opacity);
+  }
+}