react-native-compressor 1.7.1 → 1.8.0

package/ios/Image/ImageCompressor.swift

@@ -0,0 +1,354 @@
+import Accelerate
+import CoreGraphics
+import Photos
+import React
+import Foundation
+import MobileCoreServices
+
+
+class ImageCompressor {
+    static func findTargetSize(_ image: UIImage, maxWidth: Int, maxHeight: Int) -> CGSize {
+        let width = image.size.width
+        let height = image.size.height
+
+        if width > height {
+            let newHeight = height / (width / CGFloat(maxWidth))
+            return CGSize(width: CGFloat(maxWidth), height: newHeight)
+        }
+
+        let newWidth = width / (height / CGFloat(maxHeight))
+        return CGSize(width: newWidth, height: CGFloat(maxHeight))
+    }
+
+    
+    static func decodeImage(_ value: String) -> UIImage? {
+        if let data = Data(base64Encoded: value, options: .ignoreUnknownCharacters) {
+            return UIImage(data: data)
+        }
+        return nil
+    }
+
+    
+    static func loadImage(_ path: String) -> UIImage? {
+        var image: UIImage?
+
+        if path.hasPrefix("data:") || path.hasPrefix("file:") {
+            if let imageUrl = URL(string: path), let imageData = try? Data(contentsOf: imageUrl) {
+                image = UIImage(data: imageData)
+            }
+        } else {
+            image = UIImage(contentsOfFile: path)
+        }
+
+        return image
+    }
+
+    
+    static func manualResize(_ image: UIImage, maxWidth: Int, maxHeight: Int) -> UIImage {
+        let targetSize = findTargetSize(image, maxWidth: maxWidth, maxHeight: maxHeight)
+
+        if let cgImage = image.cgImage {
+            let sourceWidth = Int(image.size.width)
+            let sourceHeight = Int(image.size.height)
+            let targetWidth = Int(targetSize.width)
+            let targetHeight = Int(targetSize.height)
+            let bytesPerPixel = 4
+            let sourceBytesPerRow = sourceWidth * bytesPerPixel
+            let targetBytesPerRow = targetWidth * bytesPerPixel
+            let bitsPerComponent = 8
+
+            let colorSpace = CGColorSpaceCreateDeviceRGB()
+
+            var sourceData = [UInt8](repeating: 0, count: sourceHeight * sourceBytesPerRow)
+            let context = CGContext(data: &sourceData,
+                                    width: Int(sourceWidth),
+                                    height: Int(sourceHeight),
+                                    bitsPerComponent: bitsPerComponent,
+                                    bytesPerRow: sourceBytesPerRow,
+                                    space: colorSpace,
+                                    bitmapInfo: CGImageAlphaInfo.premultipliedFirst.rawValue | CGBitmapInfo.byteOrder32Big.rawValue)
+
+            context?.draw(cgImage, in: CGRect(x: 0, y: 0, width: sourceWidth, height: sourceHeight))
+         
+
+            var targetData = [UInt8](repeating: 0, count: targetWidth * targetHeight * bytesPerPixel)
+
+            var srcBuffer = vImage_Buffer(data: &sourceData, height: vImagePixelCount(sourceHeight), width: vImagePixelCount(sourceWidth), rowBytes: sourceBytesPerRow)
+            var targetBuffer = vImage_Buffer(data: &targetData, height: vImagePixelCount(targetHeight), width: vImagePixelCount(targetWidth), rowBytes: targetBytesPerRow)
+
+            let error = vImageScale_ARGB8888(&srcBuffer, &targetBuffer, nil, vImage_Flags(kvImageHighQualityResampling))
+
+            if error != kvImageNoError {
+                free(&targetData)
+                let exception = NSException(name: NSExceptionName(rawValue: "drawing_error"), reason: "Problem while rendering your image", userInfo: nil)
+                exception.raise()
+            }
+
+            let targetContext = CGContext(data: &targetData,
+                                          width: targetWidth,
+                                          height: targetHeight,
+                                          bitsPerComponent: bitsPerComponent,
+                                          bytesPerRow: targetBytesPerRow,
+                                          space: colorSpace,
+                                          bitmapInfo: CGImageAlphaInfo.premultipliedFirst.rawValue | CGBitmapInfo.byteOrder32Big.rawValue)
+
+            let targetRef = targetContext?.makeImage()
+            let resizedImage = UIImage(cgImage: targetRef!)
+            
+
+            return resizedImage
+        }
+        return UIImage()
+    }
+
+    
+    static func manualCompress(_ image: UIImage, output: Int, quality: Float, outputExtension: String, isBase64: Bool) -> String {
+        var data: Data
+        var exception: NSException?
+
+        switch OutputType(rawValue: output)! {
+        case .jpg:
+            data = image.jpegData(compressionQuality: CGFloat(quality))!
+        case .png:
+            data = image.pngData()!
+        }
+
+        if isBase64 {
+            return data.base64EncodedString(options: [])
+        } else {
+            let filePath = Utils.generateCacheFilePath(outputExtension)
+            do {
+                try data.write(to: URL(fileURLWithPath: filePath), options: .atomic)
+                let returnablePath = makeValidUri(filePath)
+                return returnablePath
+            } catch {
+                exception = NSException(name: NSExceptionName(rawValue: "file_error"), reason: "Error writing file", userInfo: nil)
+                exception?.raise()
+            }
+        }
+
+        return ""
+    }
+
+    
+    static func scaleAndRotateImage(_ image: UIImage) -> UIImage {
+        if image.imageOrientation == .up {
+            return image
+        }
+
+        var transform = CGAffineTransform.identity
+
+        switch image.imageOrientation {
+        case .down, .downMirrored:
+            transform = transform.translatedBy(x: image.size.width, y: image.size.height)
+            transform = transform.rotated(by: CGFloat.pi)
+        case .left, .leftMirrored:
+            transform = transform.translatedBy(x: image.size.width, y: 0)
+            transform = transform.rotated(by: CGFloat.pi / 2)
+        case .right, .rightMirrored:
+            transform = transform.translatedBy(x: 0, y: image.size.height)
+            transform = transform.rotated(by: -CGFloat.pi / 2)
+        default:
+            break
+        }
+
+        switch image.imageOrientation {
+        case .upMirrored, .downMirrored:
+            transform = transform.translatedBy(x: image.size.width, y: 0)
+            transform = transform.scaledBy(x: -1, y: 1)
+        case .leftMirrored, .rightMirrored:
+            transform = transform.translatedBy(x: image.size.height, y: 0)
+            transform = transform.scaledBy(x: -1, y: 1)
+        default:
+            break
+        }
+
+        if let cgImage = image.cgImage, let colorSpace = cgImage.colorSpace {
+            guard let context = CGContext(data: nil, width: Int(image.size.width), height: Int(image.size.height),
+                                          bitsPerComponent: cgImage.bitsPerComponent, bytesPerRow: 0,
+                                          space: colorSpace, bitmapInfo: cgImage.bitmapInfo.rawValue) else {
+                return image
+            }
+
+            context.concatenate(transform)
+
+            switch image.imageOrientation {
+            case .left, .leftMirrored, .right, .rightMirrored:
+                context.draw(cgImage, in: CGRect(x: 0, y: 0, width: image.size.height, height: image.size.width))
+            default:
+                context.draw(cgImage, in: CGRect(x: 0, y: 0, width: image.size.width, height: image.size.height))
+            }
+
+            if let rotatedCGImage = context.makeImage() {
+                return UIImage(cgImage: rotatedCGImage)
+            }
+        }
+
+        return image
+    }
+
+    
+    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 manualCompressHandler(_ imagePath: String, options: ImageCompressorOptions) -> String {
+        var exception: NSException?
+        var image: UIImage?
+
+        switch options.input {
+        case .base64:
+            image = ImageCompressor.decodeImage(imagePath)
+        case .uri:
+            image = ImageCompressor.loadImage(imagePath)
+        }
+
+        if let _image = image {
+            image = ImageCompressor.scaleAndRotateImage(_image)
+            let outputExtension = ImageCompressorOptions.getOutputInString(options.output)
+            let resizedImage = ImageCompressor.manualResize(_image, maxWidth: options.maxWidth, maxHeight: options.maxHeight)
+            let isBase64 = options.returnableOutputType == .rbase64
+            return ImageCompressor.manualCompress(resizedImage, output: options.output.rawValue, quality: options.quality, outputExtension: outputExtension, isBase64: isBase64)
+        } else {
+            exception = NSException(name: NSExceptionName(rawValue: "unsupported_value"), reason: "Unsupported value type.", userInfo: nil)
+            exception?.raise()
+        }
+
+        return ""
+    }
+
+    
+    static func autoCompressHandler(_ imagePath: String, options: ImageCompressorOptions) -> String {
+        var exception: NSException?
+        var image = ImageCompressor.loadImage(imagePath)
+
+        if var image = image {
+            image = ImageCompressor.scaleAndRotateImage(image)
+            let outputExtension = ImageCompressorOptions.getOutputInString(options.output)
+
+            var actualHeight = image.size.height
+            var actualWidth = image.size.width
+            let maxHeight: CGFloat = 1280.0
+            let maxWidth: CGFloat = 1280.0
+            var imgRatio = actualWidth / actualHeight
+            let maxRatio = maxWidth / maxHeight
+            let compressionQuality: CGFloat = 0.8
+
+            if actualHeight > maxHeight || actualWidth > maxWidth {
+                if imgRatio < maxRatio {
+                    imgRatio = maxHeight / actualHeight
+                    actualWidth = imgRatio * actualWidth
+                    actualHeight = maxHeight
+                } else if imgRatio > maxRatio {
+                    imgRatio = maxWidth / actualWidth
+                    actualHeight = imgRatio * actualHeight
+                    actualWidth = maxWidth
+                } else {
+                    actualHeight = maxHeight
+                    actualWidth = maxWidth
+                }
+            }
+
+            let rect = CGRect(x: 0.0, y: 0.0, width: actualWidth, height: actualHeight)
+            UIGraphicsBeginImageContext(rect.size)
+            image.draw(in: rect)
+            if let img = UIGraphicsGetImageFromCurrentImageContext() {
+                let imageData = img.jpegData(compressionQuality: compressionQuality)
+                UIGraphicsEndImageContext()
+                let filePath = Utils.generateCacheFilePath(outputExtension)
+                do {
+                    try imageData?.write(to: URL(fileURLWithPath: filePath), options: .atomic)
+                    let returnablePath = ImageCompressor.makeValidUri(filePath)
+                    return returnablePath
+                } catch {
+                    exception = NSException(name: NSExceptionName(rawValue: "file_error"), reason: "Error writing file", userInfo: nil)
+                    exception?.raise()
+                }
+            }
+        } else {
+            exception = NSException(name: NSExceptionName(rawValue: "unsupported_value"), reason: "Unsupported value type.", userInfo: nil)
+            exception?.raise()
+        }
+
+        return ""
+    }
+    
+    static func getAbsoluteImagePath(_ imagePath: String, options: ImageCompressorOptions, completionHandler: @escaping (String) -> Void) {
+            if imagePath.hasPrefix("http://") || imagePath.hasPrefix("https://") {
+                let uuid=options.uuid ?? ""
+                let progressDivider=options.progressDivider
+                Downloader.downloadFileAndSaveToCache(imagePath, uuid: uuid,progressDivider: progressDivider) { downloadedPath in
+                    completionHandler(downloadedPath)
+                }
+                return
+            } else if !imagePath.contains("ph://") {
+                completionHandler(imagePath)
+                return
+            }
+            
+            let imageURL = URL(string: imagePath.replacingOccurrences(of: " ", with: "%20"))
+            var size = CGSize.zero
+            var scale: CGFloat = 1
+            var resizeMode = RCTResizeMode.contain
+            var assetID = ""
+            var results: PHFetchResult<PHAsset>?
+            
+            if imageURL?.scheme?.caseInsensitiveCompare("assets-library") == .orderedSame {
+                assetID = imageURL?.absoluteString ?? ""
+                results = PHAsset.fetchAssets(withALAssetURLs: [imageURL!], options: nil)
+            } else {
+                assetID = imagePath.replacingOccurrences(of: "ph://", with: "")
+                results = PHAsset.fetchAssets(withLocalIdentifiers: [assetID], options: nil)
+            }
+            
+            guard let asset = results?.firstObject else {
+                return
+            }
+            
+            let imageOptions = PHImageRequestOptions()
+            imageOptions.isNetworkAccessAllowed = true
+            imageOptions.deliveryMode = .highQualityFormat
+            
+            var useMaximumSize = size.equalTo(CGSize.zero)
+            var targetSize: CGSize
+            
+            if useMaximumSize {
+                targetSize = PHImageManagerMaximumSize
+                imageOptions.resizeMode = .none
+            } else {
+                targetSize = CGSize(width: size.width * scale, height: size.height * scale)
+                imageOptions.resizeMode = .fast
+            }
+            
+            var contentMode = PHImageContentMode.aspectFill
+            if resizeMode == .contain {
+                contentMode = .aspectFit
+            }
+            
+            PHImageManager.default().requestImage(for: asset, targetSize: targetSize, contentMode: contentMode, options: imageOptions) { result, info in
+                if let result = result {
+                    let imageName = assetID.replacingOccurrences(of: "/", with: "_")
+                    if let imagePath = saveImageIntoCache(result, withName: imageName) {
+                        completionHandler(imagePath)
+                    }
+                }
+            }
+        }
+    
+    static func saveImageIntoCache(_ image: UIImage, withName name: String) -> String? {
+            if let imageData = image.jpegData(compressionQuality: 1),
+               let filePath: String? = Utils.generateCacheFilePath("jpg") {
+                do {
+                    try imageData.write(to: URL(fileURLWithPath: filePath!), options: .atomic)
+                    return filePath
+                } catch {
+                    return nil
+                }
+            }
+            return nil
+        }
+}

package/ios/Image/ImageCompressorOptions.swift

@@ -0,0 +1,93 @@
+import Foundation
+import UIKit
+
+enum OutputType: Int {
+    case jpg
+    case png
+}
+
+enum InputType: Int {
+    case base64
+    case uri
+}
+
+enum ReturnableOutputType: Int {
+    case rbase64
+    case ruri
+}
+
+class ImageCompressorOptions: NSObject {
+    static func fromDictionary(_ dictionary: [String: Any]?) -> ImageCompressorOptions {
+        let options = ImageCompressorOptions()
+        
+        guard let dictionary = dictionary else {
+            return options
+        }
+        
+        for (key, value) in dictionary {
+            switch key {
+            case "autoCompress":
+                options.autoCompress = (value as? Bool) ?? false
+            case "maxWidth":
+                options.maxWidth = (value as? Int) ?? 1280
+            case "maxHeight":
+                options.maxHeight = (value as? Int) ?? 1280
+            case "progressDivider":
+                options.progressDivider = (value as? Int) ?? 0
+            case "quality":
+                options.quality = (value as? Float) ?? 0.8
+            case "input":
+                options.parseInput(value as? String)
+            case "output":
+                options.parseOutput(value as? String)
+            case "returnableOutputType":
+                options.parseReturnableOutput(value as? String)
+            case "uuid":
+                options.uuid = value as? String
+            default:
+                break
+            }
+        }
+        
+        return options
+    }
+    
+    static func getOutputInString(_ output: OutputType) -> String {
+        return (output == .jpg) ? "jpg" : "png"
+    }
+    
+    var autoCompress: Bool = true
+    var maxWidth: Int = 1280
+    var maxHeight: Int = 1280
+    var progressDivider: Int = 0
+    var quality: Float = 0.8
+    var input: InputType = .uri
+    var output: OutputType = .jpg
+    var returnableOutputType: ReturnableOutputType = .ruri
+    var uuid: String?
+    
+    override init() {
+        super.init()
+    }
+    
+    private func parseInput(_ input: String?) {
+        guard let input = input else { return }
+        
+        let inputTranslations: [String: InputType] = ["base64": .base64, "uri": .uri]
+        self.input = inputTranslations[input] ?? .uri
+    }
+    
+    private func parseReturnableOutput(_ input: String?) {
+        guard let input = input else { return }
+        
+        let outputTranslations: [String: ReturnableOutputType] = ["base64": .rbase64, "uri": .ruri]
+        self.returnableOutputType = outputTranslations[input] ?? .ruri
+    }
+    
+    private func parseOutput(_ output: String?) {
+        guard let output = output else { return }
+        
+        let outputTranslations: [String: OutputType] = ["jpg": .jpg, "png": .png]
+        self.output = outputTranslations[output] ?? .jpg
+    }
+}

package/ios/Image/ImageMain.swift

@@ -0,0 +1,27 @@
+//
+//  ImageMain.swift
+//  react-native-compressor
+//
+//  Created by Numan on 10/09/2023.
+//
+
+import Foundation
+class ImageMain {
+    static func image_compress(_ imagePath: String, optionMap: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            let options = ImageCompressorOptions.fromDictionary(optionMap as! [String : Any])
+            ImageCompressor.getAbsoluteImagePath(imagePath, options: options) { absoluteImagePath in
+                if options.autoCompress {
+                    let result = ImageCompressor.autoCompressHandler(absoluteImagePath, options: options)
+                    resolve(result)
+                } else {
+                    let result = ImageCompressor.manualCompressHandler(absoluteImagePath, options: options)
+                    resolve(result)
+                }
+                MediaCache.removeCompletedImagePath(absoluteImagePath)
+            }
+        } catch {
+            reject(error.localizedDescription, error.localizedDescription, nil)
+        }
+    }
+}

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