react-native-compressor 1.19.0 → 2.0.0

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/compressor/Compressor.kt

@@ -11,6 +11,7 @@ import android.net.Uri
 import android.os.Build
 import android.util.Log
 import com.reactnativecompressor.Video.VideoCompressor.CompressionProgressListener
+import com.reactnativecompressor.Video.VideoCompressor.utils.CompressorUtils.ensureDecodableVideoFormat
 import com.reactnativecompressor.Video.VideoCompressor.utils.CompressorUtils.findTrack
 import com.reactnativecompressor.Video.VideoCompressor.utils.CompressorUtils.hasQTI
 import com.reactnativecompressor.Video.VideoCompressor.utils.CompressorUtils.prepareVideoHeight
@@ -788,32 +789,22 @@ object Compressor {
         inputFormat: MediaFormat,
         outputSurface: OutputSurface,
     ): MediaCodec {
-        val originalMime = inputFormat.getString(MediaFormat.KEY_MIME)!!
-
-        // Dolby Vision (video/dolby-vision) has no standalone decoder on most Android
-        // devices and throws NAME_NOT_FOUND. Profiles 8.1/8.4 carry an HEVC base layer
-        // that the standard HEVC decoder can render, so we remap them to HEVC. Profile 5
-        // has no compatible base layer; it is rejected by isUnsupportedDolbyVision() in
-        // start() before any codec/surface is created, so it never reaches here.
-        val resolvedMime = if (originalMime.equals("video/dolby-vision", ignoreCase = true)) {
-            inputFormat.setString(MediaFormat.KEY_MIME, MediaFormat.MIMETYPE_VIDEO_HEVC)
-            MediaFormat.MIMETYPE_VIDEO_HEVC
-        } else {
-            originalMime
-        }
 
-        val decoder = MediaCodec.createDecoderByType(resolvedMime)
+        // Some inputs (e.g. iPhone .MOV files) report a "video/dolby-vision" MIME
+        // type that many devices cannot decode. Remap to a decodable base-layer
+        // codec, or fail with a clear error, before creating the decoder (#398).
+        ensureDecodableVideoFormat(inputFormat)
 
-        try {
-            decoder.configure(inputFormat, outputSurface.getSurface(), null, 0)
-        } catch (e: Exception) {
-            // A codec that throws from configure() is unusable; release it so a
-            // configure failure here doesn't leak the decoder handle.
-            runCatching { decoder.release() }
-            throw e
+        // Clear Dolby Vision specific profile and level to prevent configuration failures
+        // when the MIME type has been remapped to AVC/HEVC.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            inputFormat.removeKey(MediaFormat.KEY_PROFILE)
+            inputFormat.removeKey(MediaFormat.KEY_LEVEL)
         }
 
-        Log.i("Compressor", "decoder selected: ${decoder.name} mime=$resolvedMime")
+        val decoder = MediaCodec.createDecoderByType(inputFormat.getString(MediaFormat.KEY_MIME)!!)
+
+        decoder.configure(inputFormat, outputSurface.getSurface(), null, 0)
 
         return decoder
     }

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/utils/CompressorUtils.kt

@@ -207,4 +207,76 @@ object CompressorUtils {
     }
     return false
   }
+
+  // MIME type reported by MediaExtractor for Dolby Vision tracks (e.g. iPhone .MOV files)
+  private const val MIMETYPE_VIDEO_DOLBY_VISION = "video/dolby-vision"
+
+  /**
+   * Check whether the device exposes a decoder for the given MIME type.
+   */
+  private fun hasDecoderForMime(mime: String): Boolean {
+    val codecList = MediaCodecList(MediaCodecList.REGULAR_CODECS)
+    for (codec in codecList.codecInfos) {
+      if (codec.isEncoder) continue
+      for (type in codec.supportedTypes) {
+        if (type.equals(mime, ignoreCase = true)) return true
+      }
+    }
+    return false
+  }
+
+  /**
+   * Resolve the backward-compatible base-layer MIME type for a Dolby Vision track.
+   *
+   * Dolby Vision profiles 8.x (DvheSt) and 4 (DvheDtr) carry an HEVC base layer, and
+   * profile 9 (DvavSe) carries an AVC base layer; these can be decoded by the standard
+   * HEVC/AVC decoders. Profiles 5 (DvheStn) and 7 (DvheDtb) have no usable single base
+   * layer, so they return null. When the profile is unknown we assume HEVC, which covers
+   * the common consumer case (e.g. iPhone records Dolby Vision profile 8).
+   */
+  private fun dolbyVisionBaseLayerMime(inputFormat: MediaFormat): String? {
+    if (!inputFormat.containsKey(MediaFormat.KEY_PROFILE)) {
+      return MediaFormat.MIMETYPE_VIDEO_HEVC
+    }
+    return when (inputFormat.getInteger(MediaFormat.KEY_PROFILE)) {
+      MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvavSe -> MediaFormat.MIMETYPE_VIDEO_AVC
+      MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheSt,
+      MediaCodecInfo.CodecProfileLevel.DolbyVisionProfileDvheDtr -> MediaFormat.MIMETYPE_VIDEO_HEVC
+      else -> null
+    }
+  }
+
+  /**
+   * Ensure the input video format can be decoded on this device.
+   *
+   * Some containers (notably iPhone `.MOV` files) expose the video track as
+   * `video/dolby-vision`. Many Android devices have no Dolby Vision decoder, so
+   * `MediaCodec.createDecoderByType("video/dolby-vision")` fails with NAME_NOT_FOUND.
+   * When the dedicated decoder is missing but the stream carries a backward-compatible
+   * base layer, this rewrites the format MIME to the base-layer codec so the standard
+   * HEVC/AVC decoder can decode it. If no compatible decoder exists, it throws a clear
+   * error instead of letting the cryptic native failure surface (see issue #398).
+   */
+  fun ensureDecodableVideoFormat(inputFormat: MediaFormat) {
+    val mime = inputFormat.getString(MediaFormat.KEY_MIME) ?: return
+    if (hasDecoderForMime(mime)) return
+
+    if (mime.equals(MIMETYPE_VIDEO_DOLBY_VISION, ignoreCase = true)) {
+      val fallbackMime = dolbyVisionBaseLayerMime(inputFormat)
+      if (fallbackMime != null && hasDecoderForMime(fallbackMime)) {
+        Log.w(
+          "Compressor",
+          "No Dolby Vision decoder on this device; decoding the $fallbackMime base layer instead."
+        )
+        inputFormat.setString(MediaFormat.KEY_MIME, fallbackMime)
+        return
+      }
+      throw IllegalStateException(
+        "This video uses Dolby Vision, which is not supported by this device's decoders " +
+          "and has no backward-compatible base layer to fall back to."
+      )
+    }
+
+    throw IllegalStateException("No decoder available for video format: $mime")
+  }
 }

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressorHelper.kt

@@ -5,6 +5,7 @@ import android.content.Context
 import android.media.MediaMetadataRetriever
 import android.net.Uri
 import android.os.Handler
+import android.os.Looper
 import android.os.PowerManager
 import android.os.PowerManager.WakeLock
 import com.facebook.react.bridge.LifecycleEventListener
@@ -58,7 +59,9 @@ class VideoCompressorHelper {
             if (!wakeLock!!.isHeld()) {
                 wakeLock!!.acquire()
             }
-            handler = Handler()
+            // Bind to the main Looper: under Nitro this runs on a background executor
+            // thread (no Looper), so the no-arg Handler() constructor would throw.
+            handler = Handler(Looper.getMainLooper())
             runnable = Runnable { }
             handler!!.post(runnable!!)
             return ""

package/ios/Audio/FormatConverter/FormatConverter+Compressed.swift

@@ -5,7 +5,7 @@ import AVFoundation
 // MARK: - internal helper functions
 
 
-public extension AVURLAsset {
+extension AVURLAsset {
     /// Audio format for  the file in the URL asset
     var audioFormat: AVAudioFormat? {
         // pull the input format out of the audio file...

package/ios/Audio/FormatConverter/FormatConverter+Utilities.swift

@@ -11,7 +11,7 @@ extension FormatConverter {
     }
 }
 
-public extension FormatConverter {
+extension FormatConverter {
     /// Is this file a PCM file?
     /// - Parameters:
     ///   - url: The URL to parse

package/ios/Audio/FormatConverter/FormatConverter.swift

@@ -19,7 +19,9 @@ import AVFoundation
  }
  ```
  */
-public class FormatConverter {
+// `internal` (not `public`): keeps these types out of the Swift↔C++ interop surface
+// that Nitro enables module-wide, which otherwise fails to link the nested `Options` type.
+class FormatConverter {
     // MARK: - properties
 
     /// The source audio file
@@ -122,7 +124,7 @@ public class FormatConverter {
 
 // MARK: - Definitions
 
-public enum AudioFileFormat: String {
+enum AudioFileFormat: String {
     case aac
     case aif
     case aifc
@@ -141,7 +143,7 @@ public enum AudioFileFormat: String {
     case wav
 }
 
-public extension FormatConverter {
+extension FormatConverter {
 
     /// FormatConverterCallback is the callback format for start()
     /// - Parameter: error This will contain one parameter of type Error which is nil if the conversion was successful.

package/ios/HybridCompressor.swift

@@ -0,0 +1,247 @@
+//
+//  HybridCompressor.swift
+//  react-native-compressor
+//
+//  Nitro HybridObject implementation of the single `Compressor` native module.
+//  It is a thin binding layer: it converts Nitro's `AnyMap` options into the
+//  `NSDictionary`/`[String: Any]` the existing domain code already consumes,
+//  bridges the Nitro `Promise` to the domain layer's `RCTPromiseResolveBlock`/
+//  `RCTPromiseRejectBlock`, and registers progress callbacks (keyed by `uuid`)
+//  with `EventEmitterHandler`. All heavy logic stays in the domain classes.
+//
+
+import Foundation
+import NitroModules
+
+// Previously imported from React. We define them locally so this Swift module no
+// longer needs to `import React`: under Nitro's Swift↔C++ interop, importing
+// React pulls move-only C++ types (e.g. jsinspector's RuntimeSamplingProfile)
+// into Swift's importer and fails to compile. These blocks are created here and
+// consumed by the domain layer entirely in Swift, so plain closures suffice.
+typealias RCTPromiseResolveBlock = (Any?) -> Void
+typealias RCTPromiseRejectBlock = (String?, String?, (any Error)?) -> Void
+
+private let videoCompressor = VideoCompressor()
+private let uploader = Uploader()
+
+final class HybridCompressor: HybridCompressorSpec {
+    // MARK: - Image
+
+    func image_compress(imagePath: String, optionMap: AnyMap, onDownloadProgress: ((Double) -> Void)?) throws -> Promise<String> {
+        let promise = Promise<String>()
+        var options = dictionary(from: optionMap)
+        // Remote-image download progress is keyed by `uuid` inside the Downloader. The JS
+        // layer no longer sends one (the callback is passed directly), so mint one here.
+        let uuid = (options["uuid"] as? String) ?? UUID().uuidString
+        options["uuid"] = uuid
+        EventEmitterHandler.registerDownloadProgress(uuid: uuid, onDownloadProgress)
+        ImageMain.image_compress(imagePath, optionMap: options as NSDictionary, resolve: resolveString(promise, uuid), reject: reject(promise, uuid))
+        return promise
+    }
+
+    func getImageMetaData(filePath: String) throws -> Promise<AnyMap> {
+        let promise = Promise<AnyMap>()
+        ImageMain.getImageMetaData(filePath, resolve: resolveAnyMap(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    // MARK: - Video
+
+    func compress(fileUrl: String, optionMap: AnyMap, onProgress: ((Double) -> Void)?, onDownloadProgress: ((Double) -> Void)?) throws -> Promise<String> {
+        let promise = Promise<String>()
+        let options = dictionary(from: optionMap)
+        let uuid = (options["uuid"] as? String) ?? ""
+        EventEmitterHandler.registerVideoCompressProgress(uuid: uuid, onProgress)
+        EventEmitterHandler.registerDownloadProgress(uuid: uuid, onDownloadProgress)
+        videoCompressor.compress(fileUrl: fileUrl, options: options, resolve: resolveString(promise, uuid), reject: reject(promise, uuid))
+        return promise
+    }
+
+    func cancelCompression(uuid: String) throws {
+        videoCompressor.cancelCompression(uuid: uuid)
+    }
+
+    func getVideoMetaData(filePath: String) throws -> Promise<AnyMap> {
+        let promise = Promise<AnyMap>()
+        videoCompressor.getVideoMetaData(filePath, resolve: resolveAnyMap(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    func activateBackgroundTask(options: AnyMap, onExpired: (() -> Void)?) throws -> Promise<String> {
+        let promise = Promise<String>()
+        EventEmitterHandler.setBackgroundTaskExpiredCallback(onExpired)
+        videoCompressor.activateBackgroundTask(options: dictionary(from: options), resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    func deactivateBackgroundTask(options: AnyMap) throws -> Promise<String> {
+        let promise = Promise<String>()
+        EventEmitterHandler.setBackgroundTaskExpiredCallback(nil)
+        videoCompressor.deactivateBackgroundTask(options: dictionary(from: options), resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    // MARK: - Audio
+
+    func compress_audio(fileUrl: String, optionMap: AnyMap) throws -> Promise<String> {
+        let promise = Promise<String>()
+        AudioMain.compress_audio(fileUrl, optionMap: dictionary(from: optionMap) as NSDictionary, resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    // MARK: - Upload / Download
+
+    func upload(fileUrl: String, options: AnyMap, onProgress: ((Double, Double) -> Void)?) throws -> Promise<AnyMap> {
+        let promise = Promise<AnyMap>()
+        let dict = dictionary(from: options)
+        let uuid = (dict["uuid"] as? String) ?? ""
+        EventEmitterHandler.registerUploadProgress(uuid: uuid, onProgress)
+        uploader.upload(filePath: fileUrl, options: dict, resolve: resolveAnyMap(promise, uuid), reject: reject(promise, uuid))
+        return promise
+    }
+
+    func cancelUpload(uuid: String, shouldCancelAll: Bool) throws {
+        uploader.cancelUpload(uuid: uuid, shouldCancelAll: shouldCancelAll)
+    }
+
+    func download(fileUrl: String, options: AnyMap, onProgress: ((Double) -> Void)?) throws -> Promise<String> {
+        let promise = Promise<String>()
+        let dict = dictionary(from: options)
+        let uuid = (dict["uuid"] as? String) ?? ""
+        let progressDivider = (dict["progressDivider"] as? NSNumber)?.intValue ?? 0
+        EventEmitterHandler.registerDownloadProgress(uuid: uuid, onProgress)
+        Downloader.downloadFileAndSaveToCache(fileUrl, uuid: uuid, progressDivider: progressDivider) { downloadedPath in
+            EventEmitterHandler.unregister(uuid: uuid)
+            promise.resolve(withResult: downloadedPath)
+        }
+        return promise
+    }
+
+    // MARK: - Others
+
+    func generateFilePath(fileExtension: String) throws -> Promise<String> {
+        let promise = Promise<String>()
+        Utils.generateFilePath(fileExtension, resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    func getRealPath(path: String, type: String) throws -> Promise<String> {
+        let promise = Promise<String>()
+        Utils.getRealPath(path, type: type, resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    func getFileSize(filePath: String) throws -> Promise<String> {
+        let promise = Promise<String>()
+        Utils.getFileSize(filePath, resolve: resolveString(promise, nil), reject: reject(promise, nil))
+        return promise
+    }
+
+    func createVideoThumbnail(fileUrl: String, options: AnyMap) throws -> Promise<VideoThumbnailResult> {
+        let promise = Promise<VideoThumbnailResult>()
+        let thumbnail = CreateVideoThumbnail()
+        thumbnail.create(fileUrl, options: dictionary(from: options) as NSDictionary, resolve: { value in
+            let dict = HybridCompressor.stringKeyedDictionary(value)
+            let result = VideoThumbnailResult(
+                path: dict["path"] as? String ?? "",
+                size: HybridCompressor.doubleValue(dict["size"]),
+                mime: dict["mime"] as? String ?? "",
+                width: HybridCompressor.doubleValue(dict["width"]),
+                height: HybridCompressor.doubleValue(dict["height"])
+            )
+            promise.resolve(withResult: result)
+        }, rejecter: reject(promise, nil))
+        return promise
+    }
+
+    func clearCache(cacheDir: String?) throws -> Promise<String> {
+        let promise = Promise<String>()
+        CreateVideoThumbnail.cleanCacheDir(cacheDir: cacheDir ?? "", resolve: resolveString(promise, nil), rejecter: reject(promise, nil))
+        return promise
+    }
+
+    // MARK: - Helpers
+
+    /// Convert a Nitro `AnyMap` to a `[String: Any]`, round-tripping through
+    /// `NSDictionary` so numbers are boxed as `NSNumber` (the domain parsers rely
+    /// on `as? Int` / `as? Bool`, which fail on a bare Swift `Double`).
+    private func dictionary(from map: AnyMap) -> [String: Any] {
+        let normalized = (HybridCompressor.normalize(map.toDictionary()) as? [String: Any]) ?? [:]
+        return ((normalized as NSDictionary) as? [String: Any]) ?? normalized
+    }
+
+    private func resolveString(_ promise: Promise<String>, _ uuid: String?) -> RCTPromiseResolveBlock {
+        return { value in
+            if let uuid = uuid { EventEmitterHandler.unregister(uuid: uuid) }
+            promise.resolve(withResult: value as? String ?? "")
+        }
+    }
+
+    private func resolveAnyMap(_ promise: Promise<AnyMap>, _ uuid: String?) -> RCTPromiseResolveBlock {
+        return { value in
+            if let uuid = uuid { EventEmitterHandler.unregister(uuid: uuid) }
+            promise.resolve(withResult: AnyMap.fromDictionaryIgnoreIncompatible(HybridCompressor.stringKeyedOptionalDictionary(value)))
+        }
+    }
+
+    private func reject<T>(_ promise: Promise<T>, _ uuid: String?) -> RCTPromiseRejectBlock {
+        return { code, message, error in
+            if let uuid = uuid { EventEmitterHandler.unregister(uuid: uuid) }
+            let nsError = error ?? RuntimeError.error(withMessage: message ?? code ?? "react-native-compressor error")
+            promise.reject(withError: nsError)
+        }
+    }
+
+    /// Recursively strip optionals so a `[String: Any?]` (what `AnyMap.toDictionary()`
+    /// returns, including nested objects/arrays) becomes a plain `[String: Any]`.
+    private static func normalize(_ value: Any?) -> Any? {
+        switch value {
+        case let dict as [String: Any?]:
+            var out = [String: Any]()
+            for (key, nested) in dict {
+                if let nestedValue = normalize(nested) { out[key] = nestedValue }
+            }
+            return out
+        case let array as [Any?]:
+            return array.compactMap { normalize($0) }
+        default:
+            return value
+        }
+    }
+
+    private static func stringKeyedDictionary(_ value: Any?) -> [String: Any] {
+        if let dict = value as? [String: Any] { return dict }
+        if let ns = value as? NSDictionary {
+            var out = [String: Any]()
+            for (key, val) in ns where key is String {
+                out[key as! String] = val
+            }
+            return out
+        }
+        return [:]
+    }
+
+    private static func stringKeyedOptionalDictionary(_ value: Any?) -> [String: Any?] {
+        if let ns = value as? NSDictionary {
+            var out = [String: Any?]()
+            for (key, val) in ns where key is String {
+                out[key as! String] = val
+            }
+            return out
+        }
+        if let dict = value as? [String: Any] {
+            var out = [String: Any?]()
+            for (key, val) in dict { out[key] = val }
+            return out
+        }
+        return [:]
+    }
+
+    private static func doubleValue(_ value: Any?) -> Double {
+        if let number = value as? NSNumber { return number.doubleValue }
+        if let double = value as? Double { return double }
+        if let float = value as? Float { return Double(float) }
+        if let int = value as? Int { return Double(int) }
+        return 0
+    }
+}

package/ios/Image/ImageCompressor.swift

@@ -1,11 +1,17 @@
 import Accelerate
 import CoreGraphics
 import Photos
-import React
 import Foundation
 import MobileCoreServices
 
 
+// Local stand-in for the single `RCTResizeMode` case this file relies on, so the
+// module no longer needs to `import React` (see HybridCompressor for the reason).
+private enum CompressorResizeMode {
+    case contain
+}
+
+
 class ImageCompressor {
     static func findTargetSize(_ image: UIImage, maxWidth: Int, maxHeight: Int) -> CGSize {
         let width = image.size.width
@@ -392,7 +398,7 @@ class ImageCompressor {
             let imageURL = URL(string: imagePath.replacingOccurrences(of: " ", with: "%20"))
             var size = CGSize.zero
             var scale: CGFloat = 1
-            var resizeMode = RCTResizeMode.contain
+            var resizeMode = CompressorResizeMode.contain
             let assetID = imagePath.replacingOccurrences(of: "ph://", with: "")
             let results = PHAsset.fetchAssets(withLocalIdentifiers: [assetID], options: nil)
             

package/ios/Utils/EventEmitterHandler.swift

@@ -6,49 +6,71 @@
 //
 
 import Foundation
+import UIKit
 
+/// Routes native progress emissions to the per-call JS callbacks that
+/// `HybridCompressor` registers. This replaces the old `RCTEventEmitter` bridge:
+/// Nitro delivers progress through callback parameters, so the domain layer's
+/// `emit*` calls (unchanged) are dispatched to the callback registered under the
+/// same `uuid` that the JS layer threads through the options map.
 class EventEmitterHandler {
-    static var sharedCompressorObject: Any!
-    static var hasListener: Bool=false
-    
-    static func initCompressorInstance(_ object: Any) {
-        sharedCompressorObject = object
+    private static let lock = NSLock()
+    private static var videoCompressProgressCallbacks = [String: (Double) -> Void]()
+    private static var downloadProgressCallbacks = [String: (Double) -> Void]()
+    private static var uploadProgressCallbacks = [String: (Double, Double) -> Void]()
+    private static var backgroundTaskExpiredCallback: (() -> Void)?
+
+    // MARK: - Registration (called by HybridCompressor)
+
+    static func registerVideoCompressProgress(uuid: String, _ callback: ((Double) -> Void)?) {
+        guard let callback = callback else { return }
+        lock.lock(); defer { lock.unlock() }
+        videoCompressProgressCallbacks[uuid] = callback
+    }
+
+    static func registerDownloadProgress(uuid: String, _ callback: ((Double) -> Void)?) {
+        guard let callback = callback else { return }
+        lock.lock(); defer { lock.unlock() }
+        downloadProgressCallbacks[uuid] = callback
     }
-    
-    
-    static func stopObserving() -> Void {
-      hasListener = false
+
+    static func registerUploadProgress(uuid: String, _ callback: ((Double, Double) -> Void)?) {
+        guard let callback = callback else { return }
+        lock.lock(); defer { lock.unlock() }
+        uploadProgressCallbacks[uuid] = callback
+    }
+
+    static func unregister(uuid: String) {
+        lock.lock(); defer { lock.unlock() }
+        videoCompressProgressCallbacks[uuid] = nil
+        downloadProgressCallbacks[uuid] = nil
+        uploadProgressCallbacks[uuid] = nil
     }
 
-    static func startObserving() -> Void {
-      hasListener = true
+    static func setBackgroundTaskExpiredCallback(_ callback: (() -> Void)?) {
+        lock.lock(); defer { lock.unlock() }
+        backgroundTaskExpiredCallback = callback
     }
-    
+
+    // MARK: - Emission (called by the domain layer — method names preserved)
+
     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)
-    }
-    
+        lock.lock(); let callback = downloadProgressCallbacks[uuid]; lock.unlock()
+        callback?(progress.doubleValue)
+    }
+
     static func emitVideoCompressProgress(_ progress: Float, uuid: String) {
-        if(self.hasListener){
-            (sharedCompressorObject as AnyObject).sendEvent(withName: "videoCompressProgress", body: ["uuid": uuid, "data": ["progress": progress]])
-        }
+        lock.lock(); let callback = videoCompressProgressCallbacks[uuid]; lock.unlock()
+        callback?(Double(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])
-        }
+        lock.lock(); let callback = uploadProgressCallbacks[uuid]; lock.unlock()
+        callback?(Double(totalBytesSent), Double(totalBytesExpectedToSend))
+    }
+
+    static func emitBackgroundTaskExpired(_ backgroundTaskId: UIBackgroundTaskIdentifier) {
+        lock.lock(); let callback = backgroundTaskExpiredCallback; lock.unlock()
+        callback?()
     }
 }