react-native-compressor 1.7.1 → 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)
+        }
+    }
+    
+}