@rnmapbox/maps 10.1.0-beta.2 → 10.1.0-beta.5

package/android/src/main/{java-v10/com/mapbox/rctmgl → java/com/rnmapbox/rnmbx}/events/PointAnnotationDragEvent.java

@@ -1,4 +1,4 @@
-package com.mapbox.rctmgl.events;
+package com.rnmapbox.rnmbx.events;
 
 import android.graphics.PointF;
 import androidx.annotation.NonNull;
@@ -7,19 +7,19 @@ import android.view.View;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.mapbox.maps.ScreenCoordinate;
-import com.mapbox.rctmgl.components.annotation.RCTMGLPointAnnotation;
-import com.mapbox.rctmgl.events.constants.EventKeys;
-import com.mapbox.rctmgl.events.constants.EventTypes;
-import com.mapbox.rctmgl.utils.ConvertUtils;
-import com.mapbox.rctmgl.utils.GeoJSONUtils;
-import com.mapbox.rctmgl.utils.LatLng;
+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 {
-    RCTMGLPointAnnotation mView;
+    RNMBXPointAnnotation mView;
     private LatLng mTouchedLatLng;
     private PointF mScreenPoint;
 
-    public PointAnnotationDragEvent(RCTMGLPointAnnotation view, @NonNull LatLng latLng, @NonNull PointF screenPoint, String eventType) {
+    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;

package/android/src/main/{java-v10/com/mapbox/rctmgl → java/com/rnmapbox/rnmbx}/events/constants/EventKeys.java

@@ -1,4 +1,4 @@
-package com.mapbox.rctmgl.events.constants;
+package com.rnmapbox.rnmbx.events.constants;
 
 /**
  * Created by nickitaliano on 8/27/17.

package/android/src/main/{java-v10/com/mapbox/rctmgl → java/com/rnmapbox/rnmbx}/events/constants/EventTypes.kt

@@ -1,4 +1,4 @@
-package com.mapbox.rctmgl.events.constants
+package com.rnmapbox.rnmbx.events.constants
 
 object EventTypes {
     // map event types

package/android/src/main/{java-v10/com/mapbox/rctmgl → java/com/rnmapbox/rnmbx}/location/LocationManager.kt

@@ -1,14 +1,8 @@
-package com.mapbox.rctmgl.location
+package com.rnmapbox.rnmbx.location
 
 import android.annotation.SuppressLint
 import android.content.Context
-import android.location.Location
-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.android.core.location.LocationEngineProvider
 import com.mapbox.android.core.permissions.PermissionsManager
 import android.os.Looper
 import android.util.Log
@@ -18,6 +12,8 @@ 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
@@ -43,24 +39,18 @@ open class SingletonHolder<out T, in A>(creator: (A) -> T) {
     }
 }
 
-internal class LocationProviderForEngine(var mEngine: LocationEngine?, val context: Context) : LocationProvider, LocationEngineCallback<LocationEngineResult> {
+internal class LocationProviderForEngine(var mEngine: LocationEngine?, val context: Context) : LocationProvider, LocationEngineCallback {
     var mConsumers = ArrayList<LocationConsumer>()
     @SuppressLint("MissingPermission")
     fun beforeAddingFirstConsumer() {
-        val request = LocationEngineRequest.Builder(LocationManager.DEFAULT_INTERVAL_MILLIS
-        )
-            .setFastestInterval(LocationManager.DEFAULT_FASTEST_INTERVAL_MILLIS)
-            .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
-            .build();
-
         if (!PermissionsManager.areLocationPermissionsGranted(context)) {
             return
         }
 
-        mEngine?.requestLocationUpdates(
-          request,
+        mEngine?.requestLocationUpdatesV11(
           this,
-          Looper.getMainLooper()
+          Looper.getMainLooper(),
+            null
         )
 
     }
@@ -85,13 +75,14 @@ internal class LocationProviderForEngine(var mEngine: LocationEngine?, val conte
         for (consumer in mConsumers) {
             val points = Point.fromLngLat(location.longitude, location.latitude)
             consumer.onLocationUpdated(points)
-            val bearings = location.bearing.toDouble()
-            consumer.onBearingUpdated(bearings)
+            location.bearing?.toDouble()?.also {
+                consumer.onBearingUpdated(it)
+            }
         }
     }
 
     // * LocationEngineCallback
-    override fun onSuccess(locationEngineResult: LocationEngineResult?) {
+    override fun onSuccess(locationEngineResult: LocationEngineResult) {
         val location = locationEngineResult?.lastLocation
         location?.let { notifyLocationUpdates(it) }
     }
@@ -99,14 +90,14 @@ internal class LocationProviderForEngine(var mEngine: LocationEngine?, val conte
     override fun onFailure(e: Exception) {}
 }
 
-class LocationManager private constructor(private val context: Context) : LocationEngineCallback<LocationEngineResult> {
+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 locationEngineRequest: LocationEngineRequest? = null
     private var locationProvider: LocationProvider? = null
     private var nStarts : Int = 0
     private var isPaused : Boolean = false
@@ -164,6 +155,7 @@ class LocationManager private constructor(private val context: Context) : Locati
 
     ////
 
+    /*
     private fun buildEngineRequest() {
         engine = LocationEngineProvider.getBestLocationEngine(context.applicationContext)
         locationEngineRequest = LocationEngineRequest.Builder(DEFAULT_INTERVAL_MILLIS)
@@ -171,7 +163,7 @@ class LocationManager private constructor(private val context: Context) : Locati
                 .setPriority(LocationEngineRequest.PRIORITY_HIGH_ACCURACY)
                 .setDisplacement(mMinDisplacement)
                 .build()
-    }
+    }*/
 
     fun addLocationListener(listener: OnUserLocationChange) {
         if (!listeners.contains(listener)) {
@@ -203,13 +195,12 @@ class LocationManager private constructor(private val context: Context) : Locati
         engine?.removeLocationUpdates(this)
 
         // refresh location engine request with new values
-        buildEngineRequest()
 
         // add new listeners
-        engine?.requestLocationUpdates(
-                locationEngineRequest!!,
-                this,
-                Looper.getMainLooper()
+        engine?.requestLocationUpdatesV11(
+            this,
+            Looper.getMainLooper(),
+            mMinDisplacement
         )
         isActive = true
     }
@@ -236,13 +227,13 @@ class LocationManager private constructor(private val context: Context) : Locati
         } else lastLocation
 
     @SuppressLint("MissingPermission")
-    fun getLastKnownLocation(callback: LocationEngineCallback<LocationEngineResult>) {
+    fun getLastKnownLocation(callback: LocationEngineCallback) {
         if (engine == null) {
             callback.onFailure(Exception("LocationEngine not initialized"))
         }
         try {
-            engine?.getLastLocation(object : LocationEngineCallback<LocationEngineResult> {
-                override fun onSuccess(result: LocationEngineResult?) {
+            engine?.getLastLocation(object : LocationEngineCallback {
+                override fun onSuccess(result: LocationEngineResult) {
                     if (result == null) {
                         callback.onFailure( NullPointerException("LocationEngineResult is null"))
                     } else {
@@ -271,7 +262,7 @@ class LocationManager private constructor(private val context: Context) : Locati
         // FMTODO handle this.
     }
 
-    override fun onSuccess(result: LocationEngineResult?) {
+    override fun onSuccess(result: LocationEngineResult) {
         onLocationChanged(result?.lastLocation)
         val provider = locationProvider
         if (provider != null && provider is LocationProviderForEngine) {
@@ -287,6 +278,6 @@ class LocationManager private constructor(private val context: Context) : Locati
     }
 
     init {
-        buildEngineRequest()
+        // buildEngineRequest()
     }
 }

package/android/src/main/{java-v10/com/mapbox/rctmgl → java/com/rnmapbox/rnmbx}/location/UserTrackingState.java

@@ -1,4 +1,4 @@
-package com.mapbox.rctmgl.location;
+package com.rnmapbox.rnmbx.location;
 
 public class UserTrackingState {
     // The map view not yet tracked the user location

package/android/src/main/{java-v10/com/mapbox/rctmgl → java/com/rnmapbox/rnmbx}/modules/CustomHttpHeaders.kt

@@ -1,8 +1,10 @@
-package com.mapbox.rctmgl.modules
+package com.rnmapbox.rnmbx.modules
 
 import com.mapbox.common.*
 
-object CustomHttpHeaders : HttpServiceInterceptorInterface {
+import com.rnmapbox.rnmbx.v11compat.httpinterceptor.*
+
+object CustomHttpHeaders : HttpServiceBase() {
     init {}
 
     val map = mutableMapOf<String, String>()
@@ -35,5 +37,11 @@ object CustomHttpHeaders : HttpServiceInterceptorInterface {
     override fun onResponse(response: HttpResponse): HttpResponse {
         return response
     }
+
+    /*
+    override fun onUpload(options: UploadOptions): UploadOptions {
+        return options;
+    }
+    */
 }
 

package/android/src/main/{java-v10/com/mapbox/rctmgl/modules/RCTMGLLocationModule.kt → java/com/rnmapbox/rnmbx/modules/RNMBXLocationModule.kt}

@@ -1,22 +1,21 @@
-package com.mapbox.rctmgl.modules
+package com.rnmapbox.rnmbx.modules
 
-import android.location.Location
 import com.facebook.react.bridge.*
-import com.mapbox.rctmgl.location.LocationManager
+import com.rnmapbox.rnmbx.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 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 = RCTMGLLocationModule.REACT_CLASS)
-class RCTMGLLocationModule(reactContext: ReactApplicationContext) :
+@ReactModule(name = RNMBXLocationModule.REACT_CLASS)
+class RNMBXLocationModule(reactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(reactContext) {
     private var isEnabled = false
     private var mMinDisplacement = 0f
@@ -104,7 +103,7 @@ class RCTMGLLocationModule(reactContext: ReactApplicationContext) :
     @ReactMethod
     fun getLastKnownLocation(promise: Promise) {
         locationManager!!.getLastKnownLocation(
-            object : LocationEngineCallback<LocationEngineResult> {
+            object : LocationEngineCallback {
                 override fun onSuccess(result: LocationEngineResult) {
                     val location = result.lastLocation
                     if (location != null) {
@@ -181,7 +180,7 @@ class RCTMGLLocationModule(reactContext: ReactApplicationContext) :
 
 
     companion object {
-        const val REACT_CLASS = "RCTMGLLocationModule"
+        const val REACT_CLASS = "RNMBXLocationModule"
         const val LOCATION_UPDATE = "MapboxUserLocationUpdate"
     }
 }

package/android/src/main/{java-v10/com/mapbox/rctmgl/modules/RCTMGLLogging.kt → java/com/rnmapbox/rnmbx/modules/RNMBXLogging.kt}

@@ -1,15 +1,15 @@
-package com.mapbox.rctmgl.modules
+package com.rnmapbox.rnmbx.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.rnmapbox.rnmbx.modules.RNMBXLogging
 import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
-import com.mapbox.rctmgl.utils.Logger
-import com.mapbox.rctmgl.utils.Logger.LoggerDefinition
+import com.rnmapbox.rnmbx.utils.Logger
+import com.rnmapbox.rnmbx.utils.Logger.LoggerDefinition
 
-@ReactModule(name = RCTMGLLogging.REACT_CLASS)
-class RCTMGLLogging(private val mReactContext: ReactApplicationContext) :
+@ReactModule(name = RNMBXLogging.REACT_CLASS)
+class RNMBXLogging(private val mReactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(
         mReactContext
     ) {
@@ -53,7 +53,7 @@ class RCTMGLLogging(private val mReactContext: ReactApplicationContext) :
     }
 
     companion object {
-        const val REACT_CLASS = "RCTMGLLogging"
+        const val REACT_CLASS = "RNMBXLogging"
     }
 
     init {

package/android/src/main/{java-v10/com/mapbox/rctmgl/modules/RCTMGLModule.kt → java/com/rnmapbox/rnmbx/modules/RNMBXModule.kt}

@@ -1,27 +1,28 @@
-package com.mapbox.rctmgl.modules
+package com.rnmapbox.rnmbx.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.rnmapbox.rnmbx.modules.RNMBXModule
 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.rnmapbox.rnmbx.events.constants.EventTypes
+import com.rnmapbox.rnmbx.modules.RNMBXOfflineModule
+import com.rnmapbox.rnmbx.modules.RNMBXLocationModule
 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 com.rnmapbox.rnmbx.components.camera.constants.CameraMode
 import java.util.HashMap
 
-@ReactModule(name = RCTMGLModule.REACT_CLASS)
-class RCTMGLModule(private val mReactContext: ReactApplicationContext) : ReactContextBaseJavaModule(
+import com.rnmapbox.rnmbx.v11compat.resourceoption.*
+
+@ReactModule(name = RNMBXModule.REACT_CLASS)
+class RNMBXModule(private val mReactContext: ReactApplicationContext) : ReactContextBaseJavaModule(
     mReactContext
 ) {
     private val mUiThreadHandler: Handler? = null
@@ -97,12 +98,12 @@ class RCTMGLModule(private val mReactContext: ReactApplicationContext) : ReactCo
 
         // offline module callback names
         val offlineModuleCallbackNames: MutableMap<String, String> = HashMap()
-        offlineModuleCallbackNames["Error"] = RCTMGLOfflineModule.OFFLINE_ERROR
-        offlineModuleCallbackNames["Progress"] = RCTMGLOfflineModule.OFFLINE_PROGRESS
+        offlineModuleCallbackNames["Error"] = RNMBXOfflineModule.OFFLINE_ERROR
+        offlineModuleCallbackNames["Progress"] = RNMBXOfflineModule.OFFLINE_PROGRESS
 
         // location module callback names
         val locationModuleCallbackNames: MutableMap<String, String> = HashMap()
-        locationModuleCallbackNames["Update"] = RCTMGLLocationModule.LOCATION_UPDATE
+        locationModuleCallbackNames["Update"] = RNMBXLocationModule.LOCATION_UPDATE
         return MapBuilder.builder<String, Any>()
             .put("MapboxV10", true)
             .put("StyleURL", styleURLS)
@@ -130,9 +131,7 @@ class RCTMGLModule(private val mReactContext: ReactApplicationContext) : ReactCo
     @ReactMethod
     fun setAccessToken(accessToken: String?, promise: Promise) {
         mReactContext.runOnUiQueueThread(Runnable {
-            getDefault(
-                reactApplicationContext, accessToken
-            )
+            setMapboxAccessToken(reactApplicationContext, accessToken)
             promise.resolve(accessToken)
         })
     }
@@ -153,11 +152,11 @@ class RCTMGLModule(private val mReactContext: ReactApplicationContext) : ReactCo
     }
 
     companion object {
-        const val REACT_CLASS = "RCTMGLModule"
+        const val REACT_CLASS = "RNMBXModule"
         private val customHeaderInterceptorAdded = false
         @JvmStatic
         fun getAccessToken(reactContext: ReactApplicationContext?): String {
-            return getDefault((reactContext)!!, null).resourceOptions.accessToken
+            return getMapboxAccessToken(reactContext)
         }
     }
 }

package/android/src/main/{java-v10/com/mapbox/rctmgl/modules/RCTMGLOfflineModule.kt → java/com/rnmapbox/rnmbx/modules/RNMBXOfflineModule.kt}

@@ -1,4 +1,4 @@
-package com.mapbox.rctmgl.modules
+package com.rnmapbox.rnmbx.modules
 
 import android.R.array
 import android.os.Build
@@ -11,12 +11,13 @@ import com.mapbox.bindgen.Value
 import com.mapbox.common.*
 import com.mapbox.geojson.*
 import com.mapbox.maps.*
-import com.mapbox.rctmgl.events.IEvent
-import com.mapbox.rctmgl.events.OfflineEvent
-import com.mapbox.rctmgl.events.constants.EventTypes
-import com.mapbox.rctmgl.utils.*
-import com.mapbox.rctmgl.utils.Logger
-import com.mapbox.rctmgl.utils.extensions.*
+import com.rnmapbox.rnmbx.events.IEvent
+import com.rnmapbox.rnmbx.events.OfflineEvent
+import com.rnmapbox.rnmbx.events.constants.EventTypes
+import com.rnmapbox.rnmbx.utils.*
+import com.rnmapbox.rnmbx.utils.Logger
+import com.rnmapbox.rnmbx.utils.extensions.*
+import com.rnmapbox.rnmbx.v11compat.offlinemanager.getOfflineManager
 import com.mapbox.turf.TurfMeasurement
 import org.json.JSONArray
 import org.json.JSONException
@@ -28,6 +29,8 @@ import java.nio.file.Paths
 import java.nio.file.StandardCopyOption
 import java.util.concurrent.CountDownLatch
 
+import com.rnmapbox.rnmbx.v11compat.offlinemanager.*
+
 data class ZoomRange(val minZoom: Byte, val maxZoom: Byte) {
 
 }
@@ -90,8 +93,8 @@ class TileRegionPack(var name: String, var state: TileRegionPackState = TileRegi
     }
 }
 
-@ReactModule(name = RCTMGLOfflineModule.REACT_CLASS)
-class RCTMGLOfflineModule(private val mReactContext: ReactApplicationContext) :
+@ReactModule(name = RNMBXOfflineModule.REACT_CLASS)
+class RNMBXOfflineModule(private val mReactContext: ReactApplicationContext) :
     ReactContextBaseJavaModule(
         mReactContext
     ) {
@@ -104,12 +107,9 @@ class RCTMGLOfflineModule(private val mReactContext: ReactApplicationContext) :
     }
 
     val offlineManager: OfflineManager by lazy {
-        OfflineManager(
-            ResourceOptions.Builder()
-                .accessToken(RCTMGLModule.getAccessToken(mReactContext)).tileStore(
-                    tileStore
-                ).build()
-        )
+        getOfflineManager(tileStore) {
+            RNMBXModule.getAccessToken(mReactContext)
+        }
     }
 
     override fun getName(): String {
@@ -218,7 +218,9 @@ class RCTMGLOfflineModule(private val mReactContext: ReactApplicationContext) :
 
     @ReactMethod
     fun setTileCountLimit(tileCountLimit: Int) {
-        val offlineRegionManager = OfflineRegionManager(ResourceOptions.Builder().accessToken(RCTMGLModule.getAccessToken(mReactContext)).build())
+        val offlineRegionManager = getOfflineRegionManager {
+            RNMBXModule.getAccessToken(mReactContext)
+        }
         offlineRegionManager.setOfflineMapboxTileCountLimit(tileCountLimit.toLong())
     }
 
@@ -628,7 +630,7 @@ class RCTMGLOfflineModule(private val mReactContext: ReactApplicationContext) :
     }
 
     companion object {
-        const val REACT_CLASS = "RCTMGLOfflineModule"
+        const val REACT_CLASS = "RNMBXOfflineModule"
         const val LOG_TAG = REACT_CLASS
         const val OFFLINE_ERROR = "MapboxOfflineRegionError"
         const val OFFLINE_PROGRESS = "MapboxOfflineRegionProgress"

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

@@ -0,0 +1,124 @@
+package com.rnmapbox.rnmbx.modules
+
+import android.util.Log
+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.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.mapbox.geojson.Feature
+import com.mapbox.geojson.Point
+import com.mapbox.maps.CameraOptions
+import com.mapbox.maps.MapSnapshotOptions
+import com.mapbox.maps.Size
+import com.mapbox.maps.Snapshotter
+import com.rnmapbox.rnmbx.modules.RNMBXModule.Companion.getAccessToken
+import com.rnmapbox.rnmbx.modules.RNMBXSnapshotModule
+import com.rnmapbox.rnmbx.utils.BitmapUtils
+import java.io.IOException
+import java.io.OutputStream
+import java.util.UUID
+
+import com.rnmapbox.rnmbx.v11compat.snapshot.*
+
+@ReactModule(name = RNMBXSnapshotModule.REACT_CLASS)
+class RNMBXSnapshotModule(private val mContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(
+        mContext
+    ) {
+    // prevents snapshotter from being GC'ed
+    private val mSnapshotterMap: MutableMap<String, Snapshotter>
+
+    init {
+        mSnapshotterMap = HashMap()
+    }
+
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    @ReactMethod
+    fun takeSnap(jsOptions: ReadableMap, promise: Promise) {
+        // FileSource.getInstance(mContext).activate();
+        mContext.runOnUiQueueThread {
+            val snapshotterID = UUID.randomUUID().toString()
+            val snapshotter = Snapshotter(mContext, getOptions(jsOptions))
+            snapshotter.setStyleUri(jsOptions.getString("styleURL")!!)
+            snapshotter.setCamera(getCameraOptions(jsOptions))
+            mSnapshotterMap[snapshotterID] = snapshotter
+            snapshotter.startV11 { image,error ->
+                try {
+                    if (image == null) {
+                        Log.w(REACT_CLASS, "Snapshot failed: $error")
+                        promise.reject(REACT_CLASS, "Snapshot failed: $error")
+                        mSnapshotterMap.remove(snapshotterID)
+                    } else {
+                        val image = image.toMapboxImage()
+                        var result: String? = null
+                        result = if (jsOptions.getBoolean("writeToDisk")) {
+                            BitmapUtils.createImgTempFile(mContext, image)
+                        } else {
+                            BitmapUtils.createImgBase64(image)
+                        }
+                        if (result == null) {
+                            promise.reject(
+                                REACT_CLASS,
+                                "Could not generate snapshot, please check Android logs for more info."
+                            )
+                            return@startV11
+                        }
+                        promise.resolve(result)
+                        mSnapshotterMap.remove(snapshotterID)
+                    }
+                } catch (e: IOException) {
+                    e.printStackTrace()
+                    promise.reject(REACT_CLASS, e.localizedMessage)
+                }
+            }
+        }
+    }
+
+    private fun getCameraOptions(jsOptions: ReadableMap): CameraOptions {
+        val centerPoint =
+            Feature.fromJson(jsOptions.getString("centerCoordinate")!!)
+        val point = centerPoint.geometry() as Point?
+        val cameraOptionsBuilder = CameraOptions.Builder()
+        return cameraOptionsBuilder
+            .center(point)
+            .pitch(jsOptions.getDouble("pitch"))
+            .bearing(jsOptions.getDouble("heading"))
+            .zoom(jsOptions.getDouble("zoomLevel"))
+            .build()
+    }
+
+    private fun getOptions(jsOptions: ReadableMap): MapSnapshotOptions {
+        val builder = MapSnapshotOptions.Builder()
+        builder.size(
+            Size(
+                jsOptions.getDouble("width").toInt().toFloat(),
+                jsOptions.getDouble("height").toInt().toFloat()
+            )
+        )
+        builder.pixelRatio(
+            java.lang.Float.valueOf(mContext.resources.displayMetrics.density).toInt().toFloat()
+        )
+        builder.accessToken(getAccessToken(mContext))
+        return builder.build()
+    }
+
+    private fun closeSnapshotOutputStream(outputStream: OutputStream?) {
+        if (outputStream == null) {
+            return
+        }
+        try {
+            outputStream.close()
+        } catch (e: IOException) {
+            Log.w(REACT_CLASS, e.localizedMessage)
+        }
+    }
+
+    companion object {
+        const val REACT_CLASS = "RNMBXSnapshotModule"
+    }
+}