shakebug-react-native 1.0.14

package/android/src/main/java/com/shakebug/utils/StorageUtil.java

@@ -0,0 +1,139 @@
+package com.shakebug.utils;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.media.MediaScannerConnection;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.provider.MediaStore;
+import android.text.TextUtils;
+import com.facebook.react.bridge.ReactApplicationContext;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+public class StorageUtil {
+  public static String getOutputPath(Context context) { // use same extension as inputFile
+    long timestamp = System.currentTimeMillis() / 1000;
+    File file = new File(context.getFilesDir(), VideoTrimmerUtil.FILE_PREFIX + "_" + timestamp + ".mp4"); // always use mp4 to prevent any issue with ffmpeg
+    return file.getAbsolutePath();
+  }
+
+  public static String[] listFiles(Context context) {
+    File filesDir = context.getFilesDir();
+    File[] files = filesDir.listFiles((dir, name) -> name.startsWith(VideoTrimmerUtil.FILE_PREFIX));
+
+    List<String> fileUrls = new ArrayList<>();
+    if (files != null) {
+      for (File file : files) {
+        fileUrls.add(file.getAbsolutePath());
+      }
+    }
+
+    return fileUrls.toArray(new String[0]);
+  }
+
+  public static boolean deleteFile(String path) {
+    if (TextUtils.isEmpty(path)) return true;
+    return deleteFile(new File(path));
+  }
+
+  public static boolean deleteFile(File file) {
+    if (file == null || !file.exists()) return true;
+
+    if (file.isFile()) {
+      return file.delete();
+    }
+
+    if (!file.isDirectory()) {
+      return false;
+    }
+
+    for (File f : file.listFiles()) {
+      if (f.isFile()) {
+        f.delete();
+      } else if (f.isDirectory()) {
+        deleteFile(f);
+      }
+    }
+    return file.delete();
+  }
+
+  public static void saveVideoToGallery(ReactApplicationContext context, String videoFilePath) throws IOException {
+    File videoFile = new File(videoFilePath);
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      // For Android 10 and higher (API >= 29)
+      saveVideoUsingMediaStore(context, videoFile);
+    } else {
+      // For Android 9 and below (API < 29)
+      try {
+        saveVideoUsingTraditionalStorage(context, videoFile);
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  // Save video using MediaStore for API level >= 29
+  private static void saveVideoUsingMediaStore(Context context, File videoFile) {
+    ContentValues values = new ContentValues();
+    values.put(MediaStore.Video.Media.TITLE, "My Video Title");
+    values.put(MediaStore.Video.Media.MIME_TYPE, "video/mp4");
+    values.put(MediaStore.Video.Media.RELATIVE_PATH, Environment.DIRECTORY_DCIM);
+    Uri uri = context.getContentResolver().insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, values);
+
+    if (uri != null) {
+      try {
+        OutputStream outputStream = context.getContentResolver().openOutputStream(uri);
+        copyFile(videoFile, outputStream);
+        MediaScannerConnection.scanFile(context, new String[]{uri.toString()}, new String[]{"video/*"}, null);
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+    }
+  }
+
+  // Save video using traditional storage for API level < 29
+  private static void saveVideoUsingTraditionalStorage(Context context, File videoFile) throws IOException {
+    File galleryDirectory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM);
+    File destinationFile = new File(galleryDirectory, videoFile.getName());
+    copyFile(videoFile, destinationFile);
+    MediaScannerConnection.scanFile(context, new String[]{destinationFile.getAbsolutePath()}, new String[]{"video/*"}, null);
+  }
+
+  private static void copyFile(File sourceFile, OutputStream outputStream) throws IOException {
+    InputStream inputStream = new FileInputStream(sourceFile);
+    copyFile(inputStream, outputStream);
+  }
+
+  private static void copyFile(File sourceFile, File destFile) throws IOException {
+    InputStream inputStream = new FileInputStream(sourceFile);
+    OutputStream outputStream = new FileOutputStream(destFile);
+    copyFile(inputStream, outputStream);
+  }
+
+  private static void copyFile(InputStream inputStream, OutputStream outputStream) throws IOException {
+    try {
+      byte[] buffer = new byte[1024];
+      int length;
+      while ((length = inputStream.read(buffer)) > 0) {
+        outputStream.write(buffer, 0, length);
+      }
+
+    } finally {
+      if (inputStream != null) {
+        inputStream.close();
+      }
+      if (outputStream != null) {
+        outputStream.close();
+      }
+    }
+  }
+}

package/android/src/main/java/com/shakebug/utils/VideoTrimmerUtil.java

@@ -0,0 +1,89 @@
+package com.shakebug.utils;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.media.MediaMetadataRetriever;
+import android.net.Uri;
+import com.arthenica.ffmpegkit.FFmpegKit;
+import com.arthenica.ffmpegkit.ReturnCode;
+import com.arthenica.ffmpegkit.SessionState;
+import com.shakebug.DeviceUtil;
+import com.shakebug.UnitConverter;
+import com.shakebug.callback.SingleCallback;
+import com.shakebug.interfaces.VideoTrimListener;
+import com.shakebug.thread.BackgroundExecutor;
+
+public class VideoTrimmerUtil {
+
+  private static final String TAG = VideoTrimmerUtil.class.getSimpleName();
+  public static final String FILE_PREFIX = "trimmedVideo";
+  public static final long MIN_SHOOT_DURATION = 3000L;// min 3 seconds for trimming
+//  public static final int VIDEO_MAX_TIME = 10;// max 10 seconds for trimming
+//  public static final long MAX_SHOOT_DURATION = VIDEO_MAX_TIME * 1000L;
+  public static long maxShootDuration = 10 * 1000L;
+  public static int MAX_COUNT_RANGE = 10;  // how many images in the highlight range of seek bar
+  public static int SCREEN_WIDTH_FULL = DeviceUtil.getDeviceWidth();
+  public static final int RECYCLER_VIEW_PADDING = UnitConverter.dpToPx(35);
+  public static int VIDEO_FRAMES_WIDTH = SCREEN_WIDTH_FULL - RECYCLER_VIEW_PADDING * 2;
+//  public static final int THUMB_WIDTH = (SCREEN_WIDTH_FULL - RECYCLER_VIEW_PADDING * 2) / VIDEO_MAX_TIME;
+  public static int mThumbWidth = 0; // make it automatic
+  public static final int THUMB_HEIGHT = UnitConverter.dpToPx(50); // x2 for better resolution
+  private static final int THUMB_RESOLUTION_RES = 2; // double thumb resolution for better quality
+
+  public static void trim(String inputFile, String outputFile, int videoDuration, long startMs, long endMs, final VideoTrimListener callback) {
+    String cmd = "-i " + inputFile + " -ss " + startMs + "ms" + " -to " + endMs + "ms -c copy " + outputFile;
+    callback.onStartTrim();
+    FFmpegKit.executeAsync(cmd, session -> {
+      SessionState state = session.getState();
+      ReturnCode returnCode = session.getReturnCode();
+
+      if (ReturnCode.isSuccess(returnCode)) {
+        // SUCCESS
+        callback.onFinishTrim(outputFile);
+      }
+      else {
+        // CANCEL + FAILURE
+        String errorMessage = String.format("Command failed with state %s and rc %s.%s", state, returnCode, session.getFailStackTrace());
+        callback.onError(errorMessage);
+      }
+    }, log -> {
+
+    }, statistics -> {
+      int timeInMilliseconds = (int) statistics.getTime();
+      if (timeInMilliseconds > 0) {
+        int completePercentage =
+          (timeInMilliseconds * 100) / videoDuration;
+        callback.onTrimmingProgress(Math.min(Math.max(completePercentage, 0), 100));
+      }
+    });
+  }
+
+  public static void shootVideoThumbInBackground(final Context context, final Uri videoUri, final int totalThumbsCount, final long startPosition,
+                                                 final long endPosition, final SingleCallback<Bitmap, Integer> callback) {
+    BackgroundExecutor.execute(new BackgroundExecutor.Task("", 0L, "") {
+      @Override public void execute() {
+        try {
+          MediaMetadataRetriever mediaMetadataRetriever = new MediaMetadataRetriever();
+          mediaMetadataRetriever.setDataSource(context, videoUri);
+          // Retrieve media data use microsecond
+          long interval = (endPosition - startPosition) / (totalThumbsCount - 1);
+          for (long i = 0; i < totalThumbsCount; ++i) {
+            long frameTime = startPosition + interval * i;
+            Bitmap bitmap = mediaMetadataRetriever.getFrameAtTime(frameTime * 1000, MediaMetadataRetriever.OPTION_CLOSEST_SYNC);
+            if(bitmap == null) continue;
+            try {
+              bitmap = Bitmap.createScaledBitmap(bitmap, mThumbWidth * THUMB_RESOLUTION_RES, THUMB_HEIGHT * THUMB_RESOLUTION_RES, false);
+            } catch (final Throwable t) {
+              t.printStackTrace();
+            }
+            callback.onSingleCallback(bitmap, (int) interval);
+          }
+          mediaMetadataRetriever.release();
+        } catch (final Throwable e) {
+          Thread.getDefaultUncaughtExceptionHandler().uncaughtException(Thread.currentThread(), e);
+        }
+      }
+    });
+  }
+}
+