react-native-video-trim 0.0.1 → 1.0.1

package/android/src/main/java/com/videotrim/adapters/VideoTrimmerAdapter.java

@@ -0,0 +1,60 @@
+package com.videotrim.adapters;
+
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.videotrim.R;
+import com.videotrim.utils.VideoTrimmerUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class VideoTrimmerAdapter extends RecyclerView.Adapter {
+  private List<Bitmap> mBitmaps = new ArrayList<>();
+  private LayoutInflater mInflater;
+  private Context context;
+
+  public VideoTrimmerAdapter(Context context) {
+    this.context = context;
+    this.mInflater = LayoutInflater.from(context);
+  }
+
+  @NonNull @Override public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+    return new TrimmerViewHolder(mInflater.inflate(R.layout.video_thumb_item_layout, parent, false));
+  }
+
+  @Override public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
+    ((TrimmerViewHolder) holder).thumbImageView.setImageBitmap(mBitmaps.get(position));
+  }
+
+  @Override public int getItemCount() {
+    return mBitmaps.size();
+  }
+
+  public void addBitmaps(Bitmap bitmap) {
+    mBitmaps.add(bitmap);
+    notifyDataSetChanged();
+  }
+
+  private final class TrimmerViewHolder extends RecyclerView.ViewHolder {
+    ImageView thumbImageView;
+
+    TrimmerViewHolder(View itemView) {
+      super(itemView);
+      thumbImageView = itemView.findViewById(R.id.thumb);
+      LinearLayout.LayoutParams layoutParams = (LinearLayout.LayoutParams) thumbImageView.getLayoutParams();
+      layoutParams.width = VideoTrimmerUtil.VIDEO_FRAMES_WIDTH / VideoTrimmerUtil.MAX_COUNT_RANGE;
+      thumbImageView.setLayoutParams(layoutParams);
+    }
+  }
+}
+

package/android/src/main/java/com/videotrim/interfaces/IVideoTrimmerView.java

@@ -0,0 +1,5 @@
+package com.videotrim.interfaces;
+
+public interface IVideoTrimmerView {
+  void onDestroy();
+}

package/android/src/main/java/com/videotrim/interfaces/VideoTrimListener.java

@@ -0,0 +1,9 @@
+package com.videotrim.interfaces;
+
+public interface VideoTrimListener {
+  void onStartTrim();
+  void onTrimmingProgress(int percentage);
+  void onFinishTrim(String url);
+  void onError();
+  void onCancel();
+}

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

@@ -0,0 +1,277 @@
+package com.videotrim.utils;
+
+import android.Manifest;
+import android.annotation.SuppressLint;
+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 android.util.Log;
+
+import androidx.fragment.app.FragmentActivity;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.permissionx.guolindev.PermissionX;
+
+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.Locale;
+
+import iknow.android.utils.BaseUtils;
+import iknow.android.utils.BuildConfig;
+
+
+@SuppressWarnings({ "ResultOfMethodCallIgnored", "FieldCanBeLocal" })
+public class StorageUtil {
+
+  private static final String TAG = "StorageUtil";
+  private static String APP_DATA_PATH = "/Android/data/" + BuildConfig.APPLICATION_ID;
+
+  private static String sDataDir;
+  private static String sCacheDir;
+
+  public static String getAppDataDir() {
+    if (TextUtils.isEmpty(sDataDir)) {
+      try {
+        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
+          sDataDir = Environment.getExternalStorageDirectory().getPath() + APP_DATA_PATH;
+          if (TextUtils.isEmpty(sDataDir)) {
+            sDataDir = BaseUtils.getContext().getFilesDir().getAbsolutePath();
+          }
+        } else {
+          sDataDir = BaseUtils.getContext().getFilesDir().getAbsolutePath();
+        }
+      } catch (Throwable e) {
+        e.printStackTrace();
+        sDataDir = BaseUtils.getContext().getFilesDir().getAbsolutePath();
+      }
+      File file = new File(sDataDir);
+      if (!file.exists()) {//判断文件目录是否存在
+        file.mkdirs();
+      }
+    }
+    return sDataDir;
+  }
+
+  public static String getCacheDir() {
+    if (TextUtils.isEmpty(sCacheDir)) {
+      File file = null;
+      Context context = BaseUtils.getContext();
+      try {
+        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
+          file = context.getExternalCacheDir();
+          if (file == null || !file.exists()) {
+            file = getExternalCacheDirManual(context);
+          }
+        }
+        if (file == null) {
+          file = context.getCacheDir();
+          if (file == null || !file.exists()) {
+            file = getCacheDirManual(context);
+          }
+        }
+        Log.w(TAG, "cache dir = " + file.getAbsolutePath());
+        sCacheDir = file.getAbsolutePath();
+      } catch (Throwable ignored) {
+      }
+    }
+    return sCacheDir;
+  }
+
+  private static File getExternalCacheDirManual(Context context) {
+    File dataDir = new File(new File(Environment.getExternalStorageDirectory(), "Android"), "data");
+    File appCacheDir = new File(new File(dataDir, context.getPackageName()), "cache");
+    if (!appCacheDir.exists()) {
+      if (!appCacheDir.mkdirs()) {//
+        Log.w(TAG, "Unable to create external cache directory");
+        return null;
+      }
+      try {
+        new File(appCacheDir, ".nomedia").createNewFile();
+      } catch (IOException e) {
+        Log.i(TAG, "Can't create \".nomedia\" file in application external cache directory");
+      }
+    }
+    return appCacheDir;
+  }
+
+  @SuppressLint("SdCardPath")
+  private static File getCacheDirManual(Context context) {
+    String cacheDirPath = "/data/data/" + context.getPackageName() + "/cache";
+    return new File(cacheDirPath);
+  }
+
+  public static boolean delFiles(String path) {
+    File cacheFile = new File(path);
+    if (!cacheFile.exists()) {
+      return false;
+    }
+    File[] files = cacheFile.listFiles();
+    for (int i = 0; i < files.length; i++) {
+      // 是文件则直接删除
+      if (files[i].exists() && files[i].isFile()) {
+        files[i].delete();
+      } else if (files[i].exists() && files[i].isDirectory()) {
+        // 递归删除文件
+        delFiles(files[i].getAbsolutePath());
+        // 删除完目录下面的所有文件后再删除该文件夹
+        files[i].delete();
+      }
+    }
+
+    return true;
+  }
+
+  public static long sizeOfDirectory(File dir) {
+    if (dir.exists()) {
+      long result = 0;
+      File[] fileList = dir.listFiles();
+      for (int i = 0; i < fileList.length; i++) {
+        // Recursive call if it's a directory
+        if (fileList[i].isDirectory()) {
+          result += sizeOfDirectory(fileList[i]);
+        } else {
+          // Sum the file size in bytes
+          result += fileList[i].length();
+        }
+      }
+      return result; // return the file size
+    }
+    return 0;
+  }
+
+  /**
+   * @param length 长度 byte为单位
+   *               将文件大小转换为KB,MB格式
+   */
+  public static String getFileSize(long length) {
+    int MB = 1024 * 1024;
+    if (length < MB) {
+      double resultKB = length * 1.0 / 1024;
+      return String.format(Locale.getDefault(), "%.1f", resultKB) + "Kb";
+    }
+    double resultMB = length * 1.0 / MB;
+    return String.format(Locale.getDefault(), "%.1f", resultMB) + "Mb";
+  }
+
+  public static boolean isFileExist(String path) {
+    if (TextUtils.isEmpty(path)) return false;
+    File file = new File(path);
+    return file.exists();
+  }
+
+  /**
+   * @param path 路径
+   * @return 是否删除成功
+   */
+  public static boolean deleteFile(String path) {
+    if (TextUtils.isEmpty(path)) return true;
+    return deleteFile(new File(path));
+  }
+
+  /**
+   * @return 是否删除成功
+   */
+  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);
+        if (outputStream != null) {
+          // Copy the video file to the output stream
+          // Here, you can use the method you have to copy the file contents
+          // For example, you can use FileInputStream to read from videoFile and write to outputStream
+
+          outputStream.close();
+          // Notify the media scanner that a new video has been added to the gallery
+          MediaScannerConnection.scanFile(context, new String[]{videoFile.getAbsolutePath()}, 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, File destFile) throws IOException {
+    InputStream inputStream = null;
+    OutputStream outputStream = null;
+
+    try {
+      inputStream = new FileInputStream(sourceFile);
+      outputStream = new FileOutputStream(destFile);
+
+      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/videotrim/utils/VideoTrimmerUtil.java

@@ -0,0 +1,109 @@
+package com.videotrim.utils;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.media.MediaMetadataRetriever;
+import android.net.Uri;
+import android.util.Log;
+
+import com.arthenica.ffmpegkit.FFmpegKit;
+import com.arthenica.ffmpegkit.FFmpegSession;
+import com.arthenica.ffmpegkit.FFmpegSessionCompleteCallback;
+import com.arthenica.ffmpegkit.LogCallback;
+import com.arthenica.ffmpegkit.ReturnCode;
+import com.arthenica.ffmpegkit.SessionState;
+import com.arthenica.ffmpegkit.Statistics;
+import com.arthenica.ffmpegkit.StatisticsCallback;
+import com.videotrim.interfaces.VideoTrimListener;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+import iknow.android.utils.DeviceUtil;
+import iknow.android.utils.UnitConverter;
+import iknow.android.utils.callback.SingleCallback;
+import iknow.android.utils.thread.BackgroundExecutor;
+
+public class VideoTrimmerUtil {
+
+  private static final String TAG = VideoTrimmerUtil.class.getSimpleName();
+  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 final int MAX_COUNT_RANGE = 10;  // how many images in the highlight range of seek bar
+  public static final int SCREEN_WIDTH_FULL = DeviceUtil.getDeviceWidth();
+  public static final int RECYCLER_VIEW_PADDING = UnitConverter.dpToPx(35);
+  public static final 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(Context context, String inputFile, String outputFile, int videoDuration, long startMs, long endMs, final VideoTrimListener callback) {
+    final String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(new Date());
+    final String outputName = "trimmedVideo_" + timeStamp + ".mp4";
+    outputFile = outputFile + "/" + outputName;
+
+    String cmd = "-i " + inputFile + " -ss " + startMs + "ms" + " -to " + endMs + "ms -c copy " + outputFile;
+    String[] command = cmd.split(" ");
+    final String tempOutFile = outputFile;
+
+    callback.onStartTrim();
+    FFmpegKit.executeAsync(cmd, session -> {
+      SessionState state = session.getState();
+      ReturnCode returnCode = session.getReturnCode();
+
+      Log.d(TAG, String.format("FFmpeg process exited with state %s and rc %s.%s", state, returnCode, session.getFailStackTrace()));
+
+      if (state.equals(SessionState.COMPLETED)) {
+        callback.onFinishTrim(tempOutFile);
+      } else {
+        callback.onError();
+      }
+    }, log -> {
+
+    }, statistics -> {
+      int timeInMilliseconds = 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 {
+              if (mThumbWidth <= 0) { // only take first item
+                int width = THUMB_HEIGHT * bitmap.getWidth() / bitmap.getHeight();
+                mThumbWidth = width;
+              }
+              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);
+        }
+      }
+    });
+  }
+}
+