@maplibre/maplibre-react-native 10.0.0-alpha.9 → 10.0.0-beta.2

package/android/src/main/java/org/maplibre/reactnative/components/camera/CameraStop.java

@@ -0,0 +1,245 @@
+package org.maplibre.reactnative.components.camera;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+import android.util.DisplayMetrics;
+
+import com.facebook.react.bridge.ReadableMap;
+import org.maplibre.geojson.FeatureCollection;
+import org.maplibre.geojson.Point;
+import org.maplibre.android.camera.CameraPosition;
+import org.maplibre.android.camera.CameraUpdate;
+import org.maplibre.android.camera.CameraUpdateFactory;
+import org.maplibre.android.geometry.LatLng;
+import org.maplibre.android.geometry.LatLngBounds;
+import org.maplibre.android.maps.MapLibreMap;
+
+import org.maplibre.reactnative.components.camera.constants.CameraMode;
+import org.maplibre.reactnative.utils.GeoJSONUtils;
+import org.maplibre.reactnative.components.mapview.MLRNMapView;
+
+public class CameraStop {
+    private Double mBearing;
+    private Double mTilt;
+    private Double mZoom;
+    private LatLng mLatLng;
+
+    private LatLngBounds mBounds;
+    private int mPaddingLeft = 0;
+    private int mPaddingRight = 0;
+    private int mPaddingBottom = 0;
+    private int mPaddingTop = 0;
+
+    private int mMode = CameraMode.EASE;
+    private int mDuration = 2000;
+    private MapLibreMap.CancelableCallback mCallback;
+
+    public CameraStop() {
+    }
+
+    public void setBearing(double bearing) {
+        mBearing = bearing;
+    }
+
+    public void setTilt(double tilt) {
+        mTilt = tilt;
+    }
+
+    public void setZoom(double zoom) {
+        mZoom = zoom;
+    }
+
+    public void setLatLng(LatLng latLng) {
+        mLatLng = latLng;
+    }
+
+    public void setDuration(int duration) {
+        mDuration = duration;
+    }
+
+    public void setCallback(MapLibreMap.CancelableCallback callback) {
+        mCallback = callback;
+    }
+
+    public void setBounds(LatLngBounds bounds) {
+        mBounds = bounds;
+    }
+
+    public void setPadding(int paddingLeft, int paddingRight, int paddingTop, int paddingBottom) {
+        mPaddingLeft = paddingLeft;
+        mPaddingRight = paddingRight;
+        mPaddingTop = paddingTop;
+        mPaddingBottom = paddingBottom;
+    }
+
+    public void setMode(@CameraMode.Mode int mode) {
+        mMode = mode;
+    }
+
+    public CameraUpdateItem toCameraUpdate(MLRNMapView mapView) {
+        MapLibreMap map = mapView.getMapboxMap();
+        CameraPosition currentCamera = map.getCameraPosition();
+        CameraPosition.Builder builder = new CameraPosition.Builder(currentCamera);
+
+        // Adding map padding to the camera padding which is the same behavior as
+        // mapbox native does on iOS
+        double[] contentInset = mapView.getContentInset();
+
+        int paddingLeft = Double.valueOf(contentInset[0] + mPaddingLeft).intValue();
+        int paddingTop = Double.valueOf(contentInset[1] + mPaddingTop).intValue();
+        int paddingRight = Double.valueOf(contentInset[2] + mPaddingRight).intValue();
+        int paddingBottom = Double.valueOf(contentInset[3] + mPaddingBottom).intValue();
+
+        int[] cameraPadding = {paddingLeft, paddingTop, paddingRight, paddingBottom};
+        int[] cameraPaddingClipped = clippedPadding(cameraPadding, mapView);
+
+        boolean hasSetZoom = false;
+
+        if (mLatLng != null) {
+            builder.target(mLatLng);
+            builder.padding(
+                cameraPaddingClipped[0],
+                cameraPaddingClipped[1],
+                cameraPaddingClipped[2],
+                cameraPaddingClipped[3]
+            );
+        } else if (mBounds != null) {
+            double tilt = mTilt != null ? mTilt : currentCamera.tilt;
+            double bearing = mBearing != null ? mBearing : currentCamera.bearing;
+
+            CameraPosition boundsCamera = map.getCameraForLatLngBounds(mBounds, cameraPaddingClipped, bearing, tilt);
+            if (boundsCamera != null) {
+                builder.target(boundsCamera.target);
+                builder.zoom(boundsCamera.zoom);
+                builder.padding(boundsCamera.padding);
+            } else {
+                CameraUpdate update = CameraUpdateFactory.newLatLngBounds(
+                    mBounds,
+                    cameraPaddingClipped[0],
+                    cameraPaddingClipped[1],
+                    cameraPaddingClipped[2],
+                    cameraPaddingClipped[3]
+                );
+                return new CameraUpdateItem(map, update, mDuration, mCallback, mMode);
+            }
+            hasSetZoom = true;
+        }
+
+        if (mBearing != null) {
+            builder.bearing(mBearing);
+        }
+
+        if (mTilt != null) {
+            builder.tilt(mTilt);
+        }
+
+        if (mZoom != null && !hasSetZoom) {
+            builder.zoom(mZoom);
+        }
+
+        return new CameraUpdateItem(map, CameraUpdateFactory.newCameraPosition(builder.build()), mDuration, mCallback, mMode);
+    }
+
+    public static CameraStop fromReadableMap(Context context, @NonNull ReadableMap readableMap, MapLibreMap.CancelableCallback callback) {
+        CameraStop stop = new CameraStop();
+
+        if (readableMap.hasKey("pitch")) {
+            stop.setTilt(readableMap.getDouble("pitch"));
+        }
+
+        if (readableMap.hasKey("heading")) {
+            stop.setBearing(readableMap.getDouble("heading"));
+        }
+
+        int paddingTop = getPaddingByKey(readableMap, "paddingTop");
+        int paddingRight = getPaddingByKey(readableMap, "paddingRight");
+        int paddingBottom = getPaddingByKey(readableMap, "paddingBottom");
+        int paddingLeft = getPaddingByKey(readableMap, "paddingLeft");
+
+        // scale padding by pixel ratio
+        DisplayMetrics metrics = context.getResources().getDisplayMetrics();
+        paddingTop = Float.valueOf(paddingTop * metrics.scaledDensity).intValue();
+        paddingRight = Float.valueOf(paddingRight * metrics.scaledDensity).intValue();
+        paddingBottom = Float.valueOf(paddingBottom * metrics.scaledDensity).intValue();
+        paddingLeft = Float.valueOf(paddingLeft * metrics.scaledDensity).intValue();
+
+        stop.setPadding(
+                paddingLeft,
+                paddingRight,
+                paddingTop,
+                paddingBottom
+        );
+
+        if (readableMap.hasKey("centerCoordinate")) {
+            Point target = GeoJSONUtils.toPointGeometry(readableMap.getString("centerCoordinate"));
+            stop.setLatLng(GeoJSONUtils.toLatLng(target));
+        }
+
+        if (readableMap.hasKey("zoom")) {
+            stop.setZoom(readableMap.getDouble("zoom"));
+        }
+
+        if (readableMap.hasKey("duration")) {
+            stop.setDuration(readableMap.getInt("duration"));
+        }
+
+        if (readableMap.hasKey("bounds")) {
+            FeatureCollection collection = FeatureCollection.fromJson(readableMap.getString("bounds"));
+            stop.setBounds(GeoJSONUtils.toLatLngBounds(collection));
+        }
+
+        if (readableMap.hasKey("mode")) {
+            switch (readableMap.getInt("mode")) {
+                case CameraMode.FLIGHT:
+                    stop.setMode(CameraMode.FLIGHT);
+                    break;
+                case CameraMode.LINEAR:
+                    stop.setMode(CameraMode.LINEAR);
+                    break;
+                case CameraMode.NONE:
+                    stop.setMode(CameraMode.NONE);
+                    break;
+                default:
+                    stop.setMode(CameraMode.EASE);
+            }
+        }
+
+        stop.setCallback(callback);
+        return stop;
+    }
+
+    private static int[] clippedPadding(int[] padding, MLRNMapView mapView) {
+        int mapHeight = mapView.getHeight();
+        int mapWidth = mapView.getWidth();
+
+        int left = padding[0];
+        int top = padding[1];
+        int right = padding[2];
+        int bottom = padding[3];
+
+        int resultLeft = left;
+        int resultTop = top;
+        int resultRight = right;
+        int resultBottom = bottom;
+
+        if (top + bottom >= mapHeight) {
+            double totalPadding = top + bottom;
+            double extra = totalPadding - mapHeight + 1.0; // add 1 to compensate for floating point math
+            resultTop -= (top * extra) / totalPadding;
+            resultBottom -= (bottom * extra) / totalPadding;
+        }
+
+        if (left + right >= mapWidth) {
+            double totalPadding = left + right;
+            double extra = totalPadding - mapWidth + 1.0; // add 1 to compensate for floating point math
+            resultLeft -= (left * extra) / totalPadding;
+            resultRight -= (right * extra) / totalPadding;
+        }
+
+        return new int[] {resultLeft, resultTop, resultRight, resultBottom};
+    }
+
+    private static int getPaddingByKey(ReadableMap map, String key) {
+        return map.hasKey(key) ? map.getInt(key) : 0;
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/camera/CameraUpdateItem.java

@@ -0,0 +1,121 @@
+package org.maplibre.reactnative.components.camera;
+
+import androidx.annotation.NonNull;
+
+import org.maplibre.android.camera.CameraUpdate;
+import org.maplibre.android.constants.MapLibreConstants;
+import org.maplibre.android.maps.MapLibreMap;
+import org.maplibre.reactnative.components.camera.constants.CameraMode;
+
+import java.lang.ref.WeakReference;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.RunnableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class CameraUpdateItem implements RunnableFuture<Void> {
+    private int mDuration;
+    private MapLibreMap.CancelableCallback mCallback;
+    private CameraUpdate mCameraUpdate;
+    private int mCameraMode;
+
+    private boolean isCameraActionFinished;
+    private boolean isCameraActionCancelled;
+
+    private WeakReference<MapLibreMap> mMap;
+
+    public CameraUpdateItem(MapLibreMap map, CameraUpdate update, int duration, MapLibreMap.CancelableCallback callback, @CameraMode.Mode int cameraMode) {
+        mCameraUpdate = update;
+        mDuration = duration;
+        mCallback = callback;
+        mCameraMode = cameraMode;
+        mMap = new WeakReference<>(map);
+    }
+
+    public int getDuration() {
+        return mDuration;
+    }
+
+    @Override
+    public void run() {
+        final MapLibreMap.CancelableCallback callback = new MapLibreMap.CancelableCallback() {
+            @Override
+            public void onCancel() {
+                handleCallbackResponse(true);
+            }
+
+            @Override
+            public void onFinish() {
+                handleCallbackResponse(false);
+            }
+        };
+
+        MapLibreMap map = mMap.get();
+        if (map == null) {
+            isCameraActionCancelled = true;
+            return;
+        }
+
+        // animateCamera / easeCamera only allows positive duration
+        if (mDuration == 0 || mCameraMode == CameraMode.NONE) {
+            map.moveCamera(mCameraUpdate, callback);
+            return;
+        }
+
+        // On iOS a duration of -1 means default or dynamic duration (based on flight-path length)
+        // On Android we can fallback to MapLibre's default duration as there is no such API
+        int duration = mDuration < 0 ? MapLibreConstants.ANIMATION_DURATION : mDuration;
+
+        if (mCameraMode == CameraMode.FLIGHT) {
+            map.animateCamera(mCameraUpdate, duration, callback);
+        } else if (mCameraMode == CameraMode.LINEAR) {
+            map.easeCamera(mCameraUpdate, duration, false, callback);
+        } else if (mCameraMode == CameraMode.EASE) {
+            map.easeCamera(mCameraUpdate, duration, true, callback);
+        }
+    }
+
+    @Override
+    public boolean cancel(boolean mayInterruptIfRunning) {
+        return false;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return isCameraActionCancelled;
+    }
+
+    @Override
+    public boolean isDone() {
+        return isCameraActionFinished;
+    }
+
+    @Override
+    public Void get() throws InterruptedException, ExecutionException {
+        return null;
+    }
+
+    @Override
+    public Void get(long timeout, @NonNull TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+        return null;
+    }
+
+    private void handleCallbackResponse(boolean isCancel) {
+        if (mCallback == null) {
+            return;
+        }
+
+        isCameraActionCancelled = isCancel;
+        isCameraActionFinished = !isCancel;
+
+        if (isCancel) {
+            mCallback.onCancel();
+        } else {
+            mCallback.onFinish();
+        }
+    }
+}

package/android/src/main/java/org/maplibre/reactnative/components/camera/CameraUpdateQueue.java

@@ -0,0 +1,68 @@
+package org.maplibre.reactnative.components.camera;
+
+import org.maplibre.android.maps.MapLibreMap;
+import org.maplibre.reactnative.components.mapview.MLRNMapView;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.FutureTask;
+
+public class CameraUpdateQueue {
+    private Queue<CameraStop> mQueue;
+
+    private OnCompleteAllListener mCompleteListener;
+
+    public interface OnCompleteAllListener {
+        void onCompleteAll();
+    }
+
+    public CameraUpdateQueue() {
+        mQueue = new LinkedList<>();
+    }
+
+    public void offer(CameraStop item) {
+        mQueue.offer(item);
+    }
+
+    public int size() {
+        return mQueue.size();
+    }
+
+    public boolean isEmpty() {
+        return mQueue.isEmpty();
+    }
+
+    public void flush() {
+        while (mQueue.size() > 0) {
+            mQueue.remove();
+        }
+        mQueue = new LinkedList<>();
+    }
+
+    public void setOnCompleteAllListener(OnCompleteAllListener listener) {
+        mCompleteListener = listener;
+    }
+
+    public void execute(MLRNMapView map) {
+        if (mQueue.isEmpty()) {
+            if (mCompleteListener != null) {
+                mCompleteListener.onCompleteAll();
+            }
+            return;
+        }
+
+        final CameraStop stop = mQueue.poll();
+        if (stop == null) {
+            return;
+        }
+
+        CameraUpdateItem item = stop.toCameraUpdate(map);
+        item.run();
+        execute(map);
+    }
+}