@rnmapbox/maps 10.0.15 → 10.1.0-beta.10

package/android/src/main/java-v10/com/mapbox/rctmgl/components/images/RCTMGLImageManager.kt

@@ -1,67 +0,0 @@
-package com.mapbox.rctmgl.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.mapbox.rctmgl.components.AbstractEventEmitter
-import com.mapbox.rctmgl.events.constants.EventKeys
-
-class RCTMGLImageManager(private val mContext: ReactApplicationContext) : AbstractEventEmitter<RCTMGLImage>(
-mContext
-) {
-    override fun getName(): String {
-        return "RCTMGLImage"
-    }
-
-    override fun createViewInstance(p0: ThemedReactContext): RCTMGLImage {
-        return RCTMGLImage(mContext, this)
-    }
-
-    override fun customEvents(): MutableMap<String, String>? {
-        return mutableMapOf();
-    }
-
-    // region React properties
-    @ReactProp(name="name")
-    fun setName(image: RCTMGLImage, value: String) {
-        image.name = value
-    }
-
-    @ReactProp(name="sdf")
-    fun setSdf(image: RCTMGLImage, value: Boolean) {
-        image.sdf = value
-    }
-
-    @ReactProp(name="stretchX")
-    fun setStretchX(image: RCTMGLImage, value: Dynamic) {
-        image.stretchX = RCTMGLImagesManager.convertStretch(value) ?: listOf()
-    }
-
-    @ReactProp(name="stretchY")
-    fun setStretchY(image: RCTMGLImage, value: Dynamic) {
-        image.stretchY = RCTMGLImagesManager.convertStretch(value) ?: listOf()
-    }
-
-    @ReactProp(name="content")
-    fun setContent(image: RCTMGLImage, value: Dynamic) {
-        image.content = RCTMGLImagesManager.convertContent(value)
-    }
-
-    @ReactProp(name="scale")
-    fun setScale(image: RCTMGLImage, value: Double) {
-        image.scale = value
-    }
-    // endregion
-
-    // region React methods
-    override fun receiveCommand(root: RCTMGLImage, commandId: String?, args: ReadableArray?) {
-        if (commandId == "refresh") {
-            root.refresh()
-        }
-    }
-    // endregion
-}

package/android/src/main/java-v10/com/mapbox/rctmgl/components/images/RCTMGLImages.kt

@@ -1,262 +0,0 @@
-package com.mapbox.rctmgl.components.images
-
-import android.content.Context
-import android.graphics.Bitmap
-import com.mapbox.rctmgl.components.images.RCTMGLImagesManager
-import com.mapbox.rctmgl.components.AbstractMapFeature
-import com.mapbox.rctmgl.utils.ImageEntry
-import android.graphics.drawable.BitmapDrawable
-import androidx.core.content.res.ResourcesCompat
-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.mapbox.rctmgl.R
-import com.mapbox.rctmgl.components.RemovalReason
-import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
-import com.mapbox.rctmgl.components.images.RCTMGLImages
-import com.mapbox.rctmgl.events.ImageMissingEvent
-import com.mapbox.rctmgl.utils.BitmapUtils
-import com.mapbox.rctmgl.utils.DownloadMapImageTask
-import java.nio.ByteBuffer
-import java.util.AbstractMap
-import java.util.ArrayList
-import java.util.HashMap
-import java.util.HashSet
-
-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()),
-        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)
-{
-    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 RCTMGLImages(context: Context, private val mManager: RCTMGLImagesManager) : AbstractMapFeature(context), NativeImageUpdater {
-    var mCurrentImages: MutableSet<String?>
-    var mImageViews = mutableListOf<RCTMGLImage>();
-    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: RCTMGLMapView, 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: RCTMGLMapView) {
-        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: RCTMGLMapView) {
-        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 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()
-
-        // 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)) {
-                mImagePlaceholder?.let { style.addBitmapImage(imageEntry.key, it, false, listOf(), listOf(), null,1.0) }
-                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);
-        }
-    }
-}

package/android/src/main/java-v10/com/mapbox/rctmgl/components/images/RCTMGLImagesManager.kt

@@ -1,221 +0,0 @@
-package com.mapbox.rctmgl.components.images
-
-import android.graphics.drawable.BitmapDrawable
-import android.view.View
-import com.facebook.react.bridge.*
-import com.facebook.react.common.MapBuilder
-import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.annotations.ReactProp
-import com.mapbox.maps.ImageContent
-import com.mapbox.maps.ImageStretches
-import com.mapbox.rctmgl.components.AbstractEventEmitter
-import com.mapbox.rctmgl.events.constants.EventKeys
-import com.mapbox.rctmgl.utils.ImageEntry
-import com.mapbox.rctmgl.utils.Logger
-import com.mapbox.rctmgl.utils.ResourceUtils
-import com.mapbox.rctmgl.utils.extensions.forEach
-import java.util.*
-
-class RCTMGLImagesManager(private val mContext: ReactApplicationContext) :
-    AbstractEventEmitter<RCTMGLImages?>(
-        mContext
-    ) {
-    override fun getName(): String {
-        return "RCTMGLImages"
-    }
-
-    public override fun createViewInstance(context: ThemedReactContext): RCTMGLImages {
-        return RCTMGLImages(context, this)
-    }
-
-    fun imageInfo(name: String, map: ReadableMap): ImageInfo {
-        var sdf = false
-        var stretchX = listOf<ImageStretches>()
-        var stretchY = listOf<ImageStretches>()
-        var content : ImageContent? = null
-        var scale : Double? = null
-        if (map.hasKey("sdf")) {
-            sdf = map.getBoolean("sdf");
-        }
-        if (map.hasKey("stretchX")) {
-            stretchX = convertStretch(map.getDynamic("stretchX")) ?: listOf()
-        }
-        if (map.hasKey("stretchY")) {
-            stretchY = convertStretch(map.getDynamic("stretchY")) ?: listOf()
-        }
-        if (map.hasKey("content")) {
-            content = convertContent(map.getDynamic("content")) ?: null
-        }
-        if (map.hasKey("scale")) {
-            if (map.getType("scale") != ReadableType.Number) {
-                Logger.e("RCTMGLImages", "scale should be a number found: $scale in $map")
-            }
-            scale = map.getDouble("scale")
-        }
-        return ImageInfo(name=name, sdf=sdf, scale=scale, content=content, stretchX = stretchX, stretchY = stretchY)
-    }
-
-    @ReactProp(name = "images")
-    fun setImages(images: RCTMGLImages, map: ReadableMap) {
-        val imagesList = mutableListOf<Map.Entry<String, ImageEntry>>()
-        map.forEach { imageName, imageInfo ->
-            when (imageInfo) {
-                is ReadableMap -> {
-                    val uri = imageInfo.getString("uri") ?: imageInfo.getString("url")
-                    if (uri != null) {
-                        imagesList.add(AbstractMap.SimpleEntry(imageName, ImageEntry(uri,  imageInfo(imageName, imageInfo))))
-                    } else {
-                        Logger.e("RCTMGLImagesManager", "Unexpected value for key: $imageName in images property, no uri/url found!")
-                    }
-                }
-                is String -> {
-                    val name = imageInfo
-                    imagesList.add(AbstractMap.SimpleEntry(imageName, ImageEntry(name, ImageInfo(name=imageName))))
-                }
-                else -> {
-                    Logger.e("RCTMGLImagesManager", "Unexpected value for key: $imageName in images property, only string/object is supported")
-                }
-            }
-        }
-        images.setImages(imagesList)
-    }
-
-    @ReactProp(name = "hasOnImageMissing")
-    fun setHasOnImageMissing(images: RCTMGLImages, value: Boolean?) {
-        images.setHasOnImageMissing(value!!)
-    }
-
-    fun toNativeImage(dynamic: Dynamic): NativeImage? {
-        when (dynamic.type) {
-            ReadableType.String -> {
-                val resourceName = dynamic.asString();
-                val drawable =
-                    ResourceUtils.getDrawableByName(mContext, resourceName) as BitmapDrawable?
-                if (drawable != null) {
-                    return NativeImage(ImageInfo(name=resourceName), drawable)
-                } else {
-                    Logger.e("RCTMGLImages", "cound not get native drawable with name: $resourceName")
-                    return null
-                }
-            }
-            ReadableType.Map -> {
-                val map = dynamic.asMap()
-                val resourceName = map.getString("name")
-                val drawable =
-                    ResourceUtils.getDrawableByName(mContext, resourceName) as BitmapDrawable?
-                if (drawable != null && resourceName != null) {
-                    return NativeImage(imageInfo(resourceName, map), drawable)
-                } else {
-                    Logger.e("RCTMGLImages", "cound not get native drawable with name: $resourceName")
-                    return null
-                }
-            }
-            else -> {
-                Logger.e("RCTMGLImages", "nativeImages element should be a string or a object, but was: $dynamic")
-                return null
-            }
-        }
-    }
-
-    @ReactProp(name = "nativeImages")
-    fun setNativeImages(images: RCTMGLImages, arr: ReadableArray) {
-        val nativeImages = mutableListOf<NativeImage>();
-        for (i in 0 until arr.size()) {
-            val nativeImage = toNativeImage(arr.getDynamic(i))
-            if (nativeImage != null) {
-                nativeImages.add(nativeImage)
-            }
-        }
-        images.setNativeImages(nativeImages)
-    }
-
-    override fun customEvents(): Map<String, String>? {
-        return MapBuilder.builder<String, String>()
-            .put(EventKeys.IMAGES_MISSING, "onImageMissing")
-            .build()
-    }
-
-    // region RCTMGLImage children
-
-    override fun addView(parent: RCTMGLImages?, childView: View?, childPosition: Int) {
-        if (parent == null || childView == null) {
-            Logger.e("RCTMGLImages", "addView: parent or childView is null")
-            return
-        }
-
-        if (childView !is RCTMGLImage) {
-            Logger.e("RCTMGLImages", "child view should be RCTMGLImage")
-            return
-        }
-
-        parent.mImageViews.add(childPosition, childView)
-        childView.nativeImageUpdater = parent
-    }
-
-    override fun removeView(parent: RCTMGLImages?, view: View?) {
-        if (parent == null || view == null) {
-            Logger.e("RCTMGLImages", "removeView: parent or view is null")
-            return
-        }
-
-        parent.mImageViews.remove(view)
-    }
-
-    override fun removeAllViews(parent: RCTMGLImages?) {
-        if (parent == null) {
-            Logger.e("RCTMGLImages", "removeAllViews parent is null")
-            return
-        }
-
-        parent.mImageViews.clear()
-    }
-
-    // endregion
-
-    companion object {
-        const val REACT_CLASS = "RCTMGLImages"
-
-        fun convertStretch(stretch: Dynamic) : List<ImageStretches>? {
-            if (stretch.type != ReadableType.Array) {
-                Logger.e("RCTMGLImages", "stretch should be an array, got $stretch")
-                return null
-            }
-            val array = stretch.asArray()
-            var result = mutableListOf<ImageStretches>();
-            for (i in 0 until array.size()) {
-                if (array.getType(i) != ReadableType.Array) {
-                    Logger.e("RTMGLImages", "each element of strech should be an array but was: ${array.getDynamic(i)}")
-                } else {
-                    val pair = array.getArray(i)
-                    if (pair.size() != 2 || pair.getType(0) != ReadableType.Number || pair.getType(1) != ReadableType.Number) {
-                        Logger.e("RCTMGLImages", "each element of stretch should be pair of 2 integers but was ${pair}")
-                    }
-                    result.add(ImageStretches(pair.getDouble(0).toFloat(), pair.getDouble(1).toFloat()))
-                }
-            }
-            return result;
-        }
-
-        fun convertContent(content: Dynamic) : ImageContent? {
-            if (content.type != ReadableType.Array) {
-                Logger.e("RCTMGLImages", "content should be an array, got $content")
-                return null
-            }
-            val array = content.asArray()
-            if (array.size() != 4) {
-                Logger.e("RCTMGLImages", "content should be an array of 4 numbers, got $content")
-                return null
-            }
-            val result = arrayOf(0.0, 0.0, 0.0, 0.0, 0.0)
-            for (i in 0 until array.size()) {
-                if (array.getType(i) != ReadableType.Number) {
-                    Logger.e("RTMGLImages", "each element of content should be an number but was : ${array}")
-                    return null
-                } else {
-                    result[i] = array.getDouble(i)
-                }
-            }
-            return ImageContent(result[0].toFloat(), result[1].toFloat() ,result[2].toFloat(), result[3].toFloat())
-        }
-    }
-}

package/android/src/main/java-v10/com/mapbox/rctmgl/components/location/CameraMode.java

@@ -1,62 +0,0 @@
-package com.mapbox.rctmgl.components.location;
-
-import androidx.annotation.IntDef;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-/**
- * Contains the variety of camera modes which determine how the camera will track
- * the user location.
- */
-public final class CameraMode {
-
-  private CameraMode() {
-  }
-
-  /**
-   * Determine the camera tracking behavior in the {@link LocationComponent}.
-   */
-  @IntDef( {NONE, NONE_COMPASS, NONE_GPS, TRACKING, TRACKING_COMPASS, TRACKING_GPS, TRACKING_GPS_NORTH})
-  @Retention(RetentionPolicy.SOURCE)
-  public @interface Mode {
-  }
-
-  /**
-   * No camera tracking.
-   */
-  public static final int NONE = 0x00000008;
-
-  /**
-   * Camera does not track location, but does track compass bearing.
-   */
-  public static final int NONE_COMPASS = 0x00000010;
-
-  /**
-   * Camera does not track location, but does track GPS {@link Location} bearing.
-   */
-  public static final int NONE_GPS = 0x00000016;
-
-  /**
-   * Camera tracks the user location.
-   */
-  public static final int TRACKING = 0x00000018;
-
-  /**
-   * Camera tracks the user location, with bearing
-   * provided by a compass.
-   */
-  public static final int TRACKING_COMPASS = 0x00000020;
-
-  /**
-   * Camera tracks the user location, with bearing
-   * provided by a normalized {@link Location#getBearing()}.
-   */
-  public static final int TRACKING_GPS = 0x00000022;
-
-  /**
-   * Camera tracks the user location, with bearing
-   * always set to north (0).
-   */
-  public static final int TRACKING_GPS_NORTH = 0x00000024;
-}