react-native-compressor 1.7.2 → 1.8.0

package/android/src/main/java/com/reactnativecompressor/Audio/AudioMain.kt

@@ -0,0 +1,31 @@
+package com.reactnativecompressor.Audio
+
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.reactnativecompressor.Utils.Utils
+import com.reactnativecompressor.Video.VideoCompressorHelper
+
+class AudioMain(private val reactContext: ReactApplicationContext) {
+  fun compress_audio(
+    fileUrl: String,
+    optionMap: ReadableMap,
+    promise: Promise) {
+    try {
+      val options = VideoCompressorHelper.fromMap(optionMap)
+      val uri = Uri.parse(fileUrl)
+      val srcPath = uri.path
+      val destinationPath = Utils.generateCacheFilePath("mp3", reactContext)
+      val metaRetriever = MediaMetadataRetriever()
+      metaRetriever.setDataSource(srcPath)
+      val bitrate = options.bitrate
+      Log.d("nomi onStart", destinationPath + "onProgress: " + bitrate)
+      AudioCompressor().CompressAudio(srcPath, destinationPath, bitrate.toInt() * 1000)
+    } catch (ex: Exception) {
+      promise.reject(ex)
+    }
+  }
+}

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

@@ -0,0 +1,157 @@
+package com.reactnativecompressor
+
+import android.os.Build
+import androidx.annotation.RequiresApi
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.reactnativecompressor.Audio.AudioMain
+import com.reactnativecompressor.Image.ImageMain
+import com.reactnativecompressor.Utils.Downloader
+import com.reactnativecompressor.Utils.EventEmitterHandler
+import com.reactnativecompressor.Utils.Uploader
+import com.reactnativecompressor.Utils.Utils
+import com.reactnativecompressor.Utils.Utils.generateCacheFilePath
+import com.reactnativecompressor.Utils.Utils.getRealPath
+import com.reactnativecompressor.Video.VideoMain
+
+class CompressorModule(private val reactContext: ReactApplicationContext) : CompressorSpec(reactContext) {
+  private val imageMain: ImageMain = ImageMain(reactContext)
+  private val videoMain: VideoMain = VideoMain(reactContext)
+  private val audioMain: AudioMain = AudioMain(reactContext)
+
+  override fun initialize() {
+    super.initialize()
+    EventEmitterHandler.reactContext=reactContext;
+  }
+
+
+  companion object {
+    const val NAME = "Compressor"
+  }
+  override fun getName(): String {
+        return NAME
+  }
+
+    //Image
+    @ReactMethod
+    override fun image_compress(
+            imagePath: String,
+            optionMap: ReadableMap,
+            promise: Promise) {
+      imageMain.image_compress(imagePath,optionMap,promise)
+    }
+
+  // VIdeo
+  @ReactMethod
+  override fun compress(
+    fileUrl: String,
+    optionMap: ReadableMap,
+    promise: Promise) {
+    videoMain.compress(fileUrl,optionMap,promise)
+  }
+
+  @ReactMethod
+  override fun cancelCompression(
+    uuid: String) {
+    videoMain.cancelCompression(uuid)
+  }
+
+  @ReactMethod
+  override fun activateBackgroundTask(
+    options: ReadableMap,
+    promise: Promise) {
+    videoMain.activateBackgroundTask(options,promise)
+  }
+
+  @ReactMethod
+  override fun deactivateBackgroundTask(
+    options: ReadableMap,
+    promise: Promise) {
+    videoMain.deactivateBackgroundTask(options,promise)
+  }
+
+ // Audio
+    @ReactMethod
+    @RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
+    override fun compress_audio(
+            fileUrl: String,
+            optionMap: ReadableMap,
+            promise: Promise) {
+   audioMain.compress_audio(fileUrl,optionMap,promise)
+    }
+
+    // Others
+    @ReactMethod
+    override fun generateFilePath(_extension: String, promise: Promise) {
+        try {
+            val outputUri = generateCacheFilePath(_extension, reactContext)
+            promise.resolve(outputUri)
+        } catch (e: Exception) {
+            promise.reject(e)
+        }
+    }
+
+    @ReactMethod
+    override fun getRealPath(path: String, type: String, promise: Promise) {
+        try {
+            val realPath = getRealPath(path, reactContext)
+            promise.resolve("file://$realPath")
+        } catch (e: Exception) {
+            promise.reject(e)
+        }
+    }
+
+    @ReactMethod
+    override fun getVideoMetaData(filePath: String, promise: Promise) {
+      videoMain.getVideoMetaData(filePath,promise)
+    }
+
+    @ReactMethod
+    override fun getFileSize(filePath: String, promise: Promise) {
+      Utils.getFileSize(filePath,promise,reactContext)
+    }
+
+  @ReactMethod
+  override fun upload(
+    fileUrl: String,
+    options: ReadableMap,
+    promise: Promise) {
+    Uploader.upload(fileUrl, options, reactContext, promise)
+  }
+
+  @ReactMethod
+  override fun download(
+    fileUrl: String,
+    options: ReadableMap,
+    promise: Promise) {
+    var uuid: String = ""
+    var progressDivider=0;
+    if(options.hasKey("uuid"))
+    {
+      uuid= options.getString("uuid") as String
+    }
+    if(options.hasKey("progressDivider"))
+    {
+      progressDivider= options.getString("progressDivider") as Int
+    }
+    val downloadedFilePath:String?=Downloader.downloadMediaWithProgress(fileUrl, uuid,progressDivider,reactContext)
+    if(downloadedFilePath!=null)
+    {
+      promise.resolve(downloadedFilePath)
+    }
+    else
+    {
+      promise.reject("Unable to download")
+    }
+  }
+
+    @ReactMethod
+    override fun addListener(eventName: String) {
+    }
+
+    @ReactMethod
+    override fun removeListeners(count: Double) {
+    }
+}

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

@@ -0,0 +1,34 @@
+package com.reactnativecompressor
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class CompressorPackage : TurboReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == CompressorModule.NAME) {
+            CompressorModule(reactContext)
+        } else {
+            null
+        }
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+            val isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+            moduleInfos[CompressorModule.NAME] = ReactModuleInfo(
+                    CompressorModule.NAME,
+                    CompressorModule.NAME,
+                    false,  // canOverrideExistingModule
+                    false,  // needsEagerInit
+                    true,  // hasConstants
+                    false,  // isCxxModule
+                    isTurboModule // isTurboModule
+            )
+            moduleInfos
+        }
+    }
+}

package/android/src/main/java/com/reactnativecompressor/Image/ImageCompressor.kt

@@ -0,0 +1,199 @@
+package com.reactnativecompressor.Image
+
+import android.graphics.Bitmap
+import android.graphics.Bitmap.CompressFormat
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.media.ExifInterface
+import android.net.Uri
+import android.util.Base64
+import com.facebook.react.bridge.ReactApplicationContext
+import com.reactnativecompressor.Utils.Utils.generateCacheFilePath
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.net.MalformedURLException
+
+object ImageCompressor {
+    fun getRNFileUrl(filePath: String?): String? {
+        var filePath = filePath
+        val returnAbleFile = File(filePath)
+        try {
+            filePath = returnAbleFile.toURL().toString()
+        } catch (e: MalformedURLException) {
+            e.printStackTrace()
+        }
+        return filePath
+    }
+
+    fun findActualSize(image: Bitmap, maxWidth: Int, maxHeight: Int): ImageSize {
+        val width = image.width.toFloat()
+        val height = image.height.toFloat()
+        if (width > height) {
+            val newHeight = Math.round(height / (width / maxWidth))
+            val scale = newHeight / height
+            return ImageSize(maxWidth, newHeight, scale)
+        }
+        val newWidth = Math.round(width / (height / maxHeight))
+        val scale = newWidth / width
+        return ImageSize(newWidth, maxHeight, scale)
+    }
+
+    fun decodeImage(value: String?): Bitmap {
+        val data = Base64.decode(value, Base64.DEFAULT)
+        return BitmapFactory.decodeByteArray(data, 0, data.size)
+    }
+
+    fun loadImage(value: String?): Bitmap {
+        val uri = Uri.parse(value)
+        val filePath = uri.path
+        return BitmapFactory.decodeFile(filePath)
+    }
+
+    fun encodeImage(imageDataByteArrayOutputStream: ByteArrayOutputStream, isBase64: Boolean, outputExtension: String?, reactContext: ReactApplicationContext?): String? {
+        if (isBase64) {
+            val imageData = imageDataByteArrayOutputStream.toByteArray()
+            return Base64.encodeToString(imageData, Base64.DEFAULT)
+        } else {
+            val outputUri = generateCacheFilePath(outputExtension!!, reactContext!!)
+            try {
+                val fos = FileOutputStream(outputUri)
+                imageDataByteArrayOutputStream.writeTo(fos)
+                return getRNFileUrl(outputUri)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+        return ""
+    }
+
+    fun resize(image: Bitmap, maxWidth: Int, maxHeight: Int): Bitmap {
+        val size = findActualSize(image, maxWidth, maxHeight)
+        val scaledImage = Bitmap.createBitmap(size.width, size.height, image.config)
+        val scaleMatrix = Matrix()
+        val canvas = Canvas(scaledImage)
+        val paint = Paint(Paint.FILTER_BITMAP_FLAG)
+        scaleMatrix.setScale(size.scale, size.scale, 0f, 0f)
+        paint.isDither = true
+        paint.isAntiAlias = true
+        paint.isFilterBitmap = true
+        canvas.drawBitmap(image, scaleMatrix, paint)
+        return scaledImage
+    }
+
+    fun compress(image: Bitmap?, output: ImageCompressorOptions.OutputType, quality: Float): ByteArrayOutputStream {
+        val stream = ByteArrayOutputStream()
+        val format = if (output === ImageCompressorOptions.OutputType.jpg) CompressFormat.JPEG else CompressFormat.PNG
+        image!!.compress(format, Math.round(100 * quality), stream)
+        return stream
+    }
+
+    fun manualCompressImage(imagePath: String?, options: ImageCompressorOptions, reactContext: ReactApplicationContext?): String? {
+        val image = if (options.input === ImageCompressorOptions.InputType.base64) decodeImage(imagePath) else loadImage(imagePath)
+        val resizedImage = resize(image, options.maxWidth, options.maxHeight)
+        val imageDataByteArrayOutputStream = compress(resizedImage, options.output, options.quality)
+        val isBase64 = options.returnableOutputType === ImageCompressorOptions.ReturnableOutputType.base64
+        return encodeImage(imageDataByteArrayOutputStream, isBase64, options.output.toString(), reactContext)
+    }
+
+    fun autoCompressImage(imagePath: String?, compressorOptions: ImageCompressorOptions, reactContext: ReactApplicationContext?): String? {
+        var imagePath = imagePath
+        val outputExtension = compressorOptions.output.toString()
+        val autoCompressMaxHeight = compressorOptions.maxHeight.toFloat()
+        val autoCompressMaxWidth = compressorOptions.maxWidth.toFloat()
+        val isBase64 = compressorOptions.returnableOutputType === ImageCompressorOptions.ReturnableOutputType.base64
+        val uri = Uri.parse(imagePath)
+        imagePath = uri.path
+        var scaledBitmap: Bitmap? = null
+        val options = BitmapFactory.Options()
+        options.inJustDecodeBounds = true
+        var bmp = BitmapFactory.decodeFile(imagePath, options)
+        var actualHeight = options.outHeight
+        var actualWidth = options.outWidth
+        var imgRatio = actualWidth.toFloat() / actualHeight.toFloat()
+        val maxRatio = autoCompressMaxWidth / autoCompressMaxHeight
+        if (actualHeight > autoCompressMaxHeight || actualWidth > autoCompressMaxWidth) {
+            if (imgRatio < maxRatio) {
+                imgRatio = autoCompressMaxHeight / actualHeight
+                actualWidth = (imgRatio * actualWidth).toInt()
+                actualHeight = autoCompressMaxHeight.toInt()
+            } else if (imgRatio > maxRatio) {
+                imgRatio = autoCompressMaxWidth / actualWidth
+                actualHeight = (imgRatio * actualHeight).toInt()
+                actualWidth = autoCompressMaxWidth.toInt()
+            } else {
+                actualHeight = autoCompressMaxHeight.toInt()
+                actualWidth = autoCompressMaxWidth.toInt()
+            }
+        }
+        options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight)
+        options.inJustDecodeBounds = false
+        options.inDither = false
+        options.inPurgeable = true
+        options.inInputShareable = true
+        options.inTempStorage = ByteArray(16 * 1024)
+        try {
+            bmp = BitmapFactory.decodeFile(imagePath, options)
+        } catch (exception: OutOfMemoryError) {
+            exception.printStackTrace()
+        }
+        try {
+            scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.RGB_565)
+        } catch (exception: OutOfMemoryError) {
+            exception.printStackTrace()
+        }
+        val ratioX = actualWidth / options.outWidth.toFloat()
+        val ratioY = actualHeight / options.outHeight.toFloat()
+        val middleX = actualWidth / 2.0f
+        val middleY = actualHeight / 2.0f
+        val scaleMatrix = Matrix()
+        scaleMatrix.setScale(ratioX, ratioY, middleX, middleY)
+        val canvas = Canvas(scaledBitmap!!)
+        canvas.setMatrix(scaleMatrix)
+        canvas.drawBitmap(bmp!!, middleX - bmp.width / 2, middleY - bmp.height / 2, Paint(Paint.FILTER_BITMAP_FLAG))
+        if (bmp != null) {
+            bmp.recycle()
+        }
+        scaledBitmap = correctImageOrientation(scaledBitmap, imagePath)
+        val imageDataByteArrayOutputStream = compress(scaledBitmap, compressorOptions.output, compressorOptions.quality)
+        return encodeImage(imageDataByteArrayOutputStream, isBase64, compressorOptions.output.toString(), reactContext)
+    }
+
+    fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int {
+        val height = options.outHeight
+        val width = options.outWidth
+        var inSampleSize = 1
+        if (height > reqHeight || width > reqWidth) {
+            val heightRatio = Math.round(height.toFloat() / reqHeight.toFloat())
+            val widthRatio = Math.round(width.toFloat() / reqWidth.toFloat())
+            inSampleSize = if (heightRatio < widthRatio) heightRatio else widthRatio
+        }
+        val totalPixels = (width * height).toFloat()
+        val totalReqPixelsCap = (reqWidth * reqHeight * 2).toFloat()
+        while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
+            inSampleSize++
+        }
+        return inSampleSize
+    }
+
+    fun correctImageOrientation(bitmap: Bitmap?, imagePath: String?): Bitmap? {
+        return try {
+            val exif = ExifInterface(imagePath!!)
+            val orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
+            val matrix = Matrix()
+            when (orientation) {
+                ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
+                ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
+                ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
+                else -> return bitmap // No rotation needed
+            }
+            Bitmap.createBitmap(bitmap!!, 0, 0, bitmap.width, bitmap.height, matrix, true)
+        } catch (e: IOException) {
+            e.printStackTrace()
+            bitmap // Return original bitmap if an error occurs
+        }
+    }
+}

package/android/src/main/java/com/reactnativecompressor/Image/ImageCompressorOptions.kt

@@ -0,0 +1,57 @@
+package com.reactnativecompressor.Image
+
+import com.facebook.react.bridge.ReadableMap
+
+class ImageCompressorOptions {
+    enum class InputType {
+        base64,
+        uri
+    }
+
+    enum class OutputType {
+        png,
+        jpg
+    }
+
+    enum class ReturnableOutputType {
+        base64,
+        uri
+    }
+
+    enum class CompressionMethod {
+        auto,
+        manual
+    }
+
+    var compressionMethod = CompressionMethod.auto
+    var maxWidth = 1280
+    var maxHeight = 1280
+    var progressDivider: Int? = 0
+    var quality = 0.8f
+    var input = InputType.uri
+    var output = OutputType.jpg
+    var uuid: String? = ""
+    var returnableOutputType = ReturnableOutputType.uri
+
+    companion object {
+        fun fromMap(map: ReadableMap): ImageCompressorOptions {
+            val options = ImageCompressorOptions()
+            val iterator = map.keySetIterator()
+            while (iterator.hasNextKey()) {
+                val key = iterator.nextKey()
+                when (key) {
+                    "compressionMethod" -> options.compressionMethod = CompressionMethod.valueOf(map.getString(key)!!)
+                    "maxWidth" -> options.maxWidth = map.getInt(key)
+                    "maxHeight" -> options.maxHeight = map.getInt(key)
+                    "progressDivider" -> options.progressDivider = map.getInt(key)
+                    "quality" -> options.quality = map.getDouble(key).toFloat()
+                    "input" -> options.input = InputType.valueOf(map.getString(key)!!)
+                    "output" -> options.output = OutputType.valueOf(map.getString(key)!!)
+                    "returnableOutputType" -> options.returnableOutputType = ReturnableOutputType.valueOf(map.getString(key)!!)
+                    "uuid" -> options.uuid = map.getString(key)
+                }
+            }
+            return options
+        }
+    }
+}

package/android/src/main/java/com/reactnativecompressor/Image/ImageMain.kt

@@ -0,0 +1,31 @@
+package com.reactnativecompressor.Image
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.reactnativecompressor.Utils.MediaCache
+import com.reactnativecompressor.Utils.Utils
+
+class ImageMain(private val reactContext: ReactApplicationContext) {
+  fun image_compress(
+    imagePath: String,
+    optionMap: ReadableMap,
+    promise: Promise
+  ) {
+    var imagePath: String? = imagePath
+    try {
+      val options = ImageCompressorOptions.fromMap(optionMap)
+      imagePath = Utils.getRealPath(imagePath, reactContext, options.uuid, options.progressDivider)
+      if (options.compressionMethod === ImageCompressorOptions.CompressionMethod.auto) {
+        val returnableResult = ImageCompressor.autoCompressImage(imagePath, options, reactContext)
+        promise.resolve(returnableResult)
+      } else {
+        val returnableResult = ImageCompressor.manualCompressImage(imagePath, options, reactContext)
+        promise.resolve(returnableResult)
+      }
+      MediaCache.removeCompletedImagePath(imagePath)
+    } catch (ex: Exception) {
+      promise.reject(ex)
+    }
+  }
+}

package/android/src/main/java/com/reactnativecompressor/Image/ImageSize.kt

@@ -0,0 +1,3 @@
+package com.reactnativecompressor.Image
+
+class ImageSize(@JvmField var width: Int, @JvmField var height: Int, @JvmField var scale: Float)

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

@@ -0,0 +1,119 @@
+package com.reactnativecompressor.Utils
+
+import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import java.io.BufferedInputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.util.UUID
+import java.util.concurrent.Semaphore
+import java.util.concurrent.atomic.AtomicReference
+
+class Downloader {
+  companion object {
+    private const val TAG = "react-native-compessor"
+
+    fun downloadMediaWithProgress(mediaUrl: String?, uuid: String,progressDivider:Int, reactContext: ReactApplicationContext): String? {
+      downloadCompression[0] = 0
+      val client = OkHttpClient()
+      val request: Request = Request.Builder()
+        .url(mediaUrl!!)
+        .build()
+      val semaphore = Semaphore(0) // Semaphore to wait for the download to complete
+      val filePathRef = AtomicReference<String?>(null) // To store the file path
+
+      // Perform the request asynchronously
+      client.newCall(request).enqueue(object : Callback {
+        @Throws(IOException::class)
+        override fun onResponse(call: Call, response: Response) {
+          if (response.isSuccessful) {
+            val responseBody = response.body
+            if (responseBody != null) {
+              var fileExtension = "unknown" // Default extension
+
+              // Detect the file extension based on the Content-Type header
+              val contentType = response.header("Content-Type")
+              if (contentType != null) {
+                if (contentType == "image/jpeg") {
+                  fileExtension = "jpg"
+                } else if (contentType == "image/png") {
+                  fileExtension = "png"
+                } else if (contentType == "video/mp4") {
+                  fileExtension = "mp4"
+                }
+              }
+              val cacheDir = reactContext.cacheDir
+              val randomFileName = UUID.randomUUID().toString() + "." + fileExtension
+              val mediaFile = File(cacheDir, randomFileName)
+              try {
+                FileOutputStream(mediaFile).use { fos ->
+                  val inputStream = BufferedInputStream(responseBody.byteStream())
+                  val buffer = ByteArray(4096)
+                  var bytesRead: Int
+                  var totalBytesRead: Long = 0
+                  var totalBytes = responseBody.contentLength()
+                  if (totalBytes <= 0) {
+                    totalBytes = 31457280
+                  }
+                  Log.d(TAG, "$totalBytesRead totalBytesRead $totalBytes")
+                  Log.d(TAG, "$response responseBody $responseBody")
+                  while (inputStream.read(buffer).also { bytesRead = it } != -1) {
+                    fos.write(buffer, 0, bytesRead)
+                    totalBytesRead += bytesRead.toLong()
+                    val progressRatio = totalBytesRead.toDouble() / totalBytes
+                    val progress = (progressRatio * 100).toInt()
+                    sendProgressUpdate(progress, uuid, progressDivider)
+                  }
+                  fos.flush()
+                  val filePath = "file://" + mediaFile.absolutePath
+                  MediaCache.addCompletedImagePath(filePath)
+                  filePathRef.set(filePath) // Set the file path
+                }
+              } catch (e: IOException) {
+                e.printStackTrace()
+                sendErrorResult(e.message, uuid)
+              } finally {
+                semaphore.release() // Release the semaphore when download is complete
+              }
+            }
+          } else {
+            sendErrorResult("Failed to download media: " + response.message, uuid)
+            semaphore.release() // Release the semaphore in case of error
+          }
+        }
+
+        override fun onFailure(call: Call, e: IOException) {
+          e.printStackTrace()
+          sendErrorResult(e.message, uuid)
+          semaphore.release() // Release the semaphore in case of failure
+        }
+      })
+      try {
+        semaphore.acquire() // Wait for the download to complete
+      } catch (e: InterruptedException) {
+        e.printStackTrace()
+      }
+      return filePathRef.get() // Return the file path
+    }
+
+    val downloadCompression = intArrayOf(0)
+    private fun sendProgressUpdate(progress: Int, uuid: String, progressDivider:Int=0) {
+      val roundProgress = Math.round(progress.toFloat())
+      if (progressDivider==0||(roundProgress % progressDivider == 0 && roundProgress > downloadCompression[0])) {
+        EventEmitterHandler.emitDownloadProgress(progress / 100.0,uuid)
+        Log.d(TAG, "downloadProgress: " + progress / 100.0)
+        downloadCompression[0] = roundProgress
+      }
+    }
+
+    private fun sendErrorResult(error: String?, uuid: String?) {
+      EventEmitterHandler.emitDownloadProgressError(uuid,error)
+    }
+  }
+}