react-native-video-trim 2.0.0 → 2.2.0

package/android/src/main/java/com/videotrim/VideoTrimModule.java

@@ -1,15 +1,21 @@
 package com.videotrim;
 
+import static android.app.Activity.RESULT_OK;
 import static com.facebook.react.bridge.UiThreadUtil.runOnUiThread;
 
 import android.app.Activity;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
 import android.content.res.ColorStateList;
 import android.graphics.Color;
-import android.media.MediaMetadataRetriever;
 import android.net.Uri;
 import android.os.Build;
+import android.util.Log;
+import android.util.TypedValue;
 import android.view.Gravity;
 import android.view.ViewGroup;
+import android.widget.Button;
 import android.widget.LinearLayout;
 import android.widget.ProgressBar;
 import android.widget.TextView;
@@ -17,8 +23,12 @@ import android.widget.TextView;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.appcompat.app.AlertDialog;
+import androidx.core.content.ContextCompat;
+import androidx.core.content.FileProvider;
 
+import com.facebook.react.bridge.ActivityEventListener;
 import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.BaseActivityEventListener;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -29,25 +39,43 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.videotrim.enums.ErrorCode;
 import com.videotrim.interfaces.VideoTrimListener;
+import com.videotrim.utils.MediaMetadataUtil;
 import com.videotrim.utils.StorageUtil;
+import com.videotrim.utils.VideoTrimmerUtil;
 import com.videotrim.widgets.VideoTrimmerView;
 
+import android.content.Intent;
+
+import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Objects;
+
 import iknow.android.utils.BaseUtils;
 
 @ReactModule(name = VideoTrimModule.NAME)
 public class VideoTrimModule extends ReactContextBaseJavaModule implements VideoTrimListener, LifecycleEventListener {
+  private static final String TAG = VideoTrimmerUtil.class.getSimpleName();
+
   public static final String NAME = "VideoTrim";
   private static Boolean isInit = false;
   private VideoTrimmerView trimmerView;
   private AlertDialog alertDialog;
   private AlertDialog mProgressDialog;
+  private AlertDialog cancelTrimmingConfirmDialog;
   private ProgressBar mProgressBar;
   private int listenerCount = 0;
-
-  private Promise showEditorPromise;
-
+  private boolean enableCancelTrimming = true;
+
+  private String cancelTrimmingButtonText = "Cancel";
+  private boolean enableCancelTrimmingDialog = true;
+  private String cancelTrimmingDialogTitle = "Warning!";
+  private String cancelTrimmingDialogMessage = "Are you sure want to cancel trimming?";
+  private String cancelTrimmingDialogCancelText = "Close";
+  private String cancelTrimmingDialogConfirmText = "Proceed";
   private boolean enableCancelDialog = true;
   private String cancelDialogTitle = "Warning!";
   private String cancelDialogMessage = "Are you sure want to cancel?";
@@ -57,11 +85,66 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
   private String saveDialogTitle = "Confirmation!";
   private String saveDialogMessage = "Are you sure want to save?";
   private String saveDialogCancelText = "Close";
-  private String saveDialogConfirmText  = "Proceed";
+  private String saveDialogConfirmText = "Proceed";
   private String trimmingText = "Trimming video...";
+  private String outputFile;
+  private boolean saveToPhoto = false;
+  private boolean removeAfterSavedToPhoto = false;
+  private boolean removeAfterFailedToSavePhoto = false;
+  private boolean removeAfterSavedToDocuments = false;
+  private boolean removeAfterFailedToSaveDocuments = false;
+  //  private boolean removeAfterShared = false; // TODO: on Android there's no way to know if user shared the file or share sheet closed
+//  private boolean removeAfterFailedToShare = false; // TODO: implement this
+  private boolean openDocumentsOnFinish = false;
+  private boolean openShareSheetOnFinish = false;
+  private boolean isVideoType = true;
+  private boolean closeWhenFinish = true;
+
+  private static final int REQUEST_CODE_SAVE_FILE = 1;
 
   public VideoTrimModule(ReactApplicationContext reactContext) {
     super(reactContext);
+    ActivityEventListener mActivityEventListener = new BaseActivityEventListener() {
+
+      @Override
+      public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent intent) {
+        if (requestCode == REQUEST_CODE_SAVE_FILE && resultCode == RESULT_OK) {
+          Uri uri = intent.getData();
+          if (uri == null) {
+            return;
+          }
+          try {
+            OutputStream outputStream = reactContext.getContentResolver().openOutputStream(uri);
+            if (outputStream == null) {
+              return;
+            }
+            FileInputStream fileInputStream = new FileInputStream(outputFile);
+            byte[] buffer = new byte[1024];
+            int length;
+            while ((length = fileInputStream.read(buffer)) > 0) {
+              outputStream.write(buffer, 0, length);
+            }
+            outputStream.close();
+            fileInputStream.close();
+            // File saved successfully
+            Log.d(TAG, "File saved successfully to " + uri);
+            if (removeAfterSavedToDocuments) {
+              StorageUtil.deleteFile(outputFile);
+            }
+          } catch (Exception e) {
+            e.printStackTrace();
+            // Handle the error
+            onError("Failed to save edited video to Documents: " + e.getLocalizedMessage(), ErrorCode.FAIL_TO_SAVE_TO_DOCUMENTS);
+            if (removeAfterFailedToSaveDocuments) {
+              StorageUtil.deleteFile(outputFile);
+            }
+          } finally {
+            hideDialog(true);
+          }
+        }
+      }
+    };
+    reactContext.addActivityEventListener(mActivityEventListener);
   }
 
   @Override
@@ -72,32 +155,46 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
 
 
   @ReactMethod
-  public void showEditor(String videoPath, ReadableMap config, Promise promise) {
-    showEditorPromise = promise;
+  public void showEditor(String videoPath, ReadableMap config) {
     if (trimmerView != null || alertDialog != null) {
       return;
     }
+    enableCancelTrimming = !config.hasKey("enableCancelTrimming") || config.getBoolean("enableCancelTrimming");
 
-    if (!isValidVideo(videoPath)) {
-      WritableMap map = Arguments.createMap();
-      map.putString("message", "File is not a valid video");
-      sendEvent(getReactApplicationContext(), "onError", map);
-      return;
-    }
+    cancelTrimmingButtonText = config.hasKey("cancelTrimmingButtonText") ? config.getString("cancelTrimmingButtonText") : "Cancel";
+    enableCancelTrimmingDialog = !config.hasKey("enableCancelTrimmingDialog") || config.getBoolean("enableCancelTrimmingDialog");
+    cancelTrimmingDialogTitle = config.hasKey("cancelTrimmingDialogTitle") ? config.getString("cancelTrimmingDialogTitle") : "Warning!";
+    cancelTrimmingDialogMessage = config.hasKey("cancelTrimmingDialogMessage") ? config.getString("cancelTrimmingDialogMessage") : "Are you sure want to cancel trimming?";
+    cancelTrimmingDialogCancelText = config.hasKey("cancelTrimmingDialogCancelText") ? config.getString("cancelTrimmingDialogCancelText") : "Close";
+    cancelTrimmingDialogConfirmText = config.hasKey("cancelTrimmingDialogConfirmText") ? config.getString("cancelTrimmingDialogConfirmText") : "Proceed";
 
-    enableCancelDialog = config.hasKey("enableCancelDialog") ? config.getBoolean("enableCancelDialog") : true;
+    enableCancelDialog = !config.hasKey("enableCancelDialog") || config.getBoolean("enableCancelDialog");
     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";
 
-    enableSaveDialog = config.hasKey("enableSaveDialog") ? config.getBoolean("enableSaveDialog") : true;
+    enableSaveDialog = !config.hasKey("enableSaveDialog") || config.getBoolean("enableSaveDialog");
     saveDialogTitle = config.hasKey("saveDialogTitle") ? config.getString("saveDialogTitle") : "Confirmation!";
     saveDialogMessage = config.hasKey("saveDialogMessage") ? config.getString("saveDialogMessage") : "Are you sure want to save?";
     saveDialogCancelText = config.hasKey("saveDialogCancelText") ? config.getString("saveDialogCancelText") : "Close";
     saveDialogConfirmText = config.hasKey("saveDialogConfirmText") ? config.getString("saveDialogConfirmText") : "Proceed";
     trimmingText = config.hasKey("trimmingText") ? config.getString("trimmingText") : "Trimming video...";
 
+    saveToPhoto = config.hasKey("saveToPhoto") && config.getBoolean("saveToPhoto");
+    removeAfterSavedToPhoto = config.hasKey("removeAfterSavedToPhoto") && config.getBoolean("removeAfterSavedToPhoto");
+    removeAfterFailedToSavePhoto = config.hasKey("removeAfterFailedToSavePhoto") && config.getBoolean("removeAfterFailedToSavePhoto");
+    removeAfterSavedToDocuments = config.hasKey("removeAfterSavedToDocuments") && config.getBoolean("removeAfterSavedToDocuments");
+    removeAfterFailedToSaveDocuments = config.hasKey("removeAfterFailedToSaveDocuments") && config.getBoolean("removeAfterFailedToSaveDocuments");
+//    removeAfterShared = config.hasKey("removeAfterShared") && config.getBoolean("removeAfterShared");
+//    removeAfterFailedToShare = config.hasKey("removeAfterFailedToShare") && config.getBoolean("removeAfterFailedToShare");
+    openDocumentsOnFinish = config.hasKey("openDocumentsOnFinish") && config.getBoolean("openDocumentsOnFinish");
+    openShareSheetOnFinish = config.hasKey("openShareSheetOnFinish") && config.getBoolean("openShareSheetOnFinish");
+
+    isVideoType = !config.hasKey("type") || !Objects.equals(config.getString("type"), "audio");
+
+    closeWhenFinish = !config.hasKey("closeWhenFinish") || config.getBoolean("closeWhenFinish");
+
     Activity activity = getReactApplicationContext().getCurrentActivity();
 
     if (!isInit) {
@@ -110,7 +207,7 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
     runOnUiThread(() -> {
       trimmerView = new VideoTrimmerView(getReactApplicationContext(), config, null);
       trimmerView.setOnTrimVideoListener(this);
-      trimmerView.initVideoByURI(Uri.parse(videoPath));
+      trimmerView.initByURI(Uri.parse(videoPath));
 
       AlertDialog.Builder builder = new AlertDialog.Builder(activity, android.R.style.Theme_Black_NoTitleBar_Fullscreen);
       builder.setCancelable(false);
@@ -125,7 +222,7 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
           trimmerView.onDestroy();
           trimmerView = null;
         }
-        hideDialog();
+        hideDialog(true);
         sendEvent(getReactApplicationContext(), "onHide", null);
       });
       sendEvent(getReactApplicationContext(), "onShow", null);
@@ -140,29 +237,39 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
 
   @Override
   public void onHostResume() {
-
+    Log.d(TAG, "onHostResume: ");
   }
 
   @Override
   public void onHostPause() {
+    Log.d(TAG, "onHostPause: ");
     if (trimmerView != null) {
-      trimmerView.onVideoPause();
+      trimmerView.onMediaPause();
     }
   }
 
   @Override
   public void onHostDestroy() {
-    hideDialog();
+    hideDialog(true);
   }
 
-  @Override public void onStartTrim() {
+  @Override
+  public void onLoad(int duration) {
+    WritableMap map = Arguments.createMap();
+    map.putInt("duration", duration);
+    sendEvent(getReactApplicationContext(), "onLoad", map);
+  }
+
+  @Override
+  public void onStartTrim() {
     sendEvent(getReactApplicationContext(), "onStartTrimming", null);
     runOnUiThread(() -> {
       buildDialog();
     });
   }
 
-  @Override public void onTrimmingProgress(int percentage) {
+  @Override
+  public void onTrimmingProgress(int percentage) {
     // prevent onTrimmingProgress is called after onFinishTrim (some rare cases)
     if (mProgressBar == null) {
       return;
@@ -176,7 +283,9 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
   }
 
 
-  @Override public void onFinishTrim(String in, long startTime, long endTime, int duration) {
+  @Override
+  public void onFinishTrim(String in, long startTime, long endTime, int duration) {
+    outputFile = in;
     runOnUiThread(() -> {
       WritableMap map = Arguments.createMap();
       map.putString("outputPath", in);
@@ -184,21 +293,50 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
       map.putDouble("startTime", (double) startTime);
       map.putDouble("endTime", (double) endTime);
       sendEvent(getReactApplicationContext(), "onFinishTrimming", map);
-      showEditorPromise.resolve(in);
     });
+
+    if (saveToPhoto && isVideoType) {
+      try {
+        StorageUtil.saveVideoToGallery(getReactApplicationContext(), in);
+        Log.d(TAG, "Edited video saved to Photo Library successfully.");
+        if (removeAfterSavedToPhoto) {
+          StorageUtil.deleteFile(in);
+        }
+      } catch (IOException e) {
+        e.printStackTrace();
+        onError("Failed to save edited video to Photo Library: " + e.getLocalizedMessage(), ErrorCode.FAIL_TO_SAVE_TO_PHOTO);
+        if (removeAfterFailedToSavePhoto) {
+          StorageUtil.deleteFile(in);
+        }
+      } finally {
+        hideDialog(closeWhenFinish);
+      }
+    } else if (openDocumentsOnFinish) {
+      saveFileToExternalStorage(new File(in));
+    } else if (openShareSheetOnFinish) {
+      hideDialog(closeWhenFinish);
+      shareFile(getReactApplicationContext(), new File(in));
+    }
+  }
+
+  @Override
+  public void onCancelTrim() {
+    sendEvent(getReactApplicationContext(), "onCancelTrimming", null);
   }
 
-  @Override public void onError(String errorMessage) {
+  @Override
+  public void onError(String errorMessage, ErrorCode errorCode) {
     WritableMap map = Arguments.createMap();
     map.putString("message", errorMessage);
+    map.putString("errorCode", errorCode.name());
     sendEvent(getReactApplicationContext(), "onError", map);
-    this.hideDialog();
   }
 
-  @Override public void onCancel() {
+  @Override
+  public void onCancel() {
     if (!enableCancelDialog) {
-      sendEvent(getReactApplicationContext(), "onCancelTrimming", null);
-      hideDialog();
+      sendEvent(getReactApplicationContext(), "onCancel", null);
+      hideDialog(true);
       return;
     }
 
@@ -208,8 +346,8 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
     builder.setCancelable(false);
     builder.setPositiveButton(cancelDialogConfirmText, (dialog, which) -> {
       dialog.cancel();
-      sendEvent(getReactApplicationContext(), "onCancelTrimming", null);
-      hideDialog();
+      sendEvent(getReactApplicationContext(), "onCancel", null);
+      hideDialog(true);
     });
     builder.setNegativeButton(cancelDialogCancelText, (dialog, which) -> {
       dialog.cancel();
@@ -218,7 +356,8 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
     alertDialog.show();
   }
 
-  @Override public void onSave() {
+  @Override
+  public void onSave() {
     if (!enableSaveDialog) {
       trimmerView.onSaveClicked();
       return;
@@ -239,27 +378,38 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
     alertDialog.show();
   }
 
-  @Override public void onLog(WritableMap log) {
+  @Override
+  public void onLog(WritableMap log) {
     sendEvent(getReactApplicationContext(), "onLog", log);
   }
 
-  @Override public void onStatistics(WritableMap statistics) {
+  @Override
+  public void onStatistics(WritableMap statistics) {
     sendEvent(getReactApplicationContext(), "onStatistics", statistics);
   }
 
-  @ReactMethod
-  private void hideDialog() {
+  private void hideDialog(boolean shouldCloseEditor) {
+    // handle the case when the cancel dialog is still showing but the trimming is finished
+    if (cancelTrimmingConfirmDialog != null) {
+      if (cancelTrimmingConfirmDialog.isShowing()) {
+        cancelTrimmingConfirmDialog.dismiss();
+      }
+      cancelTrimmingConfirmDialog = null;
+    }
+
     if (mProgressDialog != null) {
       if (mProgressDialog.isShowing()) mProgressDialog.dismiss();
       mProgressBar = null;
       mProgressDialog = null;
     }
 
-    if (alertDialog != null) {
-      if(alertDialog.isShowing()) {
-        alertDialog.dismiss();
+    if (shouldCloseEditor) {
+      if (alertDialog != null) {
+        if (alertDialog.isShowing()) {
+          alertDialog.dismiss();
+        }
+        alertDialog = null;
       }
-      alertDialog = null;
     }
   }
 
@@ -282,6 +432,7 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
       ViewGroup.LayoutParams.WRAP_CONTENT
     ));
     textView.setText(trimmingText);
+    textView.setGravity(Gravity.CENTER);
     textView.setTextSize(18);
     layout.addView(textView);
 
@@ -294,6 +445,49 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
     mProgressBar.setProgressTintList(ColorStateList.valueOf(Color.parseColor("#2196F3")));
     layout.addView(mProgressBar);
 
+    // Create button
+    if (enableCancelTrimming) {
+      Button button = new Button(activity);
+      button.setLayoutParams(new ViewGroup.LayoutParams(
+        ViewGroup.LayoutParams.WRAP_CONTENT,
+        ViewGroup.LayoutParams.WRAP_CONTENT
+      ));
+      // Set the text and style it like a text button
+      button.setText(cancelTrimmingButtonText);
+      button.setTextColor(ContextCompat.getColor(activity, android.R.color.holo_red_light)); // or use your custom color
+
+      // Apply ripple effect while keeping the button background transparent
+      TypedValue outValue = new TypedValue();
+      activity.getTheme().resolveAttribute(android.R.attr.selectableItemBackground, outValue, true);
+      button.setBackgroundResource(outValue.resourceId);
+      button.setOnClickListener(v -> {
+        if (enableCancelTrimmingDialog) {
+          AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+          builder.setMessage(cancelTrimmingDialogMessage);
+          builder.setTitle(cancelTrimmingDialogTitle);
+          builder.setCancelable(false);
+          builder.setPositiveButton(cancelTrimmingDialogConfirmText, (dialog, which) -> {
+            trimmerView.onCancelTrimClicked();
+
+            if (mProgressDialog != null && mProgressDialog.isShowing()) {
+              mProgressDialog.dismiss();
+            }
+          });
+          builder.setNegativeButton(cancelTrimmingDialogCancelText, (dialog, which) -> {
+            dialog.cancel();
+          });
+          cancelTrimmingConfirmDialog = builder.create();
+          cancelTrimmingConfirmDialog.show();
+        } else {
+          trimmerView.onCancelTrimClicked();
+          if (mProgressDialog != null && mProgressDialog.isShowing()) {
+            mProgressDialog.dismiss();
+          }
+        }
+      });
+      layout.addView(button);
+    }
+
     // Create the AlertDialog
     AlertDialog.Builder builder = new AlertDialog.Builder(activity);
     builder.setCancelable(false);
@@ -326,41 +520,6 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
     }
   }
 
-
-  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);
-  }
-
-  @ReactMethod
-  private void isValidVideo(String filePath, Promise promise) {
-    promise.resolve(isValidVideo(filePath));
-  }
-
-  @ReactMethod
-  private void saveVideo(String filePath, Promise promise) {
-    try {
-      StorageUtil.saveVideoToGallery(getReactApplicationContext(), filePath);
-    } catch (IOException e) {
-      e.printStackTrace();
-      WritableMap mapE = Arguments.createMap();
-      mapE.putString("message", "Fail while copying file to Gallery");
-      sendEvent(getReactApplicationContext(), "onError", mapE);
-    }
-
-    this.hideDialog();
-    promise.resolve(null);
-  }
-
   @ReactMethod
   private void listFiles(Promise promise) {
     String[] files = StorageUtil.listFiles(getReactApplicationContext());
@@ -385,4 +544,52 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
     boolean state = StorageUtil.deleteFile(filePath);
     promise.resolve(state);
   }
+
+  @ReactMethod
+  private void closeEditor() {
+    hideDialog(true);
+  }
+
+  @ReactMethod
+  private void isValidFile(String filePath, Promise promise) {
+    MediaMetadataUtil.checkFileValidity(filePath, (isValid, fileType, duration) -> {
+      if (isValid) {
+        System.out.println("Valid " + fileType + " file with duration: " + duration + " milliseconds");
+      } else {
+        System.out.println("Invalid file");
+      }
+
+      WritableMap map = Arguments.createMap();
+      map.putBoolean("isValid", isValid);
+      map.putString("fileType", fileType);
+      map.putDouble("duration", duration);
+      promise.resolve(map);
+    });
+  }
+
+  private void saveFileToExternalStorage(File file) {
+    Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
+    intent.addCategory(Intent.CATEGORY_OPENABLE);
+    intent.setType("*/*"); // Change MIME type as needed
+    intent.putExtra(Intent.EXTRA_TITLE, file.getName());
+    getReactApplicationContext().getCurrentActivity().startActivityForResult(intent, REQUEST_CODE_SAVE_FILE);
+  }
+
+  public void shareFile(Context context, File file) {
+    Uri fileUri = FileProvider.getUriForFile(context, context.getPackageName() + ".provider", file);
+
+    Intent shareIntent = new Intent(Intent.ACTION_SEND);
+    shareIntent.setType("*/*");
+    shareIntent.putExtra(Intent.EXTRA_STREAM, fileUri);
+    shareIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+
+    // Grant permissions to all applications that can handle the intent
+    for (ResolveInfo resolveInfo : context.getPackageManager().queryIntentActivities(shareIntent, PackageManager.MATCH_DEFAULT_ONLY)) {
+      String packageName = resolveInfo.activityInfo.packageName;
+      context.grantUriPermission(packageName, fileUri, Intent.FLAG_GRANT_READ_URI_PERMISSION);
+    }
+
+    // directly use context.startActivity(shareIntent) will cause crash
+    getReactApplicationContext().getCurrentActivity().startActivity(Intent.createChooser(shareIntent, "Share file"));
+  }
 }

package/android/src/main/java/com/videotrim/enums/ErrorCode.java

@@ -0,0 +1,10 @@
+package com.videotrim.enums;
+
+public enum ErrorCode {
+  TRIMMING_FAILED,
+  FAIL_TO_GET_VIDEO_INFO,
+  FAIL_TO_INITIALIZE_AUDIO_PLAYER,
+  FAIL_TO_LOAD_MEDIA,
+  FAIL_TO_SAVE_TO_PHOTO,
+  FAIL_TO_SAVE_TO_DOCUMENTS
+}

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

@@ -1,12 +1,15 @@
 package com.videotrim.interfaces;
 
 import com.facebook.react.bridge.WritableMap;
+import com.videotrim.enums.ErrorCode;
 
 public interface VideoTrimListener {
+  void onLoad(int duration);
   void onStartTrim();
   void onTrimmingProgress(int percentage);
   void onFinishTrim(String url, long startMs, long endMs, int videoDuration);
-  void onError(String errorMessage);
+  void onCancelTrim();
+  void onError(String errorMessage, ErrorCode errorCode);
   void onCancel();
   void onSave();
   void onLog(WritableMap log);

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

@@ -0,0 +1,75 @@
+package com.videotrim.utils;
+
+import android.media.MediaMetadataRetriever;
+import android.util.Log;
+
+import java.io.IOException;
+import java.util.HashMap;
+
+public class MediaMetadataUtil {
+
+  private static final String TAG = "MediaMetadataUtil";
+
+  // Function to return MediaMetadataRetriever or null
+  public static MediaMetadataRetriever getMediaMetadataRetriever(String source) {
+    MediaMetadataRetriever retriever = new MediaMetadataRetriever();
+    try {
+      if (source.startsWith("http://") || source.startsWith("https://")) {
+        retriever.setDataSource(source, new HashMap<>());
+      } else {
+        retriever.setDataSource(source);
+      }
+      return retriever;
+    } catch (Exception e) {
+      Log.e(TAG, "Error setting data source", e);
+      try {
+        retriever.release();
+      } catch (Exception ee) {
+        Log.e(TAG, "Error releasing retriever", ee);
+      }
+      return null;
+    }
+  }
+
+  public static void checkFileValidity(String urlString, FileValidityCallback callback) {
+    new Thread(() -> {
+      boolean isValid = false;
+      String fileType = "unknown";
+      long duration;
+      MediaMetadataRetriever retriever = getMediaMetadataRetriever(urlString);
+      if (retriever == null) {
+        callback.onResult(false, fileType, -1L);
+        return;
+      }
+
+      // Retrieve the duration
+      String durationStr = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
+      duration = durationStr == null ? -1L : Long.parseLong(durationStr);
+
+      // Determine the type
+      String hasVideo = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_VIDEO);
+      if (hasVideo != null && hasVideo.equals("yes")) {
+        fileType = "video";
+        isValid = true;
+      } else {
+        String hasAudio = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_AUDIO);
+        if (hasAudio != null && hasAudio.equals("yes")) {
+          fileType = "audio";
+          isValid = true;
+        }
+      }
+
+      try {
+        retriever.release();
+      } catch (IOException e) {
+        Log.e(TAG, "Error releasing retriever", e);
+      }
+      callback.onResult(isValid, fileType, isValid ? duration : -1L);
+    }).start();
+  }
+
+  public interface FileValidityCallback {
+    void onResult(boolean isValid, String fileType, Long duration);
+  }
+}
+

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

@@ -19,9 +19,9 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class StorageUtil {
-  public static String getOutputPath(Context context) { // use same extension as inputFile
+  public static String getOutputPath(Context context, String mOutputExt) {
     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
+    File file = new File(context.getFilesDir(), VideoTrimmerUtil.FILE_PREFIX + "_" + timestamp + "." + mOutputExt);
     return file.getAbsolutePath();
   }