shakebug-react-native 1.0.14

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

@@ -0,0 +1,199 @@
+package com.shakebug;
+
+import static com.facebook.react.bridge.UiThreadUtil.runOnUiThread;
+
+import android.app.Activity;
+import android.media.MediaMetadataRetriever;
+import android.net.Uri;
+import android.widget.ProgressBar;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AlertDialog;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.LifecycleEventListener;
+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.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.shakebug.interfaces.VideoPlayerListner;
+import com.shakebug.widgets.VideoPlayerView;
+
+public class VideoPlayerModule extends ReactContextBaseJavaModule implements VideoPlayerListner, LifecycleEventListener {
+
+
+    private static final String MODULE_NAME = "ShakebugSDKVideoPlayerModule";
+    private static Boolean isInit = false;
+    private VideoPlayerView trimmerView;
+    private AlertDialog alertDialog;
+    private AlertDialog mProgressDialog;
+    private ProgressBar mProgressBar;
+    private int listenerCount = 0;
+
+    private Promise showEditorPromise;
+
+    private boolean enableCancelDialog = true;
+    private String cancelDialogTitle = "Warning!";
+    private String cancelDialogMessage = "Are you sure want to cancel?";
+    private String cancelDialogCancelText = "Close";
+    private String cancelDialogConfirmText = "Proceed";
+//    Activity activity = getReactApplicationContext().getCurrentActivity();
+
+    public VideoPlayerModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    @NonNull
+    public String getName() {
+        return MODULE_NAME;
+    }
+
+
+
+
+
+//    From Trimmer
+
+    @ReactMethod
+    public void showEditor(String videoPath, ReadableMap config) {
+//        if (trimmerView != null || alertDialog != null) {
+//            return;
+//        }
+
+
+        if (!isValidVideo(videoPath)) {
+            WritableMap map = Arguments.createMap();
+            map.putString("message", "File is not a valid video");
+            sendEvent(getReactApplicationContext(), "onError", map);
+            return;
+        }
+
+        enableCancelDialog = config.hasKey("enableCancelDialog") ? config.getBoolean("enableCancelDialog") : true;
+        cancelDialogTitle = config.hasKey("cancelDialogTitle") ? config.getString("cancelDialogTitle") : "Warning!";
+        cancelDialogMessage = config.hasKey("cancelDialogMessage") ? config.getString("cancelDialogMessage") : "Are you sure want to cancel?";
+        cancelDialogCancelText = config.hasKey("cancelDialogCancelText") ? config.getString("cancelDialogCancelText") : "Close";
+        cancelDialogConfirmText = config.hasKey("cancelDialogConfirmText") ? config.getString("cancelDialogConfirmText") : "Proceed";
+
+
+        Activity activity = getReactApplicationContext().getCurrentActivity();
+
+        if (!isInit) {
+            init(activity);
+            isInit = true;
+        }
+
+        // here is NOT main thread, we need to create VideoTrimmerView on UI thread, so that later we can update it using same thread
+
+        runOnUiThread(() -> {
+            trimmerView = new VideoPlayerView(getReactApplicationContext(), config, null);
+            trimmerView.setOnTrimVideoListener(this);
+            trimmerView.initVideoByURI(Uri.parse(videoPath));
+
+            AlertDialog.Builder builder = new AlertDialog.Builder(activity, android.R.style.Theme_Black_NoTitleBar_Fullscreen);
+            builder.setCancelable(false);
+            alertDialog = builder.create();
+            alertDialog.setView(trimmerView);
+            alertDialog.show();
+
+            // this is to ensure to release resource if dialog is dismissed in unexpected way (Eg. open control/notification center by dragging from top of screen)
+            alertDialog.setOnDismissListener(dialog -> {
+                // This is called in same thread as the trimmer view -> UI thread
+                if (trimmerView != null) {
+                    trimmerView.onDestroy();
+                    trimmerView = null;
+                }
+                sendEvent(getReactApplicationContext(), "onHide", null);
+            });
+            sendEvent(getReactApplicationContext(), "onShow", null);
+        });
+    }
+
+    private void init(Activity activity) {
+        isInit = true;
+        // we have to init this before create videoTrimmerView
+        BaseUtils.init(getReactApplicationContext());
+    }
+
+    @Override
+    public void onHostResume() {
+
+    }
+
+    @Override
+    public void onHostPause() {
+
+    }
+
+    @Override
+    public void onHostDestroy() {
+
+    }
+
+
+    @Override public void onCancel() {
+        if (!enableCancelDialog) {
+            alertDialog.dismiss(); // Dismiss the alertDialog when the close button is clicked
+            trimmerView.onDestroy(); // Clean up the trimmerView
+            trimmerView = null;
+            sendEvent(getReactApplicationContext(), "onCancelPlayer", null);
+            return;
+        }
+
+        AlertDialog.Builder builder = new AlertDialog.Builder(getReactApplicationContext().getCurrentActivity());
+        builder.setMessage(cancelDialogMessage);
+        builder.setTitle(cancelDialogTitle);
+        builder.setCancelable(false);
+        builder.setPositiveButton(cancelDialogConfirmText, (dialog, which) -> {
+            dialog.cancel();
+            sendEvent(getReactApplicationContext(), "onCancelPlayer", null);
+        });
+        builder.setNegativeButton(cancelDialogCancelText, (dialog, which) -> {
+            dialog.cancel();
+        });
+        AlertDialog alertDialog = builder.create();
+        alertDialog.show();
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        // This method is required by React
+        listenerCount += 1;
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // This method is required by React
+        listenerCount -= count;
+    }
+
+    private void sendEvent(ReactContext reactContext, String eventName, @Nullable WritableMap params) {
+        if (listenerCount > 0) {
+            WritableMap map = params != null ? params : Arguments.createMap();
+            map.putString("name", eventName);
+            reactContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit("ShakebugSDKVideoPlayer", map);
+        }
+    }
+
+
+    public boolean isValidVideo(String filePath) {
+        MediaMetadataRetriever retriever = new MediaMetadataRetriever();
+
+        try {
+            retriever.setDataSource(getReactApplicationContext(), Uri.parse(filePath));
+        } catch (Exception e){
+            e.printStackTrace();
+            return false;
+        }
+
+        String hasVideo = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_VIDEO);
+        return "yes".equals(hasVideo);
+    }
+}

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

@@ -0,0 +1,215 @@
+package com.shakebug;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.media.MediaMetadataRetriever;
+import android.net.Uri;
+import android.os.Build.VERSION;
+import android.text.TextUtils;
+import android.webkit.URLUtil;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.GuardedResultAsyncTask;
+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.bridge.WritableMap;
+
+import org.apache.commons.io.comparator.LastModifiedFileComparator;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.lang.ref.WeakReference;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class VideoThumbnailModule extends ReactContextBaseJavaModule {
+
+    private final ReactApplicationContext reactContext;
+
+    public VideoThumbnailModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @Override
+    public String getName() {
+        return "ShakebugSDKCreateThumbnail";
+    }
+
+    @ReactMethod
+    public void create(ReadableMap options, Promise promise) {
+        new ProcessDataTask(reactContext, promise, options).execute();
+    }
+
+    private static class ProcessDataTask extends GuardedResultAsyncTask<ReadableMap> {
+        private final WeakReference<Context> weakContext;
+        private final Promise promise;
+        private final ReadableMap options;
+
+        protected ProcessDataTask(ReactContext reactContext, Promise promise, ReadableMap options) {
+            super(reactContext.getExceptionHandler());
+            this.weakContext = new WeakReference<>(reactContext.getApplicationContext());
+            this.promise = promise;
+            this.options = options;
+        }
+
+        @Override
+        protected ReadableMap doInBackgroundGuarded() {
+            String format = options.hasKey("format") ? options.getString("format") : "jpeg";
+            String cacheName = options.hasKey("cacheName") ? options.getString("cacheName") : "";
+
+            String thumbnailDir = weakContext.get().getApplicationContext().getCacheDir().getAbsolutePath() + "/thumbnails";
+            File cacheDir = createDirIfNotExists(thumbnailDir);
+            if (!TextUtils.isEmpty(cacheName)) {
+                File file = new File(thumbnailDir, cacheName + "." + format);
+                if (file.exists()) {
+                    WritableMap map = Arguments.createMap();
+                    map.putString("path", "file://" + file.getAbsolutePath());
+                    Bitmap image = BitmapFactory.decodeFile(file.getAbsolutePath());
+                    map.putDouble("size", image.getByteCount());
+                    map.putString("mime", "image/" + format);
+                    map.putDouble("width", image.getWidth());
+                    map.putDouble("height", image.getHeight());
+                    return map;
+                }
+            }
+
+            String filePath = options.hasKey("url") ? options.getString("url") : "";
+            int dirSize = options.hasKey("dirSize") ? options.getInt("dirSize") : 100;
+            int timeStamp = options.hasKey("timeStamp") ? options.getInt("timeStamp") : 0;
+            HashMap headers = options.hasKey("headers") ? options.getMap("headers").toHashMap() : new HashMap<String, String>();
+            String fileName = TextUtils.isEmpty(cacheName) ? ("thumb-" + UUID.randomUUID().toString()) : cacheName + "." + format;
+            OutputStream fOut = null;
+            try {
+                File file = new File(cacheDir, fileName);
+                Context context = weakContext.get();
+                Bitmap image = getBitmapAtTime(context, filePath, timeStamp, headers);
+                file.createNewFile();
+                fOut = new FileOutputStream(file);
+
+                // 100 means no compression, the lower you go, the stronger the compression
+                if (format.equals("png")) {
+                    image.compress(Bitmap.CompressFormat.PNG, 100, fOut);
+                } else {
+                    image.compress(Bitmap.CompressFormat.JPEG, 90, fOut);
+                }
+
+                fOut.flush();
+                fOut.close();
+
+                long cacheDirSize = (long) dirSize * 1024 * 1024;
+                long newSize = image.getByteCount() + getDirSize(cacheDir);
+                // free up some cached data if size of cache dir exceeds CACHE_DIR_MAX_SIZE
+                if (newSize > cacheDirSize) {
+                    cleanDir(cacheDir, cacheDirSize / 2);
+                }
+
+                WritableMap map = Arguments.createMap();
+                map.putString("path", "file://" + file.getAbsolutePath());
+                map.putDouble("size", image.getByteCount());
+                map.putString("mime", "image/" + format);
+                map.putDouble("width", image.getWidth());
+                map.putDouble("height", image.getHeight());
+                return map;
+            } catch (Exception e) {
+                promise.reject("CreateThumbnail_ERROR", e);
+            }
+            return null;
+        }
+
+        @Override
+        protected void onPostExecuteGuarded(ReadableMap readableArray) {
+            promise.resolve(readableArray);
+        }
+    }
+
+    // delete previously added files one by one untill requred space is available
+    private static void cleanDir(File dir, long bytes) {
+        long bytesDeleted = 0;
+        File[] files = dir.listFiles();
+        Arrays.sort(files, LastModifiedFileComparator.LASTMODIFIED_COMPARATOR);
+
+        for (File file : files) {
+            bytesDeleted += file.length();
+            file.delete();
+
+            if (bytesDeleted >= bytes) {
+                break;
+            }
+        }
+    }
+
+    private static File createDirIfNotExists(String path) {
+        File dir = new File(path);
+        if (dir.exists()) {
+            return dir;
+        }
+
+        try {
+            dir.mkdirs();
+            // Add .nomedia to hide the thumbnail directory from gallery
+            File noMedia = new File(path, ".nomedia");
+            noMedia.createNewFile();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        return dir;
+    }
+
+    private static Bitmap getBitmapAtTime(Context context, String filePath, int time, Map headers) {
+        MediaMetadataRetriever retriever = new MediaMetadataRetriever();
+        if (URLUtil.isFileUrl(filePath)) {
+            String decodedPath;
+            try {
+                decodedPath = URLDecoder.decode(filePath, "UTF-8");
+            } catch (UnsupportedEncodingException e) {
+                decodedPath = filePath;
+            }
+
+            retriever.setDataSource(decodedPath.replace("file://", ""));
+        } else if (filePath.contains("content://")) {
+            retriever.setDataSource(context, Uri.parse(filePath));
+        } else {
+            if (VERSION.SDK_INT < 14) {
+                throw new IllegalStateException("Remote videos aren't supported on sdk_version < 14");
+            }
+            retriever.setDataSource(filePath, headers);
+        }
+  
+        Bitmap image = retriever.getFrameAtTime(time * 1000, MediaMetadataRetriever.OPTION_CLOSEST_SYNC);
+        try {
+            retriever.release();
+        } catch(IOException e) {
+            e.printStackTrace();
+        }
+        if (image == null) {
+            throw new IllegalStateException("File doesn't exist or not supported");
+        }
+        return image;
+    }
+
+    private static long getDirSize(File dir) {
+        long size = 0;
+        File[] files = dir.listFiles();
+
+        for (File file : files) {
+            if (file.isFile()) {
+                size += file.length();
+            }
+        }
+
+        return size;
+    }
+}