@rnmapbox/maps 10.1.0-beta.15 → 10.1.0-beta.19

package/android/build.gradle

@@ -43,6 +43,7 @@ if (safeExtGet("RNMapboxMapsImpl", defaultMapboxMapsImpl) == "mapbox") {
 }
 
 android {
+    namespace = "com.rnmapbox.rnmbx"
     if (safeExtGet("RNMapboxMapsImpl", defaultMapboxMapsImpl) == "maplibre") {
         msg = '@rnmapbox/maps: Maplibre implementation has been removed, set RNMapboxMapsImpl to mapbox- see https://github.com/rnmapbox/maps/wiki/Deprecated-RNMapboxImpl-Maplibre#android'
         logger.error(msg)

package/android/src/main/AndroidManifest.xml

@@ -1,4 +1,4 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.rnmapbox.rnmbx">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>

package/android/src/main/java/com/rnmapbox/rnmbx/RNMBXPackage.kt

@@ -12,9 +12,13 @@ import com.rnmapbox.rnmbx.components.annotation.RNMBXMarkerViewManager
 import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotationManager
 import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotationModule
 import com.rnmapbox.rnmbx.components.camera.RNMBXCameraManager
+import com.rnmapbox.rnmbx.components.camera.RNMBXViewport
+import com.rnmapbox.rnmbx.components.camera.RNMBXViewportManager
+import com.rnmapbox.rnmbx.components.camera.RNMBXViewportModule
 import com.rnmapbox.rnmbx.components.images.RNMBXImageManager
 import com.rnmapbox.rnmbx.components.images.RNMBXImageModule
 import com.rnmapbox.rnmbx.components.images.RNMBXImagesManager
+import com.rnmapbox.rnmbx.components.location.RNMBXCustomLocationProviderManager
 import com.rnmapbox.rnmbx.components.location.RNMBXNativeUserLocationManager
 import com.rnmapbox.rnmbx.components.mapview.NativeMapViewModule
 import com.rnmapbox.rnmbx.components.mapview.RNMBXMapViewManager
@@ -50,9 +54,9 @@ class RNMBXPackage : TurboReactPackage() {
     fun getViewTagResolver(context: ReactApplicationContext) : ViewTagResolver {
         val viewTagResolver = viewTagResolver
         if (viewTagResolver == null) {
-            val viewTagResolver = ViewTagResolver(context)
-            this.viewTagResolver = viewTagResolver
-            return viewTagResolver
+            val result = ViewTagResolver(context)
+            this.viewTagResolver = result
+            return result
         }
         return viewTagResolver
     }
@@ -68,6 +72,7 @@ class RNMBXPackage : TurboReactPackage() {
             RNMBXSnapshotModule.REACT_CLASS -> return RNMBXSnapshotModule(reactApplicationContext)
             RNMBXLogging.REACT_CLASS -> return RNMBXLogging(reactApplicationContext)
             NativeMapViewModule.NAME -> return NativeMapViewModule(reactApplicationContext, getViewTagResolver(reactApplicationContext))
+            RNMBXViewportModule.NAME -> return RNMBXViewportModule(reactApplicationContext, getViewTagResolver(reactApplicationContext))
             RNMBXShapeSourceModule.NAME -> return RNMBXShapeSourceModule(reactApplicationContext, getViewTagResolver(reactApplicationContext))
             RNMBXImageModule.NAME -> return RNMBXImageModule(reactApplicationContext, getViewTagResolver(reactApplicationContext))
             RNMBXPointAnnotationModule.NAME -> return RNMBXPointAnnotationModule(reactApplicationContext, getViewTagResolver(reactApplicationContext))
@@ -85,25 +90,27 @@ class RNMBXPackage : TurboReactPackage() {
 
         // components
         managers.add(RNMBXCameraManager(reactApplicationContext))
+        managers.add(RNMBXViewportManager(reactApplicationContext))
         managers.add(RNMBXMapViewManager(reactApplicationContext, getViewTagResolver(reactApplicationContext)))
         managers.add(RNMBXStyleImportManager(reactApplicationContext))
 
         // annotations
         managers.add(RNMBXMarkerViewManager(reactApplicationContext))
-        managers.add(RNMBXPointAnnotationManager(reactApplicationContext))
+        managers.add(RNMBXPointAnnotationManager(reactApplicationContext, getViewTagResolver(reactApplicationContext)))
         managers.add(RNMBXCalloutManager())
         managers.add(RNMBXNativeUserLocationManager())
+        managers.add(RNMBXCustomLocationProviderManager())
 
         // sources
         managers.add(RNMBXVectorSourceManager(reactApplicationContext))
-        managers.add(RNMBXShapeSourceManager(reactApplicationContext))
+        managers.add(RNMBXShapeSourceManager(reactApplicationContext, getViewTagResolver(reactApplicationContext)))
         managers.add(RNMBXRasterDemSourceManager(reactApplicationContext))
         managers.add(RNMBXRasterSourceManager(reactApplicationContext))
         managers.add(RNMBXImageSourceManager())
 
         // images
         managers.add(RNMBXImagesManager(reactApplicationContext))
-        managers.add(RNMBXImageManager(reactApplicationContext))
+        managers.add(RNMBXImageManager(reactApplicationContext, getViewTagResolver(reactApplicationContext)))
 
         // layers
         managers.add(RNMBXFillLayerManager())
@@ -179,6 +186,15 @@ class RNMBXPackage : TurboReactPackage() {
                 false,  // isCxxModule
                 isTurboModule // isTurboModule
             )
+            moduleInfos[RNMBXViewportModule.NAME] = ReactModuleInfo(
+                RNMBXViewportModule.NAME,
+                RNMBXViewportModule.NAME,
+                false,  // canOverrideExistingModule
+                false,  // needsEagerInit
+                false,  // hasConstants
+                false,  // isCxxModule
+                isTurboModule // isTurboModule
+            )
             moduleInfos[RNMBXShapeSourceModule.NAME] = ReactModuleInfo(
                 RNMBXShapeSourceModule.NAME,
                 RNMBXShapeSourceModule.NAME,

package/android/src/main/java/com/rnmapbox/rnmbx/components/AbstractEvent.kt

@@ -0,0 +1,24 @@
+package com.rnmapbox.rnmbx.components
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+
+class AbstractEvent(
+    viewId: Int,
+    private val mEventName: String,
+    private val mCanCoalesce: Boolean,
+    private val mEvent: WritableMap?
+) : Event<AbstractEvent>(viewId) {
+    override fun getEventName(): String {
+        return mEventName
+    }
+
+    override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+        rctEventEmitter.receiveEvent(viewTag, eventName, mEvent)
+    }
+
+    override fun canCoalesce(): Boolean {
+        return mCanCoalesce
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/AbstractEventEmitter.kt

@@ -7,6 +7,7 @@ import com.facebook.react.common.MapBuilder
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.events.Event
 import com.facebook.react.uimanager.events.EventDispatcher
 import com.rnmapbox.rnmbx.events.IEvent
 
@@ -27,6 +28,10 @@ abstract class AbstractEventEmitter<T : ViewGroup?>(reactApplicationContext: Rea
     val activity : Activity?
         get() = mRCTAppContext.currentActivity
 
+    fun <T : Event<T>>dispatchEvent(event: Event<T>) {
+        mEventDispatcher!!.dispatchEvent(event)
+    }
+
     fun handleEvent(event: IEvent) {
         val eventCacheKey = getEventCacheKey(event)
 

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXMarkerView.kt

@@ -16,6 +16,7 @@ import com.rnmapbox.rnmbx.components.RemovalReason
 import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
 import com.rnmapbox.rnmbx.utils.Logger
 import java.util.Vector
+import com.rnmapbox.rnmbx.v11compat.annotation.*
 
 private data class Vec2(val dx: Double, val dy: Double)
 
@@ -169,12 +170,11 @@ class RNMBXMarkerView(context: Context?, private val mManager: RNMBXMarkerViewMa
         val offset = getOffset()
 
         val options = viewAnnotationOptions {
-            geometry(coordinate)
-            width(width)
-            height(height)
+            coordinate?.let { geometry(it) }
+            width(width.toDouble())
+            height(height.toDouble())
             allowOverlap(mAllowOverlap)
-            offsetX(offset.dx.toInt())
-            offsetY(offset.dy.toInt())
+            offsets(offset.dx, offset.dy)
             selected(mIsSelected)
         }
         return options

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXMarkerViewManager.kt

@@ -13,9 +13,9 @@ import com.facebook.react.uimanager.ViewManagerDelegate
 import com.facebook.react.viewmanagers.RNMBXMarkerViewManagerDelegate
 import com.facebook.react.viewmanagers.RNMBXMarkerViewManagerInterface
 import com.mapbox.maps.ScreenCoordinate
-import com.mapbox.maps.viewannotation.OnViewAnnotationUpdatedListener
 import com.mapbox.maps.viewannotation.ViewAnnotationManager
 import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.rnmapbox.rnmbx.v11compat.annotation.*
 
 class RNMBXMarkerViewManager(reactApplicationContext: ReactApplicationContext) :
     AbstractEventEmitter<RNMBXMarkerView>(reactApplicationContext),
@@ -69,7 +69,7 @@ class RNMBXMarkerViewManager(reactApplicationContext: ReactApplicationContext) :
         fun markerViewContainerSizeFixer(mapView: RNMBXMapView, viewAnnotationManager: ViewAnnotationManager) {
             // see https://github.com/rnmapbox/maps/issues/2376
             viewAnnotationManager.addOnViewAnnotationUpdatedListener(object :
-                OnViewAnnotationUpdatedListener {
+                OnViewAnnotationUpdatedListener() {
                 override fun onViewAnnotationVisibilityUpdated(view: View, visible: Boolean) {
                     val parent = view.parent
                     if (parent is FrameLayout) {
@@ -79,13 +79,7 @@ class RNMBXMarkerViewManager(reactApplicationContext: ReactApplicationContext) :
                     }
                 }
 
-                override fun onViewAnnotationPositionUpdated(
-                    view: View,
-                    leftTopCoordinate: ScreenCoordinate,
-                    width: Int,
-                    height: Int
-                ) {
-                }
+
             })
         }
     }

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXPointAnnotation.kt

@@ -74,6 +74,11 @@ class RNMBXPointAnnotation(private val mContext: Context, private val mManager:
         mMapView?.offscreenAnnotationViewContainer?.removeView(childView)
     }
 
+    override fun setId(id: Int) {
+        super.setId(id)
+        mManager.tagAssigned(id)
+    }
+
     override fun addToMap(mapView: RNMBXMapView) {
         super.addToMap(mapView)
         mMap = mapView.getMapboxMap()

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXPointAnnotationManager.kt

@@ -9,10 +9,13 @@ import com.facebook.react.uimanager.annotations.ReactProp
 import com.facebook.react.viewmanagers.RNMBXPointAnnotationManagerDelegate
 import com.facebook.react.viewmanagers.RNMBXPointAnnotationManagerInterface
 import com.rnmapbox.rnmbx.components.AbstractEventEmitter
+import com.rnmapbox.rnmbx.components.styles.sources.RNMBXShapeSource
 import com.rnmapbox.rnmbx.events.constants.EventKeys
+import com.rnmapbox.rnmbx.events.constants.eventMapOf
 import com.rnmapbox.rnmbx.utils.GeoJSONUtils.toPointGeometry
+import com.rnmapbox.rnmbx.utils.ViewTagResolver
 
-class RNMBXPointAnnotationManager(reactApplicationContext: ReactApplicationContext) : AbstractEventEmitter<RNMBXPointAnnotation>(reactApplicationContext),
+class RNMBXPointAnnotationManager(reactApplicationContext: ReactApplicationContext, val viewTagResolver: ViewTagResolver) : AbstractEventEmitter<RNMBXPointAnnotation>(reactApplicationContext),
   RNMBXPointAnnotationManagerInterface<RNMBXPointAnnotation> {
 
     private val mDelegate: ViewManagerDelegate<RNMBXPointAnnotation>
@@ -30,13 +33,13 @@ class RNMBXPointAnnotationManager(reactApplicationContext: ReactApplicationConte
     }
 
     override fun customEvents(): Map<String, String> {
-        return MapBuilder.builder<String, String>()
-            .put(EventKeys.POINT_ANNOTATION_SELECTED, "onMapboxPointAnnotationSelected")
-            .put(EventKeys.POINT_ANNOTATION_DESELECTED, "onMapboxPointAnnotationDeselected")
-            .put(EventKeys.POINT_ANNOTATION_DRAG_START, "onMapboxPointAnnotationDragStart")
-            .put(EventKeys.POINT_ANNOTATION_DRAG, "onMapboxPointAnnotationDrag")
-            .put(EventKeys.POINT_ANNOTATION_DRAG_END, "onMapboxPointAnnotationDragEnd")
-            .build()
+        return eventMapOf(
+            EventKeys.POINT_ANNOTATION_SELECTED to "onMapboxPointAnnotationSelected",
+            EventKeys.POINT_ANNOTATION_DESELECTED to "onMapboxPointAnnotationDeselected",
+            EventKeys.POINT_ANNOTATION_DRAG_START to "onMapboxPointAnnotationDragStart",
+            EventKeys.POINT_ANNOTATION_DRAG to "onMapboxPointAnnotationDrag",
+            EventKeys.POINT_ANNOTATION_DRAG_END to "onMapboxPointAnnotationDragEnd"
+        )
     }
 
     // TODO: check why it does not work correctly
@@ -44,6 +47,17 @@ class RNMBXPointAnnotationManager(reactApplicationContext: ReactApplicationConte
         return RNMBXPointAnnotation(reactContext!!, this)
     }
 
+    override fun onDropViewInstance(view: RNMBXPointAnnotation) {
+        val reactTag = view.id
+
+        viewTagResolver.viewRemoved(reactTag)
+        super.onDropViewInstance(view)
+    }
+
+    fun tagAssigned(reactTag: Int) {
+        return viewTagResolver.tagAssigned(reactTag)
+    }
+
     @ReactProp(name = "id")
     override fun setId(annotation: RNMBXPointAnnotation, id: Dynamic) {
         annotation.iD = id.asString()

package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/RNMBXCamera.kt

@@ -334,10 +334,10 @@ class RNMBXCamera(private val mContext: Context, private val mManager: RNMBXCame
                         if (location?.puckBearingEnabled == true) {
                             when (location.puckBearingSource) {
 
-                                PuckBearingSource.HEADING -> {
+                                PuckBearing.HEADING -> {
                                     UserTrackingMode.FollowWithHeading
                                 }
-                                PuckBearingSource.COURSE -> {
+                                PuckBearing.COURSE -> {
                                     UserTrackingMode.FollowWithCourse
                                 }
                                 else -> {
@@ -468,12 +468,12 @@ class RNMBXCamera(private val mContext: Context, private val mManager: RNMBXCame
             when (mFollowUserMode ?: "normal") {
                 "compass" -> {
                     location.puckBearingEnabled = true
-                    location.puckBearingSource = PuckBearingSource.HEADING
+                    location.puckBearingSource = PuckBearing.HEADING
                     followOptions.bearing(FollowPuckViewportStateBearing.SyncWithLocationPuck)
                 }
                 "course" -> {
                     location.puckBearingEnabled = true
-                    location.puckBearingSource = PuckBearingSource.COURSE
+                    location.puckBearingSource = PuckBearing.COURSE
                     followOptions.bearing(FollowPuckViewportStateBearing.SyncWithLocationPuck)
                 }
                 "normal" -> {

package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/RNMBXVIewportManager.kt

@@ -0,0 +1,55 @@
+package com.rnmapbox.rnmbx.components.camera
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNMBXViewportManagerInterface
+import com.rnmapbox.rnmbx.components.AbstractEventEmitter
+import com.rnmapbox.rnmbx.events.constants.EventKeys
+import com.rnmapbox.rnmbx.events.constants.eventMapOf
+
+class RNMBXViewportManager(private val mContext: ReactApplicationContext) : AbstractEventEmitter<RNMBXViewport?>(
+        mContext
+    ), RNMBXViewportManagerInterface<RNMBXViewport> {
+
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    override fun createViewInstance(reactContext: ThemedReactContext): RNMBXViewport {
+        return RNMBXViewport(reactContext, this)
+    }
+
+    @ReactProp(name = "transitionsToIdleUponUserInteraction")
+    override fun setTransitionsToIdleUponUserInteraction(view: RNMBXViewport?, value: Dynamic?) {
+        view?.transitionsToIdleUponUserInteraction = value?.asBoolean()
+    }
+
+    @ReactProp(name = "hasStatusChanged")
+    override fun setHasStatusChanged(view: RNMBXViewport?, value: Boolean) {
+        view?.hasStatusChanged = value
+    }
+
+    //region Custom Events
+    override fun customEvents(): Map<String, String>? {
+        return eventMapOf(
+            EventKeys.VIEWPORT_STATUS_CHANGE to "onStatusChanged"
+        )
+    }
+
+    override fun getCommandsMap(): Map<String, Int>? {
+        return mapOf(
+            "_useCommandName" to 1
+        );
+    }
+    //endregion
+
+    companion object {
+        const val REACT_CLASS = "RNMBXViewport"
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/RNMBXViewport.kt

@@ -0,0 +1,259 @@
+package com.rnmapbox.rnmbx.components.camera
+
+import android.content.Context
+import android.util.Log
+import androidx.annotation.RequiresPermission.Read
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.UIManagerHelper
+import com.mapbox.maps.MapView
+import com.mapbox.maps.plugin.viewport.CompletionListener
+import com.mapbox.maps.plugin.viewport.ViewportPlugin
+import com.mapbox.maps.plugin.viewport.ViewportStatus
+import com.mapbox.maps.plugin.viewport.ViewportStatusObserver
+import com.mapbox.maps.plugin.viewport.data.DefaultViewportTransitionOptions
+import com.mapbox.maps.plugin.viewport.data.ViewportStatusChangeReason
+import com.mapbox.maps.plugin.viewport.state.FollowPuckViewportState
+import com.mapbox.maps.plugin.viewport.state.OverviewViewportState
+import com.mapbox.maps.plugin.viewport.state.ViewportState
+import com.mapbox.maps.plugin.viewport.transition.DefaultViewportTransition
+import com.mapbox.maps.plugin.viewport.transition.ViewportTransition
+import com.mapbox.maps.plugin.viewport.viewport
+import com.rnmapbox.rnmbx.components.AbstractMapFeature
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.rnmapbox.rnmbx.modules.RNMBXLogging
+import com.rnmapbox.rnmbx.utils.Logger
+import com.rnmapbox.rnmbx.utils.extensions.getAndLogIfNotBoolean
+import com.rnmapbox.rnmbx.utils.extensions.getAndLogIfNotDouble
+import com.rnmapbox.rnmbx.utils.extensions.getAndLogIfNotString
+import com.rnmapbox.rnmbx.utils.writableMapOf
+
+import com.facebook.react.uimanager.events.Event
+import com.rnmapbox.rnmbx.events.constants.EventKeys
+
+class BaseEvent(
+    private val surfaceId: Int,
+    private val viewTag: Int,
+    private val eventName: String,
+    private val eventData: WritableMap,
+    private val canCoalesce: Boolean = false
+): Event<BaseEvent>(surfaceId, viewTag) {
+    override fun getEventName(): String {
+        return eventName
+    }
+
+    override fun canCoalesce(): Boolean {
+        return canCoalesce
+    }
+
+    override fun getEventData(): WritableMap? {
+        return eventData
+    }
+}
+
+class RNMBXViewport(private val mContext: Context, private val mManager: RNMBXViewportManager) :
+AbstractMapFeature(
+mContext
+) {
+    // region properties
+    var transitionsToIdleUponUserInteraction: Boolean? = null
+        set(value: Boolean?) {
+            field = value
+            if (value != null) {
+                mMapView?.let { applyTransitionsToIdleUponUserIntraction(it.mapView) }
+            }
+        }
+
+    fun applyTransitionsToIdleUponUserIntraction(mapView: MapView) {
+        this.transitionsToIdleUponUserInteraction?.let {
+            mapView.viewport.options = mapView.viewport.options.toBuilder().transitionsToIdleUponUserInteraction(it).build()
+        }
+    }
+
+    var hasStatusChanged: Boolean = false
+        set(value: Boolean) {
+            field = value
+            mMapView?.let { applyHasStatusChanged(it.mapView) }
+        }
+    private var statusObserver: ViewportStatusObserver? = null
+
+    private fun applyHasStatusChanged(mapView: MapView) {
+        val viewport = mapView.viewport
+        if (hasStatusChanged) {
+            if (statusObserver == null) {
+                val statusObserver = ViewportStatusObserver { from, to, reason ->
+                    val payload = writableMapOf("from" to statusToMap(from), "to" to statusToMap(to), "reason" to reasonToSrting(reason))
+                    mManager.dispatchEvent(
+                        BaseEvent(
+                            UIManagerHelper.getSurfaceId(mContext),
+                            id,
+                            EventKeys.VIEWPORT_STATUS_CHANGE.value,
+                            writableMapOf(
+                                "type" to "statuschanged",
+                                "payload" to payload
+                            )
+                        )
+                    )
+                }
+                this.statusObserver = statusObserver
+                viewport.addStatusObserver(statusObserver)
+            }
+        } else {
+            statusObserver?.let {
+                viewport.removeStatusObserver(it)
+            }
+        }
+    }
+    // endregion
+
+    override fun addToMap(mapView: RNMBXMapView) {
+        super.addToMap(mapView)
+        applyTransitionsToIdleUponUserIntraction(mapView.mapView)
+        applyHasStatusChanged(mapView.mapView)
+    }
+
+    fun toState(viewport: ViewportPlugin, state: ReadableMap): ViewportState? {
+        return when (val kind = state.getAndLogIfNotString("kind")) {
+            "followPuck" -> viewport.makeFollowPuckViewportState()
+            //"overview" -> return viewport.makeOverviewViewportState()
+            else -> {
+                Logger.e(LOG_TAG, "toState: unexpected state: $kind")
+                null
+            }
+        }
+    }
+
+    fun toDefaultViewportTransitionOptions(state: ReadableMap?): DefaultViewportTransitionOptions {
+        val builder = DefaultViewportTransitionOptions.Builder()
+        if (state?.hasKey("maxDurationMs") == true) {
+            val maxDurationMs = state.getAndLogIfNotDouble("maxDurationMs", LOG_TAG)
+            if (maxDurationMs != null) {
+                builder.maxDurationMs(maxDurationMs.toLong())
+            }
+            builder.build()
+        }
+        return builder.build()
+    }
+
+    fun toTransition(viewport: ViewportPlugin, state: ReadableMap?): ViewportTransition? {
+        viewport.idle()
+        return when (val kind = state?.getAndLogIfNotString("kind", LOG_TAG)) {
+            "default" -> viewport.makeDefaultViewportTransition(
+               toDefaultViewportTransitionOptions(state?.getMap("options"))
+            )
+            "immediate" -> viewport.makeImmediateViewportTransition()
+            null -> null
+            else -> {
+                Logger.e(LOG_TAG, "toTransition: unexpected transition to: $kind")
+                null
+            }
+        }
+    }
+
+    fun transitionTo(state: ReadableMap,
+                     transition: ReadableMap?,
+                     promise: Promise
+    ) {
+        val mapView = mMapView
+        if (mapView == null) {
+            Logger.e(LOG_TAG, "transitionTo: mapView is null")
+            return
+        }
+
+        val toState = toState(mapView.mapView.viewport, state)
+        if (toState == null) {
+            Logger.e(LOG_TAG, "transitionTo: no state to transition to: $state")
+            return;
+        }
+        val transition = toTransition(mapView.mapView.viewport, transition)
+
+        mapView.mapView.viewport.transitionTo(toState, transition, CompletionListener { promise.resolve(it) } )
+    }
+
+    fun idle() {
+        val mapView = mMapView
+        if (mapView == null) {
+            Logger.e(LOG_TAG, "transitionTo: mapView is null")
+            return
+        }
+
+        mapView.mapView.viewport.idle()
+    }
+
+    private fun transitionToMap(transition: ViewportTransition): WritableMap? {
+        return when (transition) {
+            is DefaultViewportTransition -> writableMapOf("kind" to "default", "maxDurationMs" to transition.options.maxDurationMs)
+            else ->
+                if (transition.javaClass.toString().indexOf("ImmediateViewportTransition") >= 0) {
+                    writableMapOf("kind" to "immediate")
+                } else {
+                    writableMapOf("kind" to "unknown")
+                }
+        }
+    }
+
+    private fun stateToMap(state: ViewportState): WritableMap? {
+        return when (state) {
+            is FollowPuckViewportState -> writableMapOf("kind" to "followPuck")
+            is OverviewViewportState -> writableMapOf("kind" to "overview")
+            else -> {
+                writableMapOf("kind" to "custom", "impl" to state.javaClass.toString())
+            }
+        }
+    }
+
+    private fun statusToMap(status: ViewportStatus): WritableMap? {
+        return when (status) {
+            is ViewportStatus.Idle -> {
+                writableMapOf(
+                    "kind" to "idle"
+                )
+            }
+
+            is ViewportStatus.State -> {
+                writableMapOf(
+                    "kind" to "state",
+                    "state" to stateToMap(status.state)
+                )
+            }
+
+            is ViewportStatus.Transition -> {
+                writableMapOf(
+                    "kind" to "transition",
+                    "transition" to transitionToMap(status.transition),
+                    "toState" to stateToMap(status.toState)
+                )
+            }
+        }
+    }
+
+    private fun reasonToSrting(reason: ViewportStatusChangeReason): String {
+        return when (reason) {
+           ViewportStatusChangeReason.IDLE_REQUESTED -> "IdleRequested"
+            ViewportStatusChangeReason.TRANSITION_FAILED -> "TransitionFailed"
+            ViewportStatusChangeReason.TRANSITION_STARTED -> "TransitionStarted"
+            ViewportStatusChangeReason.USER_INTERACTION -> "UserInteraction"
+            ViewportStatusChangeReason.TRANSITION_SUCCEEDED -> "TransitionSucceeded"
+            else -> {
+                "Unknown:${reason.toString()}"
+            }
+        }
+    }
+
+    fun getState(): WritableMap? {
+        val mapView = mMapView
+        if (mapView == null) {
+            Logger.e(LOG_TAG, "getState: mapView is null")
+            return null
+        }
+        return statusToMap(mapView.mapView.viewport.status)
+    }
+
+    companion object {
+        const val LOG_TAG = "RNMBXViewport"
+    }
+}