@rnmapbox/maps 10.0.0-rc.0 → 10.0.0-rc.10

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/sources/RCTMGLTileSourceManager.kt

@@ -8,7 +8,7 @@ import com.facebook.react.uimanager.annotations.ReactProp
 import com.mapbox.rctmgl.components.AbstractEventEmitter
 
 abstract class RCTMGLTileSourceManager<T : RCTMGLTileSource<*>?> internal constructor(
-    reactApplicationContext: ReactApplicationContext?
+    reactApplicationContext: ReactApplicationContext
 ) : AbstractEventEmitter<T>(reactApplicationContext) {
     override fun getChildAt(source: T, childPosition: Int): View {
         return source!!.getChildAt(childPosition)

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/styles/sources/RCTMGLVectorSourceManager.kt

@@ -11,7 +11,7 @@ import com.mapbox.rctmgl.utils.ConvertUtils
 import com.mapbox.rctmgl.utils.ExpressionParser
 import javax.annotation.Nonnull
 
-class RCTMGLVectorSourceManager(reactApplicationContext: ReactApplicationContext?) :
+class RCTMGLVectorSourceManager(reactApplicationContext: ReactApplicationContext) :
     RCTMGLTileSourceManager<RCTMGLVectorSource?>(reactApplicationContext) {
     @Nonnull
     override fun getName(): String {

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/events/AbstractEvent.kt

@@ -0,0 +1,49 @@
+package com.mapbox.rctmgl.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+
+abstract class AbstractEvent(view: View?, private val mEventType: String) : IEvent {
+    private var mTagID = 0
+    private val mTimestamp: Long
+
+    constructor(eventType: String) : this(null, eventType) {}
+
+    init {
+        if (view != null) {
+            mTagID = view.id
+        }
+        mTimestamp = System.currentTimeMillis()
+    }
+
+    override val iD
+        get() = mTagID
+
+    override val type
+        get() = mEventType
+
+    override fun equals(event: IEvent): Boolean {
+        return key == event.key && mEventType == event.type
+    }
+
+    override val payload
+        get() = Arguments.createMap()
+
+    override val timestamp
+        get() = mTimestamp
+
+    override fun toJSON(): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("type", type)
+        val payloadClone = Arguments.createMap()
+        payloadClone.merge(payload)
+        map.putMap("payload", payloadClone)
+        return map
+    }
+
+    override fun canCoalesce(): Boolean {
+        // default behavior of com.facebook.react.uimanager.events.Event
+        return true
+    }
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/events/IEvent.kt

@@ -0,0 +1,17 @@
+package com.mapbox.rctmgl.events
+
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * Created by nickitaliano on 8/23/17.
+ */
+interface IEvent {
+    val iD: Int
+    val key: String?
+    val type: String?
+    val timestamp: Long
+    fun equals(event: IEvent): Boolean
+    fun canCoalesce(): Boolean
+    val payload: WritableMap
+    fun toJSON(): WritableMap
+}

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/events/LocationEvent.kt

@@ -3,10 +3,8 @@ package com.mapbox.rctmgl.events
 import android.location.Location
 import com.facebook.react.bridge.Arguments
 import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
-import com.mapbox.rctmgl.events.IEvent
 import com.mapbox.rctmgl.events.constants.EventKeys
 import com.mapbox.rctmgl.events.constants.EventTypes
-import com.mapbox.rctmgl.events.LocationEvent
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeMap
 import java.util.*
@@ -20,21 +18,17 @@ class LocationEvent(private val location: Location, private val mapView: RCTMGLM
 
     constructor(location: Location) : this(location, null) {}
 
-    override fun getID(): Int {
-        return mapView?.id ?: -1
-    }
+    override val iD
+        get() =  mapView?.id ?: -1
 
-    override fun getKey(): String {
-        return EventKeys.USER_LOCATION_UPDATE
-    }
+    override val key
+        get() = EventKeys.USER_LOCATION_UPDATE
 
-    override fun getType(): String {
-        return EventTypes.USER_LOCATION_UPDATED
-    }
+    override val type
+        get() = EventTypes.USER_LOCATION_UPDATED
 
-    override fun getTimestamp(): Long {
-        return System.currentTimeMillis()
-    }
+    override val timestamp
+        get() =  System.currentTimeMillis()
 
     override fun equals(event: IEvent): Boolean {
         val other = event as LocationEvent
@@ -45,14 +39,15 @@ class LocationEvent(private val location: Location, private val mapView: RCTMGLM
         return uUID == event.uUID
     }
 
-    override fun getPayload(): WritableMap {
+    override val payload: WritableMap
+    get() {
         val positionProperties: WritableMap = WritableNativeMap()
         val coords: WritableMap = WritableNativeMap()
         coords.putDouble("longitude", location.longitude)
         coords.putDouble("latitude", location.latitude)
         coords.putDouble("altitude", location.altitude)
         coords.putDouble("accuracy", location.accuracy.toDouble())
-        // A better solution will be to pull the heading from the compass engine, 
+        // 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.bearing.toDouble())
         coords.putDouble("course", location.bearing.toDouble())

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/events/MapUserTrackingModeEvent.kt

@@ -7,15 +7,15 @@ import com.mapbox.rctmgl.components.location.UserTrackingMode
 import com.mapbox.rctmgl.events.constants.EventKeys
 import com.mapbox.rctmgl.events.constants.EventTypes
 
-class MapUserTrackingModeEvent(view: View?, val userTrackingMode: Int) : AbstractEvent(view, EventTypes.MAP_USER_TRACKING_MODE_CHANGE) {
-    override fun getKey(): String {
-        return EventKeys.MAP_USER_TRACKING_MODE_CHANGE;
-    }
+class MapUserTrackingModeEvent(view: View?, val userTrackingMode: Int, val basePayload: WritableMap? = null) : AbstractEvent(view, EventTypes.MAP_USER_TRACKING_MODE_CHANGE) {
+    override val key
+        get() = EventKeys.MAP_USER_TRACKING_MODE_CHANGE;
 
-    override fun getPayload(): WritableMap {
-        val payload = Arguments.createMap()
-        payload.putBoolean("followUserLocation", userTrackingMode != UserTrackingMode.NONE)
-        payload.putString("followUserMode", UserTrackingMode.toString(userTrackingMode))
-        return payload
-    }
+    override val payload : WritableMap
+        get() = {
+            val payload = basePayload?.copy() ?: Arguments.createMap()
+            payload.putBoolean("followUserLocation", userTrackingMode != UserTrackingMode.NONE)
+            payload.putString("followUserMode", UserTrackingMode.toString(userTrackingMode))
+            payload
+        }.invoke()
 }

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/events/constants/EventTypes.kt

@@ -0,0 +1,44 @@
+package com.mapbox.rctmgl.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"
+
+    // 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/rctmgl/src/main/java-v10/com/mapbox/rctmgl/modules/RCTMGLLocationModule.kt

@@ -12,6 +12,9 @@ import com.mapbox.rctmgl.events.EventEmitter
 import com.mapbox.rctmgl.location.LocationManager.Companion.getInstance
 import java.lang.Exception
 
+data class LocationEventThrottle(var waitBetweenEvents: Double? = null, var lastSentTimestamp: Long? = null) {
+}
+
 @ReactModule(name = RCTMGLLocationModule.REACT_CLASS)
 class RCTMGLLocationModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
@@ -19,6 +22,7 @@ class RCTMGLLocationModule(reactContext: ReactApplicationContext) :
     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() {
@@ -52,7 +56,7 @@ class RCTMGLLocationModule(reactContext: ReactApplicationContext) :
                 }
             }
             mLastLocation = location
-            if (changed && (location != null)) {
+            if (changed && (location != null) && shouldSendLocationEvent()) {
                 val locationEvent = LocationEvent(location)
                 val emitter = EventEmitter.getModuleEmitter(reactApplicationContext)
                 emitter?.emit(LOCATION_UPDATE, locationEvent.payload)
@@ -145,6 +149,37 @@ class RCTMGLLocationModule(reactContext: ReactApplicationContext) :
         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 = "RCTMGLLocationModule"
         const val LOCATION_UPDATE = "MapboxUserLocationUpdate"

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

@@ -87,9 +87,10 @@ class RCTMGLModule(private val mReactContext: ReactApplicationContext) : ReactCo
 
         // 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
+        offlinePackDownloadStates["Inactive"] = TileRegionPackState.INACTIVE.rawValue
+        offlinePackDownloadStates["Active"] = TileRegionPackState.ACTIVE.rawValue
+        offlinePackDownloadStates["Complete"] = TileRegionPackState.COMPLETE.rawValue
+        offlinePackDownloadStates["Unknown"] = TileRegionPackState.UNKNOWN.rawValue
 
         // offline module callback names
         val offlineModuleCallbackNames: MutableMap<String, String> = HashMap()