react-native-compressor 1.7.2 → 1.8.0

package/ios/Utils/MediaCache.swift

@@ -0,0 +1,48 @@
+import Foundation
+
+class MediaCache {
+    static var completedImagePaths: [String] = []
+
+    class func addCompletedImagePath(_ imagePath: String) {
+        if !imagePath.isEmpty {
+            completedImagePaths.append(imagePath)
+        }
+    }
+
+    class func removeCompletedImagePath(_ imagePath: String) {
+        if !imagePath.isEmpty {
+            if let index = completedImagePaths.firstIndex(of: imagePath) {
+                completedImagePaths.remove(at: index)
+                if let fileURL = URL(string: imagePath) {
+                    let fileSystemPath = fileURL.path
+                    
+                    let fileManager = FileManager.default
+                    do {
+                        if fileManager.fileExists(atPath: fileSystemPath) {
+                            try fileManager.removeItem(atPath: fileSystemPath)
+                        }
+                    } catch {
+                        print("Error deleting image at path: \(fileSystemPath)")
+                    }
+                }
+            }
+        }
+    }
+
+    class func cleanupCache() {
+        let fileManager = FileManager.default
+        if let cacheDirectory = NSSearchPathForDirectoriesInDomains(.cachesDirectory, .userDomainMask, true).first {
+            for imagePath in completedImagePaths {
+                let absoluteImagePath = (cacheDirectory as NSString).appendingPathComponent(imagePath)
+                do {
+                    if fileManager.fileExists(atPath: absoluteImagePath) {
+                        try fileManager.removeItem(atPath: absoluteImagePath)
+                    }
+                } catch {
+                    print("Error deleting image at path: \(absoluteImagePath)")
+                }
+            }
+            completedImagePaths.removeAll()
+        }
+    }
+}

package/ios/Utils/Uploader.swift

@@ -0,0 +1,99 @@
+//
+//  Uploader.swift
+//  react-native-compressor
+//
+//  Created by Numan on 10/09/2023.
+//
+
+import Foundation
+
+struct UploadError: Error {
+  private let message: String
+
+  var localizedDescription: String {
+    return message
+  }
+  
+  init(message: String) {
+    self.message = message
+  }
+}
+
+class Uploader : NSObject, URLSessionTaskDelegate{
+    var uploadResolvers: [String: RCTPromiseResolveBlock] = [:]
+    var uploadRejectors: [String: RCTPromiseRejectBlock] = [:]
+    
+    func upload(filePath: String, options: [String: Any], resolve:@escaping RCTPromiseResolveBlock, reject:@escaping RCTPromiseRejectBlock) -> Void {
+        let fileUrl = Utils.makeValidUri(filePath: filePath)
+      
+      guard let uuid = options["uuid"] as? String else {
+        let uploadError = UploadError(message: "UUID is missing")
+        reject("Upload Failed", "UUID is missing", uploadError)
+        return
+      }
+
+      guard let remoteUrl = options["url"] as? String else {
+        let uploadError = UploadError(message: "url is missing")
+        reject("Upload Failed", "url is missing", uploadError)
+        return
+      }
+
+      guard let method = options["method"] as? String else {
+        let uploadError = UploadError(message: "method is missing")
+        reject("Upload Failed", "method is missing", uploadError)
+        return
+      }
+
+      guard let file = URL(string: fileUrl) else{
+        let uploadError = UploadError(message: "invalid file url")
+        reject("Failed", "Upload Failed", uploadError)
+        return
+      }
+
+      let headers = options["headers"] as? [String: String] ?? [:]
+
+      let url = URL(string: remoteUrl)!
+      var request = URLRequest(url: url)
+      request.httpMethod=method
+      for(header, v) in headers{
+        request.setValue(v, forHTTPHeaderField: header)
+      }
+
+      uploadResolvers[uuid] = resolve
+      uploadRejectors[uuid] = reject
+      // TODO: ADD Headers
+      let config = URLSessionConfiguration.background(withIdentifier: uuid)
+      let session = URLSession(configuration: config, delegate: self, delegateQueue: nil)
+      let task = session.uploadTask(with: request, fromFile: file)
+      task.resume()
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+      guard let uuid = session.configuration.identifier else {return}
+      guard let reject = uploadRejectors[uuid] else{return}
+      guard let resolve = uploadResolvers[uuid] else{return}
+      guard error == nil else {
+        reject("failed", "Upload Failed", error)
+        uploadRejectors[uuid] = nil
+        return;
+      }
+
+      guard let response = task.response  as? HTTPURLResponse else {
+        let uploadError = UploadError(message: "Response is not defined")
+        reject("failed", "Upload Failed", uploadError)
+        uploadRejectors[uuid] = nil
+        return;
+      }
+
+      let result: [String : Any] = ["status": response.statusCode, "headers": response.allHeaderFields, "body": ""]
+      
+      resolve(result)
+      uploadResolvers[uuid] = nil
+    }
+      
+    func urlSession(_ session: URLSession, task: URLSessionTask, didSendBodyData bytesSent: Int64, totalBytesSent: Int64, totalBytesExpectedToSend: Int64)
+    {
+      guard let uuid = session.configuration.identifier else {return}
+        EventEmitterHandler.emituploadProgress(uuid,totalBytesSent: totalBytesSent,totalBytesExpectedToSend: totalBytesExpectedToSend)
+    }
+}

package/ios/Utils/Utils.swift

@@ -0,0 +1,110 @@
+//
+//  Utils.swift
+//  react-native-compressor
+//
+//  Created by Numan on 10/09/2023.
+//
+
+import Foundation
+
+class Utils {
+    static func generateCacheFilePath(_ extension: String) -> String {
+        let uuid = UUID()
+        let imageNameWithoutExtension = uuid.uuidString
+        let imageName = imageNameWithoutExtension + "." + `extension`
+        let filePath = (NSTemporaryDirectory() as NSString).appendingPathComponent(imageName)
+        return filePath
+    }
+    
+    static func makeValidUri(filePath: String) -> String {
+        let fileWithUrl = URL(fileURLWithPath: filePath)
+        let absoluteUrl = fileWithUrl.deletingLastPathComponent()
+        let fileUrl = "file://\(absoluteUrl.path)/\(fileWithUrl.lastPathComponent)"
+        return fileUrl;
+    }
+    
+    static func getFileSize(from urlString: String, completion: @escaping (NSNumber?, Error?) -> Void) {
+        if let url = URL(string: urlString) {
+            var request = URLRequest(url: url)
+            request.httpMethod = "HEAD"
+
+            let session = URLSession.shared
+            let task = session.dataTask(with: request) { data, response, error in
+                if let error = error {
+                    completion(nil, error)
+                } else if let httpResponse = response as? HTTPURLResponse {
+                    let contentLength = NSNumber(value: httpResponse.expectedContentLength)
+                    completion(contentLength, nil)
+                } else {
+                    let error = NSError(domain: "FileDownloadError", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid response."])
+                    completion(nil, error)
+                }
+            }
+
+            task.resume()
+        }
+    }
+    
+    static func getFileSize(_ filePath: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            if filePath.hasPrefix("http://") || filePath.hasPrefix("https://") {
+                getFileSize(from: filePath) { fileSize, error in
+                    if let error = error {
+                        print("Error: \(error.localizedDescription)")
+                        reject(String(error._code), error.localizedDescription, error)
+                    } else if let fileSize = fileSize {
+                        print("File size: \(fileSize)")
+                        resolve(fileSize.stringValue)
+                    }
+                }
+            } else {
+                var filePath = filePath
+                if filePath.hasPrefix("file://") {
+                    filePath = filePath.replacingOccurrences(of: "file://", with: "")
+                }
+                let fileManager = FileManager.default
+                var isDir: ObjCBool = false
+                if !fileManager.fileExists(atPath: filePath, isDirectory: &isDir) || isDir.boolValue {
+                    let err = NSError(domain: "file not found", code: -15, userInfo: nil)
+                    reject(String(err.code), err.localizedDescription, err)
+                    return
+                }
+                if let attrs = try? fileManager.attributesOfItem(atPath: filePath),
+                   let fileSize = attrs[.size] as? UInt64 {
+                    let fileSizeString = String(fileSize)
+                    resolve(fileSizeString)
+                }
+            }
+        } catch {
+            reject(error.localizedDescription, error.localizedDescription, nil)
+        }
+    }
+    
+    
+    static func getRealPath(_ path: String, type: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            if type == "video" {
+                VideoCompressor.getAbsoluteVideoPath(path, options: [:]) { absoluteImagePath in
+                    resolve(absoluteImagePath)
+                }
+            } else {
+                let options = ImageCompressorOptions.fromDictionary([:])
+                ImageCompressor.getAbsoluteImagePath(path, options: options) { absoluteImagePath in
+                    resolve(absoluteImagePath)
+                }
+            }
+        } catch {
+            reject(error.localizedDescription, error.localizedDescription, nil)
+        }
+    }
+    
+    static func generateFilePath(_ _extension: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            let outputUri = generateCacheFilePath(_extension)
+            resolve(outputUri)
+        } catch {
+            reject(error.localizedDescription, error.localizedDescription, nil)
+        }
+    }
+    
+}

package/ios/Video/{VideoCompressor.swift → VideoMain.swift}

@@ -3,6 +3,7 @@ import AssetsLibrary
 import AVFoundation
 import NextLevelSessionExporter
 import Photos
+import MobileCoreServices
 
 struct CompressionError: Error {
   private let message: String
@@ -16,39 +17,28 @@ struct CompressionError: Error {
   }
 }
 
-struct UploadError: Error {
-  private let message: String
-
-  var localizedDescription: String {
-    return message
-  }
-  
-  init(message: String) {
-    self.message = message
-  }
-}
-
-@available(iOS 11.0, *)
-@objc(VideoCompressor)
-class VideoCompressor: RCTEventEmitter, URLSessionTaskDelegate {
+class VideoCompressor {
   var backgroundTaskId: UIBackgroundTaskIdentifier = .invalid;
-  var hasListener: Bool=false
-  var uploadResolvers: [String: RCTPromiseResolveBlock] = [:]
-  var uploadRejectors: [String: RCTPromiseRejectBlock] = [:]
+ 
   var compressorExports: [String: NextLevelSessionExporter] = [:]
-    let videoCompressionThreshold:Int=7
-
-    override init() {
-        super.init()
-        ImageCompressor.initVideoCompressorInstance(self)
-    }
-
-  override static func requiresMainQueueSetup() -> Bool {
-    return false
-  }
-
+    
+    let metadatas: [String] = [
+        "albumName",
+        "artist",
+        "comment",
+        "copyrights",
+        "creationDate",
+        "date",
+        "encodedby",
+        "genre",
+        "language",
+        "location",
+        "lastModifiedDate",
+        "performer",
+        "publisher",
+        "title"
+    ]
 
-  @objc(activateBackgroundTask:withResolver:withRejecter:)
   func activateBackgroundTask(options: [String: Any], resolve:@escaping RCTPromiseResolveBlock, reject:@escaping RCTPromiseRejectBlock) -> Void {
     guard backgroundTaskId == .invalid else {
       reject("failed", "There is a background task already", nil)
@@ -57,14 +47,13 @@ class VideoCompressor: RCTEventEmitter, URLSessionTaskDelegate {
     backgroundTaskId = UIApplication.shared.beginBackgroundTask(
       withName: "video-upload",
       expirationHandler: {
-        self.sendEvent(withName: "backgroundTaskExpired", body: ["backgroundTaskId": self.backgroundTaskId])
+        EventEmitterHandler.emitBackgroundTaskExpired(self.backgroundTaskId)
         UIApplication.shared.endBackgroundTask(self.backgroundTaskId)
         self.backgroundTaskId = .invalid
     })
     resolve(backgroundTaskId)
   }
 
-  @objc(deactivateBackgroundTask:withResolver:withRejecter:)
   func deactivateBackgroundTask(options: [String: Any], resolve:@escaping RCTPromiseResolveBlock, reject:@escaping RCTPromiseRejectBlock) -> Void {
     guard backgroundTaskId != .invalid else {
       reject("failed", "There is no active background task", nil)
@@ -75,14 +64,11 @@ class VideoCompressor: RCTEventEmitter, URLSessionTaskDelegate {
     backgroundTaskId = .invalid
   }
 
-  @objc(compress:withOptions:withResolver:withRejecter:)
   func compress(fileUrl: String, options: [String: Any], resolve:@escaping RCTPromiseResolveBlock, reject:@escaping RCTPromiseRejectBlock) -> Void {
+    let progressDivider=options["progressDivider"] as? Int ?? 0
     compressVideo(url: URL(string: fileUrl)!, options:options,
-    onProgress: { progress in 
-      print("Progress", progress)
-      if(self.hasListener){
-        self.sendEvent(withName: "videoCompressProgress", body: ["uuid": options["uuid"], "data": ["progress": progress]])
-      }
+    onProgress: { progress in
+        EventEmitterHandler.emitVideoCompressProgress(progress, uuid: options["uuid"] as! String)
     }, onCompletion: { newUrl in
       resolve("\(newUrl)");
     }, onFailure: { error in
@@ -90,105 +76,10 @@ class VideoCompressor: RCTEventEmitter, URLSessionTaskDelegate {
     })
   }
     
-    @objc(cancelCompression:)
     func cancelCompression(uuid: String) -> Void {
         compressorExports[uuid]?.cancelExport()
     }
     
-func makeValidUri(filePath: String) -> String {
-    let fileWithUrl = URL(fileURLWithPath: filePath)
-    let absoluteUrl = fileWithUrl.deletingLastPathComponent()
-    let fileUrl = "file://\(absoluteUrl.path)/\(fileWithUrl.lastPathComponent)"
-    return fileUrl;
-}
-
-  @objc(upload:withOptions:withResolver:withRejecter:)
-  func upload(filePath: String, options: [String: Any], resolve:@escaping RCTPromiseResolveBlock, reject:@escaping RCTPromiseRejectBlock) -> Void {
-    let fileUrl = makeValidUri(filePath: filePath)
-    
-    guard let uuid = options["uuid"] as? String else {
-      let uploadError = UploadError(message: "UUID is missing")
-      reject("Upload Failed", "UUID is missing", uploadError)
-      return
-    }
-
-    guard let remoteUrl = options["url"] as? String else {
-      let uploadError = UploadError(message: "url is missing")
-      reject("Upload Failed", "url is missing", uploadError)
-      return
-    }
-
-    guard let method = options["method"] as? String else {
-      let uploadError = UploadError(message: "method is missing")
-      reject("Upload Failed", "method is missing", uploadError)
-      return
-    }
-
-    guard let file = URL(string: fileUrl) else{
-      let uploadError = UploadError(message: "invalid file url")
-      reject("Failed", "Upload Failed", uploadError)
-      return
-    }
-
-    let headers = options["headers"] as? [String: String] ?? [:]
-
-    let url = URL(string: remoteUrl)!
-    var request = URLRequest(url: url)
-    request.httpMethod=method
-    for(header, v) in headers{
-      request.setValue(v, forHTTPHeaderField: header)
-    }
-
-    uploadResolvers[uuid] = resolve
-    uploadRejectors[uuid] = reject
-    // TODO: ADD Headers
-    let config = URLSessionConfiguration.background(withIdentifier: uuid)
-    let session = URLSession(configuration: config, delegate: self, delegateQueue: nil)
-    let task = session.uploadTask(with: request, fromFile: file)
-    task.resume()
-  }
-
-  func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
-    guard let uuid = session.configuration.identifier else {return}
-    guard let reject = uploadRejectors[uuid] else{return}
-    guard let resolve = uploadResolvers[uuid] else{return}
-    guard error == nil else {
-      reject("failed", "Upload Failed", error)
-      uploadRejectors[uuid] = nil
-      return;
-    }
-
-    guard let response = task.response  as? HTTPURLResponse else {
-      let uploadError = UploadError(message: "Response is not defined")
-      reject("failed", "Upload Failed", uploadError)
-      uploadRejectors[uuid] = nil
-      return;
-    }
-
-    let result: [String : Any] = ["status": response.statusCode, "headers": response.allHeaderFields, "body": ""]
-    
-    resolve(result)
-    uploadResolvers[uuid] = nil
-  }
-    
-  func urlSession(_ session: URLSession, task: URLSessionTask, didSendBodyData bytesSent: Int64, totalBytesSent: Int64, totalBytesExpectedToSend: Int64)
-  {
-    guard let uuid = session.configuration.identifier else {return}
-    self.sendEvent(withName: "VideoCompressorProgress", body: ["uuid": uuid, "data": ["written": totalBytesSent, "total": totalBytesExpectedToSend]])
-  }
-
-  override func supportedEvents() -> [String]! {
-    return ["videoCompressProgress", "VideoCompressorProgress", "backgroundTaskExpired","downloadProgress"]
-  }
-
-  override func stopObserving() -> Void {
-    hasListener = false
-  }
-
-  override func startObserving() -> Void {
-    hasListener = true
-  }
-    
     func getfileSize(forURL url: Any) -> Double {
         var fileURL: URL?
         var fileSize: Double = 0.0
@@ -213,12 +104,12 @@ func makeValidUri(filePath: String) -> String {
   func compressVideo(url: URL, options: [String: Any], onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
       let uuid:String = options["uuid"] as! String
       
-      ImageCompressor.getAbsoluteVideoPath(url.absoluteString, uuid: uuid) { absoluteVideoPath in
+      VideoCompressor.getAbsoluteVideoPath(url.absoluteString, options: options) { absoluteVideoPath in
         var minimumFileSizeForCompress:Double=0.0;
-        let videoURL = URL(string: absoluteVideoPath!)
+          let videoURL = URL(string: absoluteVideoPath)
         let fileSize=self.getfileSize(forURL: videoURL!);
           if((options["minimumFileSizeForCompress"]) != nil)
-        {
+        {0
               minimumFileSizeForCompress=options["minimumFileSizeForCompress"] as! Double;
         }
         if(fileSize>minimumFileSizeForCompress)
@@ -280,6 +171,7 @@ func makeValidUri(filePath: String) -> String {
     func autoCompressionHelper(url: URL, options: [String: Any], onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
         let maxSize:Float = options["maxSize"] as! Float;
         let uuid:String = options["uuid"] as! String
+        let progressDivider=options["progressDivider"] as? Int ?? 0
     
         let asset = AVAsset(url: url)
         guard asset.tracks.count >= 1 else {
@@ -304,7 +196,7 @@ func makeValidUri(filePath: String) -> String {
             height: Int(resultHeight), width: Int(resultWidth)
             );
         
-        exportVideoHelper(url: url, asset: asset, bitRate: videoBitRate, resultWidth: resultWidth, resultHeight: resultHeight,uuid: uuid) { progress in
+        exportVideoHelper(url: url, asset: asset, bitRate: videoBitRate, resultWidth: resultWidth, resultHeight: resultHeight,uuid: uuid,progressDivider: progressDivider) { progress in
             onProgress(progress)
         } onCompletion: { outputURL in
             onCompletion(outputURL)
@@ -316,6 +208,7 @@ func makeValidUri(filePath: String) -> String {
     func manualCompressionHelper(url: URL, options: [String: Any], onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
         let uuid:String = options["uuid"] as! String
         var bitRate=options["bitrate"] as! Float?;
+        let progressDivider=options["progressDivider"] as? Int ?? 0
         let asset = AVAsset(url: url)
         guard asset.tracks.count >= 1 else {
           let error = CompressionError(message: "Invalid video URL, no track found")
@@ -343,7 +236,7 @@ func makeValidUri(filePath: String) -> String {
 
         let videoBitRate = bitRate ?? height*width*1.5
 
-        exportVideoHelper(url: url, asset: asset, bitRate: Int(videoBitRate), resultWidth: width, resultHeight: height,uuid: uuid) { progress in
+        exportVideoHelper(url: url, asset: asset, bitRate: Int(videoBitRate), resultWidth: width, resultHeight: height,uuid: uuid,progressDivider: progressDivider) { progress in
             onProgress(progress)
         } onCompletion: { outputURL in
             onCompletion(outputURL)
@@ -352,12 +245,13 @@ func makeValidUri(filePath: String) -> String {
         }
       }
     
-    func exportVideoHelper(url: URL,asset: AVAsset, bitRate: Int,resultWidth:Float,resultHeight:Float,uuid:String, onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
-        var videoCompressionCounter:Int=0
+    func exportVideoHelper(url: URL,asset: AVAsset, bitRate: Int,resultWidth:Float,resultHeight:Float,uuid:String,progressDivider: Int, onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
+        var currentVideoCompression:Int=0
+        
         var tmpURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
           .appendingPathComponent(ProcessInfo().globallyUniqueString)
           .appendingPathExtension("mp4")
-        tmpURL = URL(string:makeValidUri(filePath: tmpURL.absoluteString))!
+        tmpURL = URL(string: Utils.makeValidUri(filePath: tmpURL.absoluteString))!
         
         let exporter = NextLevelSessionExporter(withAsset: asset)
         exporter.outputURL = tmpURL
@@ -384,15 +278,14 @@ func makeValidUri(filePath: String) -> String {
         
         compressorExports[uuid] = exporter
         exporter.export(progressHandler: { (progress) in
-            let _progress:Float=progress*100;
-            if(Int(_progress)==videoCompressionCounter)
+            let roundProgress:Int=Int((progress*100).rounded());
+            if(progressDivider==0||(roundProgress%progressDivider==0&&roundProgress>currentVideoCompression))
             {
-            videoCompressionCounter=Int(_progress)+self.videoCompressionThreshold
+            currentVideoCompression=roundProgress
             onProgress(progress)
             }
-            
         }, completionHandler: { result in
-            videoCompressionCounter=0;
+            currentVideoCompression=0;
             switch exporter.status {
             case .completed:
               onCompletion(exporter.outputURL!)
@@ -413,4 +306,132 @@ func makeValidUri(filePath: String) -> String {
         return tracks[0];
         }
     
+    
+    func getVideoMetaData(_ filePath: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            VideoCompressor.getAbsoluteVideoPath(filePath, options: [:]) { absoluteImagePath in
+                if absoluteImagePath.hasPrefix("file://") {
+                    let absoluteImagePath = absoluteImagePath.replacingOccurrences(of: "file://", with: "")
+                    let fileManager = FileManager.default
+                    var isDir: ObjCBool = false
+                    
+                    if !fileManager.fileExists(atPath: absoluteImagePath, isDirectory: &isDir) || isDir.boolValue {
+                        let err = NSError(domain: "file not found", code: -15, userInfo: nil)
+                        reject(String(err.code), err.localizedDescription, err)
+                        return
+                    }
+                    
+                    let attrs = try? fileManager.attributesOfItem(atPath: absoluteImagePath)
+                    if let fileSize = attrs?[FileAttributeKey.size] as? UInt64 {
+                        let fileSizeString = String(fileSize)
+                        
+                        var result: [String: Any] = [:]
+                        let assetOptions: [String: Any] = [AVURLAssetPreferPreciseDurationAndTimingKey: true]
+                        let asset = AVURLAsset(url: URL(fileURLWithPath: absoluteImagePath), options: assetOptions)
+                        if let avAsset = asset.tracks(withMediaType: .video).first {
+                            let size = avAsset.naturalSize
+                            let _extension = (absoluteImagePath as NSString).pathExtension
+                            let time = asset.duration
+                            let seconds = Int(ceil(Double(time.value / Int64(time.timescale))))
+                            
+                            result["width"] = String(format: "%.2f", size.width)
+                            result["height"] = String(format: "%.2f", size.height)
+                            result["extension"] = _extension
+                            result["size"] = fileSizeString
+                            result["duration"] = String(seconds)
+                            
+                            var commonMetadata: [AVMetadataItem] = []
+                            for key in self.metadatas {
+                                let items = AVMetadataItem.metadataItems(from: asset.commonMetadata, withKey: key, keySpace: AVMetadataKeySpace.common)
+                                commonMetadata.append(contentsOf: items)
+                            }
+                            
+                            for item in commonMetadata {
+                                if let value = item.value {
+                                    result[item.commonKey!.rawValue] = value
+                                }
+                            }
+                            
+                            resolve(result)
+                        }
+                    }
+                }
+            }
+        } catch {
+            reject(error.localizedDescription, error.localizedDescription, nil)
+        }
+    }
+    
+    static func getAbsoluteVideoPath(_ videoPath: String, options: [String: Any], completionHandler: @escaping (String) -> Void) {
+        if videoPath.hasPrefix("http://") || videoPath.hasPrefix("https://") {
+            let uuid=options["uuid"] as? String ?? ""
+            let progressDivider=options["progressDivider"] as? Int ?? 0
+            Downloader.downloadFileAndSaveToCache(videoPath, uuid: uuid,progressDivider:progressDivider) { downloadedPath in
+                completionHandler(downloadedPath)
+            }
+            return
+        } else if !videoPath.contains("ph://") {
+            completionHandler(videoPath)
+            return
+        }
+        let assetId = videoPath.replacingOccurrences(of: "ph://", with: "")
+        let outputFileType = AVFileType.mp4
+        let pressetType = AVAssetExportPresetPassthrough
+
+        if assetId.isEmpty {
+            let error = NSError(domain: "RNGalleryManager", code: -91, userInfo: nil)
+            let exception = NSException(name: NSExceptionName(rawValue: "RNGalleryManager"), reason: "Empty asset ID.", userInfo: nil)
+            exception.raise()
+            return
+        }
+
+        let localIds = [assetId]
+        guard let videoAsset = PHAsset.fetchAssets(withLocalIdentifiers: localIds, options: nil).firstObject else {
+            return
+        }
+
+        let mimeType = UTTypeCopyPreferredTagWithClass(outputFileType as CFString, kUTTagClassMIMEType)?.takeRetainedValue() as String? ?? ""
+        let uti = UTTypeCreatePreferredIdentifierForTag(kUTTagClassMIMEType, mimeType as CFString, nil)?.takeRetainedValue() as String? ?? ""
+        let extensionValue = UTTypeCopyPreferredTagWithClass(uti as CFString, kUTTagClassFilenameExtension)?.takeRetainedValue() as String? ?? ""
+        let path = Utils.generateCacheFilePath(extensionValue)
+        let outputUrl = URL(string: "file://\(path)")!
+
+        let videoRequestOptions = PHVideoRequestOptions()
+        videoRequestOptions.isNetworkAccessAllowed = true
+        videoRequestOptions.deliveryMode = .highQualityFormat
+
+        PHImageManager.default().requestExportSession(forVideo: videoAsset, options: videoRequestOptions, exportPreset: pressetType) { exportSession, _ in
+            guard let exportSession = exportSession else {
+                let error = NSError(domain: "RNGalleryManager", code: -91, userInfo: nil)
+                let exception = NSException(name: NSExceptionName(rawValue: "RNGalleryManager"), reason: "Export session is nil.", userInfo: nil)
+                exception.raise()
+                return
+            }
+
+            exportSession.shouldOptimizeForNetworkUse = true
+            exportSession.outputFileType = outputFileType
+            exportSession.outputURL = outputUrl
+
+            exportSession.exportAsynchronously {
+                switch exportSession.status {
+                case .failed:
+                    let error = exportSession.error ?? NSError(domain: "RNGalleryManager", code: -91, userInfo: nil)
+                    let codeWithDomain = "E\(error.localizedDescription)\(error)"
+                    let exception = NSException(name: NSExceptionName(rawValue: codeWithDomain), reason: "Video export failed.", userInfo: nil)
+                    exception.raise()
+                case .cancelled:
+                    let error = NSError(domain: "RNGalleryManager", code: -91, userInfo: nil)
+                    let exception = NSException(name: NSExceptionName(rawValue: "RNGalleryManager"), reason: "Video export cancelled.", userInfo: nil)
+                    exception.raise()
+                case .completed:
+                    completionHandler(outputUrl.absoluteString)
+                default:
+                    let error = NSError(domain: "RNGalleryManager", code: -91, userInfo: nil)
+                    let exception = NSException(name: NSExceptionName(rawValue: "RNGalleryManager"), reason: "Unknown status.", userInfo: nil)
+                    exception.raise()
+                }
+            }
+        }
+    }
+    
     }