@rnmapbox/maps 10.0.15 → 10.1.0-beta.11

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

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

package/android/src/main/java/com/rnmapbox/rnmbx/utils/BitmapUtils.kt

@@ -0,0 +1,143 @@
+package com.rnmapbox.rnmbx.utils
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import android.net.Uri
+import android.util.Base64
+import android.util.Log
+import android.util.LruCache
+import android.view.View
+import com.mapbox.maps.Image
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.OutputStream
+import java.net.URL
+import java.nio.ByteBuffer
+
+import com.rnmapbox.rnmbx.v11compat.image.*
+
+object BitmapUtils {
+    const val LOG_TAG = "BitmapUtils"
+    private const val CACHE_SIZE = 1024 * 1024
+    private val mCache: LruCache<String?, Bitmap> =
+        object : LruCache<String?, Bitmap>(CACHE_SIZE) {
+            override fun sizeOf(key: String?, bitmap: Bitmap): Int {
+                return bitmap.byteCount
+            }
+        }
+
+    fun toImage(bitmap: Bitmap): Image {
+        if (bitmap.config != Bitmap.Config.ARGB_8888) {
+            throw RuntimeException("Only ARGB_8888 bitmap config is supported!")
+        }
+        val byteBuffer = ByteBuffer.allocate(bitmap.byteCount)
+        bitmap.copyPixelsToBuffer(byteBuffer)
+        return Image(bitmap.width, bitmap.height, byteBuffer.array().toImageData())
+    }
+
+    fun toImage(bitmapDrawable: BitmapDrawable): Image {
+        return toImage(bitmapDrawable.bitmap)
+    }
+
+    fun getBitmapFromDrawable(sourceDrawable: Drawable?): Bitmap? {
+        if (sourceDrawable == null) {
+            return null
+        }
+        return if (sourceDrawable is BitmapDrawable) {
+            sourceDrawable.bitmap
+        } else {
+            //copying drawable object to not manipulate on the same reference
+            val constantState = sourceDrawable.constantState ?: return null
+            val drawable = constantState.newDrawable().mutate()
+            val bitmap = Bitmap.createBitmap(
+                drawable.intrinsicWidth, drawable.intrinsicHeight,
+                Bitmap.Config.ARGB_8888
+            )
+            val canvas = Canvas(bitmap)
+            drawable.setBounds(0, 0, canvas.width, canvas.height)
+            drawable.draw(canvas)
+            bitmap
+        }
+    }
+
+
+    @Throws(IOException::class)
+    fun createImgTempFile(context: Context, image: Image): String? {
+        val bitmap = Bitmap.createBitmap(image.width, image.height, Bitmap.Config.ARGB_8888)
+        bitmap.copyPixelsFromBuffer(ByteBuffer.wrap(image.data.toByteArray()))
+        return createTempFile(context, bitmap)
+    }
+
+    fun createTempFile(context: Context, bitmap: Bitmap): String? {
+        var tempFile: File? = null
+        var outputStream: FileOutputStream? = null
+        try {
+            tempFile = File.createTempFile(LOG_TAG, ".png", context.cacheDir)
+            outputStream = FileOutputStream(tempFile)
+        } catch (e: IOException) {
+            Log.w(LOG_TAG, e.localizedMessage)
+        }
+        if (tempFile == null) {
+            return null
+        }
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
+        closeSnapshotOutputStream(outputStream)
+        return Uri.fromFile(tempFile).toString()
+    }
+
+    fun createBase64(bitmap: Bitmap): String {
+        val outputStream = ByteArrayOutputStream()
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
+        val bitmapBytes = outputStream.toByteArray()
+        closeSnapshotOutputStream(outputStream)
+        val base64Prefix = "data:image/png;base64,"
+        return base64Prefix + Base64.encodeToString(bitmapBytes, Base64.NO_WRAP)
+    }
+
+    fun createImgBase64(image: Image): String {
+        val bitmap = Bitmap.createBitmap(image.width, image.height, Bitmap.Config.ARGB_8888)
+        bitmap.copyPixelsFromBuffer(ByteBuffer.wrap(image.data.toByteArray()))
+        return createBase64(bitmap)
+    }
+
+    fun viewToBitmap(v: View?, left: Int, top: Int, right: Int, bottom: Int): Bitmap? {
+        var bitmap: Bitmap? = null
+        if (v != null) {
+            val w = right - left
+            val h = bottom - top
+            if (w > 0 && h > 0) {
+                bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
+                bitmap.eraseColor(Color.TRANSPARENT)
+                val canvas = Canvas(bitmap)
+                v.draw(canvas)
+            }
+        }
+        return bitmap
+    }
+
+    private fun addImage(imageURL: String?, bitmap: Bitmap?) {
+        mCache.put(imageURL, bitmap)
+    }
+
+    private fun getImage(imageURL: String?): Bitmap? {
+        return mCache[imageURL]
+    }
+
+    private fun closeSnapshotOutputStream(outputStream: OutputStream?) {
+        if (outputStream == null) {
+            return
+        }
+        try {
+            outputStream.close()
+        } catch (e: IOException) {
+            Log.w(LOG_TAG, e.localizedMessage)
+        }
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/ConvertUtils.java

@@ -0,0 +1,253 @@
+package com.rnmapbox.rnmbx.utils;
+
+import android.graphics.PointF;
+import android.graphics.RectF;
+import android.util.Log;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.NoSuchKeyException;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+
+import java.text.NumberFormat;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class ConvertUtils {
+    public static final String LOG_TAG = "ConvertUtils";
+
+    public static JsonObject toJsonObject(ReadableMap map) {
+        if (map == null) return null;
+        JsonObject result = new JsonObject();
+        ReadableMapKeySetIterator it = map.keySetIterator();
+
+        while (it.hasNextKey()) {
+            String key = it.nextKey();
+            switch (map.getType(key)) {
+                case Map:
+                    result.add(key, toJsonObject(map.getMap(key)));
+                    break;
+                case Array:
+                    result.add(key, toJsonArray(map.getArray(key)));
+                    break;
+                case Null:
+                    result.add(key, null);
+                    break;
+                case Number:
+                    result.addProperty(key, map.getDouble(key));
+                    break;
+                case String:
+                    result.addProperty(key, map.getString(key));
+                    break;
+                case Boolean:
+                    result.addProperty(key, map.getBoolean(key));
+                    break;
+            }
+        }
+        return result;
+    }
+
+    public static JsonArray toJsonArray(ReadableArray array) {
+        if (array == null) return null;
+        JsonArray result = new JsonArray(array.size());
+        for (int i = 0; i < array.size(); i++) {
+            switch (array.getType(i)) {
+                case Map:
+                    result.add(toJsonObject(array.getMap(i)));
+                    break;
+                case Array:
+                    result.add(toJsonArray(array.getArray(i)));
+                    break;
+                case Null:
+                    result.add((JsonElement)null);
+                    break;
+                case Number:
+                    result.add(array.getDouble(i));
+                    break;
+                case String:
+                    result.add(array.getString(i));
+                    break;
+                case Boolean:
+                    result.add(array.getBoolean(i));
+                    break;
+            }
+        }
+        return result;
+    }
+
+    public static JsonElement typedToJsonElement(ReadableMap map) {
+        if (map == null) return null;
+
+        String type = map.getString("type");
+
+        if (type.equals(ExpressionParser.TYPE_MAP)) {
+            JsonObject result = new JsonObject();
+
+            ReadableArray keyValues = map.getArray("value");
+            for (int i = 0; i < keyValues.size(); i++) {
+                ReadableArray keyValue = keyValues.getArray(i);
+                String key = keyValue.getMap(0).getString("value");
+
+                result.add(key, typedToJsonElement(keyValue.getMap(1)));
+            }
+            return result;
+        }
+        else if (type.equals(ExpressionParser.TYPE_ARRAY)) {
+            ReadableArray arrayValue = map.getArray("value");
+            JsonArray result = new JsonArray(arrayValue.size());
+            for (int i = 0; i < arrayValue.size(); i++) {
+                result.add(typedToJsonElement(arrayValue.getMap(i)));
+            }
+            return result;
+        }
+        else if (type.equals(ExpressionParser.TYPE_BOOL)) {
+            return new JsonPrimitive(map.getBoolean("value"));
+        }
+        else if (type.equals(ExpressionParser.TYPE_NUMBER)) {
+            return new JsonPrimitive(map.getDouble("value"));
+        }
+        else if (type.equals(ExpressionParser.TYPE_STRING)) {
+            return new JsonPrimitive(map.getString("value"));
+        }
+        else {
+            throw new RuntimeException(String.format("Unrecognized type {}", map.getString("type")));
+        }
+    }
+
+    public static WritableArray toWritableArray(JsonArray array) {
+        WritableArray writableArray = Arguments.createArray();
+
+        for (int i = 0; i < array.size(); i++) {
+            JsonElement element = array.get(i);
+
+            if (element.isJsonArray()) {
+                writableArray.pushArray(toWritableArray(element.getAsJsonArray()));
+            } else if (element.isJsonObject()) {
+                writableArray.pushMap(toWritableMap(element.getAsJsonObject()));
+            } else if (element.isJsonPrimitive()) {
+                JsonPrimitive primitive = element.getAsJsonPrimitive();
+
+                if (primitive.isBoolean()) {
+                    writableArray.pushBoolean(primitive.getAsBoolean());
+                } else if (primitive.isNumber()) {
+                    writableArray.pushDouble(primitive.getAsDouble());
+                } else {
+                    writableArray.pushString(primitive.getAsString());
+                }
+            }
+        }
+
+        return writableArray;
+    }
+
+    public static WritableMap toWritableMap(JsonObject object) {
+        WritableMap map = Arguments.createMap();
+
+        for (Map.Entry<String, JsonElement> entry : object.entrySet()) {
+            String propName = entry.getKey();
+            JsonElement jsonElement = entry.getValue();
+
+            if (jsonElement.isJsonPrimitive()) {
+                JsonPrimitive primitive = jsonElement.getAsJsonPrimitive();
+
+                if (primitive.isBoolean()) {
+                    map.putBoolean(propName, primitive.getAsBoolean());
+                } else if (primitive.isNumber()) {
+                    map.putDouble(propName, primitive.getAsDouble());
+                } else {
+                    map.putString(propName, primitive.getAsString());
+                }
+            } else if (jsonElement.isJsonArray()) {
+                map.putArray(propName, toWritableArray(jsonElement.getAsJsonArray()));
+            } else if (jsonElement.isJsonObject()) {
+                map.putMap(propName, toWritableMap(jsonElement.getAsJsonObject()));
+            }
+        }
+
+        return map;
+    }
+
+    public static Object getObjectFromString(String str) {
+        NumberFormat numberFormat = NumberFormat.getNumberInstance();
+
+        try {
+            return numberFormat.parse(str);
+        } catch (ParseException e) {
+            // ignore we're just figuring out what type this is
+        }
+
+        return str;
+    }
+
+    public static List<String> toStringList(ReadableArray array) {
+        List<String> list = new ArrayList<>();
+
+        if (array == null) {
+            return list;
+        }
+
+        for (int i = 0; i < array.size(); i++) {
+            list.add(array.getString(i));
+        }
+
+        return list;
+    }
+
+    public static PointF toPointF(ReadableArray array) {
+        PointF pointF = new PointF();
+
+        if (array == null) {
+            return pointF;
+        }
+
+        pointF.set((float)array.getDouble(0), (float)array.getDouble(1));
+        return pointF;
+    }
+
+    public static RectF toRectF(ReadableArray array) {
+        RectF rectF = new RectF();
+
+        if (array == null || array.size() == 0) {
+            return rectF;
+        }
+
+        rectF.set((float)array.getDouble(3), (float)array.getDouble(0), (float)array.getDouble(1), (float)array.getDouble(2));
+        return rectF;
+    }
+
+    public static double getDouble(String key, ReadableMap map, double defaultValue) {
+        double value = defaultValue;
+
+        try {
+            value = map.getDouble(key);
+        } catch (NoSuchKeyException e) {
+            // key not found use default value
+            Log.d(LOG_TAG, String.format("No key found for %s, using default value %f", key, defaultValue));
+        }
+
+        return value;
+    }
+
+    public static String getString(String key, ReadableMap map, String defaultValue) {
+        String value = defaultValue;
+
+        try {
+            value = map.getString(key);
+        } catch (NoSuchKeyException e) {
+            // key not found use default value
+            Log.d(LOG_TAG, String.format("No key found for %s, using default value %s", key, defaultValue));
+        }
+
+        return value;
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/utils/DownloadMapImageTask.kt

@@ -0,0 +1,118 @@
+package com.rnmapbox.rnmbx.utils
+
+import android.content.Context
+import android.graphics.Bitmap
+import com.mapbox.maps.Style
+import com.mapbox.maps.MapboxMap
+import android.os.AsyncTask
+import com.rnmapbox.rnmbx.utils.ImageEntry
+import android.util.DisplayMetrics
+import android.graphics.BitmapFactory
+import android.net.Uri
+import android.util.Log
+import com.facebook.common.logging.FLog
+import com.facebook.common.references.CloseableReference
+import com.facebook.datasource.DataSources
+import com.facebook.drawee.backends.pipeline.Fresco
+import com.facebook.imagepipeline.common.RotationOptions
+import com.facebook.imagepipeline.image.CloseableImage
+import com.facebook.imagepipeline.image.CloseableStaticBitmap
+import com.facebook.imagepipeline.request.ImageRequestBuilder
+import com.facebook.react.views.imagehelper.ImageSource
+import com.rnmapbox.rnmbx.components.images.ImageInfo
+import java.io.File
+import java.lang.ref.WeakReference
+import java.util.HashMap
+import com.rnmapbox.rnmbx.v11compat.image.*
+
+data class DownloadedImage(val name: String, val bitmap: Bitmap, val info: ImageInfo)
+
+class DownloadMapImageTask(context: Context, map: MapboxMap, callback: OnAllImagesLoaded?) :
+    AsyncTask<Map.Entry<String, ImageEntry>, Void?, List<DownloadedImage>>() {
+    private val mContext: WeakReference<Context>
+    private val mMap: WeakReference<MapboxMap>
+    private val mCallback: OnAllImagesLoaded?
+    private val mCallerContext: Any
+
+    interface OnAllImagesLoaded {
+        fun onAllImagesLoaded()
+    }
+
+    @SafeVarargs
+    protected override fun doInBackground(vararg objects: Map.Entry<String, ImageEntry>): List<DownloadedImage> {
+        val images = mutableListOf<DownloadedImage>()
+        val context = mContext.get() ?: return images
+        val resources = context.resources
+        val metrics = resources.displayMetrics
+        for ((key, imageEntry) in objects) {
+            var uri = imageEntry.uri
+            if (uri.startsWith("/")) {
+                uri = Uri.fromFile(File(uri)).toString()
+            }
+            val source = ImageSource(context, uri)
+            val request = ImageRequestBuilder.newBuilderWithSource(source.uri)
+                .setRotationOptions(RotationOptions.autoRotate())
+                .build()
+            val dataSource =
+                Fresco.getImagePipeline().fetchDecodedImage(request, mCallerContext)
+            var result: CloseableReference<CloseableImage>? = null
+            try {
+                result = DataSources.waitForFinalResult(dataSource)
+                if (result != null) {
+                    val image = result.get()
+                    if (image is CloseableStaticBitmap) {
+                        val bitmap =
+                            image.underlyingBitmap // Copy the bitmap to make sure it doesn't get recycled when we release
+                                // the fresco reference.
+                                .copy(Bitmap.Config.ARGB_8888, true)
+                        Log.e("RNMBXImageManager", "downloadImage: $key $uri $image ${image.width}x${image.height}")
+                        bitmap.density = DisplayMetrics.DENSITY_DEFAULT
+                        images.add(
+                            DownloadedImage(name=key, bitmap=bitmap, info=imageEntry.info)
+                        )
+                    } else {
+                        FLog.e(LOG_TAG, "Failed to load bitmap from: $uri")
+                    }
+                } else {
+                    FLog.e(LOG_TAG, "Failed to load bitmap from: $uri")
+                }
+            } catch (e: Throwable) {
+                Log.w(LOG_TAG, e.localizedMessage)
+            } finally {
+                dataSource.close()
+                if (result != null) {
+                    CloseableReference.closeSafely(result)
+                }
+            }
+        }
+        return images
+    }
+
+    override fun onPostExecute(images: List<DownloadedImage>) {
+        val map = mMap.get()
+        if (map != null && images != null && images.size > 0) {
+            val style = map.getStyle()
+            if (style != null) {
+                val bitmapImages = HashMap<String, Bitmap>()
+                for (image in images) {
+                    bitmapImages[image.name] = image.bitmap
+                    val info = image.info
+
+                    style.addBitmapImage(image.name, image.bitmap, info)
+                }
+            }
+        }
+        mCallback?.onAllImagesLoaded()
+    }
+
+    companion object {
+        const val LOG_TAG = "DownloadMapImageTask"
+    }
+
+    init {
+        mContext = WeakReference(context.applicationContext)
+        mMap = WeakReference(map)
+        mCallback = callback
+        mCallerContext = this
+    }
+}