@rnmapbox/maps 10.0.15 → 10.1.0-beta.10

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

@@ -0,0 +1,118 @@
+package com.rnmapbox.rnmbx.components.camera
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.RNMBXCameraManagerInterface
+import com.mapbox.geojson.FeatureCollection
+import com.rnmapbox.rnmbx.components.AbstractEventEmitter
+import com.rnmapbox.rnmbx.components.camera.CameraStop.Companion.fromReadableMap
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils.toLatLngBounds
+
+
+class RNMBXCameraManager(private val mContext: ReactApplicationContext) :
+    AbstractEventEmitter<RNMBXCamera?>(
+        mContext
+    ), RNMBXCameraManagerInterface<RNMBXCamera> {
+    override fun customEvents(): Map<String, String>? {
+        return HashMap()
+    }
+
+    override fun getName(): String {
+        return REACT_CLASS
+    }
+
+    override fun createViewInstance(reactContext: ThemedReactContext): RNMBXCamera {
+        return RNMBXCamera(reactContext, this)
+    }
+
+    @ReactProp(name = "stop")
+    override fun setStop(camera: RNMBXCamera, map: Dynamic) {
+        if (!map.isNull) {
+            val stop = fromReadableMap(mContext, map.asMap(), null)
+            camera.setStop(stop)
+        }
+    }
+
+    @ReactProp(name = "defaultStop")
+    override fun setDefaultStop(camera: RNMBXCamera, map: Dynamic) {
+        if (!map.isNull) {
+            val stop = fromReadableMap(mContext, map.asMap(), null)
+            camera.setDefaultStop(stop)
+        }
+    }
+
+    @ReactProp(name = "userTrackingMode")
+    override fun setUserTrackingMode(camera: RNMBXCamera, userTrackingMode: Dynamic) {
+        camera.setUserTrackingMode(userTrackingMode.asInt())
+        throw AssertionError("Unused code")
+    }
+
+    @ReactProp(name = "zoomLevel")
+    override fun setZoomLevel(camera: RNMBXCamera, zoomLevel: Dynamic) {
+        camera.setZoomLevel(zoomLevel.asDouble())
+    }
+
+    @ReactProp(name = "minZoomLevel")
+    override fun setMinZoomLevel(camera: RNMBXCamera, value: Dynamic) {
+        camera.setMinZoomLevel(value.asDouble())
+    }
+
+    @ReactProp(name = "maxZoomLevel")
+    override fun setMaxZoomLevel(camera: RNMBXCamera, value: Dynamic) {
+        camera.setMaxZoomLevel(value.asDouble())
+    }
+
+    @ReactProp(name = "followUserLocation")
+    override fun setFollowUserLocation(camera: RNMBXCamera, value: Dynamic) {
+        camera.setFollowUserLocation(value.asBoolean())
+    }
+
+    @ReactProp(name = "followUserMode")
+    override fun setFollowUserMode(camera: RNMBXCamera, value: Dynamic) {
+        camera.setFollowUserMode(value.asString())
+    }
+
+    @ReactProp(name = "followZoomLevel")
+    override fun setFollowZoomLevel(camera: RNMBXCamera, value: Dynamic) {
+        camera.setFollowZoomLevel(value.asDouble())
+    }
+
+    @ReactProp(name = "followPitch")
+    override fun setFollowPitch(camera: RNMBXCamera, value: Dynamic) {
+        camera.setFollowPitch(value.asDouble())
+    }
+
+    @ReactProp(name = "followHeading")
+    override fun setFollowHeading(camera: RNMBXCamera, value: Dynamic) {
+        camera.setFollowHeading(value.asDouble())
+    }
+
+    @ReactProp(name = "followPadding")
+    override fun setFollowPadding(camera: RNMBXCamera, value: Dynamic) {
+        camera.setFollowPadding(value.asMap())
+    }
+
+    @ReactProp(name = "maxBounds")
+    override fun setMaxBounds(camera: RNMBXCamera, value: Dynamic) {
+        if (!value.isNull) {
+            val collection = FeatureCollection.fromJson(value.asString())
+            camera.setMaxBounds(toLatLngBounds(collection))
+        } else {
+            camera.setMaxBounds(null)
+        }
+    }
+
+    override fun setAnimationDuration(view: RNMBXCamera?, value: Dynamic) {
+        // no-op on Android
+    }
+
+    override fun setAnimationMode(view: RNMBXCamera?, value: Dynamic) {
+        // no-op on Android
+    }
+
+    companion object {
+        const val REACT_CLASS = "RNMBXCamera"
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/constants/CameraMode.java

@@ -0,0 +1,18 @@
+package com.rnmapbox.rnmbx.components.camera.constants;
+
+import androidx.annotation.IntDef;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+public class CameraMode {
+
+    @IntDef({ FLIGHT, EASE, LINEAR, NONE })
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Mode {}
+
+    public static final int FLIGHT = 1;
+    public static final int EASE = 2;
+    public static final int LINEAR = 3;
+    public static final int NONE = 4;
+}

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

@@ -0,0 +1,76 @@
+package com.rnmapbox.rnmbx.components.images
+
+import android.graphics.Bitmap
+import android.view.View
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.views.view.ReactViewGroup
+import com.mapbox.maps.ImageContent
+import com.mapbox.maps.ImageStretches
+import com.rnmapbox.rnmbx.components.annotation.RNMBXCallout
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.rnmapbox.rnmbx.utils.BitmapUtils
+import com.rnmapbox.rnmbx.utils.Logger
+
+class RNMBXImage(private val mContext: ReactApplicationContext, private val mManager: RNMBXImageManager): ReactViewGroup(mContext), View.OnLayoutChangeListener {
+    var name: String? = null
+    var sdf: Boolean = false
+    var scale: Double = 1.0
+    var stretchX = listOf<ImageStretches>();
+    var stretchY = listOf<ImageStretches>();
+    var content: ImageContent? = null;
+
+    var mChildView: View? = null;
+
+    var mMapView: RNMBXMapView? = null;
+
+    var nativeImageUpdater: NativeImageUpdater? = null;
+
+    var mBitmap : Bitmap? = null
+
+    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) {
+            return
+        }
+        if (left != oldLeft || right != oldRight || top != oldTop || bottom != oldBottom) {
+            refreshBitmap(v, left, top, right, bottom)
+        }
+    }
+
+    private fun refreshBitmap(v: View, left: Int = v.left, top: Int = v.top, right: Int = v.right, bottom: Int = v.bottom) {
+        val name = this.name
+        if (name == null) {
+            Logger.e("RNMBXImage", "Image component has no name")
+            return
+        }
+        val bitmap = BitmapUtils.viewToBitmap(v, left, top, right, bottom)
+        bitmap?.let { bitmap ->
+            nativeImageUpdater?.let {
+                it.updateImage(name, bitmap, sdf, stretchX, stretchY, content, scale)
+                mBitmap = null;
+            }
+        }
+    }
+
+    fun refresh() {
+        mChildView?.let {
+            refreshBitmap(it)
+        }
+    }
+
+    override fun addView(childView: View, childPosition: Int) {
+        if (childPosition != 0) {
+            Logger.e("RNMBXImage", "expected a single subview got childView:$childView position:$childPosition")
+        }
+        mMapView?.offscreenAnnotationViewContainer?.addView(childView)
+        mChildView = childView
+        childView.addOnLayoutChangeListener(this)
+    }
+
+    // region add/remove to Map
+    fun addToMap(mapView: RNMBXMapView) {
+        mMapView = mapView
+    }
+    // endregion
+}

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

@@ -0,0 +1,67 @@
+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.rnmapbox.rnmbx.components.AbstractEventEmitter
+import com.rnmapbox.rnmbx.events.constants.EventKeys
+
+class RNMBXImageManager(private val mContext: ReactApplicationContext) : AbstractEventEmitter<RNMBXImage>(
+mContext
+) {
+    override fun getName(): String {
+        return "RNMBXImage"
+    }
+
+    override fun createViewInstance(p0: ThemedReactContext): RNMBXImage {
+        return RNMBXImage(mContext, this)
+    }
+
+    override fun customEvents(): MutableMap<String, String>? {
+        return mutableMapOf();
+    }
+
+    // region React properties
+    @ReactProp(name="name")
+    fun setName(image: RNMBXImage, value: String) {
+        image.name = value
+    }
+
+    @ReactProp(name="sdf")
+    fun setSdf(image: RNMBXImage, value: Boolean) {
+        image.sdf = value
+    }
+
+    @ReactProp(name="stretchX")
+    fun setStretchX(image: RNMBXImage, value: Dynamic) {
+        image.stretchX = RNMBXImagesManager.convertStretch(value) ?: listOf()
+    }
+
+    @ReactProp(name="stretchY")
+    fun setStretchY(image: RNMBXImage, value: Dynamic) {
+        image.stretchY = RNMBXImagesManager.convertStretch(value) ?: listOf()
+    }
+
+    @ReactProp(name="content")
+    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()
+        }
+    }
+    // endregion
+}

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

@@ -0,0 +1,295 @@
+package com.rnmapbox.rnmbx.components.images
+
+import android.content.Context
+import android.graphics.Bitmap
+import com.rnmapbox.rnmbx.components.images.RNMBXImagesManager
+import com.rnmapbox.rnmbx.components.AbstractMapFeature
+import com.rnmapbox.rnmbx.utils.ImageEntry
+import android.graphics.drawable.BitmapDrawable
+import android.util.DisplayMetrics
+import androidx.core.content.res.ResourcesCompat
+import com.mapbox.bindgen.DataRef
+import com.mapbox.bindgen.Expected
+import com.mapbox.bindgen.None
+import com.mapbox.maps.Image
+import com.mapbox.maps.ImageContent
+import com.mapbox.maps.ImageStretches
+import com.mapbox.maps.MapboxMap
+import com.mapbox.maps.Style
+import com.rnmapbox.rnmbx.R
+import com.rnmapbox.rnmbx.components.RemovalReason
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.rnmapbox.rnmbx.components.images.RNMBXImages
+import com.rnmapbox.rnmbx.events.ImageMissingEvent
+import com.rnmapbox.rnmbx.utils.BitmapUtils
+import com.rnmapbox.rnmbx.utils.DownloadMapImageTask
+import java.nio.ByteBuffer
+import java.util.AbstractMap
+import java.util.ArrayList
+import java.util.HashMap
+import java.util.HashSet
+
+import com.rnmapbox.rnmbx.v11compat.image.*;
+import java.lang.Float.max
+import java.lang.Math.ceil
+import kotlin.math.ceil
+
+fun Style.addBitmapImage(imageId: String, bitmap: Bitmap, sdf: Boolean = false, stretchX: List<ImageStretches> = listOf(), stretchY: List<ImageStretches> = listOf(), content: ImageContent? = null, scale: Double = 1.0) : Expected<String, None> {
+    val byteBuffer = ByteBuffer.allocate(bitmap.byteCount)
+    bitmap.copyPixelsToBuffer(byteBuffer)
+    return this.addStyleImage(
+        imageId,
+        (1.0/((160.0/bitmap.density)) * scale).toFloat() ,
+        Image(bitmap.width, bitmap.height, byteBuffer.array().toImageData()),
+        sdf,
+        stretchX,
+        stretchY,
+        content,
+    )
+}
+
+fun Style.addBitmapImage(nativeImage: NativeImage) : Expected<String, None> {
+    val info = nativeImage.info
+    return addBitmapImage(info.name, nativeImage.drawable.bitmap, info.sdf, info.stretchX, info.stretchY, info.content, info.getScaleOr(1.0))
+}
+
+data class ImageInfo(val name: String,  val scale: Double? = 1.0, val sdf: Boolean = false, val stretchX: List<ImageStretches> = listOf(),
+                     val stretchY: List<ImageStretches> = listOf(), val content: ImageContent? = null, val width: Double? = null, val height: Double? = null)
+{
+    fun getScaleOr(default: Double): Double {
+        return scale ?: default;
+    }
+}
+
+data class NativeImage(val info: ImageInfo, val drawable: BitmapDrawable);
+
+interface NativeImageUpdater {
+    fun updateImage(imageId: String, bitmap: Bitmap, sdf: Boolean = false, stretchX: List<ImageStretches> = listOf(), stretchY: List<ImageStretches> = listOf(), content: ImageContent? = null, scale: Double = 1.0)
+}
+
+class RNMBXImages(context: Context, private val mManager: RNMBXImagesManager) : AbstractMapFeature(context), NativeImageUpdater {
+    var mCurrentImages: MutableSet<String?>
+    var mImageViews = mutableListOf<RNMBXImage>();
+    private var mImages: MutableMap<String, ImageEntry>?
+    private var mNativeImages = mutableMapOf<String, NativeImage>()
+    private var mSendMissingImageEvents = false
+    private var mMap: MapboxMap? = null
+
+    fun setImages(images: List<Map.Entry<String, ImageEntry>>) {
+        val newImages: MutableMap<String, ImageEntry> = HashMap()
+        for ((key, value) in images) {
+            val oldValue = mImages?.put(key, value)
+            if (oldValue == null) {
+                newImages[key] = value
+            }
+        }
+        if (mMap != null && mMap?.getStyle() != null) {
+            addImagesToStyle(newImages, mMap!!)
+        }
+    }
+
+    fun setNativeImages(nativeImages: List<NativeImage>) {
+        val newImages: MutableMap<String, NativeImage> = HashMap()
+        for (nativeImage in nativeImages) {
+            val name = nativeImage.info.name
+            val oldValue = mNativeImages.put(name, nativeImage)
+            if (oldValue == null) {
+                newImages[name] = nativeImage
+            }
+        }
+        mMap?.let {
+            if (it.getStyle() != null) {
+                addNativeImagesToStyle(newImages, it)
+            }
+        }
+    }
+
+    fun setHasOnImageMissing(value: Boolean) {
+        mSendMissingImageEvents = value
+    }
+
+    override fun removeFromMap(mapView: RNMBXMapView, reason: RemovalReason): Boolean {
+        removeImages(mapView)
+        mMap = null
+        if (reason == RemovalReason.ON_DESTROY) {
+            mNativeImages = mutableMapOf()
+            mImages = HashMap()
+            mCurrentImages = HashSet()
+        }
+        return super.removeFromMap(mapView, reason)
+    }
+
+    private fun removeImages(mapView: RNMBXMapView) {
+        mapView.getStyle(object : Style.OnStyleLoaded {
+            override fun onStyleLoaded(style: Style) {
+                if (hasImages()) {
+                    for ((key) in mImages!!) {
+                        style.removeStyleImage(key)
+                    }
+                }
+                if (hasNativeImages()) {
+                    for ((key) in mNativeImages!!) {
+                        style.removeStyleImage(key!!)
+                    }
+                }
+            }
+        })
+    }
+
+    private fun hasImages(): Boolean {
+        return mImages != null && mImages!!.size > 0
+    }
+
+    private fun hasNativeImages(): Boolean {
+        return mNativeImages != null && mNativeImages!!.size > 0
+    }
+
+    fun addMissingImageToStyle(id: String, map: MapboxMap): Boolean {
+        val nativeImage = mNativeImages.get(id)
+        if (nativeImage != null) {
+            addNativeImages(listOf(nativeImage), map)
+            return true
+        }
+        if (mImages != null) {
+            val entry = mImages!![id]
+            if (entry != null) {
+                addRemoteImages(entry(id, entry), map)
+                return true
+            }
+        }
+        return false
+    }
+
+    fun addImagesToStyle(images: Map<String, ImageEntry>?, map: MapboxMap) {
+        if (images != null) {
+            addRemoteImages(ArrayList(images.entries), map)
+        }
+    }
+
+    fun addNativeImagesToStyle(images: Map<String, NativeImage>, map: MapboxMap) {
+        addNativeImages(images.values.toList(), map)
+    }
+
+    fun sendImageMissingEvent(id: String, map: MapboxMap) {
+        if (mSendMissingImageEvents) {
+            mManager.handleEvent(ImageMissingEvent.makeImageMissingEvent(this, id))
+        }
+    }
+
+    private fun hasImage(imageId: String?, map: MapboxMap): Boolean {
+        val style = map.getStyle()
+        return style != null && imageId?.let { style.getStyleImage(it) } != null
+    }
+
+    override fun addToMap(mapView: RNMBXMapView) {
+        super.addToMap(mapView)
+
+        mImageViews.forEach {
+            it.addToMap(mapView)
+        }
+        // Wait for style before adding the source to the map
+        // only then we can pre-load required images / placeholders into the style
+        // before we add the ShapeSource to the map
+        mapView.getStyle(object : Style.OnStyleLoaded {
+            override fun onStyleLoaded(style: Style) {
+                val map = mapView.getMapboxMap()
+                mMap = map
+                addNativeImagesToStyle(mNativeImages, map)
+                addImagesToStyle(mImages, map)
+                // super.addToMap(mapView);
+
+                mImageViews.forEach {
+                    it.refresh()
+                }
+            }
+        })
+    }
+
+    private fun addNativeImages(imageEntries: List<NativeImage>, map: MapboxMap) {
+        val style = map.getStyle()
+        if (style == null) return
+        for (nativeImage in imageEntries) {
+            val name = nativeImage.info.name
+            if (!hasImage(name, map)) {
+                val bitmap = nativeImage.drawable
+                style.addBitmapImage(nativeImage)
+                mCurrentImages.add(name)
+            }
+        }
+    }
+
+    private fun placeholderImageFor(info: ImageInfo): Image? {
+        if (info.width != null && info.height != null) {
+            val width = (info.width * info.getScaleOr(1.0)).toInt()
+            val height = (info.width * info.getScaleOr(1.0)).toInt()
+
+            return emptyImage(width, height)
+        } else if (info.stretchX.isNotEmpty() || info.stretchY.isNotEmpty() || info.content != null) {
+            var maxY = info.stretchY.maxOfOrNull { max(it.first, it.second) } ?: 0.0f
+            var maxX = info.stretchX.maxOfOrNull { max(it.first, it.second) } ?: 0.0f
+            if (info.content != null) {
+                maxX = max(max(info.content.left,info.content.right), maxX)
+                maxY = max(max(info.content.top,info.content.bottom), maxY)
+            }
+            return emptyImage(ceil(maxX).toInt()+1, ceil(maxY).toInt()+1)
+        } else {
+           return mImagePlaceholder?.toMapboxImage() ?: emptyImage(16, 16)
+        }
+    }
+
+    private fun addRemoteImages(imageEntries: List<Map.Entry<String, ImageEntry>>?, map: MapboxMap) {
+        val style = map.getStyle()
+        if (style == null || imageEntries == null) return
+        val missingImages: MutableList<Map.Entry<String, ImageEntry>> = ArrayList()
+
+        val metrics = context.resources.displayMetrics
+        val screenDensity = (metrics?.density ?: DisplayMetrics.DENSITY_DEFAULT).toDouble()
+
+        // Add image placeholder for images that are not yet available in the style. This way
+        // we can load the images asynchronously and add the ShapeSource to the map without delay.
+        // The same is required when this ShapeSource is updated with new/added images and the
+        // data references them. In which case addMissingImageToStyle will take care of loading
+        // them in a similar way.
+        //
+        // See also: https://github.com/mapbox/mapbox-gl-native/pull/14253#issuecomment-478827792
+        for (imageEntry in imageEntries) {
+            if (!hasImage(imageEntry.key, map)) {
+                val info = imageEntry.value.info;
+                val placeholderImage = placeholderImageFor(info)
+                placeholderImage?.let {
+                    style.addStyleImage(imageEntry.key, it, info)
+                }
+                missingImages.add(imageEntry)
+                mCurrentImages.add(imageEntry.key)
+            }
+        }
+        if (missingImages.size > 0) {
+            val task = DownloadMapImageTask(context, map, null)
+            val params = missingImages.toTypedArray()
+            task.execute(*params)
+        }
+    }
+
+    companion object {
+        private var mImagePlaceholder: Bitmap? = null
+        fun <K, V> entry(k: K, v: V): List<Map.Entry<K, V>> {
+            return listOf(AbstractMap.SimpleEntry(k, v) as Map.Entry<K, V>)
+        }
+    }
+
+    init {
+        mCurrentImages = HashSet()
+        mImages = HashMap()
+        mNativeImages = HashMap()
+        if (mImagePlaceholder == null) {
+            mImagePlaceholder = BitmapUtils.getBitmapFromDrawable(ResourcesCompat.getDrawable(context.resources, R.drawable.empty_drawable, null))
+        }
+    }
+
+    override fun updateImage(imageId: String, bitmap: Bitmap, sdf: Boolean, stretchX: List<ImageStretches>, stretchY: List<ImageStretches>, content: ImageContent?, scale: Double)
+    {
+        mMap?.getStyle()?.let {
+            it.addBitmapImage(imageId, bitmap, sdf, stretchX, stretchY, content, scale);
+        }
+    }
+}