shakebug-react-native 1.0.14

package/android/src/main/java/com/shakebug/ShakebugSDKImagePickerModuleImpl.java

@@ -0,0 +1,230 @@
+package com.shakebug;
+
+import android.app.Activity;
+import android.content.ActivityNotFoundException;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.provider.MediaStore;
+
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.Callback;
+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 java.io.File;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import static com.shakebug.Utils.*;
+
+public class ShakebugSDKImagePickerModuleImpl implements ActivityEventListener {
+    static final String NAME = "ShakebugSDKImagePicker";
+
+    // Public to let consuming apps hook into the image picker response
+    public static final int REQUEST_LAUNCH_IMAGE_CAPTURE = 13001;
+    public static final int REQUEST_LAUNCH_VIDEO_CAPTURE = 13002;
+    public static final int REQUEST_LAUNCH_LIBRARY = 13003;
+
+    private Uri fileUri;
+
+    private ReactApplicationContext reactContext;
+
+    Callback callback;
+
+    Options options;
+    Uri cameraCaptureURI;
+
+    public ShakebugSDKImagePickerModuleImpl(ReactApplicationContext reactContext) {
+        this.reactContext = reactContext;
+        this.reactContext.addActivityEventListener(this);
+    }
+
+    public void launchCamera(final ReadableMap options, final Callback callback) {
+        if (!isCameraAvailable(reactContext)) {
+            callback.invoke(getErrorMap(errCameraUnavailable, null));
+            return;
+        }
+
+        final Activity currentActivity = this.reactContext.getCurrentActivity();
+        if (currentActivity == null) {
+            callback.invoke(getErrorMap(errOthers, "Activity error"));
+            return;
+        }
+
+        if (!isCameraPermissionFulfilled(reactContext, currentActivity)) {
+            callback.invoke(getErrorMap(errOthers, cameraPermissionDescription));
+            return;
+        }
+
+        this.callback = callback;
+        this.options = new Options(options);
+
+        if (this.options.saveToPhotos && Build.VERSION.SDK_INT <= Build.VERSION_CODES.P && !hasPermission(currentActivity)) {
+            callback.invoke(getErrorMap(errPermission, null));
+            return;
+        }
+
+        int requestCode;
+        File file;
+        Intent cameraIntent;
+
+        if (this.options.mediaType.equals(mediaTypeVideo)) {
+            requestCode = REQUEST_LAUNCH_VIDEO_CAPTURE;
+            cameraIntent = new Intent(MediaStore.ACTION_VIDEO_CAPTURE);
+            cameraIntent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, this.options.videoQuality);
+            if (this.options.durationLimit > 0) {
+                cameraIntent.putExtra(MediaStore.EXTRA_DURATION_LIMIT, this.options.durationLimit);
+            }
+            file = createFile(reactContext, "mp4");
+            cameraCaptureURI = createUri(file, reactContext);
+        } else {
+            requestCode = REQUEST_LAUNCH_IMAGE_CAPTURE;
+            cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
+            file = createFile(reactContext, "jpg");
+            cameraCaptureURI = createUri(file, reactContext);
+        }
+
+        if (this.options.useFrontCamera) {
+            setFrontCamera(cameraIntent);
+        }
+
+        fileUri = Uri.fromFile(file);
+        cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, cameraCaptureURI);
+        cameraIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
+
+        try {
+            currentActivity.startActivityForResult(cameraIntent, requestCode);
+        } catch (ActivityNotFoundException e) {
+            callback.invoke(getErrorMap(errOthers, e.getMessage()));
+            this.callback = null;
+        }
+    }
+
+    public void launchImageLibrary(final ReadableMap options, final Callback callback) {
+        final Activity currentActivity = this.reactContext.getCurrentActivity();
+        if (currentActivity == null) {
+            callback.invoke(getErrorMap(errOthers, "Activity error"));
+            return;
+        }
+
+        this.callback = callback;
+        this.options = new Options(options);
+
+        int requestCode;
+        Intent libraryIntent;
+        requestCode = REQUEST_LAUNCH_LIBRARY;
+
+        int selectionLimit = this.options.selectionLimit;
+        boolean isSingleSelect = selectionLimit == 1;
+        boolean isPhoto = this.options.mediaType.equals(mediaTypePhoto);
+        boolean isVideo = this.options.mediaType.equals(mediaTypeVideo);
+
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            if (isSingleSelect && (isPhoto || isVideo)) {
+                libraryIntent = new Intent(Intent.ACTION_PICK);
+            } else {
+                libraryIntent = new Intent(Intent.ACTION_GET_CONTENT);
+                libraryIntent.addCategory(Intent.CATEGORY_OPENABLE);
+            }
+        } else {
+            libraryIntent = new Intent(MediaStore.ACTION_PICK_IMAGES);
+        }
+
+        if (!isSingleSelect) {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+                libraryIntent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
+            } else {
+                if (selectionLimit != 1) {
+                    int maxNum = selectionLimit;
+                    if (selectionLimit == 0) maxNum = MediaStore.getPickImagesMaxLimit();
+                    libraryIntent.putExtra(MediaStore.EXTRA_PICK_IMAGES_MAX, maxNum);
+                }
+            }
+        }
+
+        if (isPhoto) {
+            libraryIntent.setType("image/*");
+        } else if (isVideo) {
+            libraryIntent.setType("video/*");
+        } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            libraryIntent.setType("*/*");
+            libraryIntent.putExtra(Intent.EXTRA_MIME_TYPES, new String[]{"image/*", "video/*"});
+        }
+
+        try {
+            currentActivity.startActivityForResult(libraryIntent, requestCode);
+        } catch (ActivityNotFoundException e) {
+            callback.invoke(getErrorMap(errOthers, e.getMessage()));
+            this.callback = null;
+        }
+    }
+
+    void onAssetsObtained(List<Uri> fileUris) {
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+
+        executor.submit(() -> {
+            try {
+                callback.invoke(getResponseMap(fileUris, options, reactContext));
+            } catch (RuntimeException exception) {
+                callback.invoke(getErrorMap(errOthers, exception.getMessage()));
+            } finally {
+                callback = null;
+            }
+        });
+    }
+
+    @Override
+    public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+
+        // onActivityResult is called even when ActivityNotFoundException occurs
+        if (!isValidRequestCode(requestCode) || (this.callback == null)) {
+            return;
+        }
+
+        if (resultCode != Activity.RESULT_OK) {
+            if (requestCode == REQUEST_LAUNCH_IMAGE_CAPTURE) {
+                deleteFile(fileUri);
+            }
+            try {
+                callback.invoke(getCancelMap());
+                return;
+            } catch (RuntimeException exception) {
+                callback.invoke(getErrorMap(errOthers, exception.getMessage()));
+            } finally {
+                callback = null;
+            }
+        }
+
+        switch (requestCode) {
+            case REQUEST_LAUNCH_IMAGE_CAPTURE:
+                if (options.saveToPhotos) {
+                    saveToPublicDirectory(cameraCaptureURI, reactContext, "photo");
+                }
+
+                onAssetsObtained(Collections.singletonList(fileUri));
+                break;
+
+            case REQUEST_LAUNCH_LIBRARY:
+                onAssetsObtained(collectUrisFromData(data));
+                break;
+
+            case REQUEST_LAUNCH_VIDEO_CAPTURE:
+                if (options.saveToPhotos) {
+                    saveToPublicDirectory(cameraCaptureURI, reactContext, "video");
+                }
+
+                onAssetsObtained(Collections.singletonList(fileUri));
+                break;
+        }
+    }
+
+    @Override
+    public void onNewIntent(Intent intent) {
+    }
+}

package/android/src/main/java/com/shakebug/ShakebugSDKScreenShotModule.java

@@ -0,0 +1,196 @@
+
+package com.shakebug;
+
+import android.app.Activity;
+import android.content.Context;
+import android.net.Uri;
+import android.os.AsyncTask;
+import androidx.annotation.NonNull;
+import android.util.DisplayMetrics;
+import android.util.Log;
+
+import com.facebook.react.bridge.GuardedAsyncTask;
+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.UIManagerModule;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+import com.shakebug.ViewShot.Formats;
+import com.shakebug.ViewShot.Results;
+
+public class ShakebugSDKScreenShotModule extends ReactContextBaseJavaModule {
+
+    public static final String RNVIEW_SHOT = "ShakebugSDKRNViewShot";
+
+    private final ReactApplicationContext reactContext;
+
+    private final Executor executor = Executors.newCachedThreadPool();
+
+    public ShakebugSDKScreenShotModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @Override
+    public String getName() {
+        return RNVIEW_SHOT;
+    }
+
+    @Override
+    public Map<String, Object> getConstants() {
+        return Collections.emptyMap();
+    }
+
+    @Override
+    public void onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy();
+        new CleanTask(getReactApplicationContext()).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    }
+
+    @ReactMethod
+    public void releaseCapture(String uri) {
+        final String path = Uri.parse(uri).getPath();
+        if (path == null) return;
+        File file = new File(path);
+        if (!file.exists()) return;
+        File parent = file.getParentFile();
+        if (parent.equals(reactContext.getExternalCacheDir()) || parent.equals(reactContext.getCacheDir())) {
+            file.delete();
+        }
+    }
+
+    @ReactMethod
+    public void captureRef(int tag, ReadableMap options, Promise promise) {
+        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") ? options.getInt("width") : null;
+        final Integer scaleHeight = options.hasKey("height") ? options.getInt("height") : null;
+        final String resultStreamFormat = options.getString("result");
+        final String fileName = options.hasKey("fileName") ? options.getString("fileName") : null;
+        final Boolean snapshotContentContainer = options.getBoolean("snapshotContentContainer");
+        final boolean handleGLSurfaceView = options.hasKey("handleGLSurfaceViewOnAndroid") && options.getBoolean("handleGLSurfaceViewOnAndroid");
+
+        try {
+            File outputFile = null;
+            if (Results.TEMP_FILE.equals(resultStreamFormat)) {
+                outputFile = createTempFile(getReactApplicationContext(), extension, fileName);
+            }
+
+            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, handleGLSurfaceView, promise, executor)
+            );
+        } catch (final Throwable ex) {
+            Log.e(RNVIEW_SHOT, "Failed to snapshot view tag " + tag, ex);
+            promise.reject(ViewShot.ERROR_UNABLE_TO_SNAPSHOT, "Failed to snapshot view tag " + tag);
+        }
+    }
+
+    @ReactMethod
+    public void captureScreen(ReadableMap options, Promise promise) {
+        captureRef(-1, options, promise);
+    }
+
+    private static final String TEMP_FILE_PREFIX = "ReactNative-snapshot-image";
+
+    /**
+     * Asynchronous task that cleans up cache dirs (internal and, if available, external) of cropped
+     * 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> implements FilenameFilter {
+        private final File cacheDir;
+        private final File externalCacheDir;
+
+        private CleanTask(ReactContext context) {
+            super(context);
+
+            cacheDir = context.getCacheDir();
+            externalCacheDir = context.getExternalCacheDir();
+        }
+
+        @Override
+        protected void doInBackgroundGuarded(Void... params) {
+            if (null != cacheDir) {
+                cleanDirectory(cacheDir);
+            }
+
+            if (externalCacheDir != null) {
+                cleanDirectory(externalCacheDir);
+            }
+        }
+
+        @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) {
+                    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.
+     */
+    @NonNull
+    private File createTempFile(@NonNull final Context context, @NonNull final String ext, String fileName) 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) {
+            cacheDir = externalCacheDir;
+        } else {
+            cacheDir = externalCacheDir.getFreeSpace() > internalCacheDir.getFreeSpace() ?
+                    externalCacheDir : internalCacheDir;
+        }
+
+        final String suffix = "." + ext;
+        if (fileName != null) {
+            return File.createTempFile(fileName, suffix, cacheDir);
+        }
+        return File.createTempFile(TEMP_FILE_PREFIX, suffix, cacheDir);
+    }
+}

package/android/src/main/java/com/shakebug/SharedPreferencesModule.java

@@ -0,0 +1,39 @@
+// SharedPreferencesModule.java
+
+package com.shakebug;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.Promise;
+
+public class SharedPreferencesModule extends ReactContextBaseJavaModule {
+    private static final String PREFS_NAME = "MyPrefsFile";
+    private SharedPreferences sharedPreferences;
+
+    public SharedPreferencesModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        sharedPreferences = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+    }
+
+    @Override
+    public String getName() {
+        return "ShakebugSDKSharedPreferencesModule";
+    }
+
+    @ReactMethod
+    public void getString(String key, Promise promise) {
+        String value = sharedPreferences.getString(key, "");
+        promise.resolve(value);
+    }
+
+    @ReactMethod
+    public void setString(String key, String value, Promise promise) {
+        SharedPreferences.Editor editor = sharedPreferences.edit();
+        editor.putString(key, value);
+        editor.apply();
+        promise.resolve(null);
+    }
+}

package/android/src/main/java/com/shakebug/UnitConverter.java

@@ -0,0 +1,48 @@
+package com.shakebug;
+
+import android.util.DisplayMetrics;
+
+/**
+ * Created by choujason on 7/31/16.
+ */
+
+public class UnitConverter {
+
+
+  public static DisplayMetrics getDisplayMetrics(){
+
+    return BaseUtils.getContext().getResources().getDisplayMetrics();
+  }
+
+  public static float dpToPx(float dp) {
+    return dp * getDisplayMetrics().density;
+  }
+
+  public static int dpToPx(int dp) {
+    return (int) (dp * getDisplayMetrics().density + 0.5f);
+  }
+
+  public static float pxToDp(float px) {
+    return px / getDisplayMetrics().density;
+  }
+
+  public static int pxToDp(int px) {
+    return (int) (px / getDisplayMetrics().density + 0.5f);
+  }
+
+  public static float spToPx(float sp) {
+    return sp * getDisplayMetrics().scaledDensity;
+  }
+
+  public static int spToPx(int sp) {
+    return (int) (sp * getDisplayMetrics().scaledDensity + 0.5f);
+  }
+
+  public static float pxToSp(float px) {
+    return px / getDisplayMetrics().scaledDensity;
+  }
+
+  public static int pxToSp(int px) {
+    return (int) (px / getDisplayMetrics().scaledDensity + 0.5f);
+  }
+}

package/android/src/main/java/com/shakebug/Utility.java

@@ -0,0 +1,29 @@
+package com.shakebug;
+
+import android.util.Log;
+import android.graphics.RectF;
+
+public final class Utility {
+    public static RectF fillImage(float imgWidth, float imgHeight, float targetWidth, float targetHeight, String mode) {
+        float imageAspectRatio = imgWidth / imgHeight;
+        float targetAspectRatio = targetWidth / targetHeight;
+        switch (mode) {
+            case "AspectFill": {
+                float scaleFactor = targetAspectRatio < imageAspectRatio ? targetHeight / imgHeight : targetWidth / imgWidth;
+                float w = imgWidth * scaleFactor, h = imgHeight * scaleFactor;
+                return new RectF((targetWidth - w) / 2, (targetHeight - h) / 2, 
+                    w + (targetWidth - w) / 2, h + (targetHeight - h) / 2);
+            }
+            case "AspectFit":
+            default: {
+                float scaleFactor = targetAspectRatio > imageAspectRatio ? targetHeight / imgHeight : targetWidth / imgWidth;
+                float w = imgWidth * scaleFactor, h = imgHeight * scaleFactor;
+                return new RectF((targetWidth - w) / 2, (targetHeight - h) / 2, 
+                    w + (targetWidth - w) / 2, h + (targetHeight - h) / 2);
+            }
+            case "ScaleToFill": {
+                return  new RectF(0, 0, targetWidth, targetHeight);
+            }
+        }
+    }
+}