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

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

@@ -0,0 +1,368 @@
+package com.rnmaps.maps;
+
+import android.graphics.Bitmap;
+import android.graphics.Color;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.R;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.LayoutShadowNode;
+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.Marker;
+import com.google.android.gms.maps.model.BitmapDescriptor;
+import com.google.android.gms.maps.model.LatLng;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.WeakHashMap;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class MapMarkerManager extends ViewGroupManager<MapMarker> {
+
+    public static class AirMapMarkerSharedIcon {
+        private BitmapDescriptor iconBitmapDescriptor;
+        private Bitmap bitmap;
+        private final Map<MapMarker, Boolean> markers;
+        private boolean loadImageStarted;
+
+        public AirMapMarkerSharedIcon() {
+            this.markers = new WeakHashMap<>();
+            this.loadImageStarted = false;
+        }
+
+        /**
+         * check whether the load image process started.
+         * caller AirMapMarker will only need to load it when this returns true.
+         *
+         * @return true if it is not started, false otherwise.
+         */
+        public synchronized boolean shouldLoadImage() {
+            if (!this.loadImageStarted) {
+                this.loadImageStarted = true;
+                return true;
+            }
+            return false;
+        }
+
+        /**
+         * subscribe icon update for given marker.
+         * <p>
+         * The marker is wrapped in weakReference, so no need to remove it explicitly.
+         *
+         * @param marker
+         */
+        public synchronized void addMarker(MapMarker marker) {
+            this.markers.put(marker, true);
+            if (this.iconBitmapDescriptor != null) {
+                marker.setIconBitmapDescriptor(this.iconBitmapDescriptor, this.bitmap);
+            }
+        }
+
+        /**
+         * Remove marker from this shared icon.
+         * <p>
+         * Marker will only need to call it when the marker receives a different marker image uri.
+         *
+         * @param marker
+         */
+        public synchronized void removeMarker(MapMarker marker) {
+            this.markers.remove(marker);
+        }
+
+        /**
+         * check if there is markers still listening on this icon.
+         * when there are not markers listen on it, we can remove it.
+         *
+         * @return true if there is, false otherwise
+         */
+        public synchronized boolean hasMarker() {
+            return this.markers.isEmpty();
+        }
+
+        /**
+         * Update the bitmap descriptor and bitmap for the image uri.
+         * And notify all subscribers about the update.
+         *
+         * @param bitmapDescriptor
+         * @param bitmap
+         */
+        public synchronized void updateIcon(BitmapDescriptor bitmapDescriptor, Bitmap bitmap) {
+
+            this.iconBitmapDescriptor = bitmapDescriptor;
+            this.bitmap = bitmap.copy(Bitmap.Config.ARGB_8888, true);
+
+            if (this.markers.isEmpty()) {
+                return;
+            }
+
+            for (Map.Entry<MapMarker, Boolean> markerEntry : markers.entrySet()) {
+                if (markerEntry.getKey() != null) {
+                    markerEntry.getKey().setIconBitmapDescriptor(bitmapDescriptor, bitmap);
+                }
+            }
+        }
+    }
+
+    private final Map<String, AirMapMarkerSharedIcon> sharedIcons = new ConcurrentHashMap<>();
+
+    /**
+     * get the shared icon object, if not existed, create a new one and store it.
+     *
+     * @param uri
+     * @return the icon object for the given uri.
+     */
+    public AirMapMarkerSharedIcon getSharedIcon(String uri) {
+        AirMapMarkerSharedIcon icon = this.sharedIcons.get(uri);
+        if (icon == null) {
+            synchronized (this) {
+                if ((icon = this.sharedIcons.get(uri)) == null) {
+                    icon = new AirMapMarkerSharedIcon();
+                    this.sharedIcons.put(uri, icon);
+                }
+            }
+        }
+        return icon;
+    }
+
+    /**
+     * Remove the share icon object from our sharedIcons map when no markers are listening for it.
+     *
+     * @param uri
+     */
+    public void removeSharedIconIfEmpty(String uri) {
+        AirMapMarkerSharedIcon icon = this.sharedIcons.get(uri);
+        if (icon == null) {
+            return;
+        }
+        if (!icon.hasMarker()) {
+            synchronized (this) {
+                if ((icon = this.sharedIcons.get(uri)) != null && !icon.hasMarker()) {
+                    this.sharedIcons.remove(uri);
+                }
+            }
+        }
+    }
+
+    public MapMarkerManager() {
+    }
+
+    @Override
+    public String getName() {
+        return "AIRMapMarker";
+    }
+
+    @Override
+    public MapMarker createViewInstance(ThemedReactContext context) {
+        return new MapMarker(context, this);
+    }
+
+    @ReactProp(name = "coordinate")
+    public void setCoordinate(MapMarker view, ReadableMap map) {
+        view.setCoordinate(map);
+    }
+
+    @ReactProp(name = "title")
+    public void setTitle(MapMarker view, String title) {
+        view.setTitle(title);
+    }
+
+    @ReactProp(name = "identifier")
+    public void setIdentifier(MapMarker view, String identifier) {
+        view.setIdentifier(identifier);
+    }
+
+    @ReactProp(name = "description")
+    public void setDescription(MapMarker view, String description) {
+        view.setSnippet(description);
+    }
+
+    // NOTE(lmr):
+    // android uses normalized coordinate systems for this, and is provided through the
+    // `anchor` property  and `calloutAnchor` instead.  Perhaps some work could be done
+    // to normalize iOS and android to use just one of the systems.
+//    @ReactProp(name = "centerOffset")
+//    public void setCenterOffset(AirMapMarker view, ReadableMap map) {
+//
+//    }
+//
+//    @ReactProp(name = "calloutOffset")
+//    public void setCalloutOffset(AirMapMarker view, ReadableMap map) {
+//
+//    }
+
+    @ReactProp(name = "anchor")
+    public void setAnchor(MapMarker view, ReadableMap map) {
+        // should default to (0.5, 1) (bottom middle)
+        double x = map != null && map.hasKey("x") ? map.getDouble("x") : 0.5;
+        double y = map != null && map.hasKey("y") ? map.getDouble("y") : 1.0;
+        view.setAnchor(x, y);
+    }
+
+    @ReactProp(name = "calloutAnchor")
+    public void setCalloutAnchor(MapMarker view, ReadableMap map) {
+        // should default to (0.5, 0) (top middle)
+        double x = map != null && map.hasKey("x") ? map.getDouble("x") : 0.5;
+        double y = map != null && map.hasKey("y") ? map.getDouble("y") : 0.0;
+        view.setCalloutAnchor(x, y);
+    }
+
+    @ReactProp(name = "image")
+    public void setImage(MapMarker view, @Nullable String source) {
+        view.setImage(source);
+    }
+//    public void setImage(AirMapMarker view, ReadableMap image) {
+//        view.setImage(image);
+//    }
+
+    @ReactProp(name = "icon")
+    public void setIcon(MapMarker view, @Nullable String source) {
+        view.setImage(source);
+    }
+
+    @ReactProp(name = "pinColor", defaultInt = Color.RED, customType = "Color")
+    public void setPinColor(MapMarker view, int pinColor) {
+        float[] hsv = new float[3];
+        Color.colorToHSV(pinColor, hsv);
+        // NOTE: android only supports a hue
+        view.setMarkerHue(hsv[0]);
+    }
+
+    @ReactProp(name = "rotation", defaultFloat = 0.0f)
+    public void setMarkerRotation(MapMarker view, float rotation) {
+        view.setRotation(rotation);
+    }
+
+    @ReactProp(name = "flat", defaultBoolean = false)
+    public void setFlat(MapMarker view, boolean flat) {
+        view.setFlat(flat);
+    }
+
+    @ReactProp(name = "draggable", defaultBoolean = false)
+    public void setDraggable(MapMarker view, boolean draggable) {
+        view.setDraggable(draggable);
+    }
+
+    @Override
+    @ReactProp(name = "zIndex", defaultFloat = 0.0f)
+    public void setZIndex(MapMarker view, float zIndex) {
+        super.setZIndex(view, zIndex);
+        int integerZIndex = Math.round(zIndex);
+        view.setZIndex(integerZIndex);
+    }
+
+    @Override
+    @ReactProp(name = "opacity", defaultFloat = 1.0f)
+    public void setOpacity(MapMarker view, float opacity) {
+        super.setOpacity(view, opacity);
+        view.setOpacity(opacity);
+    }
+
+    @ReactProp(name = "tracksViewChanges", defaultBoolean = true)
+    public void setTracksViewChanges(MapMarker view, boolean tracksViewChanges) {
+        view.setTracksViewChanges(tracksViewChanges);
+    }
+
+    @ReactProp(name = "accessibilityLabel")
+    public void setAccessibilityLabel(MapMarker view, @Nullable String accessibilityLabel) {
+        view.setTag(R.id.accessibility_label, accessibilityLabel);
+    }
+
+    @Override
+    public void addView(MapMarker parent, View child, int index) {
+        // if an <Callout /> component is a child, then it is a callout view, NOT part of the
+        // marker.
+        if (child instanceof MapCallout) {
+            parent.setCalloutView((MapCallout) child);
+        } else {
+            super.addView(parent, child, index);
+            parent.update(true);
+        }
+    }
+
+    @Override
+    public void removeViewAt(MapMarker parent, int index) {
+        super.removeViewAt(parent, index);
+        parent.update(true);
+    }
+
+    @Override
+    public void receiveCommand(@NonNull MapMarker view, String commandId, @Nullable ReadableArray args) {
+        int duration;
+        double lat;
+        double lng;
+        ReadableMap region;
+
+        switch (commandId) {
+            case "showCallout":
+                ((Marker) view.getFeature()).showInfoWindow();
+                break;
+
+            case "hideCallout":
+                ((Marker) view.getFeature()).hideInfoWindow();
+                break;
+
+            case "animateMarkerToCoordinate":
+                if (args == null) {
+                    break;
+                }
+                region = args.getMap(0);
+                duration = args.getInt(1);
+
+                lng = region.getDouble("longitude");
+                lat = region.getDouble("latitude");
+                view.animateToCoodinate(new LatLng(lat, lng), duration);
+                break;
+
+            case "redraw":
+                view.updateMarkerIcon();
+                break;
+        }
+    }
+
+    @Override
+    @Nullable
+    public Map getExportedCustomDirectEventTypeConstants() {
+        return MapBuilder.<String, Map<String, String>>builder()
+                .put("onCalloutPress", MapBuilder.of("registrationName", "onCalloutPress"))
+                .put("onDragStart", MapBuilder.of("registrationName", "onDragStart"))
+                .put("onDrag", MapBuilder.of("registrationName", "onDrag"))
+                .put("onDragEnd", MapBuilder.of("registrationName", "onDragEnd"))
+                .put("onSelect", MapBuilder.of("registrationName", "onSelect"))
+                .put("onDeselect", MapBuilder.of("registrationName", "onDeselect"))
+                .build();
+    }
+
+    @Override
+    @Nullable
+    public Map getExportedCustomBubblingEventTypeConstants() {
+        return MapBuilder.<String, Map<String, Object>>builder()
+                .put("onPress", MapBuilder.of("phasedRegistrationNames", MapBuilder.of("bubbled", "onPress")))
+                .build();
+    }
+
+
+    @Override
+    public LayoutShadowNode createShadowNodeInstance() {
+        // we use a custom shadow node that emits the width/height of the view
+        // after layout with the updateExtraData method. Without this, we can't generate
+        // a bitmap of the appropriate width/height of the rendered view.
+        return new SizeReportingShadowNode();
+    }
+
+    @Override
+    public void updateExtraData(MapMarker view, Object extraData) {
+        // This method is called from the shadow node with the width/height of the rendered
+        // marker view.
+        HashMap<String, Float> data = (HashMap<String, Float>) extraData;
+        float width = data.get("width");
+        float height = data.get("height");
+        view.update((int) width, (int) height);
+    }
+}

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

@@ -0,0 +1,283 @@
+package com.rnmaps.maps;
+
+import android.app.Activity;
+import android.graphics.Bitmap;
+import android.graphics.Point;
+import android.location.Address;
+import android.location.Geocoder;
+import android.net.Uri;
+import android.util.Base64;
+import android.util.DisplayMetrics;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.google.android.gms.maps.GoogleMap;
+import com.google.android.gms.maps.model.CameraPosition;
+import com.google.android.gms.maps.model.LatLng;
+
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@ReactModule(name = MapModule.NAME)
+public class MapModule extends ReactContextBaseJavaModule {
+
+    public static final String NAME = "AirMapModule";
+    public static final String SNAPSHOT_RESULT_FILE = "file";
+    public static final String SNAPSHOT_RESULT_BASE64 = "base64";
+    public static final String SNAPSHOT_FORMAT_PNG = "png";
+    public static final String SNAPSHOT_FORMAT_JPG = "jpg";
+
+    public MapModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public Map<String, Object> getConstants() {
+        final Map<String, Object> constants = new HashMap<>();
+        constants.put("legalNotice", "This license information is displayed in Settings > Google > Open Source on any device running Google Play services.");
+        return constants;
+    }
+
+    public Activity getActivity() {
+        return getCurrentActivity();
+    }
+
+    public static void closeQuietly(Closeable closeable) {
+        if (closeable == null) return;
+        try {
+            closeable.close();
+        } catch (IOException ignored) {
+        }
+    }
+
+    @ReactMethod
+    public void takeSnapshot(final int tag, final ReadableMap options, final Promise promise) {
+
+        // Parse and verity options
+        final ReactApplicationContext context = getReactApplicationContext();
+        final String format = options.hasKey("format") ? options.getString("format") : "png";
+        final Bitmap.CompressFormat compressFormat =
+                format.equals(SNAPSHOT_FORMAT_PNG) ? Bitmap.CompressFormat.PNG :
+                        format.equals(SNAPSHOT_FORMAT_JPG) ? Bitmap.CompressFormat.JPEG : null;
+        final double quality = options.hasKey("quality") ? options.getDouble("quality") : 1.0;
+        final DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
+        final Integer width =
+                options.hasKey("width") ? (int) (displayMetrics.density * options.getDouble("width")) : 0;
+        final Integer height =
+                options.hasKey("height") ? (int) (displayMetrics.density * options.getDouble("height")) : 0;
+        final String result = options.hasKey("result") ? options.getString("result") : "file";
+
+        MapUIBlock uiBlock = new MapUIBlock(tag, promise, context, view -> {
+            view.map.snapshot(new GoogleMap.SnapshotReadyCallback() {
+                public void onSnapshotReady(@Nullable Bitmap snapshot) {
+
+                    // Convert image to requested width/height if necessary
+                    if (snapshot == null) {
+                        promise.reject("Failed to generate bitmap, snapshot = null");
+                        return;
+                    }
+                    if ((width != 0) && (height != 0) &&
+                            (width != snapshot.getWidth() || height != snapshot.getHeight())) {
+                        snapshot = Bitmap.createScaledBitmap(snapshot, width, height, true);
+                    }
+
+                    // Save the snapshot to disk
+                    if (result.equals(SNAPSHOT_RESULT_FILE)) {
+                        File tempFile;
+                        FileOutputStream outputStream;
+                        try {
+                            tempFile =
+                                    File.createTempFile("AirMapSnapshot", "." + format, context.getCacheDir());
+                            outputStream = new FileOutputStream(tempFile);
+                        } catch (Exception e) {
+                            promise.reject(e);
+                            return;
+                        }
+                        snapshot.compress(compressFormat, (int) (100.0 * quality), outputStream);
+                        closeQuietly(outputStream);
+                        String uri = Uri.fromFile(tempFile).toString();
+                        promise.resolve(uri);
+                    } else if (result.equals(SNAPSHOT_RESULT_BASE64)) {
+                        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+                        snapshot.compress(compressFormat, (int) (100.0 * quality), outputStream);
+                        closeQuietly(outputStream);
+                        byte[] bytes = outputStream.toByteArray();
+                        String data = Base64.encodeToString(bytes, Base64.NO_WRAP);
+                        promise.resolve(data);
+                    }
+                }
+            });
+
+            return null;
+        });
+
+        // Add UI-block so we can get a valid reference to the map-view
+
+        uiBlock.addToUIManager();
+    }
+
+    @ReactMethod
+    public void getCamera(final int tag, final Promise promise) {
+        final ReactApplicationContext context = getReactApplicationContext();
+
+        MapUIBlock uiBlock = new MapUIBlock(tag, promise, context, view -> {
+            CameraPosition position = view.map.getCameraPosition();
+
+            WritableMap centerJson = new WritableNativeMap();
+            centerJson.putDouble("latitude", position.target.latitude);
+            centerJson.putDouble("longitude", position.target.longitude);
+
+            WritableMap cameraJson = new WritableNativeMap();
+            cameraJson.putMap("center", centerJson);
+            cameraJson.putDouble("heading", (double) position.bearing);
+            cameraJson.putDouble("zoom", (double) position.zoom);
+            cameraJson.putDouble("pitch", (double) position.tilt);
+
+            promise.resolve(cameraJson);
+
+            return null;
+        });
+
+        uiBlock.addToUIManager();
+    }
+
+    @ReactMethod
+    public void getAddressFromCoordinates(final int tag, final ReadableMap coordinate, final Promise promise) {
+        final ReactApplicationContext context = getReactApplicationContext();
+
+        MapUIBlock uiBlock = new MapUIBlock(tag, promise, context, mapView -> {
+            if (coordinate == null ||
+                    !coordinate.hasKey("latitude") ||
+                    !coordinate.hasKey("longitude")) {
+                promise.reject("Invalid coordinate format");
+                return null;
+            }
+            Geocoder geocoder = new Geocoder(context);
+            try {
+                List<Address> list =
+                        geocoder.getFromLocation(coordinate.getDouble("latitude"), coordinate.getDouble("longitude"), 1);
+                if (list.isEmpty()) {
+                    promise.reject("Can not get address location");
+                    return null;
+                }
+                Address address = list.get(0);
+
+                WritableMap addressJson = new WritableNativeMap();
+                addressJson.putString("name", address.getFeatureName());
+                addressJson.putString("locality", address.getLocality());
+                addressJson.putString("thoroughfare", address.getThoroughfare());
+                addressJson.putString("subThoroughfare", address.getSubThoroughfare());
+                addressJson.putString("subLocality", address.getSubLocality());
+                addressJson.putString("administrativeArea", address.getAdminArea());
+                addressJson.putString("subAdministrativeArea", address.getSubAdminArea());
+                addressJson.putString("postalCode", address.getPostalCode());
+                addressJson.putString("countryCode", address.getCountryCode());
+                addressJson.putString("country", address.getCountryName());
+
+                promise.resolve(addressJson);
+            } catch (IOException e) {
+                promise.reject("Can not get address location");
+            }
+
+            return null;
+        });
+
+        uiBlock.addToUIManager();
+    }
+
+    @ReactMethod
+    public void pointForCoordinate(final int tag, ReadableMap coordinate, final Promise promise) {
+        final ReactApplicationContext context = getReactApplicationContext();
+        final double density = (double) context.getResources().getDisplayMetrics().density;
+
+        final LatLng coord = new LatLng(
+                coordinate.hasKey("latitude") ? coordinate.getDouble("latitude") : 0.0,
+                coordinate.hasKey("longitude") ? coordinate.getDouble("longitude") : 0.0
+        );
+
+        MapUIBlock uiBlock = new MapUIBlock(tag, promise, context, view -> {
+            Point pt = view.map.getProjection().toScreenLocation(coord);
+
+            WritableMap ptJson = new WritableNativeMap();
+            ptJson.putDouble("x", (double) pt.x / density);
+            ptJson.putDouble("y", (double) pt.y / density);
+
+            promise.resolve(ptJson);
+
+            return null;
+        });
+
+        uiBlock.addToUIManager();
+    }
+
+    @ReactMethod
+    public void coordinateForPoint(final int tag, ReadableMap point, final Promise promise) {
+        final ReactApplicationContext context = getReactApplicationContext();
+        final double density = (double) context.getResources().getDisplayMetrics().density;
+
+        final Point pt = new Point(
+                point.hasKey("x") ? (int) (point.getDouble("x") * density) : 0,
+                point.hasKey("y") ? (int) (point.getDouble("y") * density) : 0
+        );
+
+        MapUIBlock uiBlock = new MapUIBlock(tag, promise, context, view -> {
+            LatLng coord = view.map.getProjection().fromScreenLocation(pt);
+
+            WritableMap coordJson = new WritableNativeMap();
+            coordJson.putDouble("latitude", coord.latitude);
+            coordJson.putDouble("longitude", coord.longitude);
+
+            promise.resolve(coordJson);
+
+            return null;
+        });
+
+        uiBlock.addToUIManager();
+    }
+
+    @ReactMethod
+    public void getMapBoundaries(final int tag, final Promise promise) {
+        final ReactApplicationContext context = getReactApplicationContext();
+
+        MapUIBlock uiBlock = new MapUIBlock(tag, promise, context, view -> {
+            double[][] boundaries = view.getMapBoundaries();
+
+            WritableMap coordinates = new WritableNativeMap();
+            WritableMap northEastHash = new WritableNativeMap();
+            WritableMap southWestHash = new WritableNativeMap();
+
+            northEastHash.putDouble("longitude", boundaries[0][0]);
+            northEastHash.putDouble("latitude", boundaries[0][1]);
+            southWestHash.putDouble("longitude", boundaries[1][0]);
+            southWestHash.putDouble("latitude", boundaries[1][1]);
+
+            coordinates.putMap("northEast", northEastHash);
+            coordinates.putMap("southWest", southWestHash);
+
+            promise.resolve(coordinates);
+
+            return null;
+        });
+
+        uiBlock.addToUIManager();
+    }
+}