@rnmapbox/maps 10.0.0-beta.28

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/location/LocationComponentManager.java

@@ -0,0 +1,215 @@
+package com.mapbox.rctmgl.components.location;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Color;
+import android.graphics.ColorFilter;
+import android.graphics.LightingColorFilter;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.VectorDrawable;
+
+import com.mapbox.geojson.Point;
+import com.mapbox.maps.CameraOptions;
+import com.mapbox.maps.MapboxMap;
+import com.mapbox.maps.Style;
+import com.mapbox.maps.plugin.LocationPuck;
+import com.mapbox.maps.plugin.LocationPuck2D;
+import com.mapbox.maps.plugin.gestures.GesturesUtils;
+import com.mapbox.maps.plugin.locationcomponent.LocationComponentPlugin;
+import com.mapbox.maps.plugin.locationcomponent.LocationComponentUtils;
+import com.mapbox.maps.plugin.locationcomponent.OnIndicatorBearingChangedListener;
+import com.mapbox.maps.plugin.locationcomponent.OnIndicatorPositionChangedListener;
+import com.mapbox.maps.plugin.locationcomponent.generated.LocationComponentSettings;
+import com.mapbox.rctmgl.R;
+import com.mapbox.rctmgl.components.location.CameraMode;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView;
+import com.mapbox.rctmgl.location.LocationManager;
+import com.mapbox.rctmgl.utils.Logger;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.content.res.AppCompatResources;
+
+/**
+ * The LocationComponent on android implements both location tracking and display of user's current location.
+ * LocationComponentManager attempts to separate that, so that Camera can ask for location tracking independent of display of user current location.
+ * And NativeUserLocation can ask for display of user's current location - independent of Camera's user tracking.
+ */
+public class LocationComponentManager {
+    private RCTMGLMapView mMapView = null;
+    private MapboxMap mMap = null;
+
+    private LocationManager mLocationManager = null;
+    private LocationComponentPlugin mLocationComponent = null;
+    private Context mContext = null;
+
+    private int mCameraMode = CameraMode.NONE;
+
+    private @RenderMode.Mode int mRenderMode = RenderMode.COMPASS;
+
+    private OnIndicatorBearingChangedListener mLocationBearingChangedListener = new OnIndicatorBearingChangedListener() {
+        @Override
+        public void onIndicatorBearingChanged(double v) {
+            if (mFollowUserLocation) {
+                mMapView.getMapboxMap().setCamera(new CameraOptions.Builder().bearing(v).build());
+            }
+        }
+    };
+    private boolean bearingListenerInstalled = false;
+
+    private OnIndicatorPositionChangedListener mLocationPositionChangeListener = new OnIndicatorPositionChangedListener() {
+        @Override
+        public void onIndicatorPositionChanged(@NonNull Point point) {
+            if (mFollowUserLocation) {
+                mMapView.getMapboxMap().setCamera(new CameraOptions.Builder().center(point).build());
+                GesturesUtils.getGestures(mMapView).setFocalPoint(mMapView.getMapboxMap().pixelForCoordinate(point));
+
+                // sendUserLocationUpdateEvent(point);
+            }
+        }
+    };
+
+    public LocationComponentManager(RCTMGLMapView rctmglMapView, Context context) {
+        mMapView = rctmglMapView;
+        mMap = mMapView.getMapboxMap();
+        mContext = context;
+
+        mLocationManager = LocationManager.getInstance(context);
+    }
+
+    private boolean mShowUserLocation = false;
+
+    private boolean mFollowUserLocation = false;
+
+    private boolean mShowingUserLocation = false;
+
+    public void showUserLocation(boolean showUserLocation) {
+        mShowUserLocation = showUserLocation;
+        stateChanged();
+    }
+
+    public void setFollowUserLocation(boolean followUserLocation) {
+        mFollowUserLocation = followUserLocation;
+        stateChanged();
+    }
+
+    public void setCameraMode(@CameraMode.Mode int cameraMode) {
+        mCameraMode = cameraMode;
+        stateChanged();
+
+        LocationComponentPlugin locationComponent = LocationComponentUtils.getLocationComponent(mMapView);
+
+        if (mCameraMode == CameraMode.NONE || mCameraMode == CameraMode.TRACKING) {
+            locationComponent.removeOnIndicatorBearingChangedListener(mLocationBearingChangedListener);
+        } else {
+            locationComponent.addOnIndicatorBearingChangedListener(mLocationBearingChangedListener);
+        }
+
+        if (mCameraMode == CameraMode.NONE || mCameraMode == CameraMode.NONE_COMPASS || mCameraMode == CameraMode.NONE_GPS) {
+            locationComponent.removeOnIndicatorPositionChangedListener(mLocationPositionChangeListener);
+        } else {
+            locationComponent.addOnIndicatorPositionChangedListener(mLocationPositionChangeListener);
+        }
+    }
+
+    public void tintColorChanged() {
+        applyOptions(mShowingUserLocation, mLocationComponent);
+    }
+
+    public void setRenderMode(@RenderMode.Mode int renderMode) {
+        mRenderMode = renderMode;
+    }
+/*
+    public void addOnCameraTrackingChangedListener(OnCameraTrackingChangedListener onCameraTrackingChangedListener) {
+        // mLocationComponent.addOnCameraTrackingChangedListener(onCameraTrackingChangedListener);
+    }*/
+
+    @SuppressLint("MissingPermission")
+    private void stateChanged() {
+        mLocationComponent.setEnabled((mFollowUserLocation || mShowUserLocation));
+
+        if (mShowingUserLocation != mShowUserLocation) {
+            updateShowUserLocation(mShowUserLocation);
+        }
+
+        if (mFollowUserLocation) {
+            if (!mShowUserLocation) {
+               // mLocationComponent.setRenderMode(RenderMode.GPS);
+            } else {
+                // mLocationComponent.setRenderMode(mRenderMode);
+            }
+            mLocationComponent.onStart();
+        } else {
+            // mLocationComponent.setCameraMode(CameraMode.NONE);
+        }
+        mLocationComponent.setEnabled(mFollowUserLocation || mShowUserLocation);
+    }
+
+    public boolean hasLocationComponent() {
+        return (mLocationComponent != null);
+    }
+
+    public void update(@NonNull Style style) {
+        update(mShowUserLocation, style);
+    }
+
+    public void update(boolean displayUserLocation, @NonNull Style style) {
+        if (mLocationComponent == null) {
+            mLocationComponent = LocationComponentUtils.getLocationComponent(mMapView);
+
+            mLocationComponent.setLocationProvider(mLocationManager.getProvider());
+            mShowingUserLocation = displayUserLocation;
+        }
+
+        updateShowUserLocation(displayUserLocation);
+    }
+
+    private void updateShowUserLocation(boolean displayUserLocation) {
+        if (mShowingUserLocation != displayUserLocation) {
+            applyOptions(displayUserLocation, mLocationComponent);
+            mShowingUserLocation = displayUserLocation;
+        }
+    }
+
+    private void applyOptions(boolean displayUserLocation, LocationComponentPlugin locationComponent) {
+        locationComponent.setEnabled(true);
+        if (!displayUserLocation) {
+            LocationPuck2D locationPuck = new LocationPuck2D();
+
+            Drawable empty = AppCompatResources.getDrawable(mContext, R.drawable.empty);
+            locationPuck.setBearingImage(empty);
+            locationPuck.setShadowImage(empty);
+            locationPuck.setTopImage(empty);
+
+            locationComponent.setLocationPuck(locationPuck);
+            locationComponent.setPulsingEnabled(false);
+        } else {
+            int mapboxBlueColor = Color.parseColor("#4A90E2");
+
+            LocationPuck2D locationPuck = new LocationPuck2D();
+            Drawable topImage = AppCompatResources.getDrawable(mContext, R.drawable.mapbox_user_icon);
+
+            Integer tintColor = mMapView.getTintColor();
+            if (tintColor != null) {
+                VectorDrawable drawable = (VectorDrawable)topImage;
+                drawable.setTint(tintColor);
+
+                topImage = drawable;
+            }
+
+            locationPuck.setTopImage(topImage);
+            Drawable bearingImage = AppCompatResources.getDrawable(mContext, R.drawable.mapbox_user_stroke_icon);
+            locationPuck.setBearingImage(bearingImage);
+            Drawable shadowImage = AppCompatResources.getDrawable(mContext, R.drawable.mapbox_user_icon_shadow);
+            locationPuck.setShadowImage(shadowImage);
+            locationComponent.setLocationPuck(locationPuck);
+
+            locationComponent.setPulsingEnabled(true);
+            if (tintColor != null) {
+                locationComponent.setPulsingColor(tintColor);
+            } else {
+                locationComponent.setPulsingColor(mapboxBlueColor);
+            }
+        }
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/location/RCTMGLNativeUserLocation.kt

@@ -0,0 +1,58 @@
+package com.mapbox.rctmgl.components.location
+
+import android.annotation.SuppressLint
+import android.content.Context
+import com.mapbox.rctmgl.components.mapview.OnMapReadyCallback
+import com.mapbox.maps.MapboxMap
+import com.mapbox.android.core.permissions.PermissionsManager
+import com.mapbox.maps.Style
+import com.mapbox.rctmgl.components.AbstractMapFeature
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+
+/*
+import com.mapbox.mapboxsdk.location.modes.RenderMode;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
+import com.mapbox.mapboxsdk.maps.Style;
+ */   class RCTMGLNativeUserLocation(context: Context?) : AbstractMapFeature(context), OnMapReadyCallback, Style.OnStyleLoaded {
+    private var mEnabled = true
+    private var mMap: MapboxMap? = null
+    private var mMapView: RCTMGLMapView? = null
+
+    @RenderMode.Mode
+    private var mRenderMode = RenderMode.COMPASS
+    override fun addToMap(mapView: RCTMGLMapView) {
+        mEnabled = true
+        mMapView = mapView
+        mapView.getMapboxMap()
+        mapView.getMapAsync(this)
+        setRenderMode(mRenderMode)
+    }
+
+    override fun removeFromMap(mapView: RCTMGLMapView) {
+        mEnabled = false
+        mMap?.getStyle(this)
+    }
+
+    @SuppressLint("MissingPermission")
+    override fun onMapReady(mapboxMap: MapboxMap) {
+        mMap = mapboxMap
+        mapboxMap.getStyle(this)
+    }
+
+    @SuppressLint("MissingPermission")
+    override fun onStyleLoaded(style: Style) {
+        val context = context
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return
+        }
+
+        mMapView?.locationComponentManager?.update(style)
+        mMapView?.locationComponentManager?.showUserLocation(mEnabled)
+    }
+
+    fun setRenderMode(@RenderMode.Mode renderMode: Int) {
+        mRenderMode = renderMode
+        mMapView?.locationComponentManager?.setRenderMode(renderMode)
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/location/RCTMGLNativeUserLocationManager.java

@@ -0,0 +1,34 @@
+package com.mapbox.rctmgl.components.location;
+
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.ViewGroupManager;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+import javax.annotation.Nonnull;
+
+public class RCTMGLNativeUserLocationManager extends ViewGroupManager<RCTMGLNativeUserLocation> {
+    public static final String REACT_CLASS = "RCTMGLNativeUserLocation";
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @ReactProp(name="androidRenderMode")
+    public void setAndroidRenderMode(com.mapbox.rctmgl.components.location.RCTMGLNativeUserLocation userLocation, String mode) {
+        if ("compass".equalsIgnoreCase(mode)) {
+           userLocation.setRenderMode(RenderMode.COMPASS);
+        } else if ("gps".equalsIgnoreCase(mode)) {
+           userLocation.setRenderMode(RenderMode.GPS);
+        } else {
+           userLocation.setRenderMode(RenderMode.NORMAL);
+       }
+    }
+
+    @Nonnull
+    @Override
+    protected RCTMGLNativeUserLocation createViewInstance(@Nonnull ThemedReactContext reactContext) {
+        return new RCTMGLNativeUserLocation(reactContext);
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/location/RenderMode.java

@@ -0,0 +1,42 @@
+package com.mapbox.rctmgl.components.location;
+
+import androidx.annotation.IntDef;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Contains the variety of ways the user location can be rendered on the map.
+ */
+public final class RenderMode {
+
+  private RenderMode() {
+    // Class should not be initialized
+  }
+
+  /**
+   * One of these constants should be used with {@link LocationComponent#setRenderMode(int)}.
+   * Mode can be switched at anytime by calling the {@code setLocationLayerMode} method passing
+   * in the new mode you'd like the location layer to be in.
+   */
+  @IntDef( {COMPASS, GPS, NORMAL})
+  @Retention(RetentionPolicy.SOURCE)
+  public @interface Mode {
+  }
+
+  /**
+   * Basic tracking is enabled, bearing ignored.
+   */
+  public static final int NORMAL = 0x00000012;
+
+  /**
+   * Tracking the user location with bearing considered
+   * from a {@link CompassEngine}.
+   */
+  public static final int COMPASS = 0x00000004;
+
+  /**
+   * Tracking the user location with bearing considered from {@link android.location.Location}.
+   */
+  public static final int GPS = 0x00000008;
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/location/UserLocation.java

@@ -0,0 +1,59 @@
+package com.mapbox.rctmgl.location;
+
+import android.location.Location;
+
+import com.mapbox.rctmgl.utils.LatLng;
+
+public class UserLocation {
+    private Location currentLocation;
+    private Location previousLocation;
+
+    private int userTrackingMode = UserTrackingMode.NONE;
+
+    public UserLocation() {
+        this(null);
+    }
+
+    public UserLocation(Location currentLocation) {
+        this.currentLocation = currentLocation;
+    }
+
+    public Location getCurrentLocation() {
+        return currentLocation;
+    }
+
+    public double getBearing() {
+        if (currentLocation == null) {
+            return 0.0;
+        }
+        return currentLocation.getBearing();
+    }
+
+    public LatLng getCoordinate() {
+        if (currentLocation == null) {
+            return null;
+        }
+
+        return new LatLng(currentLocation.getLatitude(), currentLocation.getLongitude());
+    }
+
+    public void setCurrentLocation(Location currentLocation) {
+        this.previousLocation = this.currentLocation;
+        this.currentLocation = currentLocation;
+    }
+
+    public void setTrackingMode(int userTrackingMode) {
+        this.userTrackingMode = userTrackingMode;
+    }
+
+    public int getTrackingMode() {
+        return userTrackingMode;
+    }
+
+    public float getDistance(Location location) {
+        if (currentLocation == null) {
+            return 0.0f;
+        }
+        return currentLocation.distanceTo(location);
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/location/UserTrackingMode.java

@@ -0,0 +1,54 @@
+package com.mapbox.rctmgl.location;
+
+import com.mapbox.rctmgl.components.location.CameraMode;
+
+public class UserTrackingMode {
+    public static final int NONE = 0;
+    public static final int FOLLOW = 1;
+    public static final int FollowWithCourse = 2;
+    public static final int FollowWithHeading = 3;
+
+    public static @CameraMode.Mode int getCameraMode(int mode) {
+        switch(mode) {
+            case NONE:
+                return CameraMode.NONE;
+            case FOLLOW:
+                return CameraMode.TRACKING;
+            case FollowWithCourse:
+                return CameraMode.TRACKING_GPS;
+            case FollowWithHeading:
+                return CameraMode.TRACKING_COMPASS;
+        }
+        return CameraMode.NONE;
+    }
+
+    public static boolean isUserGesture(int reason) {
+        return reason == 1 || reason == 2; // user gesture or animation
+    }
+
+    public static String toString(int value) {
+        switch (value) {
+            case UserTrackingMode.FOLLOW:
+                return "normal";
+            case UserTrackingMode.FollowWithCourse:
+                return "course";
+            case UserTrackingMode.FollowWithHeading:
+                return "compass";
+        }
+        return null;
+    }
+
+    public static int fromString(String value) {
+        if (value == null) value = "";
+        switch (value) {
+            case "course":
+                return UserTrackingMode.FollowWithCourse;
+            case "normal":
+                return UserTrackingMode.FOLLOW;
+            case "compass":
+                return UserTrackingMode.FollowWithHeading;
+            default:
+                return UserTrackingMode.FOLLOW;
+        }
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/mapview/OnMapReadyCallback.java

@@ -0,0 +1,9 @@
+package com.mapbox.rctmgl.components.mapview;
+
+import androidx.annotation.NonNull;
+
+import com.mapbox.maps.MapboxMap;
+
+public interface OnMapReadyCallback {
+  public void onMapReady(@NonNull MapboxMap mapboxMap);
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLAndroidTextureMapView.java

@@ -0,0 +1,16 @@
+package com.mapbox.rctmgl.components.mapview;
+
+import android.content.Context;
+//import com.mapbox.mapboxsdk.maps.MapboxMapOptions;
+/**
+ * Created by hernanmateo on 12/11/18.
+ */
+
+@SuppressWarnings({"MissingPermission"})
+public class RCTMGLAndroidTextureMapView extends RCTMGLMapView {
+	public static final String LOG_TAG = "RCTMGLAndroidTextureMapView";
+	
+    public RCTMGLAndroidTextureMapView(Context context, RCTMGLAndroidTextureMapViewManager manager/*, MapboxMapOptions options*/) {
+        super(context, manager/*, options*/);
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/mapview/RCTMGLAndroidTextureMapViewManager.java

@@ -0,0 +1,31 @@
+package com.mapbox.rctmgl.components.mapview;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+//import com.mapbox.mapboxsdk.maps.MapboxMapOptions;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+/**
+ * Created by hernanmateo on 12/11/18.
+ */
+
+public class RCTMGLAndroidTextureMapViewManager extends RCTMGLMapViewManager {
+    public static final String LOG_TAG = "RCTMGLAndroidTextureMapViewManager";
+    public static final String REACT_CLASS = "RCTMGLAndroidTextureMapView";
+
+    public RCTMGLAndroidTextureMapViewManager(ReactApplicationContext context) {
+        super(context);
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    protected RCTMGLAndroidTextureMapView createViewInstance(ThemedReactContext themedReactContext) {
+        //MapboxMapOptions options = new MapboxMapOptions();
+        //options.textureMode(true);
+        return new RCTMGLAndroidTextureMapView(themedReactContext, this/*, options*/);
+    }
+}