@rnmapbox/maps 10.1.0-beta.8 → 10.1.0-rc.0

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

@@ -0,0 +1,408 @@
+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.ReadableType
+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.*
+import com.rnmapbox.rnmbx.utils.writableMapOf
+
+import com.facebook.react.uimanager.events.Event
+import com.mapbox.geojson.Geometry
+import com.mapbox.maps.EdgeInsets
+import com.mapbox.maps.plugin.viewport.data.FollowPuckViewportStateBearing
+import com.mapbox.maps.plugin.viewport.data.FollowPuckViewportStateOptions
+import com.mapbox.maps.plugin.viewport.data.OverviewViewportStateOptions
+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)
+    }
+
+    private fun toState(viewport: ViewportPlugin, state: ReadableMap): ViewportState? {
+        return when (val kind = state.getAndLogIfNotString("kind")) {
+            "followPuck" -> viewport.makeFollowPuckViewportState(
+                parseFollowViewportOptions(state)
+            )
+            "overview" -> return viewport.makeOverviewViewportState(
+                parseOverviewViewportOption(state)
+            )
+            else -> {
+                Logger.e(LOG_TAG, "toState: unexpected state: $kind")
+                null
+            }
+        }
+    }
+
+    data class FollowPuckViewportStateBearingOrNull(val state: FollowPuckViewportStateBearing?)
+    private fun parseFollowViewportOptions(state: ReadableMap): FollowPuckViewportStateOptions {
+        val builder = FollowPuckViewportStateOptions.Builder()
+        state.getAndLogIfNotMap("options", LOG_TAG)?.let { options ->
+            if (options.hasKey("zoom")) {
+                if (options.isKeep("zoom")) {
+                    builder.zoom(null)
+                } else {
+                    options.getAndLogIfNotDouble("zoom", LOG_TAG)?.let { zoom ->
+                        builder.zoom(zoom)
+                    }
+                }
+            }
+            if (options.hasKey("pitch")) {
+                if (options.isKeep("pitch")) {
+                    builder.pitch(null)
+                } else {
+                    options.getAndLogIfNotDouble("pitch", LOG_TAG)?.let {pitch ->
+                        builder.pitch(pitch)
+                    }
+                }
+            }
+
+            if (options.hasKey("bearing")) {
+                when (options.getType("bearing")) {
+                    ReadableType.Number ->
+                        FollowPuckViewportStateBearingOrNull(FollowPuckViewportStateBearing.Constant(options.getDouble("bearing")))
+
+                    ReadableType.String ->
+                        when (options.getString("bearing")) {
+                            "course" ->
+                                FollowPuckViewportStateBearingOrNull(FollowPuckViewportStateBearing.SyncWithLocationPuck)
+                            "heading" ->
+                                FollowPuckViewportStateBearingOrNull(FollowPuckViewportStateBearing.SyncWithLocationPuck)
+                            "keep" ->
+                                FollowPuckViewportStateBearingOrNull(null)
+                            else -> {
+                                Logger.e(
+                                    LOG_TAG,
+                                    "bearing in viewport options should be either a constant number or syncWithLocationPuck"
+                                )
+                                null
+                            }
+                        }
+                    else -> {
+                        Logger.e(
+                            LOG_TAG,
+                        "bearing in viewport options should be either constant number or course or heading or keep"
+                        )
+                        null
+                    }
+                }?.let { bearing ->
+                    builder.bearing(bearing.state)
+                }
+            }
+            if (options.hasKey("padding")) {
+                if (options.isNull("padding")) {
+                    builder.padding(null)
+                } else {
+                    options.getAndLogIfNotMap("padding", LOG_TAG)?.let { paddingMap ->
+                        paddingMap?.toPadding(LOG_TAG, resources.displayMetrics.density)?.let { padding ->
+                            builder.padding(padding)
+                        }
+                    }
+                }
+            }
+        }
+        return builder.build()
+    }
+
+    private fun parseOverviewViewportOption(state: ReadableMap): OverviewViewportStateOptions {
+        val builder = OverviewViewportStateOptions.Builder()
+
+        state.getAndLogIfNotMap("options", LOG_TAG)?.let { options ->
+            if (options.hasKey("padding")) {
+                if (!options.isNull("padding")) {
+                    options.getAndLogIfNotMap("padding", LOG_TAG)?.let { paddingMap ->
+                        paddingMap?.toPadding(LOG_TAG, resources.displayMetrics.density)?.let { padding ->
+                            builder.padding(padding)
+                        }
+                    }
+                }
+            }
+
+            if (options.hasKey("bearing")) {
+                when (options.getType("bearing")) {
+                    ReadableType.Number ->
+                        builder.bearing(options.getDouble("bearing"))
+                    ReadableType.Null ->
+                        builder.bearing(null)
+                    else -> {
+                        Logger.e(
+                            LOG_TAG,
+                            "bearing in viewport options should be either constant number or null"
+                        )
+                        null
+                    }
+                }
+            }
+
+            if (options.hasKey("pitch")) {
+                if (options.isNull("pitch")) {
+                    builder.pitch(null)
+                } else {
+                    options.getAndLogIfNotDouble("pitch", LOG_TAG)?.let {pitch ->
+                        builder.pitch(pitch)
+                    }
+                }
+            }
+
+            if (options.hasKey("animationDuration")) {
+                if (!options.isNull("animationDuration")) {
+                    options.getAndLogIfNotDouble("zoom", LOG_TAG)?.let { duration ->
+                        builder.animationDurationMs((duration * 1000.0).toLong())
+                    }
+                }
+            }
+
+            if (options.hasKey("geometry")) {
+                options.getAndLogIfNotMap("geometry")?.let {map ->
+                    map.toGeometry()?.let { geometry ->
+                        builder.geometry(geometry)
+                    }
+                }
+            }
+        }
+
+        return builder.build()
+    }
+
+
+    private 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()
+    }
+
+    private fun toGeometry(geometry: ReadableMap): Geometry? {
+        return geometry.toGeometry()
+    }
+
+    private 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"
+    }
+}
+
+private fun ReadableMap.isKeep(s: String): Boolean {
+    return ((getType(s) == ReadableType.String) && (getString(s) == "keep"))
+}
+
+

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

@@ -0,0 +1,66 @@
+package com.rnmapbox.rnmbx.components.camera
+
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeMap
+import com.rnmapbox.rnmbx.NativeRNMBXViewportModuleSpec
+import com.rnmapbox.rnmbx.components.mapview.CommandResponse
+import com.rnmapbox.rnmbx.utils.ViewTagResolver
+
+class RNMBXViewportModule(context: ReactApplicationContext, val viewTagResolver: ViewTagResolver) : NativeRNMBXViewportModuleSpec(context) {
+    private fun withViewportOnUIThread(
+        viewRef: Double?,
+        reject: Promise,
+        fn: (RNMBXViewport) -> Unit
+    ) {
+        if (viewRef == null) {
+            reject.reject(Exception("viewRef is null"))
+        } else {
+            viewTagResolver.withViewResolved(viewRef.toInt(), reject, fn)
+        }
+    }
+
+    private fun createCommandResponse(promise: Promise): CommandResponse = object : CommandResponse {
+        override fun success(builder: (WritableMap) -> Unit) {
+            val payload: WritableMap = WritableNativeMap()
+            builder(payload)
+
+            promise.resolve(payload)
+        }
+
+        override fun error(message: String) {
+            promise.reject(Exception(message))
+        }
+    }
+
+    override fun getState(viewRef: Double?, promise: Promise) {
+        withViewportOnUIThread(viewRef, promise) {
+            promise.resolve(it.getState())
+        }
+    }
+
+    override fun transitionTo(
+        viewRef: Double?,
+        state: ReadableMap,
+        transition: ReadableMap?,
+        promise: Promise
+    ) {
+        withViewportOnUIThread(viewRef, promise) {
+            it.transitionTo(state, transition, promise)
+        }
+    }
+
+    override fun idle(viewRef: Double?, promise: Promise) {
+        withViewportOnUIThread(viewRef, promise) {
+            it.idle()
+            promise.resolve(true)
+        }
+    }
+
+    companion object {
+        const val NAME = "RNMBXViewportModule"
+    }
+}

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

@@ -0,0 +1,53 @@
+package com.rnmapbox.rnmbx.components.images
+
+import android.graphics.Bitmap
+import android.graphics.drawable.BitmapDrawable
+import com.rnmapbox.rnmbx.v11compat.Cancelable
+import com.mapbox.maps.Image
+import com.rnmapbox.rnmbx.v11compat.image.toMapboxImage
+
+/**
+ImageManager helps to resolve images defined by any of RNMBXImages component.
+ */
+
+fun interface Resolver {
+    fun resolved(name: String, image: Image)
+}
+class Subscription(val name:String, val resolver: Resolver, val manager: ImageManager): Cancelable {
+
+    fun resolved(name: String, image: Image) {
+        resolver.resolved(name, image)
+    }
+    override fun cancel() {
+        manager.unsubscribe(this)
+    }
+}
+
+class ImageManager {
+    var subscriptions: MutableMap<String, MutableList<Subscription>> = hashMapOf()
+
+    fun subscribe(name: String, resolved: Resolver) : Subscription {
+        val list = subscriptions.getOrPut(name) { mutableListOf() }
+        val result = Subscription(name, resolved, this)
+        list.add(result)
+        return result
+    }
+    fun unsubscribe(subscription: Subscription) {
+        var list = subscriptions[subscription.name]
+        list?.removeAll { it === subscription }
+    }
+
+    fun resolve(name: String, image: Image) {
+        subscriptions[name]?.forEach {
+            it.resolved(name, image)
+        }
+    }
+
+    fun resolve(name: String, image: Bitmap) {
+        resolve(name, image.toMapboxImage())
+    }
+
+    fun resolve(name: String, image: BitmapDrawable) {
+        resolve(name, image.bitmap)
+    }
+}

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

@@ -28,6 +28,11 @@ class RNMBXImage(private val mContext: ReactApplicationContext, private val mMan
 
     var mBitmap : Bitmap? = null
 
+    override fun setId(id: Int) {
+        super.setId(id)
+        mManager.tagAssigned(id)
+    }
+
     override fun onLayoutChange(v: View, left: Int, top: Int, right: Int, bottom: Int, oldLeft: Int, oldTop: Int,
                                 oldRight: Int, oldBottom: Int) {
         if (left == 0 && top == 0 && right == 0 && bottom == 0) {

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

@@ -1,18 +1,18 @@
 package com.rnmapbox.rnmbx.components.images
 
 import com.facebook.react.bridge.Dynamic
-import com.facebook.react.bridge.DynamicFromArray
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.common.MapBuilder
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNMBXImageManagerInterface
 import com.rnmapbox.rnmbx.components.AbstractEventEmitter
-import com.rnmapbox.rnmbx.events.constants.EventKeys
+import com.rnmapbox.rnmbx.components.styles.sources.RNMBXShapeSource
+import com.rnmapbox.rnmbx.utils.ViewTagResolver
 
-class RNMBXImageManager(private val mContext: ReactApplicationContext) : AbstractEventEmitter<RNMBXImage>(
+class RNMBXImageManager(private val mContext: ReactApplicationContext, val viewTagResolver: ViewTagResolver) : AbstractEventEmitter<RNMBXImage>(
 mContext
-) {
+), RNMBXImageManagerInterface<RNMBXImage> {
     override fun getName(): String {
         return "RNMBXImage"
     }
@@ -25,43 +25,46 @@ mContext
         return mutableMapOf();
     }
 
+    override fun onDropViewInstance(view: RNMBXImage) {
+        val reactTag = view.id
+
+        viewTagResolver.viewRemoved(reactTag)
+        super.onDropViewInstance(view)
+    }
+
+    fun tagAssigned(reactTag: Int) {
+        return viewTagResolver.tagAssigned(reactTag)
+    }
+
     // region React properties
     @ReactProp(name="name")
-    fun setName(image: RNMBXImage, value: String) {
-        image.name = value
+    override fun setName(image: RNMBXImage, value: Dynamic) {
+        image.name = value.asString()
     }
 
     @ReactProp(name="sdf")
-    fun setSdf(image: RNMBXImage, value: Boolean) {
-        image.sdf = value
+    override fun setSdf(image: RNMBXImage, value: Dynamic) {
+        image.sdf = value.asBoolean()
     }
 
     @ReactProp(name="stretchX")
-    fun setStretchX(image: RNMBXImage, value: Dynamic) {
+    override fun setStretchX(image: RNMBXImage, value: Dynamic) {
         image.stretchX = RNMBXImagesManager.convertStretch(value) ?: listOf()
     }
 
     @ReactProp(name="stretchY")
-    fun setStretchY(image: RNMBXImage, value: Dynamic) {
+    override fun setStretchY(image: RNMBXImage, value: Dynamic) {
         image.stretchY = RNMBXImagesManager.convertStretch(value) ?: listOf()
     }
 
     @ReactProp(name="content")
-    fun setContent(image: RNMBXImage, value: Dynamic) {
+    override fun setContent(image: RNMBXImage, value: Dynamic) {
         image.content = RNMBXImagesManager.convertContent(value)
     }
 
     @ReactProp(name="scale")
-    fun setScale(image: RNMBXImage, value: Double) {
-        image.scale = value
-    }
-    // endregion
-
-    // region React methods
-    override fun receiveCommand(root: RNMBXImage, commandId: String?, args: ReadableArray?) {
-        if (commandId == "refresh") {
-            root.refresh()
-        }
+    override fun setScale(image: RNMBXImage, value: Dynamic) {
+        image.scale = value.asDouble()
     }
     // endregion
 }

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

@@ -0,0 +1,33 @@
+package com.rnmapbox.rnmbx.components.images
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.module.annotations.ReactModule
+import com.rnmapbox.rnmbx.NativeRNMBXImageModuleSpec
+import com.rnmapbox.rnmbx.utils.ViewTagResolver
+
+@ReactModule(name = RNMBXImageModule.NAME)
+class RNMBXImageModule(reactContext: ReactApplicationContext?, private val viewTagResolver: ViewTagResolver) :
+    NativeRNMBXImageModuleSpec(reactContext) {
+
+    companion object {
+        const val NAME = "RNMBXImageModule"
+    }
+
+    private fun withImageOnUIThread(viewRef: Double?, reject: Promise, fn: (RNMBXImage) -> Unit) {
+        if (viewRef == null) {
+            reject.reject(Exception("viewRef is null for RNMBXImage"))
+        } else {
+            viewTagResolver.withViewResolved(viewRef.toInt(), reject, fn)
+        }
+    }
+
+    @ReactMethod
+    override fun refresh(viewRef: Double?, promise: Promise) {
+        withImageOnUIThread(viewRef, promise) {
+            it.refresh()
+            promise.resolve(null)
+        }
+    }
+}