react-native-compressor 1.7.2 → 1.8.1

package/ios/Utils/Downloader.swift

@@ -0,0 +1,157 @@
+import Foundation
+
+class Downloader: NSObject, URLSessionDownloadDelegate {
+    private var session: URLSession?
+    private var task: URLSessionDownloadTask?
+    private var statusCode: NSNumber?
+    private var lastProgressEmitTimestamp: TimeInterval = 0
+    private var lastProgressValue: NSNumber?
+    private var contentLength: NSNumber?
+    private var bytesWritten: NSNumber?
+    private var resumeData: Data?
+    private var toFile: String?
+    private var progressDivider: Int=0
+    
+    typealias ProgressCallback = (NSNumber) -> Void
+    typealias DownloadCompleteCallback = (String) -> Void
+    typealias ErrorCallback = (Error) -> Void
+    
+    var globalProgressCallback: ProgressCallback?
+    var globalDownloadCompleteCallback: DownloadCompleteCallback?
+    var globalErrorCallback: ErrorCallback?
+    
+    private var fileHandle: FileHandle?
+    
+    func generateCacheFilePath(extension ext: String) -> String {
+        let uuid = UUID()
+        let imageNameWithoutExtension = uuid.uuidString
+        let imageName = imageNameWithoutExtension + "." + ext
+        let filePath = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent(imageName).path
+        return filePath
+    }
+    
+    static func downloadFileAndSaveToCache(_ fileUrl: String, uuid: String,progressDivider: Int, completion: @escaping (String) -> Void) {
+        let downloader = Downloader()
+        
+        downloader.downloadFile(fromUrl: fileUrl,progressDivider: progressDivider) { filePath in
+            MediaCache.addCompletedImagePath(filePath)
+            print("download completed file path: \(filePath)")
+            completion(filePath)
+        } progressCallback: { progress in
+            EventEmitterHandler.emitDownloadProgress(progress, uuid: uuid)
+        } errorCallback: { error in
+            print("error downloadFile", error)
+        }
+    }
+    
+    func downloadFile(fromUrl: String, progressDivider: Int, downloadCompleteCallback: @escaping DownloadCompleteCallback, progressCallback: @escaping ProgressCallback, errorCallback: @escaping ErrorCallback) -> String? {
+        globalProgressCallback = progressCallback
+        globalDownloadCompleteCallback = downloadCompleteCallback
+        globalErrorCallback = errorCallback
+        self.progressDivider=progressDivider
+        
+        lastProgressEmitTimestamp = 0
+        bytesWritten = 0
+        
+        guard let url = URL(string: fromUrl) else {
+            let error = NSError(domain: "Downloader", code: NSURLErrorBadURL, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"])
+            globalErrorCallback?(error)
+            return nil
+        }
+        
+        let fileExtension = url.pathExtension
+        toFile = generateCacheFilePath(extension: fileExtension)
+        
+        if FileManager.default.fileExists(atPath: toFile!) {
+            fileHandle = FileHandle(forWritingAtPath: toFile!)
+            
+            if fileHandle == nil {
+                let error = NSError(domain: "Downloader", code: NSURLErrorFileDoesNotExist, userInfo: [NSLocalizedDescriptionKey: "Failed to write target file at path: \(toFile!)"])
+                globalErrorCallback?(error)
+                return nil
+            } else {
+                fileHandle?.closeFile()
+            }
+        }
+        
+        let config = URLSessionConfiguration.default
+        session = URLSession(configuration: config, delegate: self, delegateQueue: nil)
+        task = session?.downloadTask(with: url)
+        task?.resume()
+        
+        return nil
+    }
+    
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didWriteData bytesWritten: Int64, totalBytesWritten: Int64, totalBytesExpectedToWrite: Int64) {
+        guard let httpResponse = downloadTask.response as? HTTPURLResponse else { return }
+        
+        statusCode = NSNumber(value: httpResponse.statusCode)
+        contentLength = NSNumber(value: httpResponse.expectedContentLength)
+        
+        if statusCode?.intValue == 200 {
+            self.bytesWritten = NSNumber(value: totalBytesWritten)
+            
+            let doubleBytesWritten = Double(truncating: self.bytesWritten!)
+            let doubleContentLength = Double(truncating: contentLength!)
+            let doublePercents = doubleBytesWritten / doubleContentLength * 100
+            let progress = NSNumber(value: floor(doublePercents))
+            
+            if self.progressDivider==0||progress.intValue % self.progressDivider == 0 {
+                if (progress != lastProgressValue) || (bytesWritten == contentLength as! Int64) {
+                    lastProgressValue = progress
+                    let progressPercentage = NSNumber(value: Double(truncating: self.bytesWritten!) / Double(truncating: contentLength!))
+                    globalProgressCallback?(progressPercentage)
+                }
+            }
+        }
+    }
+    
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+        guard let httpResponse = downloadTask.response as? HTTPURLResponse else { return }
+        
+        if statusCode == nil {
+            statusCode = NSNumber(value: httpResponse.statusCode)
+        }
+        
+        let destURL = URL(fileURLWithPath: toFile!)
+        let fm = FileManager.default
+        
+        do {
+            if statusCode!.intValue >= 200 && statusCode!.intValue < 300 {
+                do {
+                    try fm.removeItem(at: destURL) // Remove file at destination path, if it exists
+                }
+                catch {
+                    print("unable to remove item \(error)")
+                }
+                try fm.moveItem(at: location, to: destURL)
+                bytesWritten = NSNumber(value: try fm.attributesOfItem(atPath: toFile!)[.size] as! Int64)
+            }
+        } catch {
+            print("Downloader: Unable to move tempfile to destination. \(error)")
+        }
+        
+        // Manually flush and invalidate the session to free up space
+        if session != nil {
+            session.flush(completionHandler: {
+                session.finishTasksAndInvalidate()
+            })
+        }
+        
+        let fileURL = URL(fileURLWithPath: toFile!)
+        globalDownloadCompleteCallback?(fileURL.absoluteString)
+    }
+    
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        if let error = error {
+            print("Downloader: didCompleteWithError \(error), \(error.localizedDescription)")
+            if error._code != NSURLErrorCancelled {
+                resumeData = (error as NSError).userInfo[NSURLSessionDownloadTaskResumeData] as? Data
+                
+                if resumeData == nil {
+                    globalErrorCallback?(error)
+                }
+            }
+        }
+    }
+}

package/ios/Utils/EventEmitterHandler.swift

@@ -0,0 +1,54 @@
+//
+//  EventEmitterHandler.swift
+//  react-native-compressor
+//
+//  Created by Numan on 09/09/2023.
+//
+
+import Foundation
+
+class EventEmitterHandler {
+    static var sharedCompressorObject: Any!
+    static var hasListener: Bool=false
+    
+    static func initCompressorInstance(_ object: Any) {
+        sharedCompressorObject = object
+    }
+    
+    
+    static func stopObserving() -> Void {
+      hasListener = false
+    }
+
+    static func startObserving() -> Void {
+      hasListener = true
+    }
+    
+    static func emitDownloadProgress(_ progress: NSNumber, uuid: String) {
+        var params = [String: Any]()
+        var data = [String: Any]()
+        params["uuid"] = uuid
+        data["progress"] = progress
+        params["data"] = data
+        
+        (sharedCompressorObject as AnyObject).sendEvent(withName: "downloadProgress", body: params)
+    }
+    
+    static func emitVideoCompressProgress(_ progress: Float, uuid: String) {
+        if(self.hasListener){
+            (sharedCompressorObject as AnyObject).sendEvent(withName: "videoCompressProgress", body: ["uuid": uuid, "data": ["progress": progress]])
+        }
+    }
+    
+    static func emituploadProgress(_ uuid: String, totalBytesSent: Int64, totalBytesExpectedToSend: Int64) {
+        if(self.hasListener){
+            (sharedCompressorObject as AnyObject).sendEvent(withName: "uploadProgress", body: ["uuid": uuid, "data": ["written": totalBytesSent, "total": totalBytesExpectedToSend]])
+        }
+    }
+    
+    static func emitBackgroundTaskExpired(_ backgroundTaskId:UIBackgroundTaskIdentifier) {
+        if(self.hasListener){
+            (sharedCompressorObject as AnyObject).sendEvent(withName: "backgroundTaskExpired", body: ["backgroundTaskId": backgroundTaskId])
+        }
+    }
+}

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)
+        }
+    }
+    
+}