react-native-video-trim 3.0.9 → 4.0.0

package/android/src/main/java/com/{videotrim → margelo/nitro/videotrim}/utils/StorageUtil.java

@@ -1,4 +1,4 @@
-package com.videotrim.utils;
+package com.margelo.nitro.videotrim.utils;
 
 import android.content.ContentValues;
 import android.content.Context;
@@ -8,7 +8,9 @@ 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;

package/android/src/main/java/com/margelo/nitro/videotrim/utils/VideoTrimmerUtil.java

@@ -0,0 +1,157 @@
+package com.margelo.nitro.videotrim.utils;
+
+import android.annotation.SuppressLint;
+import android.graphics.Bitmap;
+import android.media.MediaMetadataRetriever;
+import android.util.Log;
+
+import com.arthenica.ffmpegkit.FFmpegKit;
+import com.arthenica.ffmpegkit.FFmpegSession;
+import com.arthenica.ffmpegkit.ReturnCode;
+import com.arthenica.ffmpegkit.SessionState;
+import com.margelo.nitro.videotrim.enums.ErrorCode;
+import com.margelo.nitro.videotrim.interfaces.VideoTrimListener;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TimeZone;
+
+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 String FILE_PREFIX = "trimmedVideo";
+  public static final long MIN_SHOOT_DURATION = 1000L;// 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 String DEFAULT_AUDIO_EXTENSION = ".wav";
+  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
+  public static final int THUMB_WIDTH = UnitConverter.dpToPx(25); // x2 for better resolution
+  private static final int THUMB_RESOLUTION_RES = 2; // double thumb resolution for better quality
+
+  public static FFmpegSession trim(String inputFile, String outputFile, int videoDuration, long startMs, long endMs, final VideoTrimListener callback) {
+    // Get the current date and time
+    Date currentDate = new Date();
+
+    // Create a SimpleDateFormat object with the desired format
+    @SuppressLint("SimpleDateFormat") SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
+
+    // Set the timezone to UTC
+    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+    // Format the current date and time
+    String formattedDateTime = dateFormat.format(currentDate);
+
+    String[] cmds = {
+      "-ss",
+      startMs + "ms",
+      "-to",
+      endMs + "ms",
+      "-i",
+      inputFile,
+      "-c",
+      "copy",
+      "-metadata",
+      "creation_time=" + formattedDateTime,
+      outputFile
+    };
+    Log.d(TAG,"Command111: " + String.join(",", cmds));
+
+    FFmpegSession s = FFmpegKit.execute("-protocols");
+    Log.d(TAG, "1111getOutput: " + s.getOutput());
+    Log.d(TAG, "1111getAllLogs: " + s.getAllLogs());
+
+    return FFmpegKit.executeWithArgumentsAsync(cmds, session -> {
+      SessionState state = session.getState();
+      ReturnCode returnCode = session.getReturnCode();
+      if (ReturnCode.isSuccess(session.getReturnCode())) {
+        // SUCCESS
+        callback.onFinishTrim(outputFile, startMs, endMs, videoDuration);
+      } else if (ReturnCode.isCancel(session.getReturnCode())) {
+        // CANCEL
+        callback.onCancelTrim();
+      } else {
+        // FAILURE
+        String errorMessage = String.format("Command failed with state %s and rc %s.%s", state, returnCode, session.getFailStackTrace());
+        callback.onError(errorMessage, ErrorCode.TRIMMING_FAILED);
+      }
+    }, log -> {
+      Log.d(TAG, "FFmpeg process started with log " + log.getMessage());
+
+      Map<String, String> map = new HashMap<>();
+      map.put("level", String.valueOf(log.getLevel().getValue()));
+      map.put("message", log.getMessage());
+      map.put("sessionId", String.valueOf(log.getSessionId()));
+      map.put("logStr", log.toString());
+
+      callback.onLog(map);
+    }, statistics -> {
+      int timeInMilliseconds = (int) statistics.getTime();
+      if (timeInMilliseconds > 0) {
+        int completePercentage =
+          (timeInMilliseconds * 100) / videoDuration;
+        callback.onTrimmingProgress(Math.min(Math.max(completePercentage, 0), 100));
+      }
+
+      Map<String, String> map = new HashMap<>();
+      map.put("sessionId", String.valueOf(statistics.getSessionId()));
+      map.put("videoFrameNumber", String.valueOf(statistics.getVideoFrameNumber()));
+      map.put("videoFps", String.valueOf(statistics.getVideoFps()));
+      map.put("videoQuality", String.valueOf(statistics.getVideoQuality()));
+      map.put("size", String.valueOf(statistics.getSize()));
+      map.put("time", String.valueOf(statistics.getTime()));
+      map.put("bitrate", String.valueOf(statistics.getBitrate()));
+      map.put("speed", String.valueOf(statistics.getSpeed()));
+      map.put("statisticsStr", statistics.toString());
+      callback.onStatistics(map);
+    });
+  }
+
+  public static void shootVideoThumbInBackground(final MediaMetadataRetriever mediaMetadataRetriever, 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 {
+          // 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;
+            try {
+              bitmap = mediaMetadataRetriever.getFrameAtTime(frameTime * 1000, MediaMetadataRetriever.OPTION_CLOSEST_SYNC);
+            } catch (final Throwable t) {
+              // this can happen while thumbnails are being generated in background and we press Cancel
+              t.printStackTrace();
+              break;
+            }
+
+            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);
+          }
+        } catch (final Throwable e) {
+          Thread.getDefaultUncaughtExceptionHandler().uncaughtException(Thread.currentThread(), e);
+        }
+      }
+    });
+  }
+}
+

package/android/src/main/java/com/{videotrim → margelo/nitro/videotrim}/widgets/VideoTrimmerView.java

@@ -1,8 +1,8 @@
-package com.videotrim.widgets;
+package com.margelo.nitro.videotrim.widgets;
 
 import static com.facebook.react.bridge.UiThreadUtil.runOnUiThread;
-import static com.videotrim.utils.VideoTrimmerUtil.RECYCLER_VIEW_PADDING;
-import static com.videotrim.utils.VideoTrimmerUtil.VIDEO_FRAMES_WIDTH;
+import static com.margelo.nitro.videotrim.utils.VideoTrimmerUtil.RECYCLER_VIEW_PADDING;
+import static com.margelo.nitro.videotrim.utils.VideoTrimmerUtil.VIDEO_FRAMES_WIDTH;
 
 import android.content.Context;
 import android.content.pm.ActivityInfo;
@@ -32,15 +32,16 @@ import android.widget.VideoView;
 
 import androidx.appcompat.app.AlertDialog;
 
+import com.arthenica.ffmpegkit.FFmpegSession;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReadableMap;
-import com.videotrim.R;
-import com.videotrim.enums.ErrorCode;
-import com.videotrim.interfaces.IVideoTrimmerView;
-import com.videotrim.interfaces.VideoTrimListener;
-import com.videotrim.utils.MediaMetadataUtil;
-import com.videotrim.utils.StorageUtil;
-import com.videotrim.utils.VideoTrimmerUtil;
+import com.margelo.nitro.videotrim.EditorConfig;
+import com.margelo.nitro.videotrim.R;
+import com.margelo.nitro.videotrim.enums.ErrorCode;
+import com.margelo.nitro.videotrim.interfaces.IVideoTrimmerView;
+import com.margelo.nitro.videotrim.interfaces.VideoTrimListener;
+import com.margelo.nitro.videotrim.utils.MediaMetadataUtil;
+import com.margelo.nitro.videotrim.utils.StorageUtil;
+import com.margelo.nitro.videotrim.utils.VideoTrimmerUtil;
 
 import java.io.IOException;
 import java.util.Locale;
@@ -108,23 +109,23 @@ public class VideoTrimmerView extends FrameLayout implements IVideoTrimmerView {
   private long jumpToPositionOnLoad = 0;
   private FrameLayout headerView;
   private TextView headerText;
-  private VideoTrimmerUtil.TrimSession trimSession;
+  private FFmpegSession ffmpegSession;
   private boolean alertOnFailToLoad = true;
   private String alertOnFailTitle = "Error";
   private String alertOnFailMessage = "Fail to load media. Possibly invalid file or no network connection";
   private String alertOnFailCloseText = "Close";
   private View currentSelectedhandle;
 
-  public VideoTrimmerView(ReactApplicationContext context, ReadableMap config, AttributeSet attrs) {
+  public VideoTrimmerView(ReactApplicationContext context, EditorConfig config, AttributeSet attrs) {
     this(context, attrs, 0, config);
   }
 
-  public VideoTrimmerView(ReactApplicationContext context, AttributeSet attrs, int defStyleAttr, ReadableMap config) {
+  public VideoTrimmerView(ReactApplicationContext context, AttributeSet attrs, int defStyleAttr, EditorConfig config) {
     super(context, attrs, defStyleAttr);
     init(context, config);
   }
 
-  private void init(ReactApplicationContext context, ReadableMap config) {
+  private void init(ReactApplicationContext context, EditorConfig config) {
     this.mContext = context;
 
     context.getCurrentActivity().setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
@@ -365,22 +366,21 @@ public class VideoTrimmerView extends FrameLayout implements IVideoTrimmerView {
     setHandleTouchListener(trailingHandle, false);
   }
 
-  public void onSaveClicked(float progressUpdateInterval) {
+  public void onSaveClicked() {
     onMediaPause();
-    trimSession = VideoTrimmerUtil.trim(
+    ffmpegSession = VideoTrimmerUtil.trim(
       mSourceUri.toString(),
       StorageUtil.getOutputPath(mContext, mOutputExt),
       mDuration,
       startTime,
       endTime,
-      mOnTrimVideoListener,
-      progressUpdateInterval
+      mOnTrimVideoListener
     );
   }
 
   public void onCancelTrimClicked() {
-    if (trimSession != null) {
-      trimSession.cancel();
+    if (ffmpegSession != null) {
+      ffmpegSession.cancel();
     } else {
       mOnTrimVideoListener.onCancelTrim();
     }
@@ -445,79 +445,51 @@ public class VideoTrimmerView extends FrameLayout implements IVideoTrimmerView {
     return screenWidth;
   }
 
-  private void configure(ReadableMap config) {
-    if (config.hasKey("maxDuration")) {
-      mMaxDuration = Math.max(0, config.getInt("maxDuration") * 1000L);
+  private void configure(EditorConfig config) {
+    if (config.getMaxDuration() > 0) {
+      mMaxDuration = (long) Math.max(0, config.getMaxDuration() * 1000L);
     }
-    if (config.hasKey("minDuration")) {
-      mMinDuration = Math.max(1000L, config.getInt("minDuration") * 1000L);
-    }
-    if (config.hasKey("cancelButtonText")) {
-      cancelBtn.setText(config.getString("cancelButtonText"));
-    }
-    if (config.hasKey("saveButtonText")) {
-      saveBtn.setText(config.getString("saveButtonText"));
+
+    if (config.getMinDuration() > 0) {
+      mMinDuration = (long) Math.max(1000L, config.getMinDuration() * 1000L);
     }
 
-    if (config.hasKey("type")) {
-      isVideoType = !config.getString("type").equals("audio");
+    cancelBtn.setText(config.getCancelButtonText());
 
-//      if (!isVideoType) {
-//        mThumbnailContainer.setAlpha(0f);
-//        mThumbnailContainer.setBackground(ContextCompat.getDrawable(mContext, R.drawable.thumb_container_bg));
-//      }
-    }
+    saveBtn.setText(config.getSaveButtonText());
 
-    if (config.hasKey("outputExt")) {
-      mOutputExt = config.getString("outputExt");
-    } else if (!isVideoType) {
-      mOutputExt = "wav";
-    }
+    isVideoType = config.getType().equals("video");
 
-    if (config.hasKey("enableHapticFeedback")) {
-      enableHapticFeedback = config.getBoolean("enableHapticFeedback");
+    mOutputExt = config.getOutputExt();
+    if (!isVideoType) {
+      mOutputExt = "wav";
     }
 
-    if (config.hasKey("autoplay")) {
-      autoplay = config.getBoolean("autoplay");
-    }
+    enableHapticFeedback = config.getEnableHapticFeedback();
+    autoplay = config.getAutoplay();
 
-    if (config.hasKey("jumpToPositionOnLoad")) {
-      jumpToPositionOnLoad = config.getInt("jumpToPositionOnLoad");
+    if (config.getJumpToPositionOnLoad() > 0) {
+      jumpToPositionOnLoad = (long) config.getJumpToPositionOnLoad();
     }
-    // check if config.getString("headerText") is not empty
 
-    if (config.hasKey("headerText") && !config.getString("headerText").isEmpty()){
-      headerText.setText(config.getString("headerText"));
+      headerText.setText(config.getHeaderText());
 
-      if (config.hasKey("headerTextSize")) {
-        int textSize = config.getInt("headerTextSize");
+        int textSize = (int) config.getHeaderTextSize();
         if (textSize < 0) {
           textSize = 16;
         }
         headerText.setTextSize(TypedValue.COMPLEX_UNIT_DIP, textSize);
-      }
-
-      if (config.hasKey("headerTextColor")) {
-        headerText.setTextColor(config.getInt("headerTextColor"));
-      }
+        headerText.setTextColor((int) config.getHeaderTextColor());
 
       headerView.setVisibility(View.VISIBLE);
-    }
 
-    alertOnFailToLoad = !config.hasKey("alertOnFailToLoad") || config.getBoolean("alertOnFailToLoad");
+    alertOnFailToLoad = config.getAlertOnFailToLoad();
 
-    if (config.hasKey("alertOnFailTitle")) {
-      alertOnFailTitle = config.getString("alertOnFailTitle");
-    }
+      alertOnFailTitle = config.getAlertOnFailTitle();
 
-    if (config.hasKey("alertOnFailMessage")) {
-      alertOnFailMessage = config.getString("alertOnFailMessage");
-    }
+      alertOnFailMessage = config.getAlertOnFailMessage();
 
-    if (config.hasKey("alertOnFailCloseText")) {
-      alertOnFailCloseText = config.getString("alertOnFailCloseText");
-    }
+      alertOnFailCloseText = config.getAlertOnFailCloseText();
   }
 
   private void startTimingRunnable() {

package/ios/AssetLoader.swift

@@ -1,8 +1,8 @@
 //
 //  AssetLoader.swift
-//  react-native-video-trim
+//  VideoTrim
 //
-//  Created by Duc Trung Mai on 7/27/24.
+//  Created by Duc Trung Mai on 20/5/25.
 //
 
 import AVFoundation

package/ios/ErrorCode.swift

@@ -1,8 +1,8 @@
 //
 //  ErrorCode.swift
-//  react-native-video-trim
+//  VideoTrim
 //
-//  Created by ByteDance on 7/27/24.
+//  Created by Duc Trung Mai on 20/5/25.
 //
 
 import Foundation

package/ios/ProgressAlertController.swift

@@ -1,8 +1,8 @@
 //
 //  ProgressAlertController.swift
-//  react-native-video-trim
+//  VideoTrim
 //
-//  Created by Duc Trung Mai on 8/18/24.
+//  Created by Duc Trung Mai on 20/5/25.
 //
 
 import UIKit