@mapvina-com/mapvina-react-native 1.0.0

package/android/src/main/java/io/github/mapvina/reactnative/utils/ConvertUtils.kt

@@ -0,0 +1,225 @@
+package io.github.mapvina.reactnative.utils
+
+import android.graphics.PointF
+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.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 org.json.JSONException
+import org.json.JSONObject
+
+object ConvertUtils {
+    const val LOG_TAG: String = "ConvertUtils"
+
+    fun toJsonObject(map: ReadableMap?): JsonObject? {
+        if (map == null) return null
+        val result = JsonObject()
+        val it = map.keySetIterator()
+
+        while (it.hasNextKey()) {
+            val key = it.nextKey()
+            when (map.getType(key)) {
+                ReadableType.Map -> result.add(key, toJsonObject(map.getMap(key)))
+                ReadableType.Array -> result.add(key, toJsonArray(map.getArray(key)))
+                ReadableType.Null -> result.add(key, null)
+                ReadableType.Number -> result.addProperty(key, map.getDouble(key))
+                ReadableType.String -> result.addProperty(key, map.getString(key))
+                ReadableType.Boolean -> result.addProperty(key, map.getBoolean(key))
+            }
+        }
+        return result
+    }
+
+    @JvmStatic
+    fun toJsonArray(array: ReadableArray?): JsonArray? {
+        if (array == null) return null
+        val result = JsonArray(array.size())
+        for (i in 0..<array.size()) {
+            when (array.getType(i)) {
+                ReadableType.Map -> result.add(toJsonObject(array.getMap(i)))
+                ReadableType.Array -> result.add(toJsonArray(array.getArray(i)))
+                ReadableType.Null -> result.add(null as JsonElement?)
+                ReadableType.Number -> result.add(array.getDouble(i))
+                ReadableType.String -> result.add(array.getString(i))
+                ReadableType.Boolean -> result.add(array.getBoolean(i))
+            }
+        }
+        return result
+    }
+
+    @JvmStatic
+    fun typedToJsonElement(map: ReadableMap?): JsonElement? {
+        if (map == null) return null
+
+        val type = map.getString("type")
+
+        when (type) {
+            ExpressionParser.TYPE_MAP -> {
+                val result = JsonObject()
+
+                val keyValues = map.getArray("value")
+                for (i in 0..<keyValues!!.size()) {
+                    val keyValue = keyValues.getArray(i)
+                    val key = keyValue!!.getMap(0)!!.getString("value")
+
+                    result.add(key, typedToJsonElement(keyValue.getMap(1)))
+                }
+                return result
+            }
+
+            ExpressionParser.TYPE_ARRAY -> {
+                val arrayValue = map.getArray("value")
+                val result = JsonArray(arrayValue!!.size())
+                for (i in 0..<arrayValue.size()) {
+                    result.add(typedToJsonElement(arrayValue.getMap(i)))
+                }
+                return result
+            }
+
+            ExpressionParser.TYPE_BOOL -> {
+                return JsonPrimitive(map.getBoolean("value"))
+            }
+
+            ExpressionParser.TYPE_NUMBER -> {
+                return JsonPrimitive(map.getDouble("value"))
+            }
+
+            ExpressionParser.TYPE_STRING -> {
+                return JsonPrimitive(map.getString("value"))
+            }
+
+            else -> {
+                throw RuntimeException(String.format("Unrecognized type {}", map.getString("type")))
+            }
+        }
+    }
+
+    fun toWritableArray(array: JsonArray): WritableArray {
+        val writableArray = Arguments.createArray()
+
+        for (i in 0..<array.size()) {
+            val 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) {
+                val primitive = element.getAsJsonPrimitive()
+
+                if (primitive.isBoolean) {
+                    writableArray.pushBoolean(primitive.getAsBoolean())
+                } else if (primitive.isNumber) {
+                    writableArray.pushDouble(primitive.asDouble)
+                } else {
+                    writableArray.pushString(primitive.getAsString())
+                }
+            }
+        }
+
+        return writableArray
+    }
+
+    fun toWritableMap(`object`: JsonObject): WritableMap {
+        val map = Arguments.createMap()
+
+        for (entry in `object`.entrySet()) {
+            val propName = entry.key
+            val jsonElement = entry.value
+
+            if (jsonElement.isJsonPrimitive) {
+                val primitive = jsonElement.getAsJsonPrimitive()
+
+                if (primitive.isBoolean) {
+                    map.putBoolean(propName, primitive.getAsBoolean())
+                } else if (primitive.isNumber) {
+                    map.putDouble(propName, primitive.asDouble)
+                } 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
+    }
+
+    fun isJSONValid(test: String): Boolean {
+        try {
+            JSONObject(test)
+        } catch (_: JSONException) {
+            return false
+        }
+        return true
+    }
+
+    @JvmStatic
+    fun toStringList(array: ReadableArray?): MutableList<String?> {
+        val list: MutableList<String?> = ArrayList()
+
+        if (array == null) {
+            return list
+        }
+
+        for (i in 0..<array.size()) {
+            list.add(array.getString(i))
+        }
+
+        return list
+    }
+
+    fun toPointF(map: ReadableArray): PointF = PointF(map.getDouble(0).toFloat(), map.getDouble(1).toFloat())
+
+    @JvmStatic
+    fun getDouble(
+        key: String,
+        map: ReadableMap,
+        defaultValue: Double,
+    ): Double {
+        var value = defaultValue
+
+        try {
+            value = map.getDouble(key)
+        } catch (_: NoSuchKeyException) {
+            // 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
+    }
+
+    @JvmStatic
+    fun getString(
+        key: String,
+        map: ReadableMap,
+        defaultValue: String?,
+    ): String? {
+        var value = defaultValue
+
+        try {
+            value = map.getString(key)
+        } catch (_: NoSuchKeyException) {
+            // 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/io/github/mapvina/reactnative/utils/DownloadMapImageTask.java

@@ -0,0 +1,155 @@
+package io.github.mapvina.reactnative.utils;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.util.DisplayMetrics;
+import android.util.Log;
+
+import com.facebook.common.logging.FLog;
+import com.facebook.common.references.CloseableReference;
+import com.facebook.datasource.DataSource;
+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.ImageRequest;
+import com.facebook.imagepipeline.request.ImageRequestBuilder;
+import com.facebook.react.views.imagehelper.ImageSource;
+
+import io.github.mapvina.android.maps.MapVinaMap;
+import io.github.mapvina.android.maps.Style;
+
+import java.io.File;
+import java.lang.ref.WeakReference;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry>, Void, List<Map.Entry<String, DownloadedImage>>> {
+    public static final String LOG_TAG = "DownloadMapImageTask";
+
+    private WeakReference<Context> mContext;
+    private WeakReference<MapVinaMap> mMap;
+    @Nullable
+    private OnAllImagesLoaded mCallback;
+    private final Object mCallerContext;
+
+    public DownloadMapImageTask(Context context, MapVinaMap map, @Nullable OnAllImagesLoaded callback) {
+        mContext = new WeakReference<>(context.getApplicationContext());
+        mMap = new WeakReference<>(map);
+        mCallback = callback;
+        mCallerContext = this;
+    }
+
+    public interface OnAllImagesLoaded {
+        void onAllImagesLoaded();
+    }
+
+    @SafeVarargs
+    @Override
+    protected final List<Map.Entry<String, DownloadedImage>> doInBackground(Map.Entry<String, ImageEntry>... objects) {
+        List<Map.Entry<String, DownloadedImage>> images = new ArrayList<>();
+
+        Context context = mContext.get();
+        if (context == null) return images;
+
+        Resources resources = context.getResources();
+        DisplayMetrics metrics = resources.getDisplayMetrics();
+
+        for (Map.Entry<String, ImageEntry> object : objects) {
+            ImageEntry imageEntry = object.getValue();
+
+            String uri = imageEntry.uri;
+
+            if (uri.startsWith("/")) {
+                uri = Uri.fromFile(new File(uri)).toString();
+            }
+
+            if (uri.startsWith("http://") || uri.startsWith("https://") ||
+                uri.startsWith("file://") || uri.startsWith("asset://") || uri.startsWith("data:")) {
+                ImageSource source = new ImageSource(context, uri);
+                ImageRequest request = ImageRequestBuilder.newBuilderWithSource(source.getUri())
+                    .setRotationOptions(RotationOptions.autoRotate())
+                    .build();
+
+                DataSource<CloseableReference<CloseableImage>> dataSource =
+                    Fresco.getImagePipeline().fetchDecodedImage(request, mCallerContext);
+
+                CloseableReference<CloseableImage> result = null;
+                try {
+                    result = DataSources.waitForFinalResult(dataSource);
+                    if (result != null) {
+                        CloseableImage image = result.get();
+                        if (image instanceof CloseableStaticBitmap) {
+                            CloseableStaticBitmap closeableStaticBitmap = (CloseableStaticBitmap) image;
+                            Bitmap bitmap = closeableStaticBitmap.getUnderlyingBitmap()
+                                // Copy the bitmap to make sure it doesn't get recycled when we release
+                                // the fresco reference.
+                                .copy(Bitmap.Config.ARGB_8888, true);
+                            bitmap.setDensity((int) ((double) DisplayMetrics.DENSITY_DEFAULT * imageEntry.scale));
+                            images.add(new AbstractMap.SimpleEntry<>(object.getKey(), new DownloadedImage(object.getKey(), bitmap, imageEntry)));
+                        } else {
+                            FLog.e(LOG_TAG, "Failed to load bitmap from: " + uri);
+                        }
+                    } else {
+                        FLog.e(LOG_TAG, "Failed to load bitmap from: " + uri);
+                    }
+                } catch (Throwable e) {
+                    Log.w(LOG_TAG, e.getLocalizedMessage());
+                } finally {
+                    dataSource.close();
+                    if (result != null) {
+                        CloseableReference.closeSafely(result);
+                    }
+                }
+            } else {
+                // Local asset required from JS require('image.png') or import icon from 'image.png' while in release mode
+                Bitmap bitmap = BitmapUtils.getBitmapFromResource(context, uri, getBitmapOptions(metrics, imageEntry.scale));
+                if (bitmap != null) {
+                    images.add(new AbstractMap.SimpleEntry<>(object.getKey(), new DownloadedImage(object.getKey(), bitmap, imageEntry)));
+                } else {
+                    FLog.e(LOG_TAG, "Failed to load bitmap from: " + uri);
+                }
+            }
+        }
+
+        return images;
+    }
+
+    @Override
+    protected void onPostExecute(List<Map.Entry<String, DownloadedImage>> images) {
+        MapVinaMap map = mMap.get();
+        if (map != null && images != null && images.size() > 0) {
+            Style style = map.getStyle();
+            if (style != null) {
+                for (Map.Entry<String, DownloadedImage> image : images) {
+                    style.addImage(image.getKey(), image.getValue().bitmap(), image.getValue().info().sdf);
+                }
+            }
+        }
+
+        if (mCallback != null) {
+            mCallback.onAllImagesLoaded();
+        }
+    }
+
+    private BitmapFactory.Options getBitmapOptions(DisplayMetrics metrics, Double scale) {
+        BitmapFactory.Options options = new BitmapFactory.Options();
+        options.inScreenDensity = metrics.densityDpi;
+        options.inTargetDensity = metrics.densityDpi;
+
+        if (scale != ImageEntry.DEFAULT_SCALE) {
+            options.inDensity = (int) ((double) DisplayMetrics.DENSITY_DEFAULT * scale);
+        }
+
+        return options;
+    }
+}

package/android/src/main/java/io/github/mapvina/reactnative/utils/DownloadedImage.java

@@ -0,0 +1,6 @@
+package io.github.mapvina.reactnative.utils;
+
+import android.graphics.Bitmap;
+
+public record DownloadedImage(String name, Bitmap bitmap, ImageEntry info) {
+}

package/android/src/main/java/io/github/mapvina/reactnative/utils/ExpressionParser.kt

@@ -0,0 +1,67 @@
+package io.github.mapvina.reactnative.utils
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.google.gson.JsonArray
+import io.github.mapvina.android.style.expressions.Expression
+import io.github.mapvina.reactnative.utils.ConvertUtils.toJsonArray
+import io.github.mapvina.reactnative.utils.ConvertUtils.typedToJsonElement
+import java.util.Locale
+
+object ExpressionParser {
+    const val TYPE_STRING: String = "string"
+    const val TYPE_ARRAY: String = "array"
+    const val TYPE_NUMBER: String = "number"
+    const val TYPE_MAP: String = "hashmap"
+    const val TYPE_BOOL: String = "boolean"
+
+    @JvmStatic
+    fun from(rawExpressions: ReadableArray?): Expression? {
+        if (rawExpressions == null || rawExpressions.size() == 0) {
+            return null
+        }
+
+        return Expression.Converter.convert(toJsonArray(rawExpressions)!!)
+    }
+
+    @JvmStatic
+    fun fromTyped(rawExpressions: ReadableMap?): Expression {
+        val array = typedToJsonElement(rawExpressions) as JsonArray?
+        return Expression.Converter.convert(array!!)
+    }
+
+    fun from(rawExpression: ReadableMap): Expression? = Expression.raw("[" + stringExpression(rawExpression) + "]")
+
+    private fun stringExpression(item: ReadableMap): String {
+        var expression = ""
+        val type = item.getString("type")
+
+        if (TYPE_STRING == type) {
+            val value = item.getString("value")
+            expression = String.format(Locale.ENGLISH, "\"%s\"", value)
+        } else if (TYPE_NUMBER == type) {
+            val value = item.getDouble("value")
+            expression = String.format(Locale.ENGLISH, "%f", value)
+        } else if (TYPE_BOOL == type) {
+            val value = item.getBoolean("value")
+            expression = String.format(Locale.ENGLISH, "%b", value)
+        } else if (TYPE_ARRAY == type) {
+            val entries = item.getArray("value")
+
+            expression += "["
+
+            for (i in 0..<entries!!.size()) {
+                val entryExpression = stringExpression(entries.getMap(i)!!)
+                expression += entryExpression
+
+                if (i < entries.size() - 1) {
+                    expression += ","
+                }
+            }
+
+            expression += "]"
+        }
+
+        return expression
+    }
+}