react-native-compressor 1.19.2 → 2.0.1

package/android/src/main/java/com/reactnativecompressor/Utils/EventEmitterHandler.kt

@@ -1,66 +1,70 @@
 package com.reactnativecompressor.Utils
 
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.util.concurrent.ConcurrentHashMap
 
+/**
+ * Routes native progress emissions to the per-call JS callbacks that
+ * `HybridCompressor` registers. This replaces the old `RCTDeviceEventEmitter`
+ * 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 {
   companion object {
-    public var reactContext: ReactApplicationContext?=null
+    private val videoCompressProgressCallbacks = ConcurrentHashMap<String, (Double) -> Unit>()
+    private val downloadProgressCallbacks = ConcurrentHashMap<String, (Double) -> Unit>()
+    private val uploadProgressCallbacks = ConcurrentHashMap<String, (Double, Double) -> Unit>()
 
-    private fun sendEvent(eventName: String,
-                          params: Any?) {
-      reactContext
-        ?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-        ?.emit(eventName, params)
+    @Volatile
+    private var backgroundTaskExpiredCallback: (() -> Unit)? = null
+
+    // Registration (called by HybridCompressor)
+
+    fun registerVideoCompressProgress(uuid: String, callback: ((Double) -> Unit)?) {
+      if (callback != null) videoCompressProgressCallbacks[uuid] = callback
     }
 
-    fun emitBackgroundTaskExpired(backgroundId: String?){
-      sendEvent("backgroundTaskExpired",backgroundId)
+    fun registerDownloadProgress(uuid: String, callback: ((Double) -> Unit)?) {
+      if (callback != null) downloadProgressCallbacks[uuid] = callback
     }
 
-    fun emitVideoCompressProgress(progress:Double,uuid:String){
-      val params = Arguments.createMap()
-      val data = Arguments.createMap()
-      params.putString("uuid", uuid)
-      data.putDouble("progress", progress)
-      params.putMap("data", data)
-      sendEvent("videoCompressProgress", params)
+    fun registerUploadProgress(uuid: String, callback: ((Double, Double) -> Unit)?) {
+      if (callback != null) uploadProgressCallbacks[uuid] = callback
     }
 
-    fun emitDownloadProgress(progress:Double,uuid:String){
-      val params = Arguments.createMap()
-      val data = Arguments.createMap()
-      params.putString("uuid", uuid)
-      data.putDouble("progress", progress)
-      params.putMap("data", data)
-      sendEvent("downloadProgress", params)
+    fun unregister(uuid: String) {
+      videoCompressProgressCallbacks.remove(uuid)
+      downloadProgressCallbacks.remove(uuid)
+      uploadProgressCallbacks.remove(uuid)
     }
 
-    fun emitDownloadProgressError(uuid:String?, error:String?){
-      if (uuid != null && error != null) {
-        val params = Arguments.createMap()
-        val data = Arguments.createMap()
-        params.putString("uuid", uuid)
-        params.putString("error", error)
-        params.putMap("data", data)
-        sendEvent("downloadProgressError", params)
-      }
+    fun setBackgroundTaskExpiredCallback(callback: (() -> Unit)?) {
+      backgroundTaskExpiredCallback = callback
     }
 
-    fun sendUploadProgressEvent(numBytes: Long, totalBytes: Long, uuid:String?) {
-      if(uuid!=null) {
-        val _params = Arguments.createMap()
-        val _data = Arguments.createMap()
-        _params.putString("uuid", uuid)
-        _data.putDouble("written", numBytes.toDouble())
-        _data.putDouble("total", totalBytes.toDouble())
-        _params.putMap("data", _data)
-        sendEvent("uploadProgress", _params)
-      }
+    // Emission (called by the domain layer — method names preserved)
+
+    fun emitBackgroundTaskExpired(backgroundId: String?) {
+      backgroundTaskExpiredCallback?.invoke()
     }
 
+    fun emitVideoCompressProgress(progress: Double, uuid: String) {
+      videoCompressProgressCallbacks[uuid]?.invoke(progress)
+    }
 
-  }
+    fun emitDownloadProgress(progress: Double, uuid: String) {
+      downloadProgressCallbacks[uuid]?.invoke(progress)
+    }
+
+    fun emitDownloadProgressError(uuid: String?, error: String?) {
+      // No JS consumer for `downloadProgressError`; download failures surface
+      // through the rejected Promise instead. Kept so domain call sites compile.
+    }
 
+    fun sendUploadProgressEvent(numBytes: Long, totalBytes: Long, uuid: String?) {
+      if (uuid != null) {
+        uploadProgressCallbacks[uuid]?.invoke(numBytes.toDouble(), totalBytes.toDouble())
+      }
+    }
+  }
 }

package/android/src/main/java/com/reactnativecompressor/Utils/Utils.kt

@@ -134,7 +134,7 @@ object Utils {
       if (fileSize >= 0) {
         promise.resolve(fileSize.toString())
       } else {
-        promise.resolve("")
+        promise.reject("FILE_SIZE_ERROR", "Failed to get file size for path: $filePath")
       }
     }
   }

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,6 +789,7 @@ object Compressor {
         inputFormat: MediaFormat,
         outputSurface: OutputSurface,
     ): MediaCodec {
+
         // 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).

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)