@rnmapbox/maps 10.0.0-beta.28

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

@@ -0,0 +1,199 @@
+package com.mapbox.rctmgl.location
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.location.Location
+//import com.mapbox.maps.plugin.locationcomponent.LocationConsumer.onLocationUpdated
+//import com.mapbox.maps.plugin.locationcomponent.LocationConsumer.onBearingUpdated
+import com.mapbox.android.core.location.LocationEngine
+import com.mapbox.android.core.location.LocationEngineCallback
+import com.mapbox.android.core.location.LocationEngineResult
+import com.mapbox.maps.plugin.locationcomponent.LocationConsumer
+import com.mapbox.android.core.location.LocationEngineRequest
+import com.mapbox.rctmgl.location.LocationProviderForEngine
+import com.mapbox.android.core.location.LocationEngineProvider
+import com.mapbox.android.core.permissions.PermissionsManager
+import android.os.Looper
+import android.util.Log
+import com.mapbox.geojson.Point
+import com.mapbox.maps.plugin.locationcomponent.LocationProvider
+import java.lang.Exception
+import java.lang.ref.WeakReference
+import java.util.ArrayList
+
+internal class LocationProviderForEngine(var mEngine: LocationEngine?) : LocationProvider, LocationEngineCallback<LocationEngineResult> {
+    var mConsumers = ArrayList<LocationConsumer>()
+    fun beforeAddingFirstConsumer() {}
+    fun afterRemovedLastConsumer() {}
+    @SuppressLint("MissingPermission")
+    override fun registerLocationConsumer(locationConsumer: LocationConsumer) {
+        if (mConsumers.isEmpty()) {
+            beforeAddingFirstConsumer()
+        }
+        mConsumers.add(locationConsumer)
+        mEngine?.getLastLocation(this)
+    }
+
+    override fun unRegisterLocationConsumer(locationConsumer: LocationConsumer) {
+        mConsumers.remove(locationConsumer)
+        if (mConsumers.isEmpty()) {
+            afterRemovedLastConsumer()
+        }
+    }
+
+    fun notifyLocationUpdates(location: Location) {
+        for (consumer in mConsumers) {
+            val points = Point.fromLngLat(location.longitude, location.latitude)
+            consumer.onLocationUpdated(points)
+            val bearings = location.bearing.toDouble()
+            consumer.onBearingUpdated(bearings)
+        }
+    }
+
+    // * LocationEngineCallback
+    override fun onSuccess(locationEngineResult: LocationEngineResult) {
+        val location = locationEngineResult.lastLocation
+        location?.let { notifyLocationUpdates(it) }
+    }
+
+    override fun onFailure(e: Exception) {}
+}
+
+class LocationManager private constructor(private val context: Context) : LocationEngineCallback<LocationEngineResult> {
+    var engine: LocationEngine? = null
+        private set
+    private val listeners: MutableList<OnUserLocationChange> = ArrayList()
+    private var mMinDisplacement = 0f
+    private var isActive = false
+    private var lastLocation: Location? = null
+    private var locationEngineRequest: LocationEngineRequest? = null
+    private var locationProvider: LocationProviderForEngine? = null
+    val provider: LocationProvider
+        get() {
+            if (locationProvider == null) {
+                locationProvider = LocationProviderForEngine(engine)
+            }
+            return locationProvider!!
+        }
+
+    interface OnUserLocationChange {
+        fun onLocationChange(location: Location?)
+    }
+
+    private fun buildEngineRequest() {
+        engine = LocationEngineProvider.getBestLocationEngine(context.applicationContext)
+        locationEngineRequest = LocationEngineRequest.Builder(DEFAULT_INTERVAL_MILLIS)
+                .setFastestInterval(DEFAULT_FASTEST_INTERVAL_MILLIS)
+                .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
+                .setDisplacement(mMinDisplacement)
+                .build()
+    }
+
+    fun addLocationListener(listener: OnUserLocationChange) {
+        if (!listeners.contains(listener)) {
+            listeners.add(listener)
+        }
+    }
+
+    fun removeLocationListener(listener: OnUserLocationChange) {
+        if (listeners.contains(listener)) {
+            listeners.remove(listener)
+        }
+    }
+
+    fun setMinDisplacement(minDisplacement: Float) {
+        mMinDisplacement = minDisplacement
+    }
+
+    @SuppressLint("MissingPermission")
+    fun enable() {
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return
+        }
+
+        // remove existing listeners
+        engine?.removeLocationUpdates(this)
+
+        // refresh location engine request with new values
+        buildEngineRequest()
+
+        // add new listeners
+        engine?.requestLocationUpdates(
+                locationEngineRequest!!,
+                this,
+                Looper.getMainLooper()
+        )
+        isActive = true
+    }
+
+    fun disable() {
+        engine?.removeLocationUpdates(this)
+        isActive = false
+    }
+
+    fun dispose() {
+        if (engine == null) {
+            return
+        }
+        disable()
+        engine?.removeLocationUpdates(this)
+    }
+
+    fun isActive(): Boolean {
+        return engine != null && isActive
+    }
+
+    val lastKnownLocation: Location?
+        get() = if (engine == null) {
+            null
+        } else lastLocation
+
+    @SuppressLint("MissingPermission")
+    fun getLastKnownLocation(callback: LocationEngineCallback<LocationEngineResult?>) {
+        if (engine == null) {
+            callback.onFailure(Exception("LocationEngine not initialized"))
+        }
+        try {
+            engine?.getLastLocation(callback)
+        } catch (exception: Exception) {
+            Log.w(LOG_TAG, exception)
+            callback.onFailure(exception)
+        }
+    }
+
+    fun onLocationChanged(location: Location?) {
+        lastLocation = location
+        for (listener in listeners) {
+            listener.onLocationChange(location)
+        }
+    }
+
+    override fun onFailure(exception: Exception) {
+        // FMTODO handle this.
+    }
+
+    override fun onSuccess(result: LocationEngineResult) {
+        onLocationChanged(result.lastLocation)
+        if (locationProvider != null) {
+            locationProvider!!.onSuccess(result)
+        }
+    }
+
+    companion object {
+        const val DEFAULT_FASTEST_INTERVAL_MILLIS: Long = 1000
+        const val DEFAULT_INTERVAL_MILLIS: Long = 1000
+        const val LOG_TAG = "LocationManager"
+        private var INSTANCE: WeakReference<LocationManager>? = null
+        @JvmStatic
+        fun getInstance(context: Context): LocationManager? {
+            if (INSTANCE == null) {
+                INSTANCE = WeakReference(LocationManager(context))
+            }
+            return INSTANCE!!.get()
+        }
+    }
+
+    init {
+        buildEngineRequest()
+    }
+}

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

@@ -0,0 +1,7 @@
+package com.mapbox.rctmgl.location;
+
+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-v10/com/mapbox/rctmgl/location/UserTrackingState.java

@@ -0,0 +1,15 @@
+package com.mapbox.rctmgl.location;
+
+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-v10/com/mapbox/rctmgl/modules/RCTMGLLocationModule.java

@@ -0,0 +1,160 @@
+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.android.core.location.LocationEngineCallback;
+import com.mapbox.android.core.location.LocationEngineResult;
+import com.mapbox.rctmgl.events.EventEmitter;
+import com.mapbox.rctmgl.events.IEvent;
+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) {
+         // Required for rn built in EventEmitter Calls.
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+         // Required for rn built in EventEmitter Calls.
+    }
+
+    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-v10/com/mapbox/rctmgl/modules/RCTMGLLogging.kt

@@ -0,0 +1,113 @@
+package com.mapbox.rctmgl.modules
+
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.mapbox.rctmgl.modules.RCTMGLLogging
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import com.mapbox.rctmgl.utils.Logger
+import com.mapbox.rctmgl.utils.Logger.LoggerDefinition
+
+@ReactModule(name = RCTMGLLogging.REACT_CLASS)
+class RCTMGLLogging(private val mReactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(
+        mReactContext
+    ) {
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String?) {
+        // Set up any upstream listeners or background tasks as necessary
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int?) {
+        // Remove upstream listeners, stop unnecessary background tasks
+    }
+
+    @ReactMethod
+    fun setLogLevel(level: String?) {
+        val NONE = 0
+        var logLevel = NONE
+        logLevel = when (level) {
+            "error" -> Log.ERROR
+            "warning" -> Log.WARN
+            "info" -> Log.INFO
+            "debug" -> Log.DEBUG
+            "verbose" -> Log.VERBOSE
+            else -> NONE
+        }
+        Logger.setVerbosity(logLevel)
+    }
+
+    fun onLog(level: String?, tag: String?, msg: String?, tr: Throwable?) {
+        val event = Arguments.createMap()
+        event.putString("message", msg)
+        event.putString("tag", tag)
+        event.putString("level", level)
+        mReactContext
+            .getJSModule(RCTDeviceEventEmitter::class.java)
+            .emit("LogEvent", event)
+    }
+
+    companion object {
+        const val REACT_CLASS = "RCTMGLLogging"
+    }
+
+    init {
+        Logger.setVerbosity(Log.WARN)
+        Logger.setLoggerDefinition(object : LoggerDefinition {
+            override fun v(tag: String, msg: String) {
+                Log.v(tag, msg)
+                onLog("verbose", tag, msg, null)
+            }
+
+            override fun v(tag: String, msg: String, tr: Throwable) {
+                Log.v(tag, msg, tr)
+                onLog("verbose", tag, msg, tr)
+            }
+
+            override fun d(tag: String, msg: String) {
+                Log.d(tag, msg)
+                onLog("debug", tag, msg, null)
+            }
+
+            override fun d(tag: String, msg: String, tr: Throwable) {
+                Log.d(tag, msg, tr)
+                onLog("debug", tag, msg, tr)
+            }
+
+            override fun i(tag: String, msg: String) {
+                Log.i(tag, msg)
+                onLog("info", tag, msg, null)
+            }
+
+            override fun i(tag: String, msg: String, tr: Throwable) {
+                Log.i(tag, msg, tr)
+                onLog("info", tag, msg, tr)
+            }
+
+            override fun w(tag: String, msg: String) {
+                Log.w(tag, msg)
+                onLog("warning", tag, msg, null)
+            }
+
+            override fun w(tag: String, msg: String, tr: Throwable) {
+                Log.w(tag, msg, tr)
+                onLog("warning", tag, msg, tr)
+            }
+
+            override fun e(tag: String, msg: String) {
+                Log.e(tag, msg)
+                onLog("error", tag, msg, null)
+            }
+
+            override fun e(tag: String, msg: String, tr: Throwable) {
+                Log.e(tag, msg, tr)
+                onLog("error", tag, msg, tr)
+            }
+        })
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/modules/RCTMGLModule.kt

@@ -0,0 +1,134 @@
+package com.mapbox.rctmgl.modules
+
+import android.os.Handler
+import com.mapbox.maps.extension.style.layers.properties.generated.LineJoin
+import com.mapbox.maps.ResourceOptionsManager.Companion.getDefault
+import com.facebook.react.module.annotations.ReactModule
+import com.mapbox.rctmgl.modules.RCTMGLModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.mapbox.rctmgl.events.constants.EventTypes
+import com.mapbox.rctmgl.modules.RCTMGLOfflineModule
+import com.mapbox.rctmgl.modules.RCTMGLLocationModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.common.MapBuilder
+import com.mapbox.maps.Style
+import com.mapbox.rctmgl.components.camera.constants.CameraMode
+import java.util.HashMap
+
+@ReactModule(name = RCTMGLModule.REACT_CLASS)
+class RCTMGLModule(private val mReactContext: ReactApplicationContext) : ReactContextBaseJavaModule(
+    mReactContext
+) {
+    private val mUiThreadHandler: Handler? = null
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    override fun getConstants(): Map<String, Any>? {
+        // map style urls
+        val styleURLS: MutableMap<String, String> = HashMap()
+        styleURLS["Street"] = Style.MAPBOX_STREETS
+        styleURLS["Dark"] = Style.DARK
+        styleURLS["Light"] = Style.LIGHT
+        styleURLS["Outdoors"] = Style.OUTDOORS
+        styleURLS["Satellite"] = Style.SATELLITE
+        styleURLS["SatelliteStreet"] = Style.SATELLITE_STREETS
+        styleURLS["TrafficDay"] = Style.TRAFFIC_DAY
+        styleURLS["TrafficNight"] = Style.TRAFFIC_NIGHT
+
+        // tile server
+        val tileServers: MutableMap<String, String> = HashMap()
+        tileServers["Mapbox"] = "mapbox"
+
+        // impl
+        val impl: MutableMap<String, String> = HashMap()
+        impl["Library"] = "mapbox"
+
+        // events
+        val eventTypes: MutableMap<String, String> = HashMap()
+        eventTypes["MapClick"] = EventTypes.MAP_CLICK
+        eventTypes["MapLongClick"] = EventTypes.MAP_LONG_CLICK
+        eventTypes["RegionWillChange"] = EventTypes.REGION_WILL_CHANGE
+        eventTypes["RegionIsChanging"] = EventTypes.REGION_IS_CHANGING
+        eventTypes["RegionDidChange"] = EventTypes.REGION_DID_CHANGE
+        eventTypes["UserLocationUpdated"] = EventTypes.USER_LOCATION_UPDATED
+        eventTypes["WillStartLoadingMap"] = EventTypes.WILL_START_LOADING_MAP
+        eventTypes["DidFinishLoadingMap"] = EventTypes.DID_FINISH_LOADING_MAP
+        eventTypes["DidFailLoadingMap"] = EventTypes.DID_FAIL_LOADING_MAP
+        eventTypes["WillStartRenderingFrame"] = EventTypes.WILL_START_RENDERING_FRAME
+        eventTypes["DidFinishRenderingFrame"] = EventTypes.DID_FINISH_RENDERING_FRAME
+        eventTypes["DidFinishRenderingFrameFully"] = EventTypes.DID_FINISH_RENDERING_FRAME_FULLY
+        eventTypes["WillStartRenderingMap"] = EventTypes.WILL_START_RENDERING_MAP
+        eventTypes["DidFinishRenderingMap"] = EventTypes.DID_FINISH_RENDERING_MAP
+        eventTypes["DidFinishRenderingMapFully"] = EventTypes.DID_FINISH_RENDERING_MAP_FULLY
+        eventTypes["DidFinishLoadingStyle"] = EventTypes.DID_FINISH_LOADING_STYLE
+
+        // style source constants
+        val styleSourceConsts: MutableMap<String, String> = HashMap()
+        styleSourceConsts["DefaultSourceID"] = "composite"
+
+        // line layer constants
+        val lineJoin: MutableMap<String, String> = HashMap()
+        lineJoin["Bevel"] = LineJoin.BEVEL.value
+        lineJoin["Round"] = LineJoin.ROUND.value
+        lineJoin["Miter"] = LineJoin.MITER.value
+
+        // camera modes
+        val cameraModes: MutableMap<String, Int> = HashMap()
+        cameraModes["Flight"] = CameraMode.FLIGHT
+        cameraModes["Ease"] = CameraMode.EASE
+        cameraModes["Linear"] = CameraMode.LINEAR
+        cameraModes["None"] = CameraMode.NONE
+
+        // offline region download states
+        val offlinePackDownloadStates: MutableMap<String, String> = HashMap()
+        offlinePackDownloadStates["Inactive"] = RCTMGLOfflineModule.INACTIVE_REGION_DOWNLOAD_STATE
+        offlinePackDownloadStates["Active"] = RCTMGLOfflineModule.ACTIVE_REGION_DOWNLOAD_STATE
+        offlinePackDownloadStates["Complete"] = RCTMGLOfflineModule.COMPLETE_REGION_DOWNLOAD_STATE
+
+        // offline module callback names
+        val offlineModuleCallbackNames: MutableMap<String, String> = HashMap()
+        offlineModuleCallbackNames["Error"] = RCTMGLOfflineModule.OFFLINE_ERROR
+        offlineModuleCallbackNames["Progress"] = RCTMGLOfflineModule.OFFLINE_PROGRESS
+
+        // location module callback names
+        val locationModuleCallbackNames: MutableMap<String, String> = HashMap()
+        locationModuleCallbackNames["Update"] = RCTMGLLocationModule.LOCATION_UPDATE
+        return MapBuilder.builder<String, Any>()
+            .put("StyleURL", styleURLS)
+            .put("EventTypes", eventTypes)
+            .put("StyleSource", styleSourceConsts)
+            .put("CameraModes", cameraModes)
+            .put("LineJoin", lineJoin)
+            .put("OfflinePackDownloadState", offlinePackDownloadStates)
+            .put("OfflineCallbackName", offlineModuleCallbackNames)
+            .put("LocationCallbackName", locationModuleCallbackNames)
+            .put("TileServers", tileServers)
+            .put("Implementation", impl)
+            .build()
+    }
+
+    @ReactMethod
+    fun setAccessToken(accessToken: String?) {
+        mReactContext.runOnUiQueueThread(Runnable {
+            getDefault(
+                reactApplicationContext, accessToken
+            )
+        })
+    }
+
+    @ReactMethod
+    fun setWellKnownTileServer(tileServer: String?) {
+        // NO-OP
+    }
+
+    companion object {
+        const val REACT_CLASS = "RCTMGLModule"
+        private val customHeaderInterceptorAdded = false
+        @JvmStatic
+        fun getAccessToken(reactContext: ReactApplicationContext?): String {
+            return getDefault((reactContext)!!, null).resourceOptions.accessToken
+        }
+    }
+}