@rnmapbox/maps 10.0.15 → 10.1.0-beta.11

package/android/src/main/java/com/rnmapbox/rnmbx/events/PointAnnotationClickEvent.java

@@ -0,0 +1,42 @@
+package com.rnmapbox.rnmbx.events;
+
+import android.graphics.PointF;
+import androidx.annotation.NonNull;
+import android.view.View;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.mapbox.maps.ScreenCoordinate;
+import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotation;
+import com.rnmapbox.rnmbx.events.constants.EventKeys;
+import com.rnmapbox.rnmbx.events.constants.EventTypes;
+import com.rnmapbox.rnmbx.utils.ConvertUtils;
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils;
+import com.rnmapbox.rnmbx.utils.LatLng;
+
+public class PointAnnotationClickEvent extends MapClickEvent {
+    private RNMBXPointAnnotation mView;
+    private LatLng mTouchedLatLng;
+    private ScreenCoordinate mScreenPoint;
+
+    public PointAnnotationClickEvent(RNMBXPointAnnotation view, @NonNull LatLng latLng, @NonNull ScreenCoordinate screenPoint, String eventType) {
+        super(view, latLng, screenPoint, eventType);
+        mView = view;
+        mTouchedLatLng = latLng;
+        mScreenPoint = screenPoint;
+    }
+
+    @Override
+    public String getKey() {
+        return getType().equals(EventTypes.ANNOTATION_SELECTED) ? EventKeys.POINT_ANNOTATION_SELECTED : EventKeys.POINT_ANNOTATION_DESELECTED;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        WritableMap properties = new WritableNativeMap();
+        properties.putString("id", mView.getID());
+        properties.putDouble("screenPointX", mScreenPoint.getX());
+        properties.putDouble("screenPointY", mScreenPoint.getY());
+        return GeoJSONUtils.toPointFeature(mTouchedLatLng, properties);
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/events/PointAnnotationDragEvent.java

@@ -0,0 +1,53 @@
+package com.rnmapbox.rnmbx.events;
+
+import android.graphics.PointF;
+import androidx.annotation.NonNull;
+import android.view.View;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.mapbox.maps.ScreenCoordinate;
+import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotation;
+import com.rnmapbox.rnmbx.events.constants.EventKeys;
+import com.rnmapbox.rnmbx.events.constants.EventTypes;
+import com.rnmapbox.rnmbx.utils.ConvertUtils;
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils;
+import com.rnmapbox.rnmbx.utils.LatLng;
+
+public class PointAnnotationDragEvent extends MapClickEvent {
+    RNMBXPointAnnotation mView;
+    private LatLng mTouchedLatLng;
+    private PointF mScreenPoint;
+
+    public PointAnnotationDragEvent(RNMBXPointAnnotation view, @NonNull LatLng latLng, @NonNull PointF screenPoint, String eventType) {
+        super(view, latLng, new ScreenCoordinate(screenPoint.x, screenPoint.y), eventType);
+        mView = view;
+        mTouchedLatLng = latLng;
+        mScreenPoint = screenPoint;
+    }
+
+    @Override
+    public String getKey() {
+        String eventType = getType();
+
+        if (eventType.equals(EventTypes.ANNOTATION_DRAG_START)) {
+            return EventKeys.POINT_ANNOTATION_DRAG_START;
+        }
+        if (eventType.equals(EventTypes.ANNOTATION_DRAG_END)) {
+            return EventKeys.POINT_ANNOTATION_DRAG_END;
+        }
+
+        return EventKeys.POINT_ANNOTATION_DRAG;
+    }
+
+    @Override
+    public WritableMap getPayload() {
+        WritableMap properties = new WritableNativeMap();
+        properties.putDouble("screenPointX", mScreenPoint.x);
+        properties.putDouble("screenPointY", mScreenPoint.y);
+        WritableMap feature = GeoJSONUtils.toPointFeature(mTouchedLatLng, properties);
+        feature.putString("id", mView.getID());
+        
+        return feature;
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/events/constants/EventKeys.java

@@ -0,0 +1,39 @@
+package com.rnmapbox.rnmbx.events.constants;
+
+/**
+ * Created by nickitaliano on 8/27/17.
+ */
+
+public class EventKeys {
+    public static final String NAMESPACE = "rct.mapbox";
+
+    // map events
+    public static final String MAP_CLICK = ns("map.press");
+    public static final String MAP_LONG_CLICK = ns("map.longpress");
+    public static final String MAP_ONCHANGE = ns("map.change");
+    public static final String MAP_ON_LOCATION_CHANGE = ns("map.location.change");
+    public static final String MAP_ANDROID_CALLBACK = ns("map.androidcallback");
+    public static final String MAP_USER_TRACKING_MODE_CHANGE = ns("map.usertrackingmodechange");
+
+    // point annotation events
+    public static final String POINT_ANNOTATION_SELECTED = ns("pointannotation.selected");
+    public static final String POINT_ANNOTATION_DESELECTED = ns("pointannotation.deselected");
+    public static final String POINT_ANNOTATION_DRAG_START = ns("pointannotation.dragstart");
+    public static final String POINT_ANNOTATION_DRAG = ns("pointannotation.drag");
+    public static final String POINT_ANNOTATION_DRAG_END = ns("pointannotation.dragend");
+
+    // source events
+    public static final String SHAPE_SOURCE_LAYER_CLICK = ns("shapesource.layer.pressed");
+    public static final String VECTOR_SOURCE_LAYER_CLICK = ns("vectorsource.layer.pressed");
+    public static final String RASTER_SOURCE_LAYER_CLICK = ns("rastersource.layer.pressed");
+
+    // images event
+    public static final String IMAGES_MISSING = ns("images.missing");
+
+    // location events
+    public static final String USER_LOCATION_UPDATE = ns("user.location.update");
+
+    private static String ns(String name) {
+        return String.format("%s.%s", NAMESPACE, name);
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/events/constants/EventTypes.kt

@@ -0,0 +1,45 @@
+package com.rnmapbox.rnmbx.events.constants
+
+object EventTypes {
+    // map event types
+    const val MAP_CLICK = "press"
+    const val MAP_LONG_CLICK = "longpress"
+    const val MAP_USER_TRACKING_MODE_CHANGE = "usertrackingmodechange"
+    const val REGION_WILL_CHANGE = "regionwillchange"
+    const val REGION_IS_CHANGING = "regionischanging" // deprecated
+    const val CAMERA_CHANGED = "camerachanged"
+    const val REGION_DID_CHANGE = "regiondidchange"
+    const val MAP_IDLE = "mapidle"
+    const val USER_LOCATION_UPDATED = "userlocationdupdated"
+    const val WILL_START_LOADING_MAP = "willstartloadingmap"
+    const val DID_FINISH_LOADING_MAP = "didfinishloadingmap"
+    const val DID_FAIL_LOADING_MAP = "didfailloadingmap"
+    const val WILL_START_RENDERING_FRAME = "willstartrenderingframe"
+    const val DID_FINISH_RENDERING_FRAME = "didfinishrenderingframe"
+    const val DID_FINISH_RENDERING_FRAME_FULLY = "didfinishrenderingframefully"
+    const val WILL_START_RENDERING_MAP = "willstartrenderingmap"
+    const val DID_FINISH_RENDERING_MAP = "didfinishrenderingmap"
+    const val DID_FINISH_RENDERING_MAP_FULLY = "didfinishrenderingmapfully"
+    const val DID_FINISH_LOADING_STYLE = "didfinishloadingstyle"
+    const val MAP_LOADING_ERROR = "maploadingerror"
+
+    // point annotation event types
+    const val ANNOTATION_SELECTED = "annotationselected"
+    const val ANNOTATION_DESELECTED = "annotationdeselected"
+    const val ANNOTATION_DRAG_START = "annotationdragstart"
+    const val ANNOTATION_DRAG = "annotationdrag"
+    const val ANNOTATION_DRAG_END = "annotationdragend"
+
+    // offline event types
+    const val OFFLINE_ERROR = "offlineerror"
+    const val OFFLINE_TILE_LIMIT = "offlinetilelimit"
+    const val OFFLINE_STATUS = "offlinestatus"
+
+    // shape source event types
+    const val SHAPE_SOURCE_LAYER_CLICK = "shapesourcelayerpress"
+    const val VECTOR_SOURCE_LAYER_CLICK = "vectorsourcelayerpress"
+    const val RASTER_SOURCE_LAYER_CLICK = "rastersourcelayerpress"
+
+    // image missing event type
+    const val IMAGES_MISSING = "imagesmissing"
+}

package/android/src/main/java/com/rnmapbox/rnmbx/location/LocationManager.kt

@@ -0,0 +1,277 @@
+package com.rnmapbox.rnmbx.location
+
+import android.annotation.SuppressLint
+import android.content.Context
+import com.mapbox.maps.plugin.locationcomponent.LocationConsumer
+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.ref.WeakReference
+import java.util.ArrayList
+import kotlin.Exception
+
+import com.rnmapbox.rnmbx.v11compat.location.*
+
+
+open class SingletonHolder<out T, in A>(creator: (A) -> T) {
+    private var creator: ((A) -> T)? = creator
+    @Volatile private var instance: T? = null
+
+    fun getInstance(arg: A): T {
+        val i = instance
+        if (i != null) {
+            return i
+        }
+
+        return synchronized(this) {
+            val i2 = instance
+            if (i2 != null) {
+                i2
+            } else {
+                val created = creator!!(arg)
+                instance = created
+                creator = null
+                created
+            }
+        }
+    }
+}
+
+internal class LocationProviderForEngine(var mEngine: LocationEngine?, val context: Context) : LocationProvider, LocationEngineCallback {
+    var mConsumers = ArrayList<LocationConsumer>()
+    @SuppressLint("MissingPermission")
+    fun beforeAddingFirstConsumer() {
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return
+        }
+
+        mEngine?.requestLocationUpdatesV11(
+          this,
+          Looper.getMainLooper(),
+            null
+        )
+
+    }
+    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)
+            location.bearing?.toDouble()?.also {
+                consumer.onBearingUpdated(it)
+            }
+        }
+    }
+
+    // * 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 {
+    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: LocationProvider? = null
+    private var nStarts : Int = 0
+    private var isPaused : Boolean = false
+
+    var provider: LocationProvider
+        get() {
+            var ret = locationProvider
+            if (ret == null) {
+                val engine = LocationProviderForEngine(engine, context)
+                locationProvider = engine
+                return engine
+            } else {
+                return ret
+            }
+        }
+        set(value) {
+            locationProvider = value
+        }
+
+    interface OnUserLocationChange {
+        fun onLocationChange(location: Location?)
+    }
+
+    /// public interface
+
+    fun startCounted() {
+        nStarts += 1;
+        if (nStarts == 1) {
+            enable(false);
+        }
+    }
+
+    fun stopCounted() {
+        nStarts -= 1;
+        if (nStarts == 0) {
+            dispose();
+        }
+    }
+
+    fun pause() {
+        isPaused = true
+    }
+
+    fun resume() {
+        isPaused = false
+        if (nStarts > 0) {
+            enable(false)
+        }
+    }
+
+    fun destroy() {
+        dispose();
+        nStarts = -1000;
+    }
+
+    ////
+
+    private fun buildEngineRequest() {
+        engine = createLocationEngine(context.applicationContext)
+    }
+
+    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
+
+        if (isActive) {
+            enable(true)
+        }
+    }
+
+    @SuppressLint("MissingPermission")
+    private fun enable(refresh: Boolean) {
+        if (!PermissionsManager.areLocationPermissionsGranted(context)) {
+            return
+        }
+
+        // remove existing listeners
+        engine?.removeLocationUpdates(this)
+
+        // refresh location engine request with new values
+
+        // add new listeners
+        engine?.requestLocationUpdatesV11(
+            this,
+            Looper.getMainLooper(),
+            mMinDisplacement
+        )
+        isActive = true
+    }
+
+    private fun disable() {
+        engine?.removeLocationUpdates(this)
+        isActive = false
+    }
+
+    private fun dispose() {
+        if (engine == null) {
+            return
+        }
+        disable()
+    }
+
+    fun isActive(): Boolean {
+        return engine != null && isActive
+    }
+
+    val lastKnownLocation: Location?
+        get() = if (engine == null) {
+            null
+        } else lastLocation
+
+    @SuppressLint("MissingPermission")
+    fun getLastKnownLocation(callback: LocationEngineCallback) {
+        if (engine == null) {
+            callback.onFailure(Exception("LocationEngine not initialized"))
+        }
+        try {
+            engine?.getLastLocation(object : LocationEngineCallback {
+                override fun onSuccess(result: LocationEngineResult) {
+                    if (result == null) {
+                        callback.onFailure( NullPointerException("LocationEngineResult is null"))
+                    } else {
+                        callback.onSuccess(result)
+                    }
+                }
+
+                override fun onFailure(exception: Exception) {
+                    callback.onFailure(exception)
+                }
+            })
+        } 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)
+        val provider = locationProvider
+        if (provider != null && provider is LocationProviderForEngine) {
+            provider.onSuccess(result)
+        }
+    }
+
+    companion object : SingletonHolder<LocationManager, Context>(::LocationManager) {
+        const val DEFAULT_FASTEST_INTERVAL_MILLIS: Long = 1000
+        const val DEFAULT_INTERVAL_MILLIS: Long = 1000
+        const val LOG_TAG = "LocationManager"
+
+    }
+
+    init {
+        buildEngineRequest()
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/location/UserTrackingState.java

@@ -0,0 +1,15 @@
+package com.rnmapbox.rnmbx.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/src/main/java/com/rnmapbox/rnmbx/modules/CustomHttpHeaders.kt

@@ -0,0 +1,41 @@
+package com.rnmapbox.rnmbx.modules
+
+import com.mapbox.common.*
+
+import com.rnmapbox.rnmbx.v11compat.httpinterceptor.*
+
+object CustomHttpHeaders : HttpServiceBase() {
+    init {}
+
+    val map = mutableMapOf<String, String>()
+
+    fun addCustomHeader(headerName: String, headerValue: String) {
+        HttpServiceFactory.getInstance().setInterceptor(
+            this
+        )
+        map.put(headerName, headerValue)
+    }
+
+    fun removeCustomHeader(headerName: String) {
+        map.remove(headerName)
+    }
+
+    override fun onRequest(request: HttpRequest): HttpRequest {
+        for (entry in map.entries.iterator()) {
+            request.headers[entry.key] = entry.value
+        }
+        return request
+    }
+
+    override fun onDownload(download: DownloadOptions): DownloadOptions {
+        for (entry in map.entries.iterator()) {
+            download.request.headers[entry.key] = entry.value
+        }
+        return download
+    }
+
+    override fun onResponse(response: HttpResponse): HttpResponse {
+        return response
+    }
+}
+

package/android/src/main/java/com/rnmapbox/rnmbx/modules/RNMBXLocationModule.kt

@@ -0,0 +1,186 @@
+package com.rnmapbox.rnmbx.modules
+
+import com.facebook.react.bridge.*
+import com.rnmapbox.rnmbx.location.LocationManager
+import com.facebook.react.module.annotations.ReactModule
+import com.rnmapbox.rnmbx.location.LocationManager.OnUserLocationChange
+import com.rnmapbox.rnmbx.events.LocationEvent
+import com.rnmapbox.rnmbx.events.EventEmitter
+import com.rnmapbox.rnmbx.location.LocationManager.Companion.getInstance
+import java.lang.Exception
+
+import com.rnmapbox.rnmbx.v11compat.location.*
+
+data class LocationEventThrottle(var waitBetweenEvents: Double? = null, var lastSentTimestamp: Long? = null) {
+}
+
+@ReactModule(name = RNMBXLocationModule.REACT_CLASS)
+class RNMBXLocationModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+    private var isEnabled = false
+    private var mMinDisplacement = 0f
+    private val locationManager: LocationManager? = getInstance(reactContext)
+    private var mLastLocation: Location? = null
+    private var locationEventThrottle: LocationEventThrottle = LocationEventThrottle()
+
+    private val lifecycleEventListener: LifecycleEventListener = object : LifecycleEventListener {
+        override fun onHostResume() {
+            if (isEnabled) {
+                locationManager?.resume()
+            }
+        }
+
+        override fun onHostPause() {
+            locationManager?.pause()
+        }
+
+        override fun onHostDestroy() {
+            locationManager?.destroy()
+        }
+    }
+
+    private val onUserLocationChangeCallback: OnUserLocationChange = object : OnUserLocationChange {
+        override fun onLocationChange(location: Location?) {
+            var changed = (mLastLocation != null) != (location != null)
+            val lastLocation = mLastLocation
+            if (lastLocation != null && location != null) {
+                if (
+                    lastLocation.latitude != location.latitude ||
+                    lastLocation.longitude != location.longitude ||
+                    lastLocation.altitude != location.altitude ||
+                    lastLocation.accuracy != location.accuracy ||
+                    lastLocation.bearing != location.bearing
+                ) {
+                    changed = true
+                }
+            }
+            mLastLocation = location
+            if (changed && (location != null) && shouldSendLocationEvent()) {
+                val locationEvent = LocationEvent(location)
+                val emitter = EventEmitter.getModuleEmitter(reactApplicationContext)
+                emitter?.emit(LOCATION_UPDATE, locationEvent.payload)
+            }
+        }
+    }
+
+    init {
+        reactContext.addLifecycleEventListener(lifecycleEventListener)
+    }
+
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    @ReactMethod
+    fun start(minDisplacement: Float) {
+        isEnabled = true
+        mMinDisplacement = minDisplacement
+        locationManager?.startCounted()
+        startLocationManager()
+    }
+
+    @ReactMethod
+    fun setMinDisplacement(minDisplacement: Float) {
+        if (mMinDisplacement == minDisplacement) return
+        mMinDisplacement = minDisplacement
+        if (isEnabled) {
+
+            // set minimal displacement in the manager
+            locationManager!!.setMinDisplacement(mMinDisplacement)
+        }
+    }
+
+    @ReactMethod
+    fun setRequestsAlwaysUse(requestsAlwaysUse: Boolean) {
+        // IOS only. Ignored on Android.
+    }
+
+    @ReactMethod
+    fun stop() {
+        stopLocationManager()
+    }
+
+    @ReactMethod
+    fun getLastKnownLocation(promise: Promise) {
+        locationManager!!.getLastKnownLocation(
+            object : LocationEngineCallback {
+                override fun onSuccess(result: LocationEngineResult) {
+                    val location = result.lastLocation
+                    if (location != null) {
+                        val locationEvent = LocationEvent(location)
+                        promise.resolve(locationEvent.payload)
+                    } else {
+                        promise.resolve(null)
+                    }
+                }
+
+                override fun onFailure(exception: Exception) {
+                    promise.reject(exception)
+                }
+            }
+        )
+    }
+
+    @ReactMethod
+    fun addListener(eventName: String?) {
+        // Required for rn built in EventEmitter Calls.
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int?) {
+        // Required for rn built in EventEmitter Calls.
+    }
+
+    private fun startLocationManager() {
+        mLastLocation = null;
+        locationManager!!.addLocationListener(onUserLocationChangeCallback)
+        locationManager.setMinDisplacement(mMinDisplacement)
+        locationManager.startCounted()
+    }
+
+    private fun stopLocationManager() {
+        if (!isEnabled) {
+            return
+        }
+        locationManager!!.removeLocationListener(onUserLocationChangeCallback)
+        locationManager.stopCounted()
+        isEnabled = false
+        mLastLocation = null
+    }
+
+    // region Location event throttle
+    @ReactMethod
+    fun setLocationEventThrottle(throttleValue: Double) {
+        if (throttleValue > 0) {
+            locationEventThrottle.waitBetweenEvents = throttleValue;
+        } else {
+            locationEventThrottle.waitBetweenEvents = null
+        }
+    }
+
+    fun shouldSendLocationEvent(): Boolean {
+        val waitBetweenEvents = locationEventThrottle.waitBetweenEvents
+        if (waitBetweenEvents == null) {
+            return true
+        }
+
+        val currentTimestamp = System.nanoTime()
+        val lastSentTimestamp = locationEventThrottle.lastSentTimestamp
+        if (lastSentTimestamp == null) {
+            return true
+        }
+
+        if ((currentTimestamp - lastSentTimestamp) > 1000.0*waitBetweenEvents) {
+            return true
+        }
+
+        return false
+    }
+    // endregion
+
+
+    companion object {
+        const val REACT_CLASS = "RNMBXLocationModule"
+        const val LOCATION_UPDATE = "MapboxUserLocationUpdate"
+    }
+}