react-native-maps 1.21.0-alpha.8 → 1.21.0-alpha.80

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

@@ -0,0 +1,259 @@
+package com.rnmaps.fabric;
+
+
+import android.graphics.Color;
+import android.util.Log;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.uimanager.ReactStylesDiffMap;
+import com.facebook.react.uimanager.StateWrapper;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.ViewManagerDelegate;
+import com.facebook.react.viewmanagers.RNMapsMarkerManagerDelegate;
+import com.facebook.react.viewmanagers.RNMapsMarkerManagerInterface;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.android.gms.maps.model.Marker;
+import com.google.android.gms.maps.model.MarkerOptions;
+import com.rnmaps.maps.MapCallout;
+import com.rnmaps.maps.MapMarker;
+
+import java.util.Map;
+
+@ReactModule(name = MarkerManager.REACT_CLASS)
+public class MarkerManager extends ViewGroupManager<MapMarker> implements RNMapsMarkerManagerInterface<MapMarker> {
+
+
+    public MarkerManager(ReactApplicationContext context){
+        super(context);
+    }
+    private final RNMapsMarkerManagerDelegate<MapMarker, MarkerManager> delegate =
+            new RNMapsMarkerManagerDelegate<>(this);
+
+    @Override
+    public ViewManagerDelegate<MapMarker> getDelegate() {
+        return delegate;
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    public MapMarker createViewInstance(ThemedReactContext context) {
+        return new MapMarker(context, null);
+    }
+    private MarkerOptions optionsForInitialProps(ReactStylesDiffMap initialProps){
+        MarkerOptions options = new MarkerOptions();
+        if (initialProps != null) {
+            if (initialProps.hasKey("opacity")) {
+                options.alpha(initialProps.getFloat("opacity", 1));
+            }
+            if (initialProps.hasKey("anchor")) {
+                ReadableMap map = initialProps.getMap("anchor");
+                float x = (float) (map != null && map.hasKey("x") ? map.getDouble("x") : 0.5);
+                float y = (float) (map != null && map.hasKey("y") ? map.getDouble("y") : 1.0);
+                options.anchor(x, y);
+            }
+
+            if (initialProps.hasKey("coordinate")) {
+                ReadableMap coordinate = initialProps.getMap("coordinate");
+                LatLng position = new LatLng(coordinate.getDouble("latitude"), coordinate.getDouble("longitude"));
+                options.position(position);
+            }
+            if (initialProps.hasKey("title")) {
+                options.title(initialProps.getString("title"));
+            }
+            if (initialProps.hasKey("description")) {
+                options.snippet(initialProps.getString("description"));
+            }
+            if (initialProps.hasKey("draggable")){
+                options.draggable(initialProps.getBoolean("draggable", false));
+            }
+            if (initialProps.hasKey("rotation")){
+                options.rotation(initialProps.getFloat("rotation", 0));
+            }
+            if (initialProps.hasKey("flat")) {
+                options.flat(initialProps.getBoolean("flat", false));
+            }
+            if (initialProps.hasKey("calloutAnchor")){
+                ReadableMap map = initialProps.getMap("calloutAnchor");
+                float x = (float) (map != null && map.hasKey("x") ? map.getDouble("x") : 0.5);
+                float y = (float) (map != null && map.hasKey("y") ? map.getDouble("y") : 1.0);
+                options.infoWindowAnchor(x, y);
+            }
+
+            if (initialProps.hasKey("zIndex")){
+                options.zIndex(initialProps.getFloat("zIndex", 0));
+            }
+        }
+        return options;
+    }
+
+    @Override
+    protected MapMarker createViewInstance(int reactTag, @NonNull ThemedReactContext reactContext, @Nullable ReactStylesDiffMap initialProps, @Nullable StateWrapper stateWrapper) {
+        MapMarker view = null;
+        view = new MapMarker(reactContext, optionsForInitialProps(initialProps), null);
+        view.setId(reactTag);
+        this.addEventEmitters(reactContext, view);
+        if (initialProps != null) {
+            this.updateProperties(view, initialProps);
+        }
+        if (stateWrapper != null) {
+            Object extraData = this.updateState(view, initialProps, stateWrapper);
+            if (extraData != null) {
+                this.updateExtraData(view, extraData);
+            }
+        }
+        return view;
+    }
+
+
+    public static final String REACT_CLASS = "RNMapsMarker";
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomBubblingEventTypeConstants() {
+        return MapMarker.getExportedCustomBubblingEventTypeConstants();
+    }
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        return MapMarker.getExportedCustomDirectEventTypeConstants();
+    }
+
+    @Override
+    public void setAnchor(MapMarker view, @Nullable ReadableMap map) {
+        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);
+    }
+
+    @Override
+    public void setCalloutAnchor(MapMarker view, @Nullable ReadableMap value) {
+
+    }
+
+    @Override
+    public void setImage(MapMarker view, @Nullable ReadableMap value) {
+        view.setImage(value.getString("uri"));
+    }
+
+    @Override
+    public void setCalloutOffset(MapMarker view, @Nullable ReadableMap value) {
+
+    }
+
+    @Override
+    public void setDisplayPriority(MapMarker view, @Nullable String value) {
+
+    }
+
+    @Override
+    public void setCoordinate(MapMarker view, @Nullable ReadableMap value) {
+        view.setCoordinate(value);
+    }
+
+    @Override
+    public void setDescription(MapMarker view, @Nullable String value) {
+        view.setSnippet(value);
+    }
+
+    @Override
+    public void setDraggable(MapMarker view, boolean value) {
+        view.setDraggable(value);
+    }
+
+    @Override
+    public void setTitle(MapMarker view, @Nullable String value) {
+        view.setTitle(value);
+    }
+
+    @Override
+    public void setIdentifier(MapMarker view, @Nullable String value) {
+        view.setIdentifier(value);
+    }
+
+    @Override
+    public void setIsPreselected(MapMarker view, boolean value) {
+
+    }
+
+    @Override
+    public void setOpacity(MapMarker view, double value) {
+        view.setOpacity((float) value);
+    }
+
+    @Override
+    public void setPinColor(MapMarker view, @Nullable Integer value) {
+        float[] hsv = new float[3];
+        Color.colorToHSV(value, hsv);
+        // NOTE: android only supports a hue
+        view.setMarkerHue(hsv[0]);
+    }
+
+    @Override
+    public void setTitleVisibility(MapMarker view, @Nullable String value) {
+
+    }
+
+    @Override
+    public void setSubtitleVisibility(MapMarker view, @Nullable String value) {
+
+    }
+
+    @Override
+    public void setUseLegacyPinView(MapMarker view, boolean value) {
+
+    }
+
+    @Override
+    public void animateToCoordinates(MapMarker view, double latitude, double longitude, int duration) {
+        view.animateToCoodinate(new LatLng(latitude, longitude), duration);
+    }
+
+    @Override
+    public void setCoordinates(MapMarker view, double latitude, double longitude) {
+            view.setCoordinate(new LatLng(latitude, longitude));
+    }
+
+    @Override
+    public void showCallout(MapMarker view) {
+        ((Marker) view.getFeature()).showInfoWindow();
+
+    }
+
+    @Override
+    public void hideCallout(MapMarker view) {
+        ((Marker) view.getFeature()).hideInfoWindow();
+    }
+
+    @Override
+    public void redrawCallout(MapMarker view) {
+
+    }
+
+    @Override
+    public void redraw(MapMarker view) {
+
+    }
+    @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);
+        }
+    }
+}

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

@@ -1,8 +1,38 @@
 package com.rnmaps.fabric;
 
+import static com.rnmaps.maps.MapModule.SNAPSHOT_FORMAT_JPG;
+import static com.rnmaps.maps.MapModule.SNAPSHOT_FORMAT_PNG;
+import static com.rnmaps.maps.MapModule.SNAPSHOT_RESULT_BASE64;
+import static com.rnmaps.maps.MapModule.SNAPSHOT_RESULT_FILE;
+import static com.rnmaps.maps.MapModule.closeQuietly;
+
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.util.Base64;
+import android.util.DisplayMetrics;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.fbreact.specs.NativeAirMapsModuleSpec;
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.UIManager;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.google.android.gms.maps.GoogleMap;
+import com.google.android.gms.maps.model.CameraPosition;
+import com.rnmaps.maps.MapUIBlock;
+import com.rnmaps.maps.MapView;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
 
 public class NativeAirMapsModule extends NativeAirMapsModuleSpec {
     public NativeAirMapsModule(ReactApplicationContext reactContext) {
@@ -16,22 +46,144 @@ public class NativeAirMapsModule extends NativeAirMapsModuleSpec {
 
     @Override
     public void getCamera(double tag, Promise promise) {
-
+        UIManager uiManager = UIManagerHelper.getUIManagerForReactTag(getReactApplicationContext(), (int) tag);
+        getReactApplicationContext().runOnUiQueueThread(new Runnable() {
+            @Override
+            public void run() {
+                MapView view = (MapView) uiManager.resolveView((int) tag);
+                CameraPosition position = view.map.getCameraPosition();
+                WritableMap map = Arguments.createMap();
+                WritableMap center = Arguments.createMap();
+                center.putDouble("latitude", position.target.latitude);
+                center.putDouble("longitude", position.target.longitude);
+                map.putMap("center", center);
+                map.putDouble("heading", position.bearing);
+                map.putDouble("pitch", position.tilt);
+                map.putDouble("zoom", position.zoom);
+                promise.resolve(map);
+            }
+        });
     }
 
     @Override
     public void getMarkersFrames(double tag, boolean onlyVisible, Promise promise) {
 
+        UIManager uiManager = UIManagerHelper.getUIManagerForReactTag(getReactApplicationContext(), (int) tag);
+        getReactApplicationContext().runOnUiQueueThread(() -> {
+            MapView view = (MapView) uiManager.resolveView((int) tag);
+            double[][] boundaries = view.getMarkersFrames(onlyVisible);
+            if (boundaries != null) {
+                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);
+            } else {
+                promise.resolve(null);
+            }
+        });
     }
 
     @Override
     public void getMapBoundaries(double tag, Promise promise) {
-
+        UIManager uiManager = UIManagerHelper.getUIManagerForReactTag(getReactApplicationContext(), (int) tag);
+        getReactApplicationContext().runOnUiQueueThread(() -> {
+            MapView view = (MapView) uiManager.resolveView((int) tag);
+            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);
+        });
     }
 
     @Override
-    public void takeSnapshot(double tag, ReadableMap config, Promise promise) {
-
+    public void takeSnapshot(double tag, String config, Promise promise) {
+        WritableMap options = null;
+        try {
+            if (config != null) {
+                JSONObject jsonObject = new JSONObject(config);
+                options = JSONUtil.convertJsonToWritable(jsonObject);
+                WritableMap finalOptions = options;
+
+                final ReactApplicationContext context = getReactApplicationContext();
+                final String format = finalOptions.hasKey("format") ? finalOptions.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 = finalOptions.hasKey("quality") ? finalOptions.getDouble("quality") : 1.0;
+                final DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
+                final Integer width =
+                        finalOptions.hasKey("width") ? (int) (displayMetrics.density * finalOptions.getDouble("width")) : 0;
+                final Integer height =
+                        finalOptions.hasKey("height") ? (int) (displayMetrics.density * finalOptions.getDouble("height")) : 0;
+                final String result = finalOptions.hasKey("result") ? finalOptions.getString("result") : "file";
+
+                UIManager uiManager = UIManagerHelper.getUIManagerForReactTag(getReactApplicationContext(), (int) tag);
+                getReactApplicationContext().runOnUiQueueThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        MapView view = (MapView) uiManager.resolveView((int) tag);
+                        view.map.snapshot(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);
+                            }
+                        });
+                    }
+                });
+            }
+        } catch (JSONException e) {
+            promise.reject("Failed to parse config ", config);
+
+        }
     }
 
     @Override

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

@@ -0,0 +1,89 @@
+package com.rnmaps.fabric;
+
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.ViewManagerDelegate;
+import com.facebook.react.viewmanagers.RNMapsGooglePolygonManagerDelegate;
+import com.facebook.react.viewmanagers.RNMapsGooglePolygonManagerInterface;
+import com.rnmaps.maps.MapPolygon;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@ReactModule(name = PolygonManager.REACT_CLASS)
+public class PolygonManager extends ViewGroupManager<MapPolygon> implements RNMapsGooglePolygonManagerInterface<MapPolygon> {
+
+    public PolygonManager(ReactApplicationContext context){
+        super(context);
+    }//
+    private final RNMapsGooglePolygonManagerDelegate<MapPolygon, PolygonManager> delegate =
+            new RNMapsGooglePolygonManagerDelegate<>(this);
+
+    @Override
+    public ViewManagerDelegate<MapPolygon> getDelegate() {
+        return delegate;
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    public MapPolygon createViewInstance(ThemedReactContext context) {
+        return new MapPolygon(context);
+    }
+
+
+
+    public static final String REACT_CLASS = "RNMapsGooglePolygon";
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomBubblingEventTypeConstants() {
+        return MapPolygon.getExportedCustomBubblingEventTypeConstants();
+    }
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        return new HashMap<>();
+    }
+
+
+    @Override
+    public void setCoordinates(MapPolygon view, @Nullable ReadableArray value) {
+        view.setCoordinates(value);
+    }
+
+    @Override
+    public void setFillColor(MapPolygon view, @Nullable Integer value) {
+        view.setFillColor(value);
+    }
+
+    @Override
+    public void setStrokeColor(MapPolygon view, @Nullable Integer value) {
+        view.setStrokeColor(value);
+    }
+
+    @Override
+    public void setGeodesic(MapPolygon view, boolean value) {
+        view.setGeodesic(value);
+    }
+
+    @Override
+    public void setHoles(MapPolygon view, @Nullable ReadableArray value) {
+        view.setHoles(value);
+    }
+
+    @Override
+    public void setTappable(MapPolygon view, boolean value) {
+            view.setTappable(value);
+    }
+}

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

@@ -0,0 +1,121 @@
+package com.rnmaps.fabric;
+
+
+import android.content.Context;
+import android.util.DisplayMetrics;
+import android.view.WindowManager;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.ViewManagerDelegate;
+import com.facebook.react.viewmanagers.RNMapsPolylineManagerDelegate;
+import com.facebook.react.viewmanagers.RNMapsPolylineManagerInterface;
+import com.rnmaps.maps.MapPolyline;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@ReactModule(name = PolylineManager.REACT_CLASS)
+public class PolylineManager extends ViewGroupManager<MapPolyline> implements RNMapsPolylineManagerInterface<MapPolyline> {
+    private DisplayMetrics metrics;
+
+    public PolylineManager(ReactApplicationContext context) {
+        super(context);
+        metrics = new DisplayMetrics();
+        ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE))
+                .getDefaultDisplay()
+                .getRealMetrics(metrics);
+    }
+
+    private final RNMapsPolylineManagerDelegate<MapPolyline, PolylineManager> delegate =
+            new RNMapsPolylineManagerDelegate<>(this);
+
+    @Override
+    public ViewManagerDelegate<MapPolyline> getDelegate() {
+        return delegate;
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    public MapPolyline createViewInstance(ThemedReactContext context) {
+        return new MapPolyline(context);
+    }
+
+
+    public static final String REACT_CLASS = "RNMapsPolyline";
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomBubblingEventTypeConstants() {
+        return MapPolyline.getExportedCustomBubblingEventTypeConstants();
+    }
+
+    @Nullable
+    @Override
+    public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
+        return new HashMap<>();
+    }
+
+
+    @Override
+    public void setCoordinates(MapPolyline view, @Nullable ReadableArray value) {
+        view.setCoordinates(value);
+    }
+
+
+    @Override
+    public void setStrokeColor(MapPolyline view, @Nullable Integer value) {
+        view.setColor(value);
+    }
+
+    @Override
+    public void setStrokeColors(MapPolyline view, @Nullable ReadableArray value) {
+        view.setStrokeColors(value);
+    }
+
+    @Override
+    public void setStrokeWidth(MapPolyline view, float value) {
+        float widthInScreenPx = metrics.density * value; // done for parity with iOS
+        view.setWidth(widthInScreenPx);
+    }
+
+    @Override
+    public void setGeodesic(MapPolyline view, boolean value) {
+        view.setGeodesic(value);
+    }
+
+    @Override
+    public void setLineCap(MapPolyline view, @Nullable String value) {
+        view.setLineCap(value);
+    }
+
+    @Override
+    public void setLineDashPattern(MapPolyline view, @Nullable ReadableArray value) {
+        view.setLineDashPattern(value);
+    }
+
+    @Override
+    public void setLineJoin(MapPolyline view, @Nullable String value) {
+        view.setLineJoin(value);
+    }
+
+
+    @Override
+    public void setTappable(MapPolyline view, boolean value) {
+        view.setTappable(value);
+    }
+
+    @Override
+    public void setZIndex(MapPolyline view, float value) {
+        view.setZIndex(value);
+    }
+}

package/android/src/main/java/com/rnmaps/fabric/event/OnCalloutPressEvent.java

@@ -0,0 +1,25 @@
+package com.rnmaps.fabric.event;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.Event;
+
+public class OnCalloutPressEvent extends Event<OnCalloutPressEvent> {
+    public static final String EVENT_NAME = "topCalloutPress";
+
+    private final WritableMap payload;
+
+    public OnCalloutPressEvent(int surfaceId, int viewId, WritableMap payload) {
+        super(surfaceId, viewId);
+        this.payload = payload;
+    }
+
+    @Override
+    public String getEventName() {
+        return EVENT_NAME;
+    }
+
+    @Override
+    public WritableMap getEventData() {
+        return payload;
+    }
+}