@maplibre/maplibre-react-native 8.6.0-beta.0

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/components/camera/RCTMGLCamera.java

@@ -0,0 +1,530 @@
+package com.mapbox.rctmgl.components.camera;
+
+import android.content.Context;
+import android.location.Location;
+
+import com.mapbox.mapboxsdk.camera.CameraPosition;
+import com.mapbox.mapboxsdk.camera.CameraUpdate;
+import com.mapbox.mapboxsdk.camera.CameraUpdateFactory;
+import com.mapbox.mapboxsdk.geometry.LatLng;
+import com.mapbox.mapboxsdk.geometry.LatLngBounds;
+import com.mapbox.mapboxsdk.geometry.VisibleRegion;
+import com.mapbox.mapboxsdk.location.OnCameraTrackingChangedListener;
+import com.mapbox.mapboxsdk.location.modes.CameraMode;
+import com.mapbox.mapboxsdk.location.modes.RenderMode;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.Style;
+import com.mapbox.mapboxsdk.location.LocationComponent;
+import com.mapbox.mapboxsdk.location.LocationComponentOptions;
+import com.mapbox.mapboxsdk.location.LocationComponentActivationOptions;
+// import com.mapbox.mapboxsdk.plugins.locationlayer.LocationLayerPlugin;
+import com.mapbox.rctmgl.components.AbstractMapFeature;
+import com.mapbox.rctmgl.components.location.LocationComponentManager;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView;
+import com.mapbox.rctmgl.events.IEvent;
+import com.mapbox.rctmgl.events.MapUserTrackingModeEvent;
+import com.mapbox.rctmgl.events.MapChangeEvent;
+import com.mapbox.rctmgl.location.LocationManager;
+import com.mapbox.rctmgl.location.UserLocation;
+import com.mapbox.rctmgl.location.UserLocationVerticalAlignment;
+import com.mapbox.rctmgl.location.UserTrackingMode;
+import com.mapbox.rctmgl.location.UserTrackingState;
+import com.mapbox.rctmgl.utils.GeoJSONUtils;
+
+import com.mapbox.rctmgl.R;
+
+import com.mapbox.rctmgl.events.constants.EventTypes;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+
+import com.mapbox.geojson.Point;
+
+import com.mapbox.mapboxsdk.location.permissions.PermissionsManager;
+
+import androidx.annotation.NonNull;
+
+public class RCTMGLCamera extends AbstractMapFeature {
+    private RCTMGLCameraManager mManager;
+    private RCTMGLMapView mMapView;
+
+    private boolean hasSentFirstRegion = false;
+
+    private CameraStop mDefaultStop;
+    private CameraStop mCameraStop;
+    private CameraUpdateQueue mCameraUpdateQueue;
+
+    // private LocationComponent mLocationComponent;
+    private LocationComponentManager mLocationComponentManager;
+
+    private int mUserTrackingMode;
+    private int mUserTrackingState = UserTrackingState.POSSIBLE;
+    private int mUserLocationVerticalAlignment = UserLocationVerticalAlignment.CENTER;
+
+    public static final int USER_LOCATION_CAMERA_MOVE_DURATION = 1000;
+
+    private LocationManager mLocationManager;
+    private UserLocation mUserLocation;
+
+    private Point mCenterCoordinate;
+
+    private boolean mAnimated;
+    private double mHeading;
+    private double mPitch;
+    private double mZoomLevel = -1;
+
+    private double mMinZoomLevel = -1;
+    private double mMaxZoomLevel = -1;
+
+    private LatLngBounds mMaxBounds;
+
+    private boolean mFollowUserLocation;
+    private String mFollowUserMode;
+
+    private Context mContext;
+
+
+    private LocationManager.OnUserLocationChange mLocationChangeListener = new LocationManager.OnUserLocationChange() {
+        @Override
+        public void onLocationChange(Location nextLocation) {
+        if (getMapboxMap() == null || mLocationComponentManager == null || !mLocationComponentManager.hasLocationComponent() || (!mFollowUserLocation)) {
+            return;
+        }
+
+        mUserLocation.setCurrentLocation(nextLocation);
+        sendUserLocationUpdateEvent(nextLocation);
+        }
+    };
+
+    private MapboxMap.CancelableCallback mCameraCallback = new MapboxMap.CancelableCallback() {
+        @Override
+        public void onCancel() {
+            if (!hasSentFirstRegion) {
+                mMapView.sendRegionChangeEvent(false);
+                hasSentFirstRegion = true;
+            }
+        }
+
+        @Override
+        public void onFinish() {
+            if (!hasSentFirstRegion) {
+                mMapView.sendRegionChangeEvent(false);
+                hasSentFirstRegion = true;
+            }
+        }
+    };
+
+    public RCTMGLCamera(Context context, RCTMGLCameraManager manager) {
+        super(context);
+        mContext = context;
+        mManager = manager;
+        mCameraUpdateQueue = new CameraUpdateQueue();
+
+        mUserLocation = new UserLocation();
+        mLocationManager = LocationManager.getInstance(context);
+    }
+
+    @Override
+    public void addToMap(RCTMGLMapView mapView) {
+        mMapView = mapView;
+
+        setInitialCamera();
+        updateMaxMinZoomLevel();
+        updateMaxBounds();
+
+        if (mCameraStop != null) {
+            updateCamera();
+        }
+
+        if (mFollowUserLocation) {
+            enableLocation();
+        }
+    }
+
+    @Override
+    public void removeFromMap(RCTMGLMapView mapView) {
+
+    }
+
+    public void setStop(CameraStop stop) {
+        mCameraStop = stop;
+        mCameraStop.setCallback(mCameraCallback);
+
+        if (mMapView != null) {
+            updateCamera();
+        }
+    }
+
+    public void setDefaultStop(CameraStop stop) {
+        mDefaultStop = stop;
+    }
+
+    public void setFollowPitch(double pitch) {
+        mPitch = pitch;
+        updateCameraPositionIfNeeded(true);
+    }
+
+    public void setMaxBounds(LatLngBounds bounds) {
+        mMaxBounds = bounds;
+        updateMaxBounds();
+    }
+
+    private void updateMaxBounds() {
+        MapboxMap map = getMapboxMap();
+        if (map != null && mMaxBounds != null) {
+            map.setLatLngBoundsForCameraTarget(mMaxBounds);
+        }
+    }
+
+    private void updateMaxMinZoomLevel() {
+        MapboxMap map = getMapboxMap();
+        if (map != null) {
+            if (mMinZoomLevel >= 0.0) {
+                map.setMinZoomPreference(mMinZoomLevel);
+            }
+            if (mMaxZoomLevel >= 0.0) {
+                map.setMaxZoomPreference(mMaxZoomLevel);
+            }
+        }
+    }
+
+    private void setInitialCamera() {
+        if (mDefaultStop != null) {
+            mDefaultStop.setDuration(0);
+            mDefaultStop.setMode(com.mapbox.rctmgl.components.camera.constants.CameraMode.NONE);
+            CameraUpdateItem item = mDefaultStop.toCameraUpdate(mMapView);
+            item.run();
+        }
+    }
+
+    private void updateCamera() {
+        mCameraUpdateQueue.offer(mCameraStop);
+        mCameraUpdateQueue.execute(mMapView);
+    }
+
+    private void updateUserTrackingMode(int userTrackingMode) {
+        mUserLocation.setTrackingMode(userTrackingMode);
+        IEvent event = new MapUserTrackingModeEvent(this, userTrackingMode);
+        mManager.handleEvent(event);
+    }
+
+    private void updateUserLocation(boolean isAnimated) {
+        if ((!mFollowUserLocation) || mUserLocation.getTrackingMode() == UserTrackingMode.NONE) {
+            return;
+        }
+
+        if (mUserTrackingState == UserTrackingState.POSSIBLE) {
+            updateUserLocationSignificantly(isAnimated);
+        } else if (mUserTrackingState == UserTrackingState.CHANGED) {
+            updateUserLocationIncrementally(isAnimated);
+        }
+    }
+
+    private CameraPosition getUserLocationUpdateCameraPosition(double zoomLevel) {
+        LatLng center = mUserLocation.getCoordinate();
+
+        if (mUserLocationVerticalAlignment != UserLocationVerticalAlignment.CENTER) {
+            VisibleRegion region = mMapView.getVisibleRegion(center, zoomLevel);
+
+            switch (mUserLocationVerticalAlignment) {
+                case UserLocationVerticalAlignment.TOP:
+                    center = new LatLng(region.nearRight.getLatitude(), center.getLongitude());
+                    break;
+                case UserLocationVerticalAlignment.BOTTOM:
+                    center = new LatLng(region.farLeft.getLatitude(), center.getLongitude());
+                    break;
+            }
+        }
+
+        return new CameraPosition.Builder()
+                .target(center)
+                .bearing(getDirectionForUserLocationUpdate())
+                .tilt(mPitch)
+                .zoom(zoomLevel)
+                .build();
+    }
+
+    private double getDirectionForUserLocationUpdate() {
+        // NOTE: The direction of this is used for map rotation only, not location layer rotation
+        CameraPosition currentCamera = mMapView.getCameraPosition();
+        double direction = currentCamera.bearing;
+
+        int userTrackingMode = mUserLocation.getTrackingMode();
+        if (userTrackingMode == UserTrackingMode.FollowWithHeading || userTrackingMode == UserTrackingMode.FollowWithCourse) {
+            direction = mUserLocation.getBearing();
+        } else if (mHeading != 0.0) {
+            direction = mHeading;
+        }
+
+        return direction;
+    }
+
+    private void sendUserLocationUpdateEvent(Location location) {
+        if(location == null){
+            return;
+        }
+        IEvent event = new MapChangeEvent(this, EventTypes.USER_LOCATION_UPDATED, makeLocationChangePayload(location));
+        mManager.handleEvent(event);
+    }
+
+    private boolean hasSetCenterCoordinate() {
+        CameraPosition cameraPosition = mMapView.getCameraPosition();
+        LatLng center = cameraPosition.target;
+        return center.getLatitude() != 0.0 && center.getLongitude() != 0.0;
+    }
+
+    static final double minimumZoomLevelForUserTracking = 10.5;
+    static final double defaultZoomLevelForUserTracking = 14.0;
+
+    private void updateUserLocationSignificantly(boolean isAnimated) {
+        mUserTrackingState = UserTrackingState.BEGAN;
+
+        double zoom = mZoomLevel;
+        if (zoom < 0) {
+            double camerZoom = mMapView.getMapboxMap().getCameraPosition().zoom;
+            if (camerZoom < minimumZoomLevelForUserTracking) {
+                zoom = defaultZoomLevelForUserTracking;
+            } else {
+                zoom = camerZoom;
+            }
+        }
+        CameraUpdate cameraUpdate = CameraUpdateFactory.newCameraPosition(getUserLocationUpdateCameraPosition(zoom));
+        MapboxMap.CancelableCallback cameraCallback = new MapboxMap.CancelableCallback() {
+            @Override
+            public void onCancel() {
+                mUserTrackingState = UserTrackingState.CHANGED;
+            }
+
+            @Override
+            public void onFinish() {
+                mUserTrackingState = UserTrackingState.CHANGED;
+            }
+        };
+
+        if (isAnimated && hasSetCenterCoordinate()) {
+            mMapView.animateCamera(cameraUpdate, cameraCallback);
+        } else {
+            mMapView.moveCamera(cameraUpdate, cameraCallback);
+        }
+    }
+
+    private void updateUserLocationIncrementally(boolean isAnimated) {
+        mUserTrackingState = UserTrackingState.BEGAN;
+
+        CameraPosition cameraPosition = mMapView.getCameraPosition();
+        CameraUpdate cameraUpdate = CameraUpdateFactory.newCameraPosition(getUserLocationUpdateCameraPosition(cameraPosition.zoom));
+
+        MapboxMap.CancelableCallback callback = new MapboxMap.CancelableCallback() {
+            @Override
+            public void onCancel() {
+                mUserTrackingState = UserTrackingState.CHANGED;
+            }
+
+            @Override
+            public void onFinish() {
+                mUserTrackingState = UserTrackingState.CHANGED;
+            }
+        };
+
+        if (isAnimated) {
+            mMapView.easeCamera(cameraUpdate, USER_LOCATION_CAMERA_MOVE_DURATION, true, callback);
+        } else {
+            mMapView.moveCamera(cameraUpdate, callback);
+        }
+    }
+
+    private void enableLocation() {
+        if (!PermissionsManager.areLocationPermissionsGranted(mContext)) {
+            return;
+        }
+
+        if (!mLocationManager.isActive()) {
+            mLocationManager.enable();
+        }
+
+        mMapView.getMapboxMap().getStyle(new Style.OnStyleLoaded() {
+            @Override
+            public void onStyleLoaded(@NonNull Style style) {
+                enableLocationComponent(style);
+            }
+        });
+    }
+
+    private void enableLocationComponent(@NonNull Style style) {
+        updateUserLocation(false);
+        updateLocationLayer(style);
+
+        Location lastKnownLocation = mLocationManager.getLastKnownLocation();
+        mLocationManager.addLocationListener(mLocationChangeListener);
+
+        if (lastKnownLocation != null) {
+            mLocationChangeListener.onLocationChange(lastKnownLocation);
+
+            postDelayed(new Runnable() {
+                @Override
+                public void run() {
+                    mMapView.sendRegionDidChangeEvent();
+                }
+            }, 200);
+        }
+
+    }
+
+    private void updateLocationLayer(@NonNull Style style) {
+        if (mLocationComponentManager == null) {
+            mLocationComponentManager = mMapView.getLocationComponentManager();
+        }
+
+        mLocationComponentManager.update(style);
+
+        if (mFollowUserLocation) {
+            mLocationComponentManager.setCameraMode(UserTrackingMode.getCameraMode(mUserTrackingMode));
+        }
+        mLocationComponentManager.setFollowUserLocation(mFollowUserLocation);
+
+        if (mFollowUserLocation) {
+            mLocationComponentManager.setCameraMode(UserTrackingMode.getCameraMode(mUserTrackingMode));
+            mLocationComponentManager.addOnCameraTrackingChangedListener(new OnCameraTrackingChangedListener() {
+                    @Override public void onCameraTrackingChanged(int currentMode) {
+                        int userTrackingMode = UserTrackingMode.NONE;
+                        switch (currentMode) {
+                            case CameraMode.NONE:
+                                userTrackingMode = UserTrackingMode.NONE;
+                                break;
+                            case CameraMode.TRACKING:
+                                userTrackingMode = UserTrackingMode.FOLLOW;
+                                break;
+                            case CameraMode.TRACKING_COMPASS:
+                                userTrackingMode = UserTrackingMode.FollowWithHeading;
+                                break;
+                            case CameraMode.TRACKING_GPS:
+                                userTrackingMode = UserTrackingMode.FollowWithCourse;
+                                break;
+                            default:
+                                userTrackingMode = UserTrackingMode.NONE;
+                        }
+                        updateUserTrackingMode(userTrackingMode);
+                    }
+                    @Override public void onCameraTrackingDismissed() {
+                    }
+            });
+        } else {
+            mLocationComponentManager.setCameraMode(CameraMode.NONE);
+        }
+    }
+
+    public void setMinZoomLevel(double zoomLevel) {
+        mMinZoomLevel = zoomLevel;
+        updateMaxMinZoomLevel();
+    }
+
+    public void setMaxZoomLevel(double zoomLevel) {
+        mMaxZoomLevel = zoomLevel;
+        updateMaxMinZoomLevel();
+    }
+
+    public void setZoomLevel(double zoomLevel) {
+        mZoomLevel = zoomLevel;
+        updateCameraPositionIfNeeded(false);
+    }
+
+    private CameraPosition buildCamera(CameraPosition previousPosition, boolean shouldUpdateTarget) {
+        CameraPosition.Builder builder = new CameraPosition.Builder(previousPosition)
+                .bearing(mHeading)
+                .tilt(mPitch)
+                .zoom(mZoomLevel);
+
+        if (shouldUpdateTarget) {
+            builder.target(GeoJSONUtils.toLatLng(mCenterCoordinate));
+        }
+
+        return builder.build();
+    }
+
+    private void updateCameraPositionIfNeeded(boolean shouldUpdateTarget) {
+        if (mMapView != null) {
+            CameraPosition prevPosition = mMapView.getCameraPosition();
+            CameraUpdate cameraUpdate = CameraUpdateFactory.newCameraPosition(buildCamera(prevPosition, shouldUpdateTarget));
+
+            if (mAnimated) {
+                mMapView.easeCamera(cameraUpdate);
+            } else {
+                mMapView.moveCamera(cameraUpdate);
+            }
+        }
+    }
+
+    public void setUserTrackingMode(int userTrackingMode) {
+        int oldTrackingMode = mUserTrackingMode;
+        mUserTrackingMode = userTrackingMode;
+        updateUserTrackingMode(userTrackingMode);
+
+        switch (mUserTrackingMode) {
+            case UserTrackingMode.NONE:
+                mUserTrackingState = UserTrackingState.POSSIBLE;
+                break;
+            case UserTrackingMode.FOLLOW:
+            case UserTrackingMode.FollowWithCourse:
+            case UserTrackingMode.FollowWithHeading:
+                if (oldTrackingMode == UserTrackingMode.NONE) {
+                    mUserTrackingState = UserTrackingState.POSSIBLE;
+                }
+                break;
+
+        }
+
+        if (getMapboxMap() != null) {
+            updateLocationLayer(getMapboxMap().getStyle());
+        }
+    }
+
+
+    public void setFollowUserLocation(boolean value) {
+        mFollowUserLocation = value;
+        updatedFollowUserMode();
+    }
+
+    public void setFollowUserMode(String mode) {
+        mFollowUserMode = mode;
+        updatedFollowUserMode();
+    }
+
+    private void updatedFollowUserMode() {
+        if (mFollowUserLocation) {
+            setUserTrackingMode(UserTrackingMode.fromString(mFollowUserMode));
+        } else {
+            setUserTrackingMode(UserTrackingMode.NONE);
+        }
+    }
+
+    MapboxMap getMapboxMap() {
+        if (mMapView == null) {
+            return null;
+        }
+        return mMapView.getMapboxMap();
+    }
+
+    /**
+     * Create a payload of the location data per the web api geolocation spec
+     * https://dev.w3.org/geo/api/spec-source.html#position
+     * @return
+     */
+    private WritableMap makeLocationChangePayload(Location location) {
+        WritableMap positionProperties = new WritableNativeMap();
+        WritableMap coords = new WritableNativeMap();
+
+        coords.putDouble("longitude", location.getLongitude());
+        coords.putDouble("latitude", location.getLatitude());
+        coords.putDouble("altitude", location.getAltitude());
+        coords.putDouble("accuracy", location.getAccuracy());
+        // A better solution will be to pull the heading from the compass engine, 
+        // unfortunately the api is not publicly available in the mapbox sdk
+        coords.putDouble("heading", location.getBearing());
+        coords.putDouble("course", location.getBearing());
+        coords.putDouble("speed", location.getSpeed());
+
+        positionProperties.putMap("coords", coords);
+        positionProperties.putDouble("timestamp", location.getTime());
+        return positionProperties;
+    }
+}

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/components/camera/RCTMGLCameraManager.java

@@ -0,0 +1,101 @@
+package com.mapbox.rctmgl.components.camera;
+
+import com.mapbox.geojson.FeatureCollection;
+import com.facebook.common.logging.FLog;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.mapbox.rctmgl.components.AbstractEventEmitter;
+import com.mapbox.rctmgl.utils.GeoJSONUtils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class RCTMGLCameraManager extends AbstractEventEmitter<RCTMGLCamera> {
+    public static final String REACT_CLASS = "RCTMGLCamera";
+
+    private ReactApplicationContext mContext;
+
+    public RCTMGLCameraManager(ReactApplicationContext context) {
+        super(context);
+        mContext = context;
+    }
+
+    @Override
+    public Map<String, String> customEvents() {
+        return new HashMap<>();
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    protected RCTMGLCamera createViewInstance(ThemedReactContext reactContext) {
+        return new RCTMGLCamera(reactContext, this);
+    }
+
+    @ReactProp(name="stop")
+    public void setStop(RCTMGLCamera camera, ReadableMap map) {
+        if (map != null) {
+            CameraStop stop = CameraStop.fromReadableMap(mContext, map, null);
+            camera.setStop(stop);
+        }
+    }
+
+    @ReactProp(name="defaultStop")
+    public void setDefaultStop(RCTMGLCamera camera, ReadableMap map) {
+        if (map != null) {
+            CameraStop stop = CameraStop.fromReadableMap(mContext, map, null);
+            camera.setDefaultStop(stop);
+        }
+    }
+
+    @ReactProp(name="maxBounds")
+    public void setMaxBounds(RCTMGLCamera camera, String value) {
+        if (value != null) {
+            FeatureCollection collection = FeatureCollection.fromJson(value);
+            camera.setMaxBounds(GeoJSONUtils.toLatLngBounds(collection));
+        }
+    }
+
+
+    @ReactProp(name="userTrackingMode")
+    public void setUserTrackingMode(RCTMGLCamera camera, int userTrackingMode) {
+        camera.setUserTrackingMode(userTrackingMode);
+        throw new AssertionError("Unused code");
+    }
+
+    @ReactProp(name="followZoomLevel")
+    public void setZoomLevel(RCTMGLCamera camera, double zoomLevel) {
+        camera.setZoomLevel(zoomLevel);
+    }
+
+    @ReactProp(name="followUserLocation")
+    public void setFollowUserLocation(RCTMGLCamera camera, boolean value) {
+        camera.setFollowUserLocation(value);
+    }
+
+    @ReactProp(name="followUserMode")
+    public void setFollowUserMode(RCTMGLCamera camera, String value) {
+        camera.setFollowUserMode(value);
+    }
+
+    @ReactProp(name="minZoomLevel")
+    public void setMinZoomLevel(RCTMGLCamera camera, double value) {
+        camera.setMinZoomLevel(value);
+    }
+
+    @ReactProp(name="maxZoomLevel")
+    public void setMaxZoomLevel(RCTMGLCamera camera, double value) {
+        camera.setMaxZoomLevel(value);
+    }
+
+    @ReactProp(name="followPitch")
+    public void setFollowPitch(RCTMGLCamera camera, double value) {
+        camera.setFollowPitch(value);
+    }
+
+}

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/components/camera/constants/CameraMode.java

@@ -0,0 +1,22 @@
+package com.mapbox.rctmgl.components.camera.constants;
+
+import androidx.annotation.IntDef;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Created by nickitaliano on 9/6/17.
+ */
+
+public class CameraMode {
+
+    @IntDef({ FLIGHT, EASE, LINEAR, NONE })
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Mode {}
+
+    public static final int FLIGHT = 1;
+    public static final int EASE = 2;
+    public static final int LINEAR = 3;
+    public static final int NONE = 4;
+}