added support of RAW image format and zip-base64 packaging of the results

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

 
 package fr.greweb.reactnativeviewshot;
 
+import android.app.Activity;
 import android.content.Context;
-import android.graphics.Bitmap;
 import android.net.Uri;
 import android.os.AsyncTask;
-import android.os.Environment;
+import android.support.annotation.NonNull;
 import android.util.DisplayMetrics;
-import android.view.View;
-
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactMethod;
+import android.util.Log;
 
 import com.facebook.react.bridge.GuardedAsyncTask;
-import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
 import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.uimanager.UIBlock;
 import com.facebook.react.uimanager.UIManagerModule;
 
 import java.io.File;
 import java.io.FilenameFilter;
 import java.io.IOException;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.Map;
 
+import fr.greweb.reactnativeviewshot.ViewShot.Formats;
+import fr.greweb.reactnativeviewshot.ViewShot.Results;
+
 public class RNViewShotModule extends ReactContextBaseJavaModule {
 
+    public static final String RNVIEW_SHOT = "RNViewShot";
+
     private final ReactApplicationContext reactContext;
 
     public RNViewShotModule(ReactApplicationContext reactContext) {
 
     @Override
     public String getName() {
-        return "RNViewShot";
+        return RNVIEW_SHOT;
     }
 
     @Override
 
     @ReactMethod
     public void captureRef(int tag, ReadableMap options, Promise promise) {
-        ReactApplicationContext context = getReactApplicationContext();
-        String format = options.getString("format");
-        Bitmap.CompressFormat compressFormat =
-          format.equals("jpg")
-          ? Bitmap.CompressFormat.JPEG
-          : format.equals("webm")
-          ? Bitmap.CompressFormat.WEBP
-          : Bitmap.CompressFormat.PNG;
-        double quality = options.getDouble("quality");
-        DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
-        Integer width = options.hasKey("width") ? (int)(displayMetrics.density * options.getDouble("width")) : null;
-        Integer height = options.hasKey("height") ? (int)(displayMetrics.density * options.getDouble("height")) : null;
-        String result = options.getString("result");
-        Boolean snapshotContentContainer = options.getBoolean("snapshotContentContainer");
+        final ReactApplicationContext context = getReactApplicationContext();
+        final DisplayMetrics dm = context.getResources().getDisplayMetrics();
+
+        final String extension = options.getString("format");
+        final int imageFormat = "jpg".equals(extension)
+                ? Formats.JPEG
+                : "webm".equals(extension)
+                ? Formats.WEBP
+                : "raw".equals(extension)
+                ? Formats.RAW
+                : Formats.PNG;
+
+        final double quality = options.getDouble("quality");
+        final Integer scaleWidth = options.hasKey("width") ? (int) (dm.density * options.getDouble("width")) : null;
+        final Integer scaleHeight = options.hasKey("height") ? (int) (dm.density * options.getDouble("height")) : null;
+        final String resultStreamFormat = options.getString("result");
+        final Boolean snapshotContentContainer = options.getBoolean("snapshotContentContainer");
+
         try {
-            File file = null;
-            if ("tmpfile".equals(result)) {
-              file = createTempFile(getReactApplicationContext(), format);
+            File outputFile = null;
+            if (Results.TEMP_FILE.equals(resultStreamFormat)) {
+                outputFile = createTempFile(getReactApplicationContext(), extension);
             }
-            UIManagerModule uiManager = this.reactContext.getNativeModule(UIManagerModule.class);
-            uiManager.addUIBlock(new ViewShot(tag, format, compressFormat, quality, width, height, file, result, snapshotContentContainer,reactContext, getCurrentActivity(), promise));
-        }
-        catch (Exception e) {
-            promise.reject(ViewShot.ERROR_UNABLE_TO_SNAPSHOT, "Failed to snapshot view tag "+tag);
+
+            final Activity activity = getCurrentActivity();
+            final UIManagerModule uiManager = this.reactContext.getNativeModule(UIManagerModule.class);
+
+            uiManager.addUIBlock(new ViewShot(
+                    tag, extension, imageFormat, quality,
+                    scaleWidth, scaleHeight, outputFile, resultStreamFormat,
+                    snapshotContentContainer, reactContext, activity, promise)
+            );
+        } catch (final Throwable ignored) {
+            promise.reject(ViewShot.ERROR_UNABLE_TO_SNAPSHOT, "Failed to snapshot view tag " + tag);
         }
     }
 
      * image files. This is run when the catalyst instance is being destroyed (i.e. app is shutting
      * down) and when the module is instantiated, to handle the case where the app crashed.
      */
-    private static class CleanTask extends GuardedAsyncTask<Void, Void> {
-        private final Context mContext;
+    private static class CleanTask extends GuardedAsyncTask<Void, Void> implements FilenameFilter {
+        private final File cacheDir;
+        private final File externalCacheDir;
 
         private CleanTask(ReactContext context) {
             super(context);
-            mContext = context;
+
+            cacheDir = context.getCacheDir();
+            externalCacheDir = context.getExternalCacheDir();
         }
 
         @Override
         protected void doInBackgroundGuarded(Void... params) {
-            cleanDirectory(mContext.getCacheDir());
-            File externalCacheDir = mContext.getExternalCacheDir();
+            if (null != cacheDir) {
+                cleanDirectory(cacheDir);
+            }
+
             if (externalCacheDir != null) {
                 cleanDirectory(externalCacheDir);
             }
         }
 
-        private void cleanDirectory(File directory) {
-            File[] toDelete = directory.listFiles(
-                    new FilenameFilter() {
-                        @Override
-                        public boolean accept(File dir, String filename) {
-                            return filename.startsWith(TEMP_FILE_PREFIX);
-                        }
-                    });
+        @Override
+        public final boolean accept(File dir, String filename) {
+            return filename.startsWith(TEMP_FILE_PREFIX);
+        }
+
+        private void cleanDirectory(@NonNull final File directory) {
+            final File[] toDelete = directory.listFiles(this);
+
             if (toDelete != null) {
-                for (File file: toDelete) {
-                    file.delete();
+                for (File file : toDelete) {
+                    if (file.delete()) {
+                        Log.d(RNVIEW_SHOT, "deleted file: " + file.getAbsolutePath());
+                    }
                 }
             }
         }
      * Create a temporary file in the cache directory on either internal or external storage,
      * whichever is available and has more free space.
      */
-    private File createTempFile(Context context, String ext)
-            throws IOException {
-        File externalCacheDir = context.getExternalCacheDir();
-        File internalCacheDir = context.getCacheDir();
-        File cacheDir;
+    @NonNull
+    private File createTempFile(@NonNull final Context context, @NonNull final String ext) throws IOException {
+        final File externalCacheDir = context.getExternalCacheDir();
+        final File internalCacheDir = context.getCacheDir();
+        final File cacheDir;
+
         if (externalCacheDir == null && internalCacheDir == null) {
             throw new IOException("No cache directory available");
         }
+
         if (externalCacheDir == null) {
             cacheDir = internalCacheDir;
-        }
-        else if (internalCacheDir == null) {
+        } else if (internalCacheDir == null) {
             cacheDir = externalCacheDir;
         } else {
             cacheDir = externalCacheDir.getFreeSpace() > internalCacheDir.getFreeSpace() ?
                     externalCacheDir : internalCacheDir;
         }
-        String suffix = "." + ext;
-        File tmpFile = File.createTempFile(TEMP_FILE_PREFIX, suffix, cacheDir);
-        return tmpFile;
-    }
 
+        final String suffix = "." + ext;
+        return File.createTempFile(TEMP_FILE_PREFIX, suffix, cacheDir);
+    }
 }