react-native-compressor 1.8.1 → 1.8.2

package/README.md

@@ -68,6 +68,7 @@ We should use **react-native-compressor** instead of **FFmpeg** because **react-
   - [Audio](#audio)
   - [Background Upload](#background-upload)
   - [Download File](#download)
+  - [Create Video Thumbnail and Clear Cache](#create-video-thumbnail-and-clear-cache)
 
 * [Other Utilities](#api)
   - [Background Upload](#background-upload-1)
@@ -431,7 +432,7 @@ type FileSystemUploadOptions = (
 
 - ##### download: ( fileUrl: string, downloadProgress?: (progress: number) => void, progressDivider?: number ) => Promise< string >
 
-### Create Video Thumbnail and clear cache
+### Create Video Thumbnail and Clear Cache
 
 - #### createVideoThumbnail( fileUrl: string, options: {header:Object} ): Promise<{ path: string;size: number; mime: string; width: number; height: number; }>
 

package/android/build.gradle

@@ -110,9 +110,12 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation 'commons-io:commons-io:2.8.0'
+
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
+  implementation "com.googlecode.mp4parser:isoparser:1.0.6"
+
   implementation 'io.github.lizhangqu:coreprogress:1.0.2'
-  implementation 'com.github.numandev1:VideoCompressor:1a262bba37'
 }
 
 if (isNewArchitectureEnabled()) {

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

@@ -11,7 +11,7 @@ import android.media.MediaMuxer
 import android.os.Build
 import android.util.Log
 import androidx.annotation.RequiresApi
-import numan.dev.videocompressor.codecinputsurface.CodecInputSurface
+import com.reactnativecompressor.Video.VideoCompressor.video.OutputSurface
 import java.io.File
 import java.io.IOException
 import java.nio.ByteBuffer
@@ -24,7 +24,7 @@ class AudioCompressor {
     private var mEncoder: MediaCodec? = null
     private var mDecoder: MediaCodec? = null
     private var mTrackIndex = 0
-    private var mInputSurface: CodecInputSurface? = null
+    private var mInputSurface: OutputSurface? = null
 
     // bit rate, in bits per second
     private var mBitRate = -1

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

@@ -8,7 +8,7 @@ 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.CreateVideoThumbnail
+import com.reactnativecompressor.Utils.CreateVideoThumbnailClass
 import com.reactnativecompressor.Utils.Downloader
 import com.reactnativecompressor.Utils.EventEmitterHandler
 import com.reactnativecompressor.Utils.Uploader
@@ -21,7 +21,7 @@ class CompressorModule(private val reactContext: ReactApplicationContext) : Comp
   private val imageMain: ImageMain = ImageMain(reactContext)
   private val videoMain: VideoMain = VideoMain(reactContext)
   private val audioMain: AudioMain = AudioMain(reactContext)
-  private val videoThumbnail: CreateVideoThumbnail = CreateVideoThumbnail(reactContext)
+  private val videoThumbnail: CreateVideoThumbnailClass = CreateVideoThumbnailClass(reactContext)
 
   override fun initialize() {
     super.initialize()
@@ -156,7 +156,7 @@ class CompressorModule(private val reactContext: ReactApplicationContext) : Comp
 
   @ReactMethod
   override fun clearCache(cacheDir:String?, promise:Promise) {
-    CreateVideoThumbnail.clearCache(cacheDir, promise, reactContext)
+    CreateVideoThumbnailClass.clearCache(cacheDir, promise, reactContext)
   }
 
     @ReactMethod

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

@@ -32,17 +32,17 @@ object Uploader {
       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 headerIterator = options?.headers?.keySetIterator()
+        while (headerIterator?.hasNextKey() == true) {
+          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 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.
@@ -52,7 +52,7 @@ object Uploader {
             }
 
             override fun onUIProgressChanged(numBytes: Long, totalBytes: Long, percent: Float, speed: Float) {
-                EventEmitterHandler.sendUploadProgressEvent(numBytes,totalBytes,options.uuid)
+                EventEmitterHandler.sendUploadProgressEvent(numBytes,totalBytes,options?.uuid)
                 Log.d(TAG, "=============start===============")
                 Log.d(TAG, "numBytes:$numBytes")
                 Log.d(TAG, "totalBytes:$totalBytes")

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

@@ -7,8 +7,8 @@ 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 com.reactnativecompressor.Video.VideoCompressor.CompressionListener
+import com.reactnativecompressor.Video.VideoCompressor.VideoCompressorClass
 import java.io.FileNotFoundException
 import java.io.IOException
 import java.net.HttpURLConnection
@@ -17,7 +17,7 @@ import java.util.UUID
 
 object Utils {
     private const val TAG = "react-native-compessor"
-    var compressorExports: MutableMap<String, VideoCompressTask> = HashMap()
+    var compressorExports: MutableMap<String, VideoCompressorClass?> = HashMap()
     @JvmStatic
     fun generateCacheFilePath(extension: String, reactContext: ReactApplicationContext): String {
         val outputDir = reactContext.cacheDir
@@ -26,48 +26,54 @@ object Utils {
 
     @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
+      val currentVideoCompression = intArrayOf(0)
+      val videoCompressorClass: VideoCompressorClass? = VideoCompressorClass(reactContext);
+      compressorExports[uuid] = videoCompressorClass
+      videoCompressorClass?.start(srcPath, destinationPath, resultWidth, resultHeight, videoBitRate.toInt(),
+          listener = object : CompressionListener {
+            override fun onProgress(index: Int, percent: Float) {
+              if (percent <= 100)
+              {
+                val roundProgress = Math.round(percent)
+                if (progressDivider==0||(roundProgress % progressDivider == 0 && roundProgress > currentVideoCompression[0])) {
+                  EventEmitterHandler.emitVideoCompressProgress((percent / 100).toDouble(),uuid)
+                  currentVideoCompression[0] = roundProgress
                 }
+              }
+            }
 
-                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 onStart(index: Int) {
 
-                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
-        }
+            override fun onSuccess(index: Int, size: Long, path: String?) {
+              val fileUrl = "file://$destinationPath"
+              //convert finish,result(true is success,false is fail)
+              promise.resolve(fileUrl)
+              MediaCache.removeCompletedImagePath(fileUrl)
+              currentVideoCompression[0] = 0
+              compressorExports[uuid]=null
+            }
+
+            override fun onFailure(index: Int, failureMessage: String) {
+              Log.wtf("failureMessage", failureMessage)
+              currentVideoCompression[0] = 0
+            }
+
+            override fun onCancelled(index: Int) {
+              Log.wtf("TAG", "compression has been cancelled")
+              // make UI changes, cleanup, etc
+              currentVideoCompression[0] = 0
+            }
+          },
+        )
     }
 
     fun cancelCompressionHelper(uuid: String) {
         try {
             val export = compressorExports[uuid]
-            export!!.cancel(true)
+            export?.cancel()
+          compressorExports[uuid]=null
         } catch (ex: Exception) {
         }
     }

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

@@ -26,7 +26,7 @@ import java.net.URLDecoder
 import java.util.UUID
 
 
-class CreateVideoThumbnail(private val reactContext: ReactApplicationContext) {
+class CreateVideoThumbnailClass(private val reactContext: ReactApplicationContext) {
     @ReactMethod
     fun create(fileUrl:String,options: ReadableMap, promise: Promise) {
         ProcessDataTask(reactContext,fileUrl, promise, options).execute()

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

@@ -0,0 +1,73 @@
+package com.reactnativecompressor.Video.VideoCompressor
+
+import androidx.annotation.MainThread
+import androidx.annotation.WorkerThread
+
+/**
+ * Interface for listening to video compression events.
+ */
+interface CompressionListener {
+  /**
+   * Called when video compression starts.
+   *
+   * @param index The index of the video being compressed.
+   */
+  @MainThread
+  fun onStart(index: Int)
+
+  /**
+   * Called when video compression succeeds.
+   *
+   * @param index The index of the video that was compressed.
+   * @param size The size of the compressed video.
+   * @param path The path to the compressed video file (nullable).
+   */
+  @MainThread
+  fun onSuccess(index: Int, size: Long, path: String?)
+
+  /**
+   * Called when video compression fails.
+   *
+   * @param index The index of the video that failed to compress.
+   * @param failureMessage A message describing the reason for the failure.
+   */
+  @MainThread
+  fun onFailure(index: Int, failureMessage: String)
+
+  /**
+   * Called to report the progress of video compression.
+   *
+   * @param index The index of the video being compressed.
+   * @param percent The progress percentage (0.0 to 100.0).
+   */
+  @WorkerThread
+  fun onProgress(index: Int, percent: Float)
+
+  /**
+   * Called when video compression is canceled.
+   *
+   * @param index The index of the video that was canceled.
+   */
+  @WorkerThread
+  fun onCancelled(index: Int)
+}
+
+/**
+ * Interface for tracking the progress of video compression.
+ */
+interface CompressionProgressListener {
+  /**
+   * Called when the progress of video compression changes.
+   *
+   * @param index The index of the video being compressed.
+   * @param percent The current progress percentage (0.0 to 100.0).
+   */
+  fun onProgressChanged(index: Int, percent: Float)
+
+  /**
+   * Called when the compression progress is canceled.
+   *
+   * @param index The index of the video compression that was canceled.
+   */
+  fun onProgressCancelled(index: Int)
+}

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

@@ -0,0 +1,148 @@
+package com.reactnativecompressor.Video.VideoCompressor
+
+import android.database.Cursor
+import android.net.Uri
+import android.provider.MediaStore
+import com.facebook.react.bridge.ReactApplicationContext
+import com.reactnativecompressor.Video.VideoCompressor.compressor.Compressor.compressVideo
+import com.reactnativecompressor.Video.VideoCompressor.compressor.Compressor.isRunning
+import com.reactnativecompressor.Video.VideoCompressor.video.Result
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+
+class VideoCompressorClass(private val context: ReactApplicationContext) {
+  private var job: Job? = null
+
+  @JvmOverloads
+  fun start(
+    srcPath: String,
+    destPath: String,
+    outputWidth: Int,
+    outputHeight: Int,
+    bitrate: Int,
+    listener: CompressionListener,
+  ) {
+    val uris = mutableListOf<Uri>()
+    val uri = Uri.parse(srcPath)
+    uris.add(uri)
+    val isStreamable: Boolean = false
+    doVideoCompression(
+      uris,
+      isStreamable,
+      outputWidth,
+      outputHeight,
+      bitrate,
+      listener,
+      destPath
+    )
+  }
+
+  fun cancel() {
+    job?.cancel()
+    isRunning = false
+  }
+
+  private fun doVideoCompression(
+    uris: List<Uri>,
+    isStreamable: Boolean,
+    outputWidth: Int,
+    outputHeight: Int,
+    bitrate: Int,
+    listener: CompressionListener,
+    destPath: String
+  ) {
+    var streamableFile: File? = null
+    for (i in uris.indices) {
+      job = CoroutineScope(Dispatchers.Main).launch {
+        val desFile = File(destPath)
+
+        if (isStreamable)
+          streamableFile = File(destPath)
+
+        desFile?.let {
+          isRunning = true
+          listener.onStart(i)
+          val result = startCompression(
+            i,
+            uris[i],
+            desFile.path,
+            streamableFile?.path,
+            outputWidth,
+            outputHeight,
+            bitrate,
+            listener,
+          )
+
+          // Runs in Main(UI) Thread
+          if (result.success) {
+            listener.onSuccess(i, result.size, result.path)
+          } else {
+            listener.onFailure(i, result.failureMessage ?: "An error has occurred!")
+          }
+        }
+      }
+    }
+  }
+
+  private suspend fun startCompression(
+    index: Int,
+    srcUri: Uri,
+    destPath: String,
+    streamableFile: String? = null,
+    outputWidth: Int,
+    outputHeight: Int,
+    bitrate: Int,
+    listener: CompressionListener,
+  ): Result = withContext(Dispatchers.Default) {
+    return@withContext compressVideo(
+      index,
+      context,
+      srcUri,
+      destPath,
+      streamableFile,
+      outputWidth,
+      outputHeight,
+      bitrate,
+      object : CompressionProgressListener {
+        override fun onProgressChanged(index: Int, percent: Float) {
+          listener.onProgress(index, percent)
+        }
+
+        override fun onProgressCancelled(index: Int) {
+          listener.onCancelled(index)
+        }
+      },
+    )
+  }
+
+  private fun getMediaPath(uri: Uri): String {
+    val scheme = uri.scheme
+    if (scheme == null || scheme == "file") {
+      // The URI is a file URI, so use the path directly.
+      return uri.path ?: ""
+    } else {
+      // The URI is not a file URI, so try to copy the content to a file.
+      val resolver = context.contentResolver
+      val projection = arrayOf(MediaStore.Video.Media.DATA)
+      var cursor: Cursor? = null
+      try {
+        cursor = resolver.query(uri, projection, null, null, null)
+        if (cursor != null && cursor.moveToFirst()) {
+          val columnIndex = cursor.getColumnIndexOrThrow(MediaStore.Video.Media.DATA)
+          return cursor.getString(columnIndex)
+        }
+      } catch (e: Exception) {
+        // Handle the exception as needed.
+      } finally {
+        cursor?.close()
+      }
+    }
+
+    // If all else fails, return an empty string or handle the error accordingly.
+    return ""
+  }
+}