@rnmapbox/maps 10.0.0-beta.28

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

@@ -0,0 +1,151 @@
+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.maps.CameraOptions;
+import com.mapbox.maps.Image;
+import com.mapbox.maps.MapSnapshotInterface;
+import com.mapbox.maps.MapSnapshotOptions;
+import com.mapbox.maps.ResourceOptions;
+import com.mapbox.maps.SnapshotCreatedListener;
+import com.mapbox.maps.Snapshotter;
+import com.mapbox.maps.Size;
+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;
+
+@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, Snapshotter> 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 Snapshotter snapshotter = new Snapshotter(mContext, getOptions(jsOptions));
+                snapshotter.setStyleUri(jsOptions.getString("styleURL"));
+                snapshotter.setCamera(getCameraOptions(jsOptions));
+
+                mSnapshotterMap.put(snapshotterID, snapshotter);
+
+                snapshotter.start(new SnapshotCreatedListener() {
+                    @Override
+                    public void onSnapshotResult(MapSnapshotInterface snapshot) {
+                        try {
+                            if (snapshot == null) {
+                                Log.w(REACT_CLASS, "Snapshot failed");
+                                promise.reject(REACT_CLASS, "Snapshot failed");
+                                mSnapshotterMap.remove(snapshotterID);
+                            } else {
+                                Image image = snapshot.image();
+
+                                String result = null;
+                                if (jsOptions.getBoolean("writeToDisk")) {
+                                    result = BitmapUtils.createImgTempFile(mContext, image);
+                                } else {
+                                    result = BitmapUtils.createImgBase64(image);
+                                }
+
+                                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);
+                            }
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                            promise.reject(REACT_CLASS, e.getLocalizedMessage());
+                        }
+                    }
+                });
+            }
+        });
+    }
+
+    private CameraOptions getCameraOptions(ReadableMap jsOptions) {
+        Feature centerPoint = Feature.fromJson(jsOptions.getString("centerCoordinate"));
+        Point point = (Point) centerPoint.geometry();
+
+        CameraOptions.Builder cameraOptionsBuilder = new CameraOptions.Builder();
+        CameraOptions cameraOptions = cameraOptionsBuilder
+                .center(point)
+                .pitch(jsOptions.getDouble("pitch"))
+                .bearing(jsOptions.getDouble("heading"))
+                .zoom(jsOptions.getDouble("zoomLevel"))
+                .build();
+        return cameraOptions;
+    }
+
+    private MapSnapshotOptions getOptions(ReadableMap jsOptions) {
+        MapSnapshotOptions.Builder builder = new MapSnapshotOptions.Builder();
+
+        builder.size(
+                new Size(
+                        (int) jsOptions.getDouble("width"),
+                        (int) jsOptions.getDouble("height")
+                )
+        );
+        builder.pixelRatio(Float.valueOf(mContext.getResources().getDisplayMetrics().scaledDensity).intValue());
+
+        builder.resourceOptions(new ResourceOptions.Builder().accessToken(RCTMGLModule.getAccessToken(mContext)).build());
+        return builder.build();
+    }
+
+    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-v10/com/mapbox/rctmgl/utils/BitmapUtils.java

@@ -0,0 +1,183 @@
+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.graphics.drawable.Drawable;
+import android.graphics.drawable.BitmapDrawable;
+import android.net.Uri;
+import android.util.Base64;
+import android.util.Log;
+import android.util.LruCache;
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+import com.mapbox.maps.Image;
+import com.mapbox.maps.extension.style.image.ImageExtensionImpl;
+
+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;
+import java.nio.ByteBuffer;
+
+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 Image toImage(Bitmap bitmap) {
+        if (bitmap.getConfig() != Bitmap.Config.ARGB_8888) {
+            throw new RuntimeException("Only ARGB_8888 bitmap config is supported!");
+        }
+        ByteBuffer byteBuffer = ByteBuffer.allocate(bitmap.getByteCount());
+        bitmap.copyPixelsToBuffer(byteBuffer);
+        return new Image(bitmap.getWidth(), bitmap.getHeight(), byteBuffer.array());
+    }
+
+    public static Image toImage(BitmapDrawable bitmapDrawable) {
+        return toImage(bitmapDrawable.getBitmap());
+    }
+
+    @Nullable
+    public static Bitmap getBitmapFromDrawable(@Nullable Drawable sourceDrawable) {
+        if (sourceDrawable == null) {
+            return null;
+        }
+
+        if (sourceDrawable instanceof BitmapDrawable) {
+            return ((BitmapDrawable) sourceDrawable).getBitmap();
+        } else {
+            //copying drawable object to not manipulate on the same reference
+            Drawable.ConstantState constantState = sourceDrawable.getConstantState();
+            if (constantState == null) {
+                return null;
+            }
+            Drawable drawable = constantState.newDrawable().mutate();
+
+            Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(),
+                    Bitmap.Config.ARGB_8888);
+            Canvas canvas = new Canvas(bitmap);
+            drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
+            drawable.draw(canvas);
+            return bitmap;
+        }
+    }
+
+    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 createImgTempFile(Context context, Image image) throws IOException {
+        Bitmap bitmap = Bitmap.createBitmap(image.getWidth(), image.getHeight(), Bitmap.Config.ARGB_8888);
+        bitmap.copyPixelsFromBuffer(ByteBuffer.wrap(image.getData()));
+        return createTempFile(context, bitmap);
+    }
+
+    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 String createImgBase64(Image image) {
+        Bitmap bitmap = Bitmap.createBitmap(image.getWidth(), image.getHeight(), Bitmap.Config.ARGB_8888);
+        bitmap.copyPixelsFromBuffer(ByteBuffer.wrap(image.getData()));
+        return createBase64(bitmap);
+    }
+
+    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-v10/com/mapbox/rctmgl/utils/ConvertUtils.java

@@ -0,0 +1,253 @@
+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;
+
+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;
+    }
+}