@rnmapbox/maps 10.0.15 → 10.1.0-beta.11

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

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

@@ -1,39 +0,0 @@
-package com.mapbox.rctmgl.modules
-
-import com.mapbox.common.*
-
-object CustomHttpHeaders : HttpServiceInterceptorInterface {
-    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-v10/com/mapbox/rctmgl/modules/RCTMGLLocationModule.kt

@@ -1,187 +0,0 @@
-package com.mapbox.rctmgl.modules
-
-import android.location.Location
-import com.facebook.react.bridge.*
-import com.mapbox.rctmgl.location.LocationManager
-import com.facebook.react.module.annotations.ReactModule
-import com.mapbox.rctmgl.location.LocationManager.OnUserLocationChange
-import com.mapbox.rctmgl.events.LocationEvent
-import com.mapbox.android.core.location.LocationEngineCallback
-import com.mapbox.android.core.location.LocationEngineResult
-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) {
-    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<LocationEngineResult> {
-                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 = "RCTMGLLocationModule"
-        const val LOCATION_UPDATE = "MapboxUserLocationUpdate"
-    }
-}

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

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

@@ -1,163 +0,0 @@
-package com.mapbox.rctmgl.modules
-
-import android.os.Handler
-import com.facebook.react.bridge.Promise
-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.common.*
-import com.mapbox.maps.MapView
-import com.mapbox.maps.Style
-import com.mapbox.maps.plugin.attribution.attribution
-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 // deprecated
-        eventTypes["CameraChanged"] = EventTypes.CAMERA_CHANGED
-        eventTypes["RegionDidChange"] = EventTypes.REGION_DID_CHANGE // deprecated
-        eventTypes["MapIdle"] = EventTypes.MAP_IDLE
-        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
-        eventTypes["MapLoadingError"] = EventTypes.MAP_LOADING_ERROR
-
-        // 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"] = 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()
-        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("MapboxV10", true)
-            .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 setTelemetryEnabled(telemetryEnabled: Boolean) {
-        mReactContext.runOnUiQueueThread {
-            val dummyView = MapView(mReactContext)
-            val telemetry = dummyView.attribution.getMapAttributionDelegate().telemetry()
-            telemetry.userTelemetryRequestState = telemetryEnabled
-        }
-    }
-
-    @ReactMethod
-    fun setAccessToken(accessToken: String?, promise: Promise) {
-        mReactContext.runOnUiQueueThread(Runnable {
-            getDefault(
-                reactApplicationContext, accessToken
-            )
-            promise.resolve(accessToken)
-        })
-    }
-
-    @ReactMethod
-    fun setWellKnownTileServer(tileServer: String?) {
-        // NO-OP
-    }
-
-    @ReactMethod
-    fun addCustomHeader(headerName: String, headerValue: String) {
-        CustomHttpHeaders.addCustomHeader(headerName, headerValue)
-    }
-
-    @ReactMethod
-    fun removeCustomHeader(headerName: String) {
-        CustomHttpHeaders.removeCustomHeader(headerName)
-    }
-
-    companion object {
-        const val REACT_CLASS = "RCTMGLModule"
-        private val customHeaderInterceptorAdded = false
-        @JvmStatic
-        fun getAccessToken(reactContext: ReactApplicationContext?): String {
-            return getDefault((reactContext)!!, null).resourceOptions.accessToken
-        }
-    }
-}