@rnmapbox/maps 10.0.15 → 10.1.0-beta.10

package/android/src/main/java/com/rnmapbox/rnmbx/utils/ReadableMapToValue.java

@@ -0,0 +1,51 @@
+package com.rnmapbox.rnmbx.utils;
+
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.mapbox.bindgen.Value;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+public class ReadableMapToValue {
+    static Value convert(Dynamic dynamic) {
+        switch (dynamic.getType()) {
+            case Map:
+                return Value.valueOf(convert(dynamic.asMap()));
+            case Array:
+                return Value.valueOf(convert(dynamic.asArray()));
+            case String:
+                return Value.valueOf(dynamic.asString());
+            case Number:
+                return Value.valueOf(dynamic.asDouble());
+            case Boolean:
+                return Value.valueOf(dynamic.asBoolean());
+            case Null:
+                return Value.nullValue();
+        }
+        return null;
+    }
+
+    static List<Value> convert(ReadableArray array) {
+        ArrayList<Value> list = new ArrayList<>();
+        for (int i = 0; i < array.size(); ++i) {
+            list.add(convert(array.getDynamic(i)));
+        }
+        return list;
+    }
+
+    public static HashMap<String, Value> convert(ReadableMap map) {
+        HashMap<String, Value> result = new HashMap<>();
+        for (Iterator<Map.Entry<String, Object>> it = map.getEntryIterator(); it.hasNext(); ) {
+            Map.Entry<String, Object> entry = it.next();
+
+            String key = entry.getKey();
+            result.put(key, convert(map.getDynamic(key)));
+        }
+        return result;
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/ResourceUtils.java

@@ -0,0 +1,26 @@
+package com.rnmapbox.rnmbx.utils;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.drawable.Drawable;
+import androidx.core.content.ContextCompat;
+
+public class ResourceUtils {
+    public static Drawable getDrawableByName(Context context, String resourceName) {
+        if (context == null || resourceName == null || resourceName.isEmpty()) {
+            return null;
+        }
+
+        Resources resources = context.getResources();
+        if (resources == null) {
+            return null;
+        }
+
+        final int resID = resources.getIdentifier(resourceName, "drawable", context.getPackageName());
+        if (resID == 0) {
+            return null;
+        }
+        
+        return ContextCompat.getDrawable(context, resID);
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/ViewTagResolver.kt

@@ -0,0 +1,68 @@
+package com.rnmapbox.rnmbx.utils
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.uimanager.IllegalViewOperationException
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.rnmapbox.rnmbx.BuildConfig
+
+data class ViewTagWaiter<V>(
+    val fn: (V) -> Unit,
+    val reject: Promise?
+)
+
+// see https://github.com/rnmapbox/maps/pull/3074
+open class ViewTagResolver<V>(val context: ReactApplicationContext) {
+    private val createdViews: HashSet<Int> = hashSetOf<Int>()
+    private val viewWaiters: HashMap<Int, MutableList<ViewTagWaiter<V>>> = hashMapOf()
+
+    // to be called from view.setId
+    fun tagAssigned(viewTag: Int) {
+        createdViews.add(viewTag)
+
+        val list = viewWaiters[viewTag]
+        if (list != null) {
+            context.runOnUiQueueThread {
+                try {
+                    val view = manager.resolveView(viewTag) as V
+
+                    list.forEach { it.fn(view) }
+                } catch (err: IllegalViewOperationException) {
+                    list.forEach { it.reject?.reject(err) }
+                }
+                viewWaiters.remove(viewTag)
+            }
+        }
+    }
+
+    fun viewRemoved(viewTag: Int) {
+        viewWaiters.remove(viewTag)
+        createdViews.remove(viewTag)
+    }
+
+    private val manager : UIManager
+        get() =
+            if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+                UIManagerHelper.getUIManager(context, UIManagerType.FABRIC)!!
+            } else {
+                UIManagerHelper.getUIManager(context, UIManagerType.DEFAULT)!!
+            }
+
+    // calls on UiQueueThread with resolved view
+    fun withViewResolved(viewTag: Int, reject: Promise? = null, fn: (V) -> Unit) {
+        context.runOnUiQueueThread() {
+            try {
+                val view = manager.resolveView(viewTag) as V
+                fn(view)
+            } catch (err: IllegalViewOperationException) {
+                if (!createdViews.contains(viewTag)) {
+                    viewWaiters.getOrPut(viewTag) { mutableListOf<ViewTagWaiter<V>>() }.add(ViewTagWaiter(fn, reject))
+                } else {
+                    reject?.reject(err)
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/CoordinateBounds.kt

@@ -0,0 +1,17 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.mapbox.maps.CoordinateBounds
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils
+import com.rnmapbox.rnmbx.utils.LatLng
+
+fun CoordinateBounds.toReadableArray() : ReadableArray {
+    val array = Arguments.createArray()
+    val ne = northeast
+    val sw = southwest
+
+    array.pushArray(GeoJSONUtils.fromLatLng(LatLng(ne.latitude(), ne.longitude())));
+    array.pushArray(GeoJSONUtils.fromLatLng(LatLng(sw.latitude(), sw.longitude())));
+    return array
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/Dynamic.kt

@@ -0,0 +1,57 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.mapbox.bindgen.Value
+
+fun ReadableMap.toValueHashMap(): HashMap<String, Value> {
+    var result = hashMapOf<String, Value>()
+    var iterator = keySetIterator()
+    while (iterator.hasNextKey()) {
+        val i = iterator.nextKey()
+
+        result[i] = when (getType(i)) {
+            ReadableType.Null -> Value.nullValue()
+            ReadableType.Boolean -> Value.valueOf(getBoolean(i))
+            ReadableType.Number -> Value.valueOf(getDouble(i))
+            ReadableType.String -> Value.valueOf(getString(i)!!)
+            ReadableType.Array -> getArray(i)!!.toValue()
+            ReadableType.Map -> getMap(i)!!.toValue()
+        }
+    }
+    return result
+}
+
+fun ReadableMap.toValue() : Value {
+    return Value.valueOf(toValueHashMap())
+}
+
+fun ReadableArray.toValue(): Value {
+    var result = ArrayList<Value>(size())
+
+    for (i in 0 until size()) {
+        result.add(
+        when (getType(i)) {
+            ReadableType.Null -> Value.nullValue()
+            ReadableType.Boolean -> Value.valueOf(getBoolean(i))
+            ReadableType.Number -> Value.valueOf(getDouble(i))
+            ReadableType.String -> Value.valueOf(getString(i))
+            ReadableType.Array -> getArray(i).toValue()
+            ReadableType.Map -> getMap(i).toValue()
+        })
+    }
+    return Value.valueOf(result)
+}
+
+fun Dynamic.toValue(): Value {
+    return when (type) {
+        ReadableType.Null -> Value.nullValue()
+        ReadableType.Boolean -> Value.valueOf(asBoolean())
+        ReadableType.Number -> Value.valueOf(asDouble())
+        ReadableType.String -> Value.valueOf(asString())
+        ReadableType.Array -> asArray().toValue()
+        ReadableType.Map -> asMap().toValue()
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/FeatureCollection.kt

@@ -0,0 +1,10 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.mapbox.geojson.FeatureCollection
+import com.mapbox.geojson.GeometryCollection
+
+fun FeatureCollection.toGeometryCollection(): GeometryCollection {
+    return GeometryCollection.fromGeometries(
+        this.features()!!.map { it.geometry() !! }
+    )
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/Geometry.kt

@@ -0,0 +1,22 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.mapbox.geojson.BoundingBox
+import com.mapbox.geojson.Geometry
+import com.mapbox.geojson.Polygon
+import com.mapbox.turf.TurfMeasurement
+import org.json.JSONObject
+
+fun Geometry.toJSONObject(): JSONObject? {
+    return JSONObject(this.toJson())
+}
+
+fun Geometry.calculateBoundingBox(): BoundingBox {
+    val storedBBox = bbox()
+    if (storedBBox != null) {
+        return storedBBox
+    }
+    val bbox = TurfMeasurement.bbox(this)
+    return BoundingBox.fromLngLats(
+        bbox[0], bbox[1], bbox[2], bbox[3]
+    )
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/JSONObject.kt

@@ -0,0 +1,78 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.mapbox.bindgen.Value
+import com.mapbox.geojson.Geometry
+import com.mapbox.geojson.Polygon
+import com.rnmapbox.rnmbx.utils.Logger
+import org.json.JSONArray
+import org.json.JSONObject
+
+fun JSONObject.toGeometry(): Geometry? {
+    when (this.optString("type")) {
+        "polygon", "Polygon" -> return Polygon.fromJson(this.toString())
+        else -> {
+            Logger.w("JSONObject", "Unexpected geometry: ${this.toString()}")
+            return null
+        }
+    }
+}
+
+fun JSONObject.toMapboxValue(): Value {
+    return Value.fromJson(this.toString()).value!!
+}
+
+fun JSONObject.toWritableMap(): WritableMap? {
+    val result = Arguments.createMap()
+    val iterator = keys()
+    while (iterator.hasNext()) {
+        val key = iterator.next()
+        val value = get(key)
+        if (value is JSONObject) {
+            result.putMap(key, value.toReadableMap());
+        } else if (value is JSONArray) {
+            result.putArray(key, value.toReadableArray());
+        } else if (value is  Boolean) {
+            result.putBoolean(key, value);
+        } else if (value is  Int) {
+            result.putInt(key, value);
+        } else if (value is  Double) {
+            result.putDouble(key, value);
+        } else if (value is String)  {
+            result.putString(key, value);
+        } else {
+            result.putString(key, value.toString());
+        }
+    }
+    return result
+}
+
+fun JSONObject.toReadableMap(): ReadableMap? {
+    return toWritableMap()
+}
+
+fun JSONArray.toReadableArray(): ReadableArray? {
+    val result = Arguments.createArray()
+    for (i in 0 until length()) {
+        val value: Any = get(i)
+        if (value is JSONObject) {
+            result.pushMap(value.toReadableMap())
+        } else if (value is JSONArray) {
+            result.pushArray(value.toReadableArray())
+        } else if (value is Boolean) {
+            result.pushBoolean(value)
+        } else if (value is Int) {
+            result.pushInt(value)
+        } else if (value is Double) {
+            result.pushDouble(value)
+        } else if (value is String) {
+            result.pushString(value)
+        } else {
+            result.pushString(value.toString())
+        }
+    }
+    return result
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/Point.kt

@@ -0,0 +1,17 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableNativeArray
+import com.mapbox.geojson.Point
+import com.rnmapbox.rnmbx.utils.Logger
+
+fun Point.toReadableArray() : ReadableArray {
+    val array = WritableNativeArray()
+    array.pushDouble(this.longitude())
+    array.pushDouble(this.latitude())
+    return array
+}
+
+fun Point.toDoubleArray() : DoubleArray {
+    return doubleArrayOf(this.longitude(), this.latitude())
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/ReadableArray.kt

@@ -0,0 +1,38 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import android.graphics.RectF
+import com.facebook.react.bridge.ReadableArray
+import com.mapbox.geojson.Point
+import com.mapbox.maps.ScreenCoordinate
+import com.rnmapbox.rnmbx.utils.Logger
+import java.lang.Float.min
+import java.lang.Float.max
+
+fun ReadableArray.toCoordinate() : Point {
+    if (this.size() != 2) {
+        Logger.e("ReadableArray.toCoordinate","Cannot convert $this to point, 2 coordinates are required")
+    }
+    return Point.fromLngLat(
+        getDouble(0),
+        getDouble(1)
+    )
+}
+
+fun ReadableArray.toScreenCoordinate() : ScreenCoordinate {
+    if (this.size() != 2) {
+        Logger.e("ReadableArray.toCoordinate","Cannot convert $this to point, 2 coordinates are required")
+    }
+    return ScreenCoordinate(getDouble(0), getDouble(1))
+}
+
+fun ReadableArray.toRectF() : RectF? {
+    if (size() != 4) {
+        return null;
+    }
+    return RectF(
+        min(getDouble(3).toFloat(), getDouble(1).toFloat()),
+        min(getDouble(0).toFloat(), getDouble(2).toFloat()),
+        max(getDouble(3).toFloat(), getDouble(1).toFloat()),
+        max(getDouble(0).toFloat(), getDouble(2).toFloat())
+    )
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/ReadableMap.kt

@@ -0,0 +1,19 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+
+fun ReadableMap.forEach(action: (String, Any) -> Unit) {
+    val iterator = this.entryIterator
+    while (iterator.hasNext()) {
+        val next = iterator.next()
+        action(next.key, next.value)
+    }
+}
+fun ReadableMap.getIfDouble(key: String): Double? {
+    return if (hasKey(key) && (getType(key) == ReadableType.Number)) {
+        getDouble(key)
+    } else {
+        null
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/extensions/Value.kt

@@ -0,0 +1,9 @@
+package com.rnmapbox.rnmbx.utils.extensions
+
+import com.mapbox.bindgen.Value
+import org.json.JSONObject
+
+fun Value.toJSONObject(): JSONObject? {
+    val jsonString = this.toJson()
+    return JSONObject(jsonString)
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/writeableMapArrayOf.kt

@@ -0,0 +1,41 @@
+package com.rnmapbox.rnmbx.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+
+fun writableMapOf(vararg values: Pair<String, *>): WritableMap {
+    val map = Arguments.createMap()
+    for ((key, value) in values) {
+        when (value) {
+            null -> map.putNull(key)
+            is Boolean -> map.putBoolean(key, value)
+            is Double -> map.putDouble(key, value)
+            is Int -> map.putInt(key, value)
+            is Long -> map.putInt(key, value.toInt())
+            is String -> map.putString(key, value)
+            is WritableMap -> map.putMap(key, value)
+            is WritableArray -> map.putArray(key, value)
+            else -> throw IllegalArgumentException("Unsupported value type ${value::class.java.name} for key [$key]")
+        }
+    }
+    return map
+}
+
+fun writableArrayOf(vararg values: Any): WritableArray {
+    val array = Arguments.createArray()
+    for (value in values) {
+        when (value) {
+            null -> array.pushNull()
+            is Boolean -> array.pushBoolean(value)
+            is Double -> array.pushDouble(value)
+            is Int -> array.pushInt(value)
+            is Long -> array.pushInt(value.toInt())
+            is String -> array.pushString(value)
+            is WritableMap -> array.pushMap(value)
+            is WritableArray -> array.pushArray(value)
+            else -> throw IllegalArgumentException("Unsupported value type ${value::class.java.name}")
+        }
+    }
+    return array
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Annotation.kt

@@ -0,0 +1,4 @@
+package com.rnmapbox.rnmbx.v11compat.annotation;
+
+public const val INVALID_ANNOTATION_ID: Long = -1
+typealias AnnotationID = Long

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Event.kt

@@ -0,0 +1,17 @@
+package com.rnmapbox.rnmbx.v11compat.event;
+
+//import com.mapbox.maps.MapboxMap
+//import com.mapbox.maps.extension.observable.getMapLoadingErrorEventData
+
+//fun MapboxMap.subscribe(callback: (Any?)->Void) {
+//
+//}
+
+import com.mapbox.maps.Event
+import com.mapbox.maps.extension.observable.eventdata.MapLoadingErrorEventData
+import com.mapbox.maps.extension.observable.getMapLoadingErrorEventData as _getMapLoadingErrorEventData
+
+fun Event.getMapLoadingErrorEventData() : MapLoadingErrorEventData {
+    return _getMapLoadingErrorEventData()
+};
+

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Feature.kt

@@ -0,0 +1,10 @@
+package com.rnmapbox.rnmbx.v11compat.feature;
+
+import com.mapbox.geojson.Feature;
+
+import com.mapbox.maps.QueriedFeature as _QueriedFeature;
+
+typealias QueriedRenderedFeature = _QueriedFeature;
+
+typealias QueriedSourceFeature = _QueriedFeature;
+

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/HttpInterceptor.kt

@@ -0,0 +1,22 @@
+package com.rnmapbox.rnmbx.v11compat.httpinterceptor;
+
+import com.mapbox.common.*
+
+open class HttpServiceBase : HttpServiceInterceptorInterface {
+  override fun onRequest(request: HttpRequest): HttpRequest {
+        return request
+    }
+
+    override fun onDownload(download: DownloadOptions): DownloadOptions {
+        return download
+    }
+
+    override fun onResponse(response: HttpResponse): HttpResponse {
+        return response
+    }
+
+/*    override fun onUpload(options: UploadOptions): UploadOptions {
+        return options
+    }
+*/
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Image.kt

@@ -0,0 +1,53 @@
+package com.rnmapbox.rnmbx.v11compat.image;
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.VectorDrawable
+import androidx.annotation.DrawableRes
+import androidx.appcompat.content.res.AppCompatResources
+import com.mapbox.maps.Image
+import com.mapbox.maps.Style
+import com.rnmapbox.rnmbx.components.images.ImageInfo
+import com.rnmapbox.rnmbx.components.images.addBitmapImage
+import java.nio.ByteBuffer
+
+typealias ImageHolder = Drawable;
+
+fun ByteArray.toByteArray(): ByteArray {
+    return this
+}
+
+fun ByteArray.toImageData() : ByteArray {
+    return this
+}
+
+fun VectorDrawable.toBitmapImageHolder(): Drawable {
+    return this
+}
+
+fun emptyImage(width: Int, height: Int): Image {
+    return Image(width, height, ByteArray(width * height * 4) /* ByteBuffer.allocateDirect(width * height * 4).array()*/)
+}
+
+fun Bitmap.toMapboxImage(): Image {
+    val byteBuffer = ByteBuffer.allocate(byteCount)
+    copyPixelsToBuffer(byteBuffer)
+    return Image(width, height, byteBuffer.array())
+}
+
+fun Style.addStyleImage(imageId: String, image: Image, info: ImageInfo, scale: Double = 1.0) {
+    addStyleImage(imageId, (info.getScaleOr(1.0) * scale).toFloat(), image, info.sdf, info.stretchX, info.stretchY, info.content)
+}
+
+fun Style.addBitmapImage(imageId: String, bitmap: Bitmap, info: ImageInfo, scale: Double = 1.0) {
+    addStyleImage(imageId, bitmap.toMapboxImage(), info, scale)
+}
+
+class AppCompatResourcesV11 {
+    companion object {
+        fun getDrawableImageHolder(context: Context, @DrawableRes resId: Int) : ImageHolder? {
+            return AppCompatResources.getDrawable(context, resId)
+        }
+    }
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Light.kt

@@ -0,0 +1,15 @@
+package com.rnmapbox.rnmbx.v11compat.light;
+
+import com.mapbox.maps.Style
+import com.mapbox.maps.extension.style.light.generated.Light as _Light;
+import com.mapbox.maps.extension.style.light.generated.setLight as _setLight
+
+typealias Light = _Light
+
+fun Style.setLight(light: Light) {
+    this._setLight(light)
+}
+
+fun createLight(): Light {
+    return Light()
+}

package/android/src/main/mapbox-v11-compat/v10/com/mapbox/rnmbx/v11compat/Location.kt

@@ -0,0 +1,65 @@
+package com.rnmapbox.rnmbx.v11compat.location;
+
+import android.Manifest.permission.ACCESS_COARSE_LOCATION
+import android.Manifest.permission.ACCESS_FINE_LOCATION
+import android.content.Context
+import android.location.LocationManager
+import android.os.Looper
+import androidx.annotation.RequiresPermission
+import com.mapbox.maps.MapView
+import com.mapbox.maps.plugin.PuckBearingSource
+import com.mapbox.maps.plugin.locationcomponent.LocationComponentPlugin2
+import com.mapbox.maps.plugin.locationcomponent.location2 as _location2
+
+
+import com.mapbox.android.core.location.LocationEngineResult as _LocationEngineResult
+
+import com.mapbox.android.core.location.LocationEngine as _LocationEngine
+import com.mapbox.android.core.location.LocationEngineCallback as _LocationEngineCallback
+import com.mapbox.android.core.location.LocationEngineRequest
+import com.mapbox.android.core.location.LocationEngineProvider
+import com.mapbox.common.location.LocationService
+import com.mapbox.common.location.LocationUpdatesReceiver
+import com.mapbox.common.location.LocationServiceFactory
+
+
+import android.location.Location as _Location
+//import com.mapbox.common.location.Location as _Location
+
+typealias Location = _Location;
+typealias PuckBearingSource = com.mapbox.maps.plugin.PuckBearingSource
+
+val MapView.location2 : LocationComponentPlugin2
+    get() = _location2
+
+typealias LocationEngine = _LocationEngine
+typealias LocationEngineResult = _LocationEngineResult
+typealias LocationEngineCallback = _LocationEngineCallback<LocationEngineResult>
+
+const val DEFAULT_FASTEST_INTERVAL_MILLIS: Long = 1000
+const val DEFAULT_INTERVAL_MILLIS: Long = 1000
+
+@RequiresPermission(anyOf = [ACCESS_COARSE_LOCATION, ACCESS_FINE_LOCATION])
+fun LocationEngine.requestLocationUpdatesV11(callback: LocationEngineCallback, looper: Looper?, minDisplacement: Float?) {
+  val builder = LocationEngineRequest.Builder(DEFAULT_INTERVAL_MILLIS)
+      .setFastestInterval(DEFAULT_FASTEST_INTERVAL_MILLIS)
+      .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
+  if (minDisplacement != null && minDisplacement > 0.0) {
+    builder.setDisplacement(minDisplacement)
+  }
+  val request = builder
+      .build();
+
+  this.requestLocationUpdates(
+    request,
+    callback,
+    looper
+  )
+}
+
+val Location.timestamp: Long
+  get() = this.time
+
+fun createLocationEngine(context: Context): LocationEngine {
+    return LocationEngineProvider.getBestLocationEngine(context)
+}