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

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

@@ -0,0 +1,63 @@
+package com.mapbox.rctmgl.location;
+
+import android.location.Location;
+
+import com.mapbox.mapboxsdk.geometry.LatLng;
+
+/**
+ * Created by nickitaliano on 12/13/17.
+ */
+
+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/com/mapbox/rctmgl/location/UserLocationVerticalAlignment.java

@@ -0,0 +1,11 @@
+package com.mapbox.rctmgl.location;
+
+/**
+ * Created by nickitaliano on 12/13/17.
+ */
+
+public class UserLocationVerticalAlignment {
+    public static final int CENTER = 0;
+    public static final int TOP = 1;
+    public static final int BOTTOM = 2;
+}

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

@@ -0,0 +1,63 @@
+package com.mapbox.rctmgl.location;
+
+/*
+import com.mapbox.mapboxsdk.plugins.locationlayer.modes.RenderMode;
+*/
+
+import com.mapbox.mapboxsdk.location.modes.CameraMode;
+import com.mapbox.mapboxsdk.location.modes.RenderMode;
+
+/**
+ * Created by nickitaliano on 12/13/17.
+ */
+
+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/com/mapbox/rctmgl/location/UserTrackingState.java

@@ -0,0 +1,19 @@
+package com.mapbox.rctmgl.location;
+
+/**
+ * Created by nickitaliano on 12/13/17.
+ */
+
+public class UserTrackingState {
+    // The map view not yet tracked the user location
+    public static final int POSSIBLE = 0;
+
+    // The map view has begun to move to the first user location
+    public static final int BEGAN = 1;
+
+    // The map views begins a significant transition
+    public static final int SIGNIFICANT_TRANSITION = 2;
+
+    // The map view has finished moving to the user location
+    public static final int CHANGED = 3;
+}

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/modules/RCTMGLLocationModule.java

@@ -0,0 +1,158 @@
+package com.mapbox.rctmgl.modules;
+
+import android.location.Location;
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.LifecycleEventListener;
+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.module.annotations.ReactModule;
+import com.facebook.react.modules.core.RCTNativeAppEventEmitter;
+import com.mapbox.mapboxsdk.location.engine.LocationEngineCallback;
+import com.mapbox.mapboxsdk.location.engine.LocationEngineResult;
+import com.mapbox.rctmgl.events.EventEmitter;
+import com.mapbox.rctmgl.events.LocationEvent;
+import com.mapbox.rctmgl.location.LocationManager;
+
+@ReactModule(name = RCTMGLLocationModule.REACT_CLASS)
+public class RCTMGLLocationModule extends ReactContextBaseJavaModule {
+    public static final String REACT_CLASS = "RCTMGLLocationModule";
+    public static final String LOCATION_UPDATE = "MapboxUserLocationUpdate";
+
+    private boolean isEnabled;
+    private float mMinDisplacement;
+    private boolean isPaused;
+
+    private LocationManager locationManager;
+
+    private LifecycleEventListener lifecycleEventListener = new LifecycleEventListener() {
+        @Override
+        public void onHostResume() {
+            if (isEnabled) {
+                startLocationManager();
+            }
+        }
+
+        @Override
+        public void onHostPause() {
+            pauseLocationManager();
+        }
+
+        @Override
+        public void onHostDestroy() {
+            stopLocationManager();
+        }
+    };
+
+    private LocationManager.OnUserLocationChange onUserLocationChangeCallback = new LocationManager.OnUserLocationChange() {
+        @Override
+        public void onLocationChange(Location location) {
+            LocationEvent locationEvent = new LocationEvent(location);
+
+            RCTNativeAppEventEmitter emitter = EventEmitter.getModuleEmitter(getReactApplicationContext());
+            if (emitter != null) {
+                emitter.emit(LOCATION_UPDATE, locationEvent.getPayload());
+            }
+        }
+    };
+
+    public RCTMGLLocationModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        locationManager = LocationManager.getInstance(reactContext);
+        reactContext.addLifecycleEventListener(lifecycleEventListener);
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+
+    @ReactMethod
+    public void start(float minDisplacement) {
+        isEnabled = true;
+        mMinDisplacement = minDisplacement;
+        startLocationManager();
+    }
+
+    @ReactMethod
+    public void setMinDisplacement(float minDisplacement) {
+        if (mMinDisplacement == minDisplacement) return;
+        mMinDisplacement = minDisplacement;
+        if (isEnabled) {
+
+            // set minimal displacement in the manager
+            locationManager.setMinDisplacement(mMinDisplacement);
+
+            // refresh values in location engine request
+            locationManager.enable();
+        }
+    }
+
+    @ReactMethod
+    public void stop() {
+        stopLocationManager();
+    }
+
+    @ReactMethod
+    public void pause() {
+        pauseLocationManager();
+    }
+
+    @ReactMethod
+    public void getLastKnownLocation(final Promise promise) {
+        locationManager.getLastKnownLocation(
+          new LocationEngineCallback<LocationEngineResult>() {
+              public void onSuccess(LocationEngineResult result) {
+                  Location location = result.getLastLocation();
+                  if (result.getLastLocation() != null) {
+                      LocationEvent locationEvent = new LocationEvent(location);
+                      promise.resolve(locationEvent.getPayload());
+                  } else {
+                      promise.resolve(null);
+                  }
+              }
+              public void onFailure(@NonNull Exception exception) {
+                  promise.reject(exception);
+              }
+          }
+        );
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        // Set up any upstream listeners or background tasks as necessary
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Remove upstream listeners, stop unnecessary background tasks
+    }
+
+    private void startLocationManager() {
+        locationManager.addLocationListener(onUserLocationChangeCallback);
+        locationManager.setMinDisplacement(mMinDisplacement);
+        locationManager.enable();
+        isPaused = false;
+    }
+
+    private void pauseLocationManager() {
+        if (isPaused) {
+            return;
+        }
+        locationManager.disable();
+        isPaused = true;
+    }
+
+    private void stopLocationManager() {
+        if (!isEnabled) {
+            return;
+        }
+        locationManager.removeLocationListener(onUserLocationChangeCallback);
+        locationManager.dispose();
+        isEnabled = false;
+        isPaused = false;
+    }
+}

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/modules/RCTMGLLogging.java

@@ -0,0 +1,140 @@
+package com.mapbox.rctmgl.modules;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.mapbox.mapboxsdk.log.Logger;
+import com.mapbox.mapboxsdk.log.LoggerDefinition;
+import android.util.Log;
+
+@ReactModule(name = RCTMGLLogging.REACT_CLASS)
+public class RCTMGLLogging extends ReactContextBaseJavaModule {
+    public static final String REACT_CLASS = "RCTMGLLogging";
+    private ReactApplicationContext mReactContext;
+
+    public RCTMGLLogging(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+        mReactContext = reactApplicationContext;
+
+        Logger.setVerbosity(Logger.WARN);
+        Logger.setLoggerDefinition(new LoggerDefinition() {
+            @Override
+            public void v(String tag, String msg) {
+                Log.v(tag, msg);
+                onLog("verbose", tag, msg, null);
+            }
+
+            @Override
+            public void v(String tag, String msg, Throwable tr) {
+                Log.v(tag, msg, tr);
+                onLog("verbose", tag, msg, tr);
+            }
+
+            @Override
+            public void d(String tag, String msg) {
+                Log.d(tag, msg);
+                onLog("debug", tag, msg, null);
+            }
+
+            @Override
+            public void d(String tag, String msg, Throwable tr) {
+                Log.d(tag, msg, tr);
+                onLog("debug",tag,msg,tr);
+            }
+
+            @Override
+            public void i(String tag, String msg) {
+                Log.i(tag, msg);
+                onLog("info", tag, msg, null);
+            }
+
+            @Override
+            public void i(String tag, String msg, Throwable tr) {
+                Log.i(tag, msg, tr);
+                onLog("info", tag, msg, tr);
+            }
+
+            @Override
+            public void w(String tag, String msg) {
+                Log.w(tag, msg);
+                onLog("warning", tag, msg, null);
+            }
+
+            @Override
+            public void w(String tag, String msg, Throwable tr) {
+                Log.w(tag, msg, tr);
+                onLog("warning", tag, msg, tr);
+            }
+
+            @Override
+            public void e(String tag, String msg) {
+                Log.e(tag, msg);
+                onLog("error", tag, msg, null);
+            }
+
+            @Override
+            public void e(String tag, String msg, Throwable tr) {
+                Log.e(tag, msg, tr);
+                onLog("error", tag, msg, tr);
+            }
+        });
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @ReactMethod
+    public void setLogLevel(String level) {
+        @Logger.LogLevel int logLevel = Logger.NONE;
+        switch(level)
+        {
+            case "error":
+                logLevel = Logger.ERROR;
+                break;
+            case "warning":
+                logLevel = Logger.WARN;
+                break;
+            case "info":
+                logLevel = Logger.INFO;
+                break;
+            case "debug":
+                logLevel = Logger.DEBUG;
+                break;
+            case "verbose":
+                logLevel = Logger.VERBOSE;
+                break;
+            default:
+                logLevel = Logger.NONE;
+                break;
+        }
+        Logger.setVerbosity(logLevel);
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        // Set up any upstream listeners or background tasks as necessary
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Remove upstream listeners, stop unnecessary background tasks
+    }
+
+    public void onLog(String level, String tag, String msg, Throwable tr) {
+        WritableMap event = Arguments.createMap();
+        event.putString("message", msg);
+        event.putString("tag", tag);
+        event.putString("level", level);
+
+        mReactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit("LogEvent", event);
+    }
+
+}