react-native-compressor 1.7.1 → 1.8.0

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

@@ -0,0 +1,61 @@
+package com.reactnativecompressor.Utils
+
+import android.util.Log
+import java.io.File
+
+object MediaCache {
+    private const val TAG = "MediaCache"
+    private val completedImagePaths: MutableList<String> = ArrayList()
+    fun addCompletedImagePath(imagePath: String?) {
+        if (imagePath != null) {
+            // Your code to add the imagePath to a list or perform other actions if needed.
+            completedImagePaths.add(imagePath)
+            Log.d(TAG, "Successfully added image path: $imagePath")
+        }
+    }
+
+    @JvmStatic
+    fun removeCompletedImagePath(imagePath: String?) {
+        var imagePath = imagePath
+        if (imagePath != null) {
+            if (completedImagePaths.contains(imagePath)) {
+                // Image path exists in the list, so remove it
+                completedImagePaths.remove(imagePath)
+                if (imagePath.startsWith("file://")) {
+                    imagePath = imagePath.substring(7) // Remove "file://"
+                }
+
+                // Remove the image file
+                val file = File(imagePath)
+                if (file.exists()) {
+                    if (file.delete()) {
+                        Log.d(TAG, "Successfully deleted image file: $imagePath")
+                    } else {
+                        Log.d(TAG, "Failed to delete image file: $imagePath")
+                    }
+                } else {
+                    Log.d(TAG, "Image file not found: $imagePath")
+                }
+            } else {
+                Log.d(TAG, "Image path not found in the completedImagePaths list: $imagePath")
+            }
+        }
+    }
+
+    fun cleanupCache() {
+        // Iterate through the list of completed image paths and delete the corresponding files
+        for (imagePath in completedImagePaths) {
+            val file = File(imagePath)
+            if (file.exists()) {
+                if (file.delete()) {
+                    Log.d(TAG, "Successfully deleted image file during cache cleanup: $imagePath")
+                } else {
+                    Log.d(TAG, "Failed to delete image file during cache cleanup: $imagePath")
+                }
+            } else {
+                Log.d(TAG, "Image file not found during cache cleanup: $imagePath")
+            }
+        }
+        completedImagePaths.clear()
+    }
+}

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

@@ -0,0 +1,177 @@
+package com.reactnativecompressor.Utils
+
+import android.annotation.SuppressLint
+import android.content.ContentUris
+import android.content.Context
+import android.database.Cursor
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.DocumentsContract
+import android.provider.MediaStore
+import androidx.loader.content.CursorLoader
+
+object RealPathUtil {
+    fun getRealPath(context: Context, fileUri: Uri): String? {
+        val realPath: String?
+        // SDK < API11
+        realPath = if (Build.VERSION.SDK_INT < 11) {
+            getRealPathFromURI_BelowAPI11(context, fileUri)
+        } else if (Build.VERSION.SDK_INT < 19) {
+            getRealPathFromURI_API11to18(context, fileUri)
+        } else {
+            getRealPathFromURI_API19(context, fileUri)
+        }
+        return realPath
+    }
+
+    @SuppressLint("NewApi")
+    fun getRealPathFromURI_API11to18(context: Context?, contentUri: Uri?): String? {
+        val proj = arrayOf(MediaStore.Images.Media.DATA)
+        var result: String? = null
+        val cursorLoader = CursorLoader(context!!, contentUri!!, proj, null, null, null)
+        val cursor = cursorLoader.loadInBackground()
+        if (cursor != null) {
+            val column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA)
+            cursor.moveToFirst()
+            result = cursor.getString(column_index)
+            cursor.close()
+        }
+        return result
+    }
+
+    fun getRealPathFromURI_BelowAPI11(context: Context, contentUri: Uri?): String {
+        val proj = arrayOf(MediaStore.Images.Media.DATA)
+        val cursor = context.contentResolver.query(contentUri!!, proj, null, null, null)
+        var column_index = 0
+        var result = ""
+        if (cursor != null) {
+            column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA)
+            cursor.moveToFirst()
+            result = cursor.getString(column_index)
+            cursor.close()
+            return result
+        }
+        return result
+    }
+
+    /**
+     * Get a file path from a Uri. This will get the the path for Storage Access
+     * Framework Documents, as well as the _data field for the MediaStore and
+     * other file-based ContentProviders.
+     *
+     * @param context The context.
+     * @param uri     The Uri to query.
+     * @author paulburke
+     */
+    @SuppressLint("NewApi")
+    fun getRealPathFromURI_API19(context: Context, uri: Uri): String? {
+        val isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT
+
+        // DocumentProvider
+        if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {
+            // ExternalStorageProvider
+            if (isExternalStorageDocument(uri)) {
+                val docId = DocumentsContract.getDocumentId(uri)
+                val split = docId.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+                val type = split[0]
+                if ("primary".equals(type, ignoreCase = true)) {
+                    return Environment.getExternalStorageDirectory().toString() + "/" + split[1]
+                }
+
+                // TODO handle non-primary volumes
+            } else if (isDownloadsDocument(uri)) {
+                val id = DocumentsContract.getDocumentId(uri)
+                val contentUri = ContentUris.withAppendedId(
+                        Uri.parse("content://downloads/public_downloads"), java.lang.Long.valueOf(id))
+                return getDataColumn(context, contentUri, null, null)
+            } else if (isMediaDocument(uri)) {
+                val docId = DocumentsContract.getDocumentId(uri)
+                val split = docId.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+                val type = split[0]
+                var contentUri: Uri? = null
+                if ("image" == type) {
+                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+                } else if ("video" == type) {
+                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+                } else if ("audio" == type) {
+                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
+                }
+                val selection = "_id=?"
+                val selectionArgs = arrayOf(
+                        split[1]
+                )
+                return getDataColumn(context, contentUri, selection, selectionArgs)
+            }
+        } else if ("content".equals(uri.scheme, ignoreCase = true)) {
+
+            // Return the remote address
+            return if (isGooglePhotosUri(uri)) uri.lastPathSegment else getDataColumn(context, uri, null, null)
+        } else if ("file".equals(uri.scheme, ignoreCase = true)) {
+            return uri.path
+        }
+        return null
+    }
+
+    /**
+     * Get the value of the data column for this Uri. This is useful for
+     * MediaStore Uris, and other file-based ContentProviders.
+     *
+     * @param context       The context.
+     * @param uri           The Uri to query.
+     * @param selection     (Optional) Filter used in the query.
+     * @param selectionArgs (Optional) Selection arguments used in the query.
+     * @return The value of the _data column, which is typically a file path.
+     */
+    fun getDataColumn(context: Context, uri: Uri?, selection: String?,
+                      selectionArgs: Array<String>?): String? {
+        var cursor: Cursor? = null
+        val column = "_data"
+        val projection = arrayOf(
+                column
+        )
+        try {
+            cursor = context.contentResolver.query(uri!!, projection, selection, selectionArgs,
+                    null)
+            if (cursor != null && cursor.moveToFirst()) {
+                val index = cursor.getColumnIndexOrThrow(column)
+                return cursor.getString(index)
+            }
+        } finally {
+            cursor?.close()
+        }
+        return null
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is ExternalStorageProvider.
+     */
+    fun isExternalStorageDocument(uri: Uri): Boolean {
+        return "com.android.externalstorage.documents" == uri.authority
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is DownloadsProvider.
+     */
+    fun isDownloadsDocument(uri: Uri): Boolean {
+        return "com.android.providers.downloads.documents" == uri.authority
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is MediaProvider.
+     */
+    fun isMediaDocument(uri: Uri): Boolean {
+        return "com.android.providers.media.documents" == uri.authority
+    }
+
+    /**
+     * @param uri The Uri to check.
+     * @return Whether the Uri authority is Google Photos.
+     */
+    fun isGooglePhotosUri(uri: Uri): Boolean {
+        return "com.google.android.apps.photos.content" == uri.authority
+    }
+}

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

@@ -0,0 +1,117 @@
+package com.reactnativecompressor.Utils
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import io.github.lizhangqu.coreprogress.ProgressHelper
+import io.github.lizhangqu.coreprogress.ProgressUIListener
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.MediaType
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.OkHttpClient
+import okhttp3.Request.Builder
+import okhttp3.RequestBody
+import okhttp3.Response
+import java.io.File
+import java.io.IOException
+import java.util.Locale
+
+object Uploader {
+    private const val TAG = "asyncTaskUploader"
+
+    fun upload(fileUrl: String, _options: ReadableMap?, reactContext: ReactApplicationContext, promise: Promise) {
+        val options = _options?.let { UploaderHelper.fromMap(it) }
+        val uploadableFile = File(fileUrl)
+        val url = options?.url
+        var contentType: String? = "video"
+        val okHttpClient = OkHttpClient()
+        val builder = Builder()
+      if (url != null) {
+        builder.url(url)
+      }
+        val headerIterator = options!!.headers!!.keySetIterator()
+        while (headerIterator.hasNextKey()) {
+            val key = headerIterator.nextKey()
+            val value = options.headers!!.getString(key)
+            Log.d(TAG, "$key  value: $value")
+            builder.addHeader(key, value.toString())
+            if (key.lowercase(Locale.getDefault()) === "content-type:") {
+                contentType = value
+            }
+        }
+        val mediaType: MediaType = contentType?.toMediaTypeOrNull()!!;
+        val body = RequestBody.create(mediaType, uploadableFile)
+        val requestBody = ProgressHelper.withProgress(body, object : ProgressUIListener() {
+            //if you don't need this method, don't override this methd. It isn't an abstract method, just an empty method.
+            override fun onUIProgressStart(totalBytes: Long) {
+                super.onUIProgressStart(totalBytes)
+                Log.d(TAG, "onUIProgressStart:$totalBytes")
+            }
+
+            override fun onUIProgressChanged(numBytes: Long, totalBytes: Long, percent: Float, speed: Float) {
+                EventEmitterHandler.sendUploadProgressEvent(numBytes,totalBytes,options.uuid)
+                Log.d(TAG, "=============start===============")
+                Log.d(TAG, "numBytes:$numBytes")
+                Log.d(TAG, "totalBytes:$totalBytes")
+                Log.d(TAG, "percent:$percent")
+                Log.d(TAG, "speed:$speed")
+                Log.d(TAG, "============= end ===============")
+            }
+
+            //if you don't need this method, don't override this methd. It isn't an abstract method, just an empty method.
+            override fun onUIProgressFinish() {
+                super.onUIProgressFinish()
+                Log.d(TAG, "onUIProgressFinish:")
+            }
+        })
+        builder.put(requestBody)
+        val call = okHttpClient.newCall(builder.build())
+        call.enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {
+                Log.d(TAG, "=============onFailure===============")
+                promise.reject("")
+                e.printStackTrace()
+            }
+
+            @Throws(IOException::class)
+            override fun onResponse(call: Call, response: Response) {
+                Log.d(TAG, "=============onResponse===============")
+                Log.d(TAG, "request headers:" + response.request.headers)
+                Log.d(TAG, "response code:" + response.code)
+                Log.d(TAG, "response headers:" + response.headers)
+                Log.d(TAG, "response body:" + response.body!!.string())
+                val param = Arguments.createMap()
+                param.putInt("status", response.code)
+                promise.resolve(param)
+            }
+        })
+    }
+}
+
+
+class UploaderHelper {
+  var uuid: String? = null
+  var method: String? = null
+  var headers: ReadableMap? = null
+  var url: String? = null
+
+  companion object {
+    fun fromMap(map: ReadableMap): UploaderHelper {
+      val options = UploaderHelper()
+      val iterator = map.keySetIterator()
+      while (iterator.hasNextKey()) {
+        val key = iterator.nextKey()
+        when (key) {
+          "uuid" -> options.uuid = map.getString(key)
+          "method" -> options.method = map.getString(key)
+          "headers" -> options.headers = map.getMap(key)
+          "url" -> options.url = map.getString(key)
+        }
+      }
+      return options
+    }
+  }
+}

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

@@ -0,0 +1,162 @@
+package com.reactnativecompressor.Utils
+
+import android.content.ContentResolver
+import android.content.res.AssetFileDescriptor
+import android.net.Uri
+import android.provider.OpenableColumns
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import numan.dev.videocompressor.VideoCompressTask
+import numan.dev.videocompressor.VideoCompressor
+import java.io.FileNotFoundException
+import java.io.IOException
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.UUID
+
+object Utils {
+    private const val TAG = "react-native-compessor"
+    var compressorExports: MutableMap<String, VideoCompressTask> = HashMap()
+    @JvmStatic
+    fun generateCacheFilePath(extension: String, reactContext: ReactApplicationContext): String {
+        val outputDir = reactContext.cacheDir
+        return String.format("%s/%s.$extension", outputDir.path, UUID.randomUUID().toString())
+    }
+
+    @JvmStatic
+    fun compressVideo(srcPath: String, destinationPath: String, resultWidth: Int, resultHeight: Int, videoBitRate: Float, uuid: String,progressDivider:Int, promise: Promise, reactContext: ReactApplicationContext) {
+        val currentVideoCompression = intArrayOf(0)
+        try {
+            val export = VideoCompressor.convertVideo(srcPath, destinationPath, resultWidth, resultHeight, videoBitRate.toInt(), object : VideoCompressor.ProgressListener {
+                override fun onStart() {
+                    //convert start
+                }
+
+                override fun onFinish(result: Boolean) {
+                    val fileUrl = "file://$destinationPath"
+                    //convert finish,result(true is success,false is fail)
+                    promise.resolve(fileUrl)
+                    MediaCache.removeCompletedImagePath(fileUrl)
+                }
+
+                override fun onError(errorMessage: String) {
+                    if (errorMessage == "class java.lang.AssertionError") {
+                        promise.resolve("file://$srcPath")
+                    } else {
+                        promise.reject("Compression has canncelled")
+                    }
+                }
+
+                override fun onProgress(percent: Float) {
+                    val roundProgress = Math.round(percent)
+                    if (progressDivider==0||(roundProgress % progressDivider == 0 && roundProgress > currentVideoCompression[0])) {
+                      EventEmitterHandler.emitVideoCompressProgress((percent / 100).toDouble(),uuid)
+                        currentVideoCompression[0] = roundProgress
+                    }
+                }
+            })
+            compressorExports[uuid] = export
+        } catch (ex: Exception) {
+            promise.reject(ex)
+        } finally {
+            currentVideoCompression[0] = 0
+        }
+    }
+
+    fun cancelCompressionHelper(uuid: String) {
+        try {
+            val export = compressorExports[uuid]
+            export!!.cancel(true)
+        } catch (ex: Exception) {
+        }
+    }
+
+    @JvmStatic
+    fun getFileSizeFromURL(urlString: String?): Int {
+        val url: URL
+        var conn: HttpURLConnection? = null
+        return try {
+            url = URL(urlString)
+            conn = url.openConnection() as HttpURLConnection
+            conn.requestMethod = "HEAD"
+            conn!!.inputStream
+            conn.contentLength
+        } catch (e: IOException) {
+            throw RuntimeException(e)
+        } finally {
+            conn?.disconnect()
+        }
+    }
+
+    @JvmStatic
+    fun getRealPath(fileUrl: String?, reactContext: ReactApplicationContext, vararg args: Any?): String? {
+        var fileUrl = fileUrl
+        if (fileUrl!!.startsWith("content://")) {
+            try {
+                val uri = Uri.parse(fileUrl)
+                fileUrl = RealPathUtil.getRealPath(reactContext, uri)
+            } catch (ex: Exception) {
+                Log.d(TAG, " Please see this issue: https://github.com/numandev1/react-native-compressor/issues/25")
+            }
+        } else if (fileUrl.startsWith("http://") || fileUrl.startsWith("https://")) {
+            val uuid: String = if (args.size > 0) args[0].toString() else ""
+            val progressDivider: Int = if (args.size > 1) args[1] as Int else 0
+            fileUrl = Downloader.downloadMediaWithProgress(fileUrl, uuid,progressDivider, reactContext)
+            Log.d(TAG, "getRealPath: $fileUrl")
+        }
+        return fileUrl
+    }
+
+
+
+  fun getFileSize(filePath: String, promise: Promise, reactContext:ReactApplicationContext) {
+    var filePath: String? = filePath
+    if (filePath!!.startsWith("http://") || filePath.startsWith("https://")) {
+      promise.resolve(getFileSizeFromURL(filePath))
+    } else {
+      filePath = getRealPath(filePath, reactContext)
+      val uri = Uri.parse(filePath)
+      val contentResolver = reactContext.contentResolver
+      val fileSize = getLength(uri, contentResolver)
+      if (fileSize >= 0) {
+        promise.resolve(fileSize.toString())
+      } else {
+        promise.resolve("")
+      }
+    }
+  }
+
+  fun getLength(uri: Uri, contentResolver: ContentResolver): Long {
+    var assetFileDescriptor: AssetFileDescriptor? = null
+    try {
+      assetFileDescriptor = contentResolver.openAssetFileDescriptor(uri, "r")
+    } catch (e: FileNotFoundException) {
+      // Do nothing
+    }
+    val length = assetFileDescriptor?.length ?: -1L
+    if (length != -1L) {
+      return length
+    }
+    return if (ContentResolver.SCHEME_CONTENT == uri.scheme) {
+      val cursor = contentResolver.query(uri, arrayOf(OpenableColumns.SIZE), null, null, null)
+      if (cursor != null) {
+        try {
+          val sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE)
+          if (sizeIndex != -1 && cursor.moveToFirst()) {
+            return try {
+              cursor.getLong(sizeIndex)
+            } catch (ignored: Throwable) {
+              -1L
+            }
+          }
+        } finally {
+          cursor.close()
+        }
+      }
+      -1L
+    } else {
+      -1L
+    }
+  }
+}

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

@@ -0,0 +1,63 @@
+package com.reactnativecompressor.Video
+
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.reactnativecompressor.Utils.Utils.compressVideo
+import com.reactnativecompressor.Utils.Utils.generateCacheFilePath
+import java.io.File
+
+object AutoVideoCompression {
+    fun createCompressionSettings(fileUrl: String?, options: VideoCompressorHelper, promise: Promise, reactContext: ReactApplicationContext?) {
+        val maxSize = options.maxSize
+        val minimumFileSizeForCompress = options.minimumFileSizeForCompress
+        try {
+            val uri = Uri.parse(fileUrl)
+            val srcPath = uri.path
+            val metaRetriever = MediaMetadataRetriever()
+            metaRetriever.setDataSource(srcPath)
+            val file = File(srcPath)
+            val sizeInBytes = file.length().toFloat()
+            val sizeInMb = sizeInBytes / (1024 * 1024)
+            if (sizeInMb > minimumFileSizeForCompress) {
+                val destinationPath = generateCacheFilePath("mp4", reactContext!!)
+                val actualHeight = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)!!.toInt()
+                val actualWidth = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)!!.toInt()
+                val bitrate = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE)!!.toInt()
+                val scale = if (actualWidth > actualHeight) maxSize / actualWidth else maxSize / actualHeight
+                val resultWidth = Math.round(actualWidth * scale / 2) * 2
+                val resultHeight = Math.round(actualHeight * scale / 2) * 2
+                val videoBitRate = makeVideoBitrate(
+                  actualHeight, actualWidth,
+                  bitrate,
+                  resultHeight, resultWidth
+                ).toFloat()
+                compressVideo(srcPath!!, destinationPath, resultWidth, resultHeight, videoBitRate, options.uuid!!,options.progressDivider!!, promise, reactContext)
+            } else {
+                promise.resolve(fileUrl)
+            }
+        } catch (ex: Exception) {
+            promise.reject(ex)
+        }
+    }
+
+    fun makeVideoBitrate(originalHeight: Int, originalWidth: Int, originalBitrate: Int, height: Int, width: Int): Int {
+        val compressFactor = 0.8f
+        val minCompressFactor = 0.8f
+        val maxBitrate = 1669000
+        var remeasuredBitrate = (originalBitrate / Math.min(originalHeight / height.toFloat(), originalWidth / width.toFloat())).toInt()
+        remeasuredBitrate = (remeasuredBitrate * compressFactor).toInt()
+        val minBitrate = (getVideoBitrateWithFactor(minCompressFactor) / (1280f * 720f / (width * height))).toInt()
+        if (originalBitrate < minBitrate) {
+            return remeasuredBitrate
+        }
+        return if (remeasuredBitrate > maxBitrate) {
+            maxBitrate
+        } else Math.max(remeasuredBitrate, minBitrate)
+    }
+
+    private fun getVideoBitrateWithFactor(f: Float): Int {
+        return (f * 2000f * 1000f * 1.13f).toInt()
+    }
+}