react-native-video-trim 2.0.0 → 2.2.0

package/ios/VideoTrim.swift

@@ -2,15 +2,53 @@ import React
 import Photos
 import ffmpegkit
 
+@available(iOS 13.0, *)
 @objc(VideoTrim)
-class VideoTrim: RCTEventEmitter {
+class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDelegate {
     private let FILE_PREFIX = "trimmedVideo"
     private var hasListeners = false
     private var isShowing = false
     
-    private var saveToPhoto = true
+    private var saveToPhoto = false
     private var removeAfterSavedToPhoto = false
+    private var removeAfterFailedToSavePhoto = false
+    private var removeAfterSavedToDocuments = false
+    private var removeAfterFailedToSaveDocuments = false
+    private var removeAfterShared = false
+    private var removeAfterFailedToShare = false
+    
     private var trimmingText = "Trimming video..."
+    private var enableCancelDialog = true
+    private var cancelDialogTitle = "Warning!"
+    private var cancelDialogMessage = "Are you sure want to cancel?"
+    private var cancelDialogCancelText = "Close"
+    private var cancelDialogConfirmText = "Proceed"
+    private var enableSaveDialog = true
+    private var saveDialogTitle = "Confirmation!"
+    private var saveDialogMessage = "Are you sure want to save?"
+    private var saveDialogCancelText = "Close"
+    private var saveDialogConfirmText = "Proceed"
+    private var fullScreenModalIOS  = false
+    private var cancelButtonText = "Cancel"
+    private var saveButtonText = "Save"
+    private var vc: VideoTrimmerViewController?
+    private var isVideoType = true
+    private var outputExt = "mp4"
+    private var openDocumentsOnFinish = false
+    private var openShareSheetOnFinish = false
+    private var outputFile: URL?
+    private var closeWhenFinish = true
+    private var enableCancelTrimming = true;
+    private var cancelTrimmingButtonText = "Cancel";
+    private var enableCancelTrimmingDialog = true;
+    private var cancelTrimmingDialogTitle = "Warning!";
+    private var cancelTrimmingDialogMessage = "Are you sure want to trimming?";
+    private var cancelTrimmingDialogCancelText = "Close";
+    private var cancelTrimmingDialogConfirmText = "Proceed";
+    private var alertOnFailToLoad = true;
+    private var alertOnFailTitle = "Error";
+    private var alertOnFailMessage = "Fail to load media. Possibly invalid file or no network connection";
+    private var alertOnFailCloseText = "Close";
     
     @objc
     static override func requiresMainQueueSetup() -> Bool {
@@ -29,150 +67,155 @@ class VideoTrim: RCTEventEmitter {
         hasListeners = false
     }
     
-    @objc(isValidVideo:withResolver:withRejecter:)
-    func isValidVideo(uri: String, resolve: @escaping RCTPromiseResolveBlock,reject: @escaping RCTPromiseRejectBlock) -> Void {
-        if let destPath = copyFileToDocumentDir(uri: uri) {
-            resolve(UIVideoEditorController.canEditVideo(atPath: destPath.path))
-            let _ = deleteFile(url: destPath) // remove the file we just copied to document directory
-        } else {
-            resolve(false)
-        }
-    }
-    
     @objc(showEditor:withConfig:)
     func showEditor(uri: String, config: NSDictionary){
         if isShowing {
             return
         }
-  
-        saveToPhoto = config["saveToPhoto"] as? Bool ?? true
+        saveToPhoto = config["saveToPhoto"] as? Bool ?? false
+        
         removeAfterSavedToPhoto = config["removeAfterSavedToPhoto"] as? Bool ?? false
+        removeAfterFailedToSavePhoto = config["removeAfterFailedToSavePhoto"] as? Bool ?? false
+        removeAfterSavedToDocuments = config["removeAfterSavedToDocuments"] as? Bool ?? false
+        removeAfterFailedToSaveDocuments = config["removeAfterFailedToSaveDocuments"] as? Bool ?? false
+        removeAfterShared = config["removeAfterShared"] as? Bool ?? false
+        removeAfterFailedToShare = config["removeAfterFailedToShare"] as? Bool ?? false
         
-        let enableCancelDialog = config["enableCancelDialog"] as? Bool ?? true
-        let cancelDialogTitle = config["cancelDialogTitle"] as? String ?? "Warning!"
-        let cancelDialogMessage = config["cancelDialogMessage"] as? String ?? "Are you sure want to cancel?"
-        let cancelDialogCancelText = config["cancelDialogCancelText"] as? String ?? "Close"
-        let cancelDialogConfirmText = config["cancelDialogConfirmText"] as? String ?? "Proceed"
-
-        let enableSaveDialog = config["enableSaveDialog"] as? Bool ?? true
-        let saveDialogTitle = config["saveDialogTitle"] as? String ?? "Confirmation!"
-        let saveDialogMessage = config["saveDialogMessage"] as? String ?? "Are you sure want to save?"
-        let saveDialogCancelText = config["saveDialogCancelText"] as? String ?? "Close"
-        let saveDialogConfirmText = config["saveDialogConfirmText"] as? String ?? "Proceed"
+        enableCancelDialog = config["enableCancelDialog"] as? Bool ?? true
+        cancelDialogTitle = config["cancelDialogTitle"] as? String ?? "Warning!"
+        cancelDialogMessage = config["cancelDialogMessage"] as? String ?? "Are you sure want to cancel?"
+        cancelDialogCancelText = config["cancelDialogCancelText"] as? String ?? "Close"
+        cancelDialogConfirmText = config["cancelDialogConfirmText"] as? String ?? "Proceed"
+        
+        enableSaveDialog = config["enableSaveDialog"] as? Bool ?? true
+        saveDialogTitle = config["saveDialogTitle"] as? String ?? "Confirmation!"
+        saveDialogMessage = config["saveDialogMessage"] as? String ?? "Are you sure want to save?"
+        saveDialogCancelText = config["saveDialogCancelText"] as? String ?? "Close"
+        saveDialogConfirmText = config["saveDialogConfirmText"] as? String ?? "Proceed"
         trimmingText = config["trimmingText"] as? String ?? "Trimming video..."
-        let fullScreenModalIOS = config["fullScreenModalIOS"] as? Bool ?? false
+        fullScreenModalIOS = config["fullScreenModalIOS"] as? Bool ?? false
+        isVideoType = (config["type"] as? String ?? "video") == "video"
+        outputExt = config["outputExt"] as? String ?? "mp4"
+        openDocumentsOnFinish = config["openDocumentsOnFinish"] as? Bool ?? false
+        openShareSheetOnFinish = config["openShareSheetOnFinish"] as? Bool ?? false
         
-        if let destPath = copyFileToDocumentDir(uri: uri) {
-            if UIVideoEditorController.canEditVideo(atPath: destPath.path) {
-                DispatchQueue.main.async {
-                    if #available(iOS 13.0, *) {
-                        let vc = VideoTrimmerViewController()
-                        vc.asset = AVURLAsset(url: destPath, options: [AVURLAssetPreferPreciseDurationAndTimingKey: true])
-                        
-                        if let maxDuration = config["maxDuration"] as? Int {
-                            vc.maximumDuration = maxDuration
-                        }
-                        
-                        if let minDuration = config["minDuration"] as? Int {
-                            vc.minimumDuration = minDuration
-                        }
-                        
-                        if let cancelBtnText = config["cancelButtonText"] as? String, !cancelBtnText.isEmpty {
-                            vc.cancelBtnText = cancelBtnText
-                        }
-                        
-                        if let saveButtonText = config["saveButtonText"] as? String, !saveButtonText.isEmpty {
-                            vc.saveButtonText = saveButtonText
-                        }
-                        
-                        vc.cancelBtnClicked = {
-                            if !enableCancelDialog {
-                                let _ = self.deleteFile(url: destPath) // remove the file we just copied to document directory
-                                self.emitEventToJS("onCancelTrimming", eventData: nil)
-                                
-                                vc.dismiss(animated: true, completion: {
-                                    self.emitEventToJS("onHide", eventData: nil)
-                                    self.isShowing = false
-                                })
-                                return
-                            }
-                            
-                            // Create Alert
-                            let dialogMessage = UIAlertController(title: cancelDialogTitle, message: cancelDialogMessage, preferredStyle: .alert)
-
-                            // Create OK button with action handler
-                            let ok = UIAlertAction(title: cancelDialogConfirmText, style: .destructive, handler: { (action) -> Void in
-                                let _ = self.deleteFile(url: destPath) // remove the file we just copied to document directory
-                                self.emitEventToJS("onCancelTrimming", eventData: nil)
-                                
-                                vc.dismiss(animated: true, completion: {
-                                    self.emitEventToJS("onHide", eventData: nil)
-                                    self.isShowing = false
-                                })
-                            })
-
-                            // Create Cancel button with action handlder
-                            let cancel = UIAlertAction(title: cancelDialogCancelText, style: .cancel)
-
-                            //Add OK and Cancel button to an Alert object
-                            dialogMessage.addAction(ok)
-                            dialogMessage.addAction(cancel)
-
-                            // Present alert message to user
-                            if let root = RCTPresentedViewController() {
-                                root.present(dialogMessage, animated: true, completion: nil)
-                            }
-                        }
-                        
-                        vc.saveBtnClicked = {(selectedRange: CMTimeRange) in
-                            if !enableSaveDialog {
-                                self.trim(viewController: vc,inputFile: destPath, videoDuration: vc.asset.duration.seconds, startTime: selectedRange.start.seconds, endTime: selectedRange.end.seconds)
-                                return
-                            }
-                            
-                            // Create Alert
-                            let dialogMessage = UIAlertController(title: saveDialogTitle, message: saveDialogMessage, preferredStyle: .alert)
-
-                            // Create OK button with action handler
-                            let ok = UIAlertAction(title: saveDialogConfirmText, style: .default, handler: { (action) -> Void in
-                                self.trim(viewController: vc,inputFile: destPath, videoDuration: vc.asset.duration.seconds, startTime: selectedRange.start.seconds, endTime: selectedRange.end.seconds)
-                            })
-
-                            // Create Cancel button with action handlder
-                            let cancel = UIAlertAction(title: saveDialogCancelText, style: .cancel)
+        closeWhenFinish = config["closeWhenFinish"] as? Bool ?? true
+        enableCancelTrimming = config["enableCancelTrimming"] as? Bool ?? true
+        cancelTrimmingButtonText = config["cancelTrimmingButtonText"] as? String ?? "Cancel"
+        enableCancelTrimmingDialog = config["enableCancelTrimmingDialog"] as? Bool ?? true
+        cancelTrimmingDialogTitle = config["cancelTrimmingDialogTitle"] as? String ?? "Warning!"
+        cancelTrimmingDialogMessage = config["cancelTrimmingDialogMessage"] as? String ?? "Are you sure want to cancel trimming?"
+        cancelTrimmingDialogCancelText = config["cancelTrimmingDialogCancelText"] as? String ?? "Close"
+        cancelTrimmingDialogConfirmText = config["cancelTrimmingDialogConfirmText"] as? String ?? "Proceed"
+        alertOnFailToLoad = config["alertOnFailToLoad"] as? Bool ?? true
+        alertOnFailTitle = config["alertOnFailTitle"] as? String ?? "Error"
+        alertOnFailMessage = config["alertOnFailMessage"] as? String ?? "Fail to load media. Possibly invalid file or no network connection"
+        alertOnFailCloseText = config["alertOnFailCloseText"] as? String ?? "Close"
+        
+        if let cancelBtnText = config["cancelButtonText"] as? String, !cancelBtnText.isEmpty {
+            self.cancelButtonText = cancelBtnText
+        }
+        
+        if let saveButtonText = config["saveButtonText"] as? String, !saveButtonText.isEmpty {
+            self.saveButtonText = saveButtonText
+        }
+        
+        let destPath = URL(string: uri)
+        guard let destPath = destPath else { return }
+        
+        DispatchQueue.main.async {
+            self.vc = VideoTrimmerViewController()
+            
+            guard let vc = self.vc else { return }
+            
+            vc.configure(config: config)
 
-                            //Add OK and Cancel button to an Alert object
-                            dialogMessage.addAction(ok)
-                            dialogMessage.addAction(cancel)
+            vc.cancelBtnClicked = {
+                if !self.enableCancelDialog {
+                    self.emitEventToJS("onCancel", eventData: nil)
+                    
+                    vc.dismiss(animated: true, completion: {
+                        self.emitEventToJS("onHide", eventData: nil)
+                        self.isShowing = false
+                    })
+                    return
+                }
+                
+                // Create Alert
+                let dialogMessage = UIAlertController(title: self.cancelDialogTitle, message: self.cancelDialogMessage, preferredStyle: .alert)
+                dialogMessage.overrideUserInterfaceStyle = .dark
+                
+                // Create OK button with action handler
+                let ok = UIAlertAction(title: self.cancelDialogConfirmText, style: .destructive, handler: { (action) -> Void in
+                    self.emitEventToJS("onCancel", eventData: nil)
+                    
+                    vc.dismiss(animated: true, completion: {
+                        self.emitEventToJS("onHide", eventData: nil)
+                        self.isShowing = false
+                    })
+                })
+                
+                // Create Cancel button with action handlder
+                let cancel = UIAlertAction(title: self.cancelDialogCancelText, style: .cancel)
+                
+                //Add OK and Cancel button to an Alert object
+                dialogMessage.addAction(ok)
+                dialogMessage.addAction(cancel)
+                
+                // Present alert message to user
+                if let root = RCTPresentedViewController() {
+                    root.present(dialogMessage, animated: true, completion: nil)
+                }
+            }
+            
+            vc.saveBtnClicked = {(selectedRange: CMTimeRange) in
+                if !self.enableSaveDialog {
+                    self.trim(viewController: vc,inputFile: destPath, videoDuration: self.vc!.asset!.duration.seconds, startTime: selectedRange.start.seconds, endTime: selectedRange.end.seconds)
+                    return
+                }
+                
+                // Create Alert
+                let dialogMessage = UIAlertController(title: self.saveDialogTitle, message: self.saveDialogMessage, preferredStyle: .alert)
+                dialogMessage.overrideUserInterfaceStyle = .dark
 
-                            // Present alert message to user
-                            if let root = RCTPresentedViewController() {
-                                root.present(dialogMessage, animated: true, completion: nil)
-                            }
-                        }
-                        
-                        vc.isModalInPresentation = true // prevent modal closed by swipe down
-                        
-                        if fullScreenModalIOS {
-                            vc.modalPresentationStyle = .fullScreen
-                        }
-                        
-                        if let root = RCTPresentedViewController() {
-                            root.present(vc, animated: true, completion: {
-                                self.emitEventToJS("onShow", eventData: nil)
-                                self.isShowing = true
-                            })
-                        }
-                    }
+                // Create OK button with action handler
+                let ok = UIAlertAction(title: self.saveDialogConfirmText, style: .default, handler: { (action) -> Void in
+                    self.trim(viewController: vc,inputFile: destPath, videoDuration: vc.asset!.duration.seconds, startTime: selectedRange.start.seconds, endTime: selectedRange.end.seconds)
+                })
+                
+                // Create Cancel button with action handlder
+                let cancel = UIAlertAction(title: self.saveDialogCancelText, style: .cancel)
+                
+                //Add OK and Cancel button to an Alert object
+                dialogMessage.addAction(ok)
+                dialogMessage.addAction(cancel)
+                
+                // Present alert message to user
+                if let root = RCTPresentedViewController() {
+                    root.present(dialogMessage, animated: true, completion: nil)
                 }
-            } else {
-                let eventPayload: [String: Any] = ["message": "File is not a valid video"]
-                self.emitEventToJS("onError", eventData: eventPayload)
             }
-        } else {
-            let eventPayload: [String: Any] = ["message": "File is invalid"]
-            self.emitEventToJS("onError", eventData: eventPayload)
+            
+            vc.isModalInPresentation = true // prevent modal closed by swipe down
+            
+            if self.fullScreenModalIOS {
+                vc.modalPresentationStyle = .fullScreen
+            }
+            
+            if let root = RCTPresentedViewController() {
+                root.present(vc, animated: true, completion: {
+                    self.emitEventToJS("onShow", eventData: nil)
+                    self.isShowing = true
+                    
+                    // start loading asset after view is finished presenting
+                    // otherwise it may run too fast for local file and autoplay looks weird
+                    let assetLoader = AssetLoader()
+                    assetLoader.delegate = self
+                    assetLoader.loadAsset(url: destPath, isVideoType: self.isVideoType)
+                })
+            }
         }
+        
     }
     
     private func copyFileToDocumentDir(uri: String) -> URL? {
@@ -270,36 +313,73 @@ class VideoTrim: RCTEventEmitter {
         }
     }
     
-    @available(iOS 13.0, *)
     private func trim(viewController: VideoTrimmerViewController, inputFile: URL, videoDuration: Double, startTime: Double, endTime: Double) {
+        vc?.pausePlayer()
+        
         let timestamp = Int(Date().timeIntervalSince1970)
-        let outputName = "\(FILE_PREFIX)_\(timestamp).mp4" // use mp4 to prevent any issue with ffmpeg about file extension
-        let outputFile = "\(inputFile.deletingLastPathComponent().absoluteURL)\(outputName)"
+        let outputName = "\(FILE_PREFIX)_\(timestamp).\(outputExt)"
+        let documentsDirectory = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+        outputFile = documentsDirectory.appendingPathComponent(outputName)
         
         let formatter = DateFormatter()
         formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSZ"
         formatter.timeZone = TimeZone(identifier: "UTC")
         let dateTime = formatter.string(from: Date())
         
-        self.emitEventToJS("onStartTrimming", eventData: nil)
+        emitEventToJS("onStartTrimming", eventData: nil)
+        
+        var ffmpegSession: FFmpegSession?
+        let progressAlert = ProgressAlertController()
+        progressAlert.modalPresentationStyle = .overFullScreen
+        progressAlert.modalTransitionStyle = .crossDissolve
+        progressAlert.setTitle(trimmingText)
         
-        // Create Alert
-        let dialogMessage = UIAlertController(title: trimmingText, message: nil, preferredStyle: .alert)
+        if enableCancelTrimming {
+            progressAlert.setCancelTitle(cancelTrimmingButtonText)
+            progressAlert.showCancelBtn()
+            progressAlert.onDismiss = {
+                if self.enableCancelTrimmingDialog {
+                    let dialogMessage = UIAlertController(title: self.cancelTrimmingDialogTitle, message: self.cancelTrimmingDialogMessage, preferredStyle: .alert)
+                    dialogMessage.overrideUserInterfaceStyle = .dark
 
-        // Present alert message to user
-        let progressView = UIProgressView(frame: .zero)
-        progressView.tintColor = .systemBlue
-        if let root = RCTPresentedViewController() {
-            root.present(dialogMessage, animated: true, completion: {
-                dialogMessage.view.addSubview(progressView)
+                    // Create OK button with action handler
+                    let ok = UIAlertAction(title: self.cancelDialogConfirmText, style: .destructive, handler: { (action) -> Void in
+                        
+                        if let ffmpegSession = ffmpegSession {
+                            ffmpegSession.cancel()
+                        } else {
+                            self.emitEventToJS("onCancelTrimming", eventData: nil)
+                        }
+                        
+                        progressAlert.dismiss(animated: true)
+                    })
+                    
+                    // Create Cancel button with action handlder
+                    let cancel = UIAlertAction(title: self.cancelDialogCancelText, style: .cancel)
+                    
+                    //Add OK and Cancel button to an Alert object
+                    dialogMessage.addAction(ok)
+                    dialogMessage.addAction(cancel)
+                    
+                    // Present alert message to user
+                    if let root = RCTPresentedViewController() {
+                        root.present(dialogMessage, animated: true, completion: nil)
+                    }
+                } else {
+                    if let ffmpegSession = ffmpegSession {
+                        ffmpegSession.cancel()
+                    } else {
+                        self.emitEventToJS("onCancelTrimming", eventData: nil)
+                    }
+                    
+                    progressAlert.dismiss(animated: true)
+                }
                 
-                progressView.translatesAutoresizingMaskIntoConstraints = false
-                NSLayoutConstraint.activate([
-                    progressView.leadingAnchor.constraint(equalTo: dialogMessage.view.leadingAnchor, constant: 8),
-                    progressView.trailingAnchor.constraint(equalTo: dialogMessage.view.trailingAnchor, constant: -8),
-                    progressView.bottomAnchor.constraint(equalTo: dialogMessage.view.bottomAnchor, constant: -8)
-                ])
-            })
+            }
+        }
+        
+        if let root = RCTPresentedViewController() {
+            root.present(progressAlert, animated: true, completion: nil)
         }
         
         let cmds = [
@@ -313,60 +393,83 @@ class VideoTrim: RCTEventEmitter {
             "copy",
             "-metadata",
             "creation_time=\(dateTime)",
-            outputFile
+            outputFile!.absoluteString
+        ]
+        
+        print("Command: ", cmds.joined(separator: " "))
+        
+        let eventPayload: [String: Any] = [
+            "command": cmds.joined(separator: " ")
         ]
+        self.emitEventToJS("onLog", eventData: eventPayload)
         
-        FFmpegKit.execute(withArgumentsAsync: cmds, withCompleteCallback: { session in
-            let _ = self.deleteFile(url: inputFile) // remove the file we just copied to document directory
+        ffmpegSession = FFmpegKit.execute(withArgumentsAsync: cmds, withCompleteCallback: { session in
+            
+            // always hide progressAlert
+            DispatchQueue.main.async {
+                progressAlert.dismiss(animated: true)
+            }
             
             let state = session?.getState()
             let returnCode = session?.getReturnCode()
             
             if ReturnCode.isSuccess(returnCode) {
-                let eventPayload: [String: Any] = ["outputPath": outputFile, "startTime": startTime, "endTime": endTime, "duration": videoDuration]
+                let eventPayload: [String: Any] = ["outputPath": self.outputFile!.absoluteString, "startTime": (startTime * 1000).rounded(), "endTime": (endTime * 1000).rounded(), "duration": (videoDuration * 1000).rounded()]
                 self.emitEventToJS("onFinishTrimming", eventData: eventPayload)
                 
-                if (self.saveToPhoto) {
+                if (self.saveToPhoto && self.isVideoType) {
                     PHPhotoLibrary.requestAuthorization { status in
                         guard status == .authorized else {
-                            let eventPayload: [String: Any] = ["message": "Permission to access Photo Library is not granted"]
-                            self.emitEventToJS("onError", eventData: eventPayload)
+                            self.onError(message: "Permission to access Photo Library is not granted", code: .noPhotoPermission)
                             return
                         }
                         
                         PHPhotoLibrary.shared().performChanges({
-                            let request = PHAssetChangeRequest.creationRequestForAssetFromVideo(atFileURL: URL(string: outputFile)!)
+                            let request = PHAssetChangeRequest.creationRequestForAssetFromVideo(atFileURL: self.outputFile!)
                             request?.creationDate = Date()
                         }) { success, error in
                             if success {
                                 print("Edited video saved to Photo Library successfully.")
                                 
                                 if self.removeAfterSavedToPhoto {
-                                    let _ = self.deleteFile(url: URL(string: outputFile)!)
+                                    let _ = self.deleteFile(url: self.outputFile!)
                                 }
                             } else {
-                                let eventPayload: [String: Any] = ["message": "Failed to save edited video to Photo Library: \(error?.localizedDescription ?? "Unknown error")"]
-                                self.emitEventToJS("onError", eventData: eventPayload)
+                                self.onError(message: "Failed to save edited video to Photo Library: \(error?.localizedDescription ?? "Unknown error")", code: .failToSaveToPhoto)
+                                if self.removeAfterFailedToSavePhoto {
+                                    let _ = self.deleteFile(url: self.outputFile!)
+                                }
                             }
                         }
                     }
+                } else if self.openDocumentsOnFinish {
+                    self.saveFileToFilesApp(fileURL: self.outputFile!)
+                    
+                    // must return otherwise editor will close
+                    return
+                } else if self.openShareSheetOnFinish {
+                    self.shareFile(fileURL: self.outputFile!)
+                    
+                    // must return otherwise editor will close
+                    return
+                }
+                
+                if self.closeWhenFinish {
+                    self.closeEditor()
                 }
+                
+            } else if ReturnCode.isCancel(returnCode) {
+                // CANCEL
+                self.emitEventToJS("onCancelTrimming", eventData: nil)
             } else {
-                // CANCEL + FAILURE
-                let eventPayload: [String: Any] = ["message": "Command failed with state \(String(describing: FFmpegKitConfig.sessionState(toString: state ?? .failed))) and rc \(String(describing: returnCode)).\(String(describing: session?.getFailStackTrace()))"]
-                self.emitEventToJS("onError", eventData: eventPayload)
+                // FAILURE
+                self.onError(message: "Command failed with state \(String(describing: FFmpegKitConfig.sessionState(toString: state ?? .failed))) and rc \(String(describing: returnCode)).\(String(describing: session?.getFailStackTrace()))", code: .trimmingFailed)
+                if self.closeWhenFinish {
+                    self.closeEditor()
+                }
             }
             
-            // some how in case we trim a very short video the view controller is still visible after first .dismiss call
-            // even the file is successfully saved
-            // that's why we need a small delay here to ensure vc will be dismissed
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
-                dialogMessage.dismiss(animated: false)
-                viewController.dismiss(animated: true, completion: {
-                    self.emitEventToJS("onHide", eventData: nil)
-                    self.isShowing = false
-                })
-            }
+            
         }, withLogCallback: { log in
             guard let log = log else { return }
             
@@ -381,12 +484,12 @@ class VideoTrim: RCTEventEmitter {
             
         }, withStatisticsCallback: { statistics in
             guard let statistics = statistics else { return }
-
+            
             let timeInMilliseconds = statistics.getTime()
             if timeInMilliseconds > 0 {
                 let completePercentage = timeInMilliseconds / (videoDuration * 1000); // from 0 -> 1
                 DispatchQueue.main.async {
-                    progressView.setProgress(Float(completePercentage), animated: true)
+                    progressAlert.setProgress(Float(completePercentage))
                 }
             }
             
@@ -403,4 +506,196 @@ class VideoTrim: RCTEventEmitter {
             self.emitEventToJS("onStatistics", eventData: eventPayload)
         })
     }
+    
+    func assetLoader(_ loader: AssetLoader, didFailWithError error: any Error, forKey key: String) {
+        let message = "Failed to load \(key): \(error.localizedDescription)"
+        print(message)
+        
+        self.onError(message: message, code: .failToLoadMedia)
+        vc?.onAssetFailToLoad()
+        
+        if alertOnFailToLoad {
+            let dialogMessage = UIAlertController(title: alertOnFailTitle, message: alertOnFailMessage, preferredStyle: .alert)
+            dialogMessage.overrideUserInterfaceStyle = .dark
+
+            // Create Cancel button with action handlder
+            let ok = UIAlertAction(title: alertOnFailCloseText, style: .default)
+            
+            //Add OK and Cancel button to an Alert object
+            dialogMessage.addAction(ok)
+            
+            // Present alert message to user
+            if let root = RCTPresentedViewController() {
+                root.present(dialogMessage, animated: true, completion: nil)
+            }
+        }
+    }
+    
+    func assetLoaderDidSucceed(_ loader: AssetLoader) {
+        print("Asset loaded successfully")
+        
+        vc?.asset = loader.asset
+        
+        let eventPayload: [String: Any] = [
+            "duration": loader.asset!.duration.seconds * 1000,
+        ]
+        self.emitEventToJS("onLoad", eventData: eventPayload)
+    }
+    
+    
+    
+    private func saveFileToFilesApp(fileURL: URL) {
+        DispatchQueue.main.async {
+            let documentPicker = UIDocumentPickerViewController(url: fileURL, in: .exportToService)
+            documentPicker.delegate = self
+            documentPicker.modalPresentationStyle = .formSheet
+            if let root = RCTPresentedViewController() {
+                root.present(documentPicker, animated: true, completion: nil)
+            }
+        }
+    }
+    
+    private func shareFile(fileURL: URL) {
+        DispatchQueue.main.async {
+            // Create an instance of UIActivityViewController
+            let activityViewController = UIActivityViewController(activityItems: [fileURL], applicationActivities: nil)
+            
+            activityViewController.completionWithItemsHandler = { activityType, completed, returnedItems, error in
+                
+                if let error = error {
+                    let message = "Sharing error: \(error.localizedDescription)"
+                    print(message)
+                    self.onError(message: message, code: .failToShare)
+                    
+                    if self.removeAfterFailedToShare {
+                        let _ = self.deleteFile(url: self.outputFile!)
+                    }
+                    return
+                }
+                
+                if completed {
+                    print("User completed the sharing activity")
+                    if self.removeAfterShared {
+                        let _ = self.deleteFile(url: self.outputFile!)
+                    }
+                } else {
+                    print("User cancelled or failed to complete the sharing activity")
+                    if self.removeAfterFailedToShare {
+                        let _ = self.deleteFile(url: self.outputFile!)
+                    }
+                }
+                
+                self.closeEditor()
+
+            }
+            
+            // Present the share sheet
+            if let root = RCTPresentedViewController() {
+                root.present(activityViewController, animated: true, completion: nil)
+            }
+        }
+        
+    }
+    
+    func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
+        if removeAfterSavedToDocuments {
+            let _ = deleteFile(url: outputFile!)
+        }
+        closeEditor()
+    }
+    
+    func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
+        if removeAfterFailedToSaveDocuments {
+            let _ = deleteFile(url: outputFile!)
+        }
+        closeEditor()
+    }
+    
+    @objc(closeEditor:withRejecter:)
+    func closeEditor(resolve: @escaping RCTPromiseResolveBlock,reject: @escaping RCTPromiseRejectBlock) -> Void {
+        closeEditor()
+        resolve(true)
+    }
+    
+    private func closeEditor() {
+        guard let vc = vc else { return }
+        // some how in case we trim a very short video the view controller is still visible after first .dismiss call
+        // even the file is successfully saved
+        // that's why we need a small delay here to ensure vc will be dismissed
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+            vc.dismiss(animated: true, completion: {
+                self.emitEventToJS("onHide", eventData: nil)
+                self.isShowing = false
+            })
+        }
+    }
+    
+    @objc(isValidFile:withResolver:withRejecter:)
+    func isValidFile(uri: String, resolve: @escaping RCTPromiseResolveBlock,reject: @escaping RCTPromiseRejectBlock) -> Void {
+        let fileURL = URL(string: uri)!
+        checkFileValidity(url: fileURL) { isValid, fileType, duration in
+            if isValid {
+                print("Valid \(fileType) file with duration: \(duration) milliseconds")
+            } else {
+                print("Invalid file")
+            }
+            
+            let payload: [String: Any] = [
+                "isValid": isValid,
+                "fileType": fileType,
+                "duration": duration
+            ]
+            resolve(payload)
+        }
+        
+    }
+    
+    private func onError(message: String, code: ErrorCode) {
+        let eventPayload: [String: String] = [
+            "message": message,
+            "errorCode": code.rawValue
+        ]
+        self.emitEventToJS("onError", eventData: eventPayload)
+    }
+    
+    private func checkFileValidity(url: URL, completion: @escaping (Bool, String, Double) -> Void) {
+        let asset = AVAsset(url: url)
+        
+        // Load the duration and tracks asynchronously
+        asset.loadValuesAsynchronously(forKeys: ["duration", "tracks"]) {
+            var error: NSError? = nil
+            
+            // Check if the duration and tracks are loaded
+            let durationStatus = asset.statusOfValue(forKey: "duration", error: &error)
+            let tracksStatus = asset.statusOfValue(forKey: "tracks", error: &error)
+            
+            // Ensure both properties are loaded successfully
+            guard durationStatus == .loaded, tracksStatus == .loaded, error == nil else {
+                DispatchQueue.main.async {
+                    completion(false, "unknown", -1)
+                }
+                return
+            }
+            
+            // Check if the asset contains any video or audio tracks
+            let videoTracks = asset.tracks(withMediaType: .video)
+            let audioTracks = asset.tracks(withMediaType: .audio)
+            
+            let isValid = !videoTracks.isEmpty || !audioTracks.isEmpty
+            let fileType: String
+            if !videoTracks.isEmpty {
+                fileType = "video"
+            } else if !audioTracks.isEmpty {
+                fileType = "audio"
+            } else {
+                fileType = "unknown"
+            }
+            
+            let duration = CMTimeGetSeconds(asset.duration) * 1000
+            
+            DispatchQueue.main.async {
+                completion(isValid, fileType, isValid ? duration.rounded() : -1)
+            }
+        }
+    }
 }