implemented super fast way of screenshot making. removed places that slow down screenshot making and delivery to the react side.

android/src/main/java/fr/greweb/reactnativeviewshot/ViewShot.java

@@ -1,12 +1,15 @@
 package fr.greweb.reactnativeviewshot;
 
-import javax.annotation.Nullable;
-
 import android.app.Activity;
-import android.content.Intent;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Point;
+import android.graphics.Rect;
 import android.net.Uri;
+import android.support.annotation.IntDef;
+import android.support.annotation.NonNull;
+import android.support.annotation.StringDef;
 import android.util.Base64;
 import android.view.TextureView;
 import android.view.View;
@@ -23,42 +26,113 @@ import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.zip.Deflater;
+
+import javax.annotation.Nullable;
 
 /**
  * Snapshot utility class allow to screenshot a view.
  */
 public class ViewShot implements UIBlock {
-
+    //region Constants
     static final String ERROR_UNABLE_TO_SNAPSHOT = "E_UNABLE_TO_SNAPSHOT";
+    /**
+     * pre-allocated output stream size for screenshot. In real life example it will eb around 7Mb.
+     */
+    private static final int PREALLOCATE_SIZE = 64 * 1024;
+    /**
+     * ARGB size in bytes.
+     */
+    private static final int ARGB_SIZE = 4;
+
+    @SuppressWarnings("WeakerAccess")
+    @IntDef({Formats.JPEG, Formats.PNG, Formats.WEBP, Formats.RAW})
+    public @interface Formats {
+        int JPEG = 0; // Bitmap.CompressFormat.JPEG.ordinal();
+        int PNG = 1;  // Bitmap.CompressFormat.PNG.ordinal();
+        int WEBP = 2; // Bitmap.CompressFormat.WEBP.ordinal();
+        int RAW = -1;
+
+        Bitmap.CompressFormat[] mapping = {
+                Bitmap.CompressFormat.JPEG,
+                Bitmap.CompressFormat.PNG,
+                Bitmap.CompressFormat.WEBP
+        };
+    }
+
+    /**
+     * Supported Output results.
+     */
+    @StringDef({Results.BASE_64, Results.DATA_URI, Results.TEMP_FILE, Results.ZIP_BASE_64})
+    public @interface Results {
+        /**
+         * Save screenshot as temp file on device.
+         */
+        String TEMP_FILE = "tmpfile";
+        /**
+         * Base 64 encoded image.
+         */
+        String BASE_64 = "base64";
+        /**
+         * Zipped RAW image in base 64 encoding.
+         */
+        String ZIP_BASE_64 = "zip-base64";
+        /**
+         * Base64 data uri.
+         */
+        String DATA_URI = "data-uri";
+    }
+    //endregion
 
+    //region Static members
+    /**
+     * Image output buffer used as a source for base64 encoding
+     */
+    private static byte[] outputBuffer = new byte[PREALLOCATE_SIZE];
+    //endregion
+
+    //region Class members
     private final int tag;
     private final String extension;
-    private final Bitmap.CompressFormat format;
+    @Formats
+    private final int format;
     private final double quality;
     private final Integer width;
     private final Integer height;
     private final File output;
+    @Results
     private final String result;
     private final Promise promise;
     private final Boolean snapshotContentContainer;
+    @SuppressWarnings({"unused", "FieldCanBeLocal"})
     private final ReactApplicationContext reactContext;
     private final Activity currentActivity;
+    //endregion
 
+    //region Constructors
+    @SuppressWarnings("WeakerAccess")
     public ViewShot(
-            int tag,
-            String extension,
-            Bitmap.CompressFormat format,
-            double quality,
+            final int tag,
+            final String extension,
+            @Formats final int format,
+            final double quality,
             @Nullable Integer width,
             @Nullable Integer height,
-            File output,
-            String result,
-            Boolean snapshotContentContainer,
-            ReactApplicationContext reactContext,
-            Activity currentActivity,
-            Promise promise) {
+            final File output,
+            @Results final String result,
+            final Boolean snapshotContentContainer,
+            final ReactApplicationContext reactContext,
+            final Activity currentActivity,
+            final Promise promise) {
         this.tag = tag;
         this.extension = extension;
         this.format = format;
@@ -72,7 +146,9 @@ public class ViewShot implements UIBlock {
         this.currentActivity = currentActivity;
         this.promise = promise;
     }
+    //endregion
 
+    //region Overrides
     @Override
     public void execute(NativeViewHierarchyManager nativeViewHierarchyManager) {
         final View view;
@@ -84,74 +160,146 @@ public class ViewShot implements UIBlock {
         }
 
         if (view == null) {
-            promise.reject(ERROR_UNABLE_TO_SNAPSHOT, "No view found with reactTag: "+tag);
+            promise.reject(ERROR_UNABLE_TO_SNAPSHOT, "No view found with reactTag: " + tag);
             return;
         }
+
         try {
-            if ("tmpfile".equals(result)) {
-                captureView(view, new FileOutputStream(output));
-                final String uri = Uri.fromFile(output).toString();
-                promise.resolve(uri);
-            } else if ("base64".equals(result)) {
-                final ByteArrayOutputStream os = new ByteArrayOutputStream();
-                captureView(view, os);
-                final byte[] bytes = os.toByteArray();
-                final String data = Base64.encodeToString(bytes, Base64.NO_WRAP);
-                promise.resolve(data);
-            } else if ("data-uri".equals(result)) {
-                final ByteArrayOutputStream os = new ByteArrayOutputStream();
-                captureView(view, os);
-                final byte[] bytes = os.toByteArray();
-                String data = Base64.encodeToString(bytes, Base64.NO_WRAP);
-                // correct the extension if JPG
-                String imageFormat = extension;
-                if ("jpg".equals(extension)) {
-                    imageFormat = "jpeg";
-                }
-                data = "data:image/"+imageFormat+";base64," + data;
-                promise.resolve(data);
+            final ReusableByteArrayOutputStream stream = new ReusableByteArrayOutputStream(outputBuffer);
+            stream.setSize(proposeSize(view));
+            outputBuffer = stream.innerBuffer();
+
+            if (Results.TEMP_FILE.equals(result) && Formats.RAW == this.format) {
+                saveToRawFileOnDevice(view);
+            } else if (Results.TEMP_FILE.equals(result) && Formats.RAW != this.format) {
+                saveToTempFileOnDevice(view);
+            } else if (Results.BASE_64.equals(result) || Results.ZIP_BASE_64.equals(result)) {
+                saveToBase64String(view);
+            } else if (Results.DATA_URI.equals(result)) {
+                saveToDataUriString(view);
             }
-        } catch (Exception e) {
-            e.printStackTrace();
+        } catch (final Throwable ignored) {
             promise.reject(ERROR_UNABLE_TO_SNAPSHOT, "Failed to capture view snapshot");
         }
     }
+    //endregion
+
+    //region Implementation
+    private void saveToTempFileOnDevice(@NonNull final View view) throws IOException {
+        final FileOutputStream fos = new FileOutputStream(output);
+        captureView(view, fos);
+
+        promise.resolve(Uri.fromFile(output).toString());
+    }
+
+    private void saveToRawFileOnDevice(@NonNull final View view) throws IOException {
+        final String uri = Uri.fromFile(output).toString();
+
+        final FileOutputStream fos = new FileOutputStream(output);
+        final ReusableByteArrayOutputStream os = new ReusableByteArrayOutputStream(outputBuffer);
+        final Point size = captureView(view, os);
+
+        // in case of buffer grow that will be a new array with bigger size
+        outputBuffer = os.innerBuffer();
+        final int length = os.size();
+        final String resolution = String.format(Locale.US, "%d:%d|", size.x, size.y);
+
+        fos.write(resolution.getBytes(Charset.forName("US-ASCII")));
+        fos.write(outputBuffer, 0, length);
+        fos.close();
+
+        promise.resolve(uri);
+    }
 
-    private List<View> getAllChildren(View v) {
+    private void saveToDataUriString(@NonNull final View view) throws IOException {
+        final ReusableByteArrayOutputStream os = new ReusableByteArrayOutputStream(outputBuffer);
+        captureView(view, os);
 
+        outputBuffer = os.innerBuffer();
+        final int length = os.size();
+
+        final String data = Base64.encodeToString(outputBuffer, 0, length, Base64.NO_WRAP);
+
+        // correct the extension if JPG
+        final String imageFormat = "jpg".equals(extension) ? "jpeg" : extension;
+
+        promise.resolve("data:image/" + imageFormat + ";base64," + data);
+    }
+
+    private void saveToBase64String(@NonNull final View view) throws IOException {
+        final boolean isRaw = Formats.RAW == this.format;
+        final boolean isZippedBase64 = Results.ZIP_BASE_64.equals(this.result);
+
+        final ReusableByteArrayOutputStream os = new ReusableByteArrayOutputStream(outputBuffer);
+        final Point size = captureView(view, os);
+
+        // in case of buffer grow that will be a new array with bigger size
+        outputBuffer = os.innerBuffer();
+        final int length = os.size();
+        final String resolution = String.format(Locale.US, "%d:%d|", size.x, size.y);
+        final String header = (isRaw ? resolution : "");
+        final String data;
+
+        if (isZippedBase64) {
+            final Deflater deflater = new Deflater();
+            deflater.setInput(outputBuffer, 0, length);
+            deflater.finish();
+
+            final ReusableByteArrayOutputStream zipped = new ReusableByteArrayOutputStream(new byte[32]);
+            byte[] buffer = new byte[1024];
+            while (!deflater.finished()) {
+                int count = deflater.deflate(buffer); // returns the generated code... index
+                zipped.write(buffer, 0, count);
+            }
+
+            data = header + Base64.encodeToString(zipped.innerBuffer(), 0, zipped.size(), Base64.NO_WRAP);
+        } else {
+            data = header + Base64.encodeToString(outputBuffer, 0, length, Base64.NO_WRAP);
+        }
+
+        promise.resolve(data);
+    }
+
+    @NonNull
+    private List<View> getAllChildren(@NonNull final View v) {
         if (!(v instanceof ViewGroup)) {
-            ArrayList<View> viewArrayList = new ArrayList<View>();
+            final ArrayList<View> viewArrayList = new ArrayList<>();
             viewArrayList.add(v);
+
             return viewArrayList;
         }
 
-        ArrayList<View> result = new ArrayList<View>();
+        final ArrayList<View> result = new ArrayList<>();
 
         ViewGroup viewGroup = (ViewGroup) v;
         for (int i = 0; i < viewGroup.getChildCount(); i++) {
-
             View child = viewGroup.getChildAt(i);
 
             //Do not add any parents, just add child elements
             result.addAll(getAllChildren(child));
         }
+
         return result;
     }
 
     /**
-     * Screenshot a view and return the captured bitmap.
-     * @param view the view to capture
-     * @return the screenshot or null if it failed.
+     * Wrap {@link #captureViewImpl(View, OutputStream)} call and on end close output stream.
      */
-    private void captureView(View view, OutputStream os) throws IOException {
+    private Point captureView(@NonNull final View view, @NonNull final OutputStream os) throws IOException {
         try {
-            captureViewImpl(view, os);
+            return captureViewImpl(view, os);
         } finally {
             os.close();
         }
     }
 
-    private void captureViewImpl(View view, OutputStream os) {
+    /**
+     * Screenshot a view and return the captured bitmap.
+     *
+     * @param view the view to capture
+     * @return screenshot resolution, Width * Height
+     */
+    private Point captureViewImpl(@NonNull final View view, @NonNull final OutputStream os) {
         int w = view.getWidth();
         int h = view.getHeight();
 
@@ -161,47 +309,201 @@ public class ViewShot implements UIBlock {
 
         //evaluate real height
         if (snapshotContentContainer) {
-            h=0;
-            ScrollView scrollView = (ScrollView)view;
+            h = 0;
+            ScrollView scrollView = (ScrollView) view;
             for (int i = 0; i < scrollView.getChildCount(); i++) {
                 h += scrollView.getChildAt(i).getHeight();
             }
         }
-        Bitmap bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
-        Bitmap childBitmapBuffer;
-        Canvas c = new Canvas(bitmap);
+
+        final Point resolution = new Point(w, h);
+        Bitmap bitmap = getBitmapForScreenshot(w, h);
+
+        final Canvas c = new Canvas(bitmap);
         view.draw(c);
 
         //after view is drawn, go through children
-        List<View> childrenList = getAllChildren(view);
-
-        for (View child : childrenList) {
-            if(child instanceof TextureView) {
-                ((TextureView) child).setOpaque(false);
-                childBitmapBuffer = ((TextureView) child).getBitmap(child.getWidth(), child.getHeight());
-                if (childBitmapBuffer != null) {
-                    int left = child.getLeft();
-                    int top = child.getTop();
-                    View parentElem = (View)child.getParent();
-                    while (parentElem != null) {
-                        if (parentElem == view) {
-                            break;
-                        }
-                        left += parentElem.getLeft();
-                        top += parentElem.getTop();
-                        parentElem = (View)parentElem.getParent();
-                    }
-                    c.drawBitmap(childBitmapBuffer, left + child.getPaddingLeft(), top + child.getPaddingTop(), null);
+        final List<View> childrenList = getAllChildren(view);
+
+        for (final View child : childrenList) {
+            // skip any child that we don't know how to process
+            if (!(child instanceof TextureView)) continue;
+
+            final TextureView tvChild = (TextureView) child;
+            tvChild.setOpaque(false);
+
+            final Point offsets = getParentOffsets(view, child);
+            final int left = child.getLeft() + child.getPaddingLeft() + offsets.x;
+            final int top = child.getTop() + child.getPaddingTop() + offsets.y;
+            final int childWidth = child.getWidth();
+            final int childHeight = child.getHeight();
+            final Rect source = new Rect(0, 0, childWidth, childHeight);
+            final Rect destination = new Rect(left, top, left + childWidth, top + childHeight);
+
+            // get re-usable bitmap
+            final Bitmap childBitmapBuffer = tvChild.getBitmap(getBitmapForScreenshot(child.getWidth(), child.getHeight()));
+            // due to re-use of bitmaps for screenshot, we can get bitmap that is bigger in size than requested
+            c.drawBitmap(childBitmapBuffer, source, destination, null);
+            recycleBitmap(childBitmapBuffer);
+        }
+
+        if (width != null && height != null && (width != w || height != h)) {
+            final Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, width, height, true);
+            recycleBitmap(bitmap);
+
+            bitmap = scaledBitmap;
+        }
+
+        // special case, just save RAW ARGB array without any compression
+        if (Formats.RAW == this.format && os instanceof ReusableByteArrayOutputStream) {
+            final int total = w * h * ARGB_SIZE;
+            final ReusableByteArrayOutputStream rbaos = cast(os);
+            bitmap.copyPixelsToBuffer(rbaos.asBuffer(total));
+            rbaos.setSize(total);
+        } else {
+            final Bitmap.CompressFormat cf = Formats.mapping[this.format];
+
+            bitmap.compress(cf, (int) (100.0 * quality), os);
+        }
+
+        recycleBitmap(bitmap);
+
+        return resolution; // return image width and height
+    }
+
+    @NonNull
+    private Point getParentOffsets(@NonNull final View view, @NonNull final View child) {
+        int left = 0;
+        int top = 0;
+
+        View parentElem = (View) child.getParent();
+        while (parentElem != null) {
+            if (parentElem == view) break;
+
+            left += parentElem.getLeft();
+            top += parentElem.getTop();
+            parentElem = (View) parentElem.getParent();
+        }
+
+        return new Point(left, top);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T extends A, A> T cast(final A instance) {
+        return (T) instance;
+    }
+    //endregion
+
+    //region Cache re-usable bitmaps
+    /**
+     * Synchronization guard.
+     */
+    private static final Object guardBitmaps = new Object();
+    /**
+     * Reusable bitmaps for screenshots.
+     */
+    private static final Set<Bitmap> weakBitmaps = Collections.newSetFromMap(new WeakHashMap<Bitmap, Boolean>());
+
+    /**
+     * Propose allocation size of the array output stream.
+     */
+    private static int proposeSize(@NonNull final View view) {
+        final int w = view.getWidth();
+        final int h = view.getHeight();
+
+        return Math.min(w * h * ARGB_SIZE, 32);
+    }
+
+    /**
+     * Return bitmap to set of available.
+     */
+    private static void recycleBitmap(@NonNull final Bitmap bitmap) {
+        synchronized (guardBitmaps) {
+            weakBitmaps.add(bitmap);
+        }
+    }
+
+    /**
+     * Try to find a bitmap for screenshot in reusabel set and if not found create a new one.
+     */
+    @NonNull
+    private static Bitmap getBitmapForScreenshot(final int width, final int height) {
+        synchronized (guardBitmaps) {
+            for (final Bitmap bmp : weakBitmaps) {
+                if (bmp.getWidth() * bmp.getHeight() <= width * height) {
+                    weakBitmaps.remove(bmp);
+                    bmp.eraseColor(Color.TRANSPARENT);
+                    return bmp;
                 }
             }
         }
 
-        if (width != null && height != null && (width != w || height != h)) {
-            bitmap = Bitmap.createScaledBitmap(bitmap, width, height, true);
+        return Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+    }
+    //endregion
+
+    //region Nested declarations
+
+    /**
+     * Stream that can re-use pre-allocated buffer.
+     */
+    @SuppressWarnings("WeakerAccess")
+    public static class ReusableByteArrayOutputStream extends ByteArrayOutputStream {
+        private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
+
+        public ReusableByteArrayOutputStream(@NonNull final byte[] buffer) {
+            super(0);
+
+            this.buf = buffer;
+        }
+
+        /**
+         * Get access to inner buffer without any memory copy operations.
+         */
+        public byte[] innerBuffer() {
+            return this.buf;
+        }
+
+        @NonNull
+        public ByteBuffer asBuffer(final int size) {
+            if (this.buf.length < size) {
+                grow(size);
+            }
+
+            return ByteBuffer.wrap(this.buf);
         }
-        if (bitmap == null) {
-            throw new RuntimeException("Impossible to snapshot the view");
+
+        public void setSize(final int size) {
+            this.count = size;
         }
-        bitmap.compress(format, (int)(100.0 * quality), os);
+
+        /**
+         * Increases the capacity to ensure that it can hold at least the
+         * number of elements specified by the minimum capacity argument.
+         *
+         * @param minCapacity the desired minimum capacity
+         */
+        protected void grow(int minCapacity) {
+            // overflow-conscious code
+            int oldCapacity = buf.length;
+            int newCapacity = oldCapacity << 1;
+            if (newCapacity - minCapacity < 0)
+                newCapacity = minCapacity;
+            if (newCapacity - MAX_ARRAY_SIZE > 0)
+                newCapacity = hugeCapacity(minCapacity);
+            buf = Arrays.copyOf(buf, newCapacity);
+        }
+
+        protected static int hugeCapacity(int minCapacity) {
+            if (minCapacity < 0) // overflow
+                throw new OutOfMemoryError();
+
+            return (minCapacity > MAX_ARRAY_SIZE) ?
+                    Integer.MAX_VALUE :
+                    MAX_ARRAY_SIZE;
+        }
+
     }
+    //endregion
+
 }