react-native-maps 1.21.0-alpha.83 → 1.21.0-alpha.84

package/android/src/main/java/com/rnmaps/fabric/MapViewManager.java

@@ -322,10 +322,6 @@ public class MapViewManager extends ViewGroupManager<MapView> implements RNMapsM
             ((MapMarker) child).setImageLoadedListener((uri, drawable, b) -> {
                 parent.addFeature(child, parent.getFeatureCount());
             });
-//        } else if (child instanceof MapOverlay && ((MapOverlay) child).isLoadingImage()){
-//            ((MapOverlay) child).setImageLoadedListener((uri, drawable, b) -> {
-//                parent.addFeature(child, parent.getFeatureCount());
-//            });
         } else {
             parent.addFeature(child, index);
         }

package/android/src/main/java/com/rnmaps/fabric/OverlayManager.java

@@ -84,7 +84,8 @@ public class OverlayManager extends ViewGroupManager<MapOverlay> implements RNMa
 
     @Override
     public void setOpacity(MapOverlay view, float value) {
-        view.setTransparency(value);
+        // todo report to google that it's not working / fix it
+       // view.setTransparency(value);
     }
 
     @Override

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

@@ -2,25 +2,29 @@ package com.rnmaps.maps;
 
 import android.content.Context;
 import android.graphics.Bitmap;
-import android.graphics.BitmapFactory;
 import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
 import android.graphics.drawable.Animatable;
-import android.graphics.drawable.Drawable;
 import android.net.Uri;
+import android.os.Handler;
+import android.os.Looper;
 
 import androidx.annotation.Nullable;
 
 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.controller.BaseControllerListener;
 import com.facebook.drawee.controller.ControllerListener;
 import com.facebook.drawee.drawable.ScalingUtils;
 import com.facebook.drawee.generic.GenericDraweeHierarchy;
 import com.facebook.drawee.generic.GenericDraweeHierarchyBuilder;
-import com.facebook.drawee.interfaces.DraweeController;
 import com.facebook.drawee.view.DraweeHolder;
 import com.facebook.imagepipeline.core.ImagePipeline;
+import com.facebook.imagepipeline.image.CloseableBitmap;
 import com.facebook.imagepipeline.image.CloseableImage;
 import com.facebook.imagepipeline.image.CloseableStaticBitmap;
 import com.facebook.imagepipeline.image.ImageInfo;
@@ -39,300 +43,262 @@ 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 implements ImageReadable {
 
 
-  private String imageUri;
-  private boolean loadingImage;
-
-  private GroundOverlayOptions groundOverlayOptions;
-  private GroundOverlay groundOverlay;
-  private LatLngBounds bounds;
-  private float bearing;
-  private BitmapDescriptor iconBitmapDescriptor;
-  private Bitmap iconBitmap;
-  private boolean tappable;
-  private float zIndex;
-  private float transparency;
-
-  private DataSource<CloseableReference<CloseableImage>> dataSource;
-
-  private final ImageReader mImageReader;
-  private GroundOverlayManager.Collection groundOverlayCollection;
-
-  private final DraweeHolder<?> logoHolder;
-  private ImageManager.OnImageLoadedListener imageLoadedListener;
-
-  public boolean isLoadingImage() {
-    return loadingImage;
-  }
-
-  public ImageManager.OnImageLoadedListener getImageLoadedListener() {
-    return imageLoadedListener;
-  }
-
-  public void setImageLoadedListener(ImageManager.OnImageLoadedListener imageLoadedListener) {
-    this.imageLoadedListener = imageLoadedListener;
-  }
-
-
-  public MapOverlay(Context context) {
-    super(context);
-    this.mImageReader = new ImageReader(context, getResources(), this);
-    logoHolder = DraweeHolder.create(createDraweeHierarchy(), context);
-    logoHolder.onAttach();
-  }
-
-  private GenericDraweeHierarchy createDraweeHierarchy() {
-    return new GenericDraweeHierarchyBuilder(getResources())
-            .setActualImageScaleType(ScalingUtils.ScaleType.FIT_CENTER)
-            .setFadeDuration(0)
-            .build();
-  }
-
-  private final ControllerListener<ImageInfo> mLogoControllerListener =
-          new BaseControllerListener<ImageInfo>() {
-            @Override
-            public void onSubmit(String id, Object callerContext){
-              loadingImage = true;
-            }
-            @Override
-            public void onFinalImageSet(
-                    String id,
-                    @Nullable final ImageInfo imageInfo,
-                    @Nullable Animatable animatable) {
-              CloseableReference<CloseableImage> imageReference = null;
-              try {
-                imageReference = dataSource.getResult();
-                if (imageReference != null) {
-                  CloseableImage image = imageReference.get();
-                  if (image instanceof CloseableStaticBitmap) {
-                    CloseableStaticBitmap closeableStaticBitmap = (CloseableStaticBitmap) image;
-                    Bitmap bitmap = closeableStaticBitmap.getUnderlyingBitmap();
-                    if (bitmap != null) {
-                      bitmap = bitmap.copy(Bitmap.Config.ARGB_8888, true);
-                      iconBitmap = bitmap;
-                      iconBitmapDescriptor = BitmapDescriptorFactory.fromBitmap(bitmap);
-                    }
-                  }
-                }
-              } finally {
-                dataSource.close();
-                if (imageReference != null) {
-                  CloseableReference.closeSafely(imageReference);
-                }
-              }
-
-              loadingImage = false;
-              if (imageLoadedListener != null){
-                imageLoadedListener.onImageLoaded(null, null, false);
-                // fire and forget
-                imageLoadedListener = null;
-              }
-              update();
-            }
-          };
-
-  // 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);
+    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();
+    }
+
+
+    // 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);
+        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);
-  }
+        LatLng sw = new LatLng(southLat, westLon);
+        LatLng ne = new LatLng(northLat, eastLon);
+        return new LatLngBounds(sw, ne);
+    }
+
+    public void setBounds(ReadableArray bounds) {
 
-  public void setBounds(ReadableArray bounds) {
+        this.bounds = fixBoundsIfNecessary(bounds);
+        if (this.groundOverlay != null) {
+            this.groundOverlay.setPositionFromBounds(this.bounds);
+        }
+    }
 
-    this.bounds = fixBoundsIfNecessary(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 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);
+        }
     }
-  }
 
-  public void setZIndex(float zIndex) {
-    this.zIndex = zIndex;
-    if (this.groundOverlay != null) {
-      this.groundOverlay.setZIndex(zIndex);
+
+    private BitmapDescriptor getBitmapDescriptorByName(String name) {
+        return BitmapDescriptorFactory.fromResource(getDrawableResourceByName(name));
     }
-  }
-
-  public void setTransparency(float transparency) {
-      this.transparency = transparency;
-      if (groundOverlay != null) {
-          groundOverlay.setTransparency(transparency);
-      }
-  }
-
-  public void setImage(String uri) {
-    this.mImageReader.setImage(uri);
-    boolean shouldLoadImage = true;
-
-    this.imageUri = uri;
-    if (!shouldLoadImage) {return;}
-
-    if (uri == null) {
-      iconBitmapDescriptor = 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);
-      DraweeController controller = Fresco.newDraweeControllerBuilder()
-              .setImageRequest(imageRequest)
-              .setControllerListener(mLogoControllerListener)
-              .setOldController(logoHolder.getController())
-              .build();
-      logoHolder.setController(controller);
-    } else {
-      iconBitmapDescriptor = getBitmapDescriptorByName(uri);
-      int drawableId = getDrawableResourceByName(uri);
-      iconBitmap = BitmapFactory.decodeResource(getResources(), drawableId);
-      if (iconBitmap == null) { // VectorDrawable or similar
-        Drawable drawable = getResources().getDrawable(drawableId);
-        iconBitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
-        drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
-        Canvas canvas = new Canvas(iconBitmap);
-        drawable.draw(canvas);
-      }
-
-  }
+
+    private int getDrawableResourceByName(String name) {
+        return getResources().getIdentifier(
+                name,
+                "drawable",
+                getContext().getPackageName());
     }
 
-  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 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 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();
+    public GroundOverlayOptions getGroundOverlayOptions() {
+        if (this.groundOverlayOptions == null) {
+            this.groundOverlayOptions = createGroundOverlayOptions();
+        }
+        return this.groundOverlayOptions;
     }
-    return this.groundOverlayOptions;
-  }
 
-  private GroundOverlayOptions createGroundOverlayOptions() {
-    if (this.groundOverlayOptions != null) {
-      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;
     }
-    GroundOverlayOptions options = new GroundOverlayOptions();
-    if (this.iconBitmapDescriptor != null) {
-      options.image(iconBitmapDescriptor);
-    } 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);
+
+    @Override
+    public Object getFeature() {
+        return groundOverlay;
     }
-    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 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;
+
+    @Override
+    public void removeFromMap(Object collection) {
+        if (groundOverlay != null) {
+            GroundOverlayManager.Collection groundOverlayCollection = (GroundOverlayManager.Collection) collection;
+            groundOverlayCollection.remove(groundOverlay);
+            groundOverlay = null;
+            groundOverlayOptions = null;
+        }
+        groundOverlayCollection = null;
     }
-    groundOverlayCollection = null;
-  }
-
-  @Override
-  public void setIconBitmap(Bitmap bitmap) {
-  }
-
-  @Override
-  public void setIconBitmapDescriptor(
-      BitmapDescriptor iconBitmapDescriptor) {
-    this.iconBitmapDescriptor = iconBitmapDescriptor;
-  }
-
-  @Override
-  public void update() {
-    this.groundOverlay = getGroundOverlay();
-    if (this.groundOverlay != null) {
-      this.groundOverlay.setVisible(true);
-      this.groundOverlay.setImage(this.iconBitmapDescriptor);
-      this.groundOverlay.setTransparency(this.transparency);
-      this.groundOverlay.setClickable(this.tappable);
+
+    @Override
+    public void setIconBitmap(Bitmap bitmap) {
     }
-  }
 
-  private GroundOverlay getGroundOverlay() {
-    if (this.groundOverlay != null) {
-      return this.groundOverlay;
+    @Override
+    public void setBitmapDescriptor(
+            BitmapDescriptor bitmapDescriptor) {
+        this.bitmapDescriptor = bitmapDescriptor;
     }
-    if (this.groundOverlayCollection == null) {
-      return null;
+
+    @Override
+    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);
+        }
     }
-    GroundOverlayOptions groundOverlayOptions = getGroundOverlayOptions();
-    if (groundOverlayOptions != null) {
-      return this.groundOverlayCollection.addGroundOverlay(groundOverlayOptions);
+
+    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;
     }
-    return null;
-  }
 }

package/lib/MapOverlay.js

@@ -54,7 +54,6 @@ class MapOverlay extends React.Component {
                 image = resolvedImage.uri || this.props.image;
             }
         }
-        console.log('MapOverlay image: ' + image);
         return (<AIRMapOverlay {...this.props} opacity={opacity} 
         // @ts-ignore
         image={image} style={[styles.overlay, this.props.style]}/>);

package/package.json

@@ -5,7 +5,7 @@
   "main": "lib/index.js",
   "author": "Leland Richardson <leland.m.richardson@gmail.com>",
   "homepage": "https://github.com/react-native-maps/react-native-maps#readme",
-  "version": "1.21.0-alpha.83",
+  "version": "1.21.0-alpha.84",
   "license": "MIT",
   "scripts": {
     "lint": "eslint . --max-warnings 0",