@maplibre/maplibre-react-native 8.6.0-beta.0

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/modules/RCTMGLSnapshotModule.java

@@ -0,0 +1,139 @@
+package com.mapbox.rctmgl.modules;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Base64;
+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.FeatureCollection;
+import com.mapbox.geojson.Point;
+import com.mapbox.mapboxsdk.camera.CameraPosition;
+import com.mapbox.mapboxsdk.snapshotter.MapSnapshot;
+import com.mapbox.mapboxsdk.snapshotter.MapSnapshotter;
+import com.mapbox.mapboxsdk.storage.FileSource;
+import com.mapbox.rctmgl.utils.BitmapUtils;
+import com.mapbox.rctmgl.utils.GeoJSONUtils;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import static android.content.Context.CONTEXT_IGNORE_SECURITY;
+
+/**
+ * Created by nickitaliano on 11/30/17.
+ */
+
+@ReactModule(name = RCTMGLSnapshotModule.REACT_CLASS)
+public class RCTMGLSnapshotModule extends ReactContextBaseJavaModule {
+    public static final String REACT_CLASS = "RCTMGLSnapshotModule";
+
+    private ReactApplicationContext mContext;
+
+    // prevents snapshotter from being GC'ed
+    private Map<String, MapSnapshotter> mSnapshotterMap;
+
+    public RCTMGLSnapshotModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        mContext = reactContext;
+        mSnapshotterMap = new HashMap<>();
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @ReactMethod
+    public void takeSnap(final ReadableMap jsOptions, final Promise promise) {
+        FileSource.getInstance(mContext).activate();
+
+        mContext.runOnUiQueueThread(new Runnable() {
+            @Override
+            public void run() {
+                final String snapshotterID = UUID.randomUUID().toString();
+                final MapSnapshotter snapshotter = new MapSnapshotter(mContext, getOptions(jsOptions));
+                mSnapshotterMap.put(snapshotterID, snapshotter);
+
+                snapshotter.start(new MapSnapshotter.SnapshotReadyCallback() {
+                    @Override
+                    public void onSnapshotReady(MapSnapshot snapshot) {
+                        Bitmap bitmap = snapshot.getBitmap();
+
+                        String result = null;
+                        if (jsOptions.getBoolean("writeToDisk")) {
+                            result = BitmapUtils.createTempFile(mContext, bitmap);
+                        } else {
+                            result = BitmapUtils.createBase64(bitmap);
+                        }
+
+                        if (result == null) {
+                            promise.reject(REACT_CLASS, "Could not generate snapshot, please check Android logs for more info.");
+                            return;
+                        }
+
+                        promise.resolve(result);
+                        mSnapshotterMap.remove(snapshotterID);
+                    }
+                }, new MapSnapshotter.ErrorHandler() {
+                    @Override
+                    public void onError(String error) {
+                        Log.w(REACT_CLASS, error);
+                        mSnapshotterMap.remove(snapshotterID);
+                    }
+                });
+            }
+        });
+    }
+
+    private MapSnapshotter.Options getOptions(ReadableMap jsOptions) {
+        MapSnapshotter.Options options = new MapSnapshotter.Options(
+                (int) jsOptions.getDouble("width"),
+                (int) jsOptions.getDouble("height"));
+
+        options.withLogo(jsOptions.getBoolean("withLogo"));
+        options.withStyle(jsOptions.getString("styleURL"));
+        options.withPixelRatio(Float.valueOf(mContext.getResources().getDisplayMetrics().scaledDensity).intValue());
+
+        if (jsOptions.hasKey("bounds")) {
+            FeatureCollection bounds = FeatureCollection.fromJson(jsOptions.getString("bounds"));
+            options.withRegion(GeoJSONUtils.toLatLngBounds(bounds));
+        } else {
+            Feature centerPoint = Feature.fromJson(jsOptions.getString("centerCoordinate"));
+            CameraPosition cameraPosition = new CameraPosition.Builder()
+                    .target(GeoJSONUtils.toLatLng((Point) centerPoint.geometry()))
+                    .tilt(jsOptions.getDouble("pitch"))
+                    .bearing(jsOptions.getDouble("heading"))
+                    .zoom(jsOptions.getDouble("zoomLevel"))
+                    .build();
+            options.withCameraPosition(cameraPosition);
+        }
+
+        return options;
+    }
+
+    private void closeSnapshotOutputStream(OutputStream outputStream) {
+        if (outputStream == null) {
+            return;
+        }
+        try {
+            outputStream.close();
+        } catch (IOException e) {
+            Log.w(REACT_CLASS, e.getLocalizedMessage());
+        }
+    }
+}

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/utils/BitmapUtils.java

@@ -0,0 +1,129 @@
+package com.mapbox.rctmgl.utils;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.net.Uri;
+import android.util.Base64;
+import android.util.Log;
+import android.util.LruCache;
+import android.view.View;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URL;
+
+/**
+ * Created by nickitaliano on 10/9/17.
+ */
+
+public class BitmapUtils {
+    public static final String LOG_TAG = "BitmapUtils";
+
+    private  static int CACHE_SIZE = 1024 * 1024;
+    private static LruCache<String, Bitmap> mCache = new LruCache<String, Bitmap>(CACHE_SIZE) {
+        protected int sizeOf(String key, Bitmap bitmap) {
+            return bitmap.getByteCount();
+        }
+    };
+
+    public static Bitmap getBitmapFromURL(String url) {
+        return BitmapUtils.getBitmapFromURL(url, null);
+    }
+
+    public static Bitmap getBitmapFromURL(String url, BitmapFactory.Options options) {
+        Bitmap bitmap = getImage(url);
+
+        if (bitmap != null) {
+            return  bitmap;
+        }
+
+        try {
+            InputStream bitmapStream = new URL(url).openStream();
+            bitmap = BitmapFactory.decodeStream(bitmapStream, null, options);
+            bitmapStream.close();
+            addImage(url, bitmap);
+        } catch (Exception e) {
+            Log.w(LOG_TAG, e.getLocalizedMessage());
+            bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ALPHA_8); // Returns a transparent bitmap
+        }
+
+        return bitmap;
+    }
+
+    public static Bitmap getBitmapFromResource(Context context, String resourceName, BitmapFactory.Options options) {
+        Resources resources = context.getResources();
+        int resID = resources.getIdentifier(resourceName, "drawable", context.getPackageName());
+        return BitmapFactory.decodeResource(resources, resID, options);
+    }
+
+    public static String createTempFile(Context context, Bitmap bitmap) {
+        File tempFile = null;
+        FileOutputStream outputStream = null;
+
+        try {
+            tempFile = File.createTempFile(LOG_TAG, ".png", context.getCacheDir());
+            outputStream = new FileOutputStream(tempFile);
+        } catch (IOException e) {
+            Log.w(LOG_TAG, e.getLocalizedMessage());
+        }
+
+        if (tempFile == null) {
+            return null;
+        }
+
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
+        closeSnapshotOutputStream(outputStream);
+        return Uri.fromFile(tempFile).toString();
+    }
+
+    public static String createBase64(Bitmap bitmap) {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);
+        byte[] bitmapBytes = outputStream.toByteArray();
+        closeSnapshotOutputStream(outputStream);
+        String base64Prefix = "data:image/png;base64,";
+        return base64Prefix + Base64.encodeToString(bitmapBytes, Base64.NO_WRAP);
+    }
+
+    public static Bitmap viewToBitmap(View v, int left, int top, int right, int bottom) {
+        Bitmap bitmap = null;
+        if (v != null) {
+            int w = right - left;
+            int h = bottom - top;
+            if (w > 0 && h > 0) {
+                bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
+                bitmap.eraseColor(Color.TRANSPARENT);
+                Canvas canvas = new Canvas(bitmap);
+                v.draw(canvas);
+            }
+        }
+        return bitmap;
+    }
+
+    private static void addImage(String imageURL, Bitmap bitmap) {
+        mCache.put(imageURL, bitmap);
+    }
+
+    private static Bitmap getImage(String imageURL) {
+        return mCache.get(imageURL);
+    }
+
+    private static void closeSnapshotOutputStream(OutputStream outputStream) {
+        if (outputStream == null) {
+            return;
+        }
+        try {
+            outputStream.close();
+        } catch (IOException e) {
+            Log.w(LOG_TAG, e.getLocalizedMessage());
+        }
+    }
+}

package/android/rctmgl/src/main/java/com/mapbox/rctmgl/utils/ConvertUtils.java

@@ -0,0 +1,257 @@
+package com.mapbox.rctmgl.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;
+
+/**
+ * Created by nickitaliano on 8/18/17.
+ */
+
+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) {
+            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/rctmgl/src/main/java/com/mapbox/rctmgl/utils/DownloadMapImageTask.java

@@ -0,0 +1,159 @@
+package com.mapbox.rctmgl.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 com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.mapboxsdk.maps.Style;
+
+import java.io.File;
+import java.lang.ref.WeakReference;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+/**
+ * Created by nickitaliano on 9/13/17.
+ */
+
+public class DownloadMapImageTask extends AsyncTask<Map.Entry<String, ImageEntry>, Void, List<Map.Entry<String, Bitmap>>> {
+    public static final String LOG_TAG = "DownloadMapImageTask";
+
+    private WeakReference<Context> mContext;
+    private WeakReference<MapboxMap> mMap;
+    @Nullable
+    private OnAllImagesLoaded mCallback;
+    private final Object mCallerContext;
+
+    public DownloadMapImageTask(Context context, MapboxMap 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, Bitmap>> doInBackground(Map.Entry<String, ImageEntry>... objects) {
+        List<Map.Entry<String, Bitmap>> 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.getScaleOr(1.0)));
+                            images.add(new AbstractMap.SimpleEntry<>(object.getKey(), bitmap));
+                        } 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(), bitmap));
+                } else {
+                    FLog.e(LOG_TAG, "Failed to load bitmap from: " + uri);
+                }
+            }
+        }
+
+        return images;
+    }
+
+    @Override
+    protected void onPostExecute(List<Map.Entry<String, Bitmap>> images) {
+        MapboxMap map = mMap.get();
+        if (map != null && images != null && images.size() > 0) {
+            Style style = map.getStyle();
+            if (style != null) {
+                HashMap<String, Bitmap> bitmapImages = new HashMap<>();
+                for (Map.Entry<String, Bitmap> image : images) {
+                    bitmapImages.put(image.getKey(), image.getValue());
+                }
+                style.addImages(bitmapImages);
+            }
+        }
+
+        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.defaultScale) {
+            options.inDensity = (int) ((double) DisplayMetrics.DENSITY_DEFAULT * scale);
+        }
+        return options;
+    }
+}