react-native-compressor 1.8.16 → 1.8.18

package/README.md

@@ -1,6 +1,7 @@
 <div align="center">
- <img height="150" src="/media/logo.png"></h2>
+ <img height="150" src="/media/logo.png" />
 </div>
+ 
 <br/>
 
 <div align="center">
@@ -15,6 +16,11 @@
 
 **REACT-NATIVE-COMPRESSOR** is a react-native package, which helps us to Compress `Image`, `Video`, and `Audio` before uploading, same like **Whatsapp** without knowing the compression `algorithm`
 
+<div align="center">
+ <b>Also supports Auto/Manual Compression | Background Upload | Download File | Create Video Thumbnail</b>
+</div>
+<br/>
+
 <div align="center">
 <pre>
 <img height="90" src="/media/whatsapp_logo.png"/>               <img height="90" src="/media/compress_media.png"/>
@@ -129,9 +135,9 @@ react-native link react-native-compressor
 
 #### iOS
 
-1. In XCode, in the project navigator, right click `Libraries` ➜ `Add Files to [your project's name]`
-2. Go to `node_modules` ➜ `react-native-compressor` and add `Compressor.xcodeproj`
-3. In XCode, in the project navigator, select your project. Add `libCompressor.a` to your project's `Build Phases` ➜ `Link Binary With Libraries`
+1. In XCode, open Podfile
+2. paste this line `pod 'react-native-compressor', :path => '../node_modules/react-native-compressor'` into `Podfile`
+3. run this command inside ios folder `pod install`
 4. Run your project (`Cmd+R`)<
 
 #### Android
@@ -270,6 +276,17 @@ const result = await Audio.compress(
   'file://path_of_file/file_example_MP3_2MG.wav', // recommended wav file but can be use mp3 file
   { quality: 'medium' }
 );
+
+// OR
+
+const result = await Audio.compress(
+  'file://path_of_file/file_example_MP3_2MG.wav', // recommended wav file but can be use mp3 file
+  {
+    bitrate: 64000,
+    samplerate: 44100,
+    channels: 1,
+  }
+);
 ```
 
 ### Background Upload
@@ -300,6 +317,53 @@ const uploadResult = await backgroundUpload(
 );
 ```
 
+### Cancel Background Upload
+for cancellation Upload, there is two ways
+1. by calling, cancelUpload function
+2. by calling abort function
+
+##### cancelUpload (support single and all)
+```js
+import { cancelUpload, backgroundUpload } from 'react-native-compressor';
+
+// if we will call without passing any param then it will remove last pushed uploading
+cancelUpload()
+
+// if you pass true as second param then it will cancel all the uploading
+cancelUpload("",true)
+
+// if there is multiple files are uploading, and you wanna cancel specific uploading then you pass specific video id like this
+let videoId=''
+const uploadResult = await backgroundUpload(
+  url,
+  fileUrl,
+  { httpMethod: 'PUT',  getCancellationId: (cancellationId) =>(videoId = cancellationId), },
+  (written, total) => {
+    console.log(written, total);
+  }
+);
+cancelUpload(videoId)
+```
+
+##### cancel by calling abort
+```js
+import { backgroundUpload } from 'react-native-compressor';
+
+const abortSignalRef = useRef(new AbortController());
+
+const uploadResult = await backgroundUpload(
+  url,
+  fileUrl,
+  { httpMethod: 'PUT' },
+  (written, total) => {
+    console.log(written, total);
+  },
+  abortSignalRef.current.signal
+);
+
+abortSignalRef.current?.abort(); // this will cancel uploading
+```
+
 ### Download File
 
 ```js
@@ -377,8 +441,14 @@ await clearCache(); // this will clear cache of thumbnails cache directory
 - ###### `compress(url: string, options?: videoCompresssionType , onProgress?: (progress: number)): Promise<string>`
 
 - ###### `cancelCompression(cancellationId: string): void`
+
   we can get cancellationId from `getCancellationId` which is the callback method of compress method options
 
+- ###### `activateBackgroundTask(onExpired?: (data: any) => void): Promise<any>`
+  if you wanna compress video while app is in backgroup then you should call this method before compression
+- ###### `deactivateBackgroundTask(): Promise<any>`
+  if you call `activateBackgroundTask` method, then after video compression, you should call `deactivateBackgroundTask` for disable background task mode.
+
 ### videoCompresssionType
 
 - ###### `compressionMethod: compressionMethod` (default: "manual")
@@ -415,10 +485,20 @@ await clearCache(); // this will clear cache of thumbnails cache directory
 
 ### audioCompresssionType
 
-- ###### `quality: qualityType` (default: medium)
+- ###### `quality?: qualityType` (default: medium)
+
   we can also control bitrate through quality. qualityType can be `low` | `medium` | `high`
 
-**Note: manual bitrate, samplerate etc will add soon**
+- ###### `bitrate?: number` Range [64000-320000]
+
+  we can control bitrate of audio through bitrate, it should be in the range of `64000-320000`
+
+- ###### `samplerate?: number` Range [44100 - 192000]
+
+  we can control samplerate of audio through samplerate, it should be in the range of `44100 - 192000`
+
+- ###### `channels?: number` Typically 1 or 2
+  we can control channels of audio through channels, Typically 1 or 2
 
 ## Background Upload
 
@@ -460,12 +540,25 @@ export declare type UploaderOptions = (
 ) & {
   headers?: Record<string, string>;
   httpMethod?: UploaderHttpMethod;
+  getCancellationId?: (cancellationId: string) => void;
 };
 ```
 
 **Note:** some of the uploader code is borrowed from [Expo](https://github.com/expo/expo)
 I tested file uploader on this backend [Nodejs-File-Uploader](https://github.com/numandev1/nodejs-file-uploader)
 
+### Cancel Background Upload
+for cancellation Upload, there is two ways, you can use one of it
+- ##### cancelUpload: ( uuid?: string, shouldCancelAll?: boolean) => void
+  1. If we call without passing any param then it will remove the last pushed uploading
+  2. If you pass true as the second param then it will cancel all the uploading
+  3. if there is multiple files are uploading, and you wanna cancel specific uploading then you pass a specific video ID like this
+
+- ##### we can use [AbortController](https://github.com/facebook/react-native/blob/255fef5263afdf9933ba2f8a3dbcbca39ea9928a/packages/react-native/types/modules/globals.d.ts#L531) in backgroundUpload [Usage](#cancel-background-upload)
+  `const abortSignalRef = useRef(new AbortController());`
+
+  `abortSignalRef.current?.abort();`
+
 ### Download
 
 - ##### download: ( fileUrl: string, downloadProgress?: (progress: number) => void, progressDivider?: number ) => Promise< string >
@@ -492,11 +585,11 @@ const metaData = await getVideoMetaData(filePath);
 
 ```
 {
-	"duration": "6",
+	"duration": 20.11,
 	"extension": "mp4",
-	"height": "1080",
-	"size": "16940.0",
-	"width": "1920"
+	"height": 1080,
+	"size": 16940.0,
+	"width": 1920
 }
 ```
 

package/android/build.gradle

@@ -78,8 +78,8 @@ android {
   }
 
   compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
+    sourceCompatibility JavaVersion.VERSION_11
+    targetCompatibility JavaVersion.VERSION_11
   }
 
   sourceSets {

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

@@ -4,6 +4,7 @@ package com.reactnativecompressor.Audio
 import android.annotation.SuppressLint
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
 import com.naman14.androidlame.LameBuilder
 import com.naman14.androidlame.WaveReader
 import com.reactnativecompressor.Utils.MediaCache
@@ -27,21 +28,22 @@ class AudioCompressor {
     @JvmStatic
     fun CompressAudio(
       fileUrl: String,
-      quality: String,
+      optionMap: ReadableMap,
       context: ReactApplicationContext,
       promise: Promise,
     ) {
-      var _fileUrl=fileUrl
+      val realPath = Utils.getRealPath(fileUrl, context)
+      var _fileUrl=realPath
+      val filePathWithoutFileUri = realPath!!.replace("file://", "")
       try {
-        val filePath = fileUrl.replace("file://", "")
-        var wavPath=filePath;
+        var wavPath=filePathWithoutFileUri;
         var isNonWav:Boolean=false
         if (fileUrl.endsWith(".mp4", ignoreCase = true))
         {
           addLog("mp4 file found")
           val mp3Path= Utils.generateCacheFilePath("mp3", context)
           AudioExtractor().genVideoUsingMuxer(fileUrl, mp3Path, -1, -1, true, false)
-          _fileUrl="file:/"+mp3Path
+          _fileUrl=Utils.slashifyFilePath(mp3Path)
           wavPath= Utils.generateCacheFilePath("wav", context)
           try {
             val converter = Converter()
@@ -58,7 +60,7 @@ class AudioCompressor {
           wavPath= Utils.generateCacheFilePath("wav", context)
           try {
           val converter = Converter()
-          converter.convert(filePath, wavPath)
+          converter.convert(filePathWithoutFileUri, wavPath)
         } catch (e: JavaLayerException) {
           addLog("JavaLayerException error"+e.localizedMessage)
           e.printStackTrace();
@@ -67,7 +69,7 @@ class AudioCompressor {
         }
 
 
-        autoCompressHelper(wavPath, quality,context) { mp3Path, finished ->
+        autoCompressHelper(wavPath,filePathWithoutFileUri, optionMap,context) { mp3Path, finished ->
           if (finished) {
             val returnableFilePath:String="file://$mp3Path"
             addLog("finished: " + returnableFilePath)
@@ -87,28 +89,23 @@ class AudioCompressor {
       }
     }
 
-    private fun getAudioBitrateByQuality(quality: String): Int {
-      return when (quality) {
-        "low" -> 64 // Set your low bitrate value here
-        "medium" -> 128 // Set your medium bitrate value here
-        "high" -> 256 // Set your high bitrate value here
-        else -> 128 // Default to medium bitrate if quality is not recognized
-      }
-    }
-
     @SuppressLint("WrongConstant")
     private fun autoCompressHelper(
       fileUrl: String,
-      quality: String,
+      actualFileUrl: String,
+      optionMap: ReadableMap,
       context: ReactApplicationContext,
       completeCallback: (String, Boolean) -> Unit
     ) {
+
+      val options = AudioHelper.fromMap(optionMap)
+      val quality = options.quality
+
       var isCompletedCallbackTriggered:Boolean=false
       try {
         var mp3Path = Utils.generateCacheFilePath("mp3", context)
         val input = File(fileUrl)
         val output = File(mp3Path)
-        val audioBitrate= getAudioBitrateByQuality(quality)
 
         val CHUNK_SIZE = 8192
       addLog("Initialising wav reader")
@@ -122,12 +119,46 @@ class AudioCompressor {
       }
 
       addLog("Intitialising encoder")
-      val androidLame = LameBuilder()
-        .setInSampleRate(waveReader!!.sampleRate)
-        .setOutChannels(waveReader!!.channels)
-        .setOutBitrate(audioBitrate)
-        .setOutSampleRate(waveReader!!.sampleRate)
-        .build()
+
+
+        // for bitrate
+        var audioBitrate:Int
+        if(options.bitrate != -1)
+        {
+          audioBitrate= options.bitrate/1000
+        }
+        else
+        {
+          audioBitrate=AudioHelper.getDestinationBitrateByQuality(actualFileUrl, quality!!)
+          Utils.addLog("dest bitrate: $audioBitrate")
+        }
+
+        var androidLame = LameBuilder();
+        androidLame.setOutBitrate(audioBitrate)
+
+        // for channels
+        var audioChannels:Int
+        if(options.channels != -1){
+          audioChannels= options.channels!!
+        }
+        else
+        {
+          audioChannels=waveReader!!.channels
+        }
+        androidLame.setOutChannels(audioChannels)
+
+        // for sample rate
+        androidLame.setInSampleRate(waveReader!!.sampleRate)
+        var audioSampleRate:Int
+        if(options.samplerate != -1){
+          audioSampleRate= options.samplerate!!
+        }
+        else
+        {
+          audioSampleRate=waveReader!!.sampleRate
+        }
+        androidLame.setOutSampleRate(audioSampleRate)
+        val androidLameBuild=androidLame.build()
 
       try {
         outputStream = BufferedOutputStream(FileOutputStream(output), OUTPUT_STREAM_BUFFER)
@@ -154,7 +185,7 @@ class AudioCompressor {
             if (bytesRead > 0) {
 
               var bytesEncoded = 0
-              bytesEncoded = androidLame.encode(buffer_l, buffer_r, bytesRead, mp3Buf)
+              bytesEncoded = androidLameBuild.encode(buffer_l, buffer_r, bytesRead, mp3Buf)
               addLog("bytes encoded=$bytesEncoded")
 
               if (bytesEncoded > 0) {
@@ -177,7 +208,7 @@ class AudioCompressor {
             if (bytesRead > 0) {
               var bytesEncoded = 0
 
-              bytesEncoded = androidLame.encode(buffer_l, buffer_l, bytesRead, mp3Buf)
+              bytesEncoded = androidLameBuild.encode(buffer_l, buffer_l, bytesRead, mp3Buf)
               addLog("bytes encoded=$bytesEncoded")
 
               if (bytesEncoded > 0) {
@@ -202,7 +233,7 @@ class AudioCompressor {
       }
 
       addLog("flushing final mp3buffer")
-      val outputMp3buf = androidLame.flush(mp3Buf)
+      val outputMp3buf = androidLameBuild.flush(mp3Buf)
       addLog("flushed $outputMp3buf bytes")
       if (outputMp3buf > 0) {
         try {

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

@@ -1,10 +1,19 @@
 package com.reactnativecompressor.Audio
 
+import android.media.MediaExtractor
+import android.media.MediaFormat
 import com.facebook.react.bridge.ReadableMap
+import com.reactnativecompressor.Utils.Utils
+import java.io.File
+import java.io.IOException
+
 
 class AudioHelper {
 
   var quality: String? = "medium"
+  var bitrate: Int = -1
+  var samplerate: Int = -1
+  var channels: Int = -1
   var progressDivider: Int? = 0
 
   companion object {
@@ -15,9 +24,49 @@ class AudioHelper {
         val key = iterator.nextKey()
         when (key) {
           "quality" -> options.quality = map.getString(key)
+          "bitrate" -> {
+            val bitrate = map.getInt(key)
+            options.bitrate = if (bitrate > 320000 || bitrate < 64000) 64000 else bitrate
+          }
+          "samplerate" -> options.samplerate = map.getInt(key)
+          "channels" -> options.channels = map.getInt(key)
         }
       }
       return options
     }
+
+
+    fun getAudioBitrate(path: String): Int {
+      val file = File(path)
+      val fileSize = file.length() * 8 // size in bits
+
+      val mex = MediaExtractor()
+      try {
+        mex.setDataSource(path)
+      } catch (e: IOException) {
+        e.printStackTrace()
+      }
+
+      val mf = mex.getTrackFormat(0)
+      val durationUs = mf.getLong(MediaFormat.KEY_DURATION)
+      val durationSec = durationUs / 1_000_000.0 // convert duration to seconds
+
+      return (fileSize / durationSec).toInt()/1000 // bitrate in bits per second
+    }
+    fun getDestinationBitrateByQuality(path: String, quality: String): Int {
+      val originalBitrate = getAudioBitrate(path)
+      var destinationBitrate = originalBitrate
+      Utils.addLog("source bitrate: $originalBitrate")
+
+      when (quality.toLowerCase()) {
+        "low" -> destinationBitrate = maxOf(64, (originalBitrate * 0.3).toInt())
+        "medium" -> destinationBitrate = (originalBitrate * 0.5).toInt()
+        "high" -> destinationBitrate = minOf(320, (originalBitrate * 0.7).toInt())
+        else -> Utils.addLog("Invalid quality level. Please enter 'low', 'medium', or 'high'.")
+      }
+
+      return destinationBitrate
+    }
+
   }
 }

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

@@ -3,7 +3,6 @@ package com.reactnativecompressor.Audio
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
-import com.reactnativecompressor.Utils.Utils
 
 class AudioMain(private val reactContext: ReactApplicationContext) {
   fun compress_audio(
@@ -11,11 +10,8 @@ class AudioMain(private val reactContext: ReactApplicationContext) {
     optionMap: ReadableMap,
     promise: Promise) {
     try {
-      val options = AudioHelper.fromMap(optionMap)
-      val quality = options.quality
-      val realPath = Utils.getRealPath(fileUrl, reactContext)
-      Utils.addLog(fileUrl + "\n realPath= " + realPath)
-      AudioCompressor.CompressAudio(realPath!!, quality!!,reactContext,promise)
+
+      AudioCompressor.CompressAudio(fileUrl,optionMap,reactContext,promise)
     } catch (ex: Exception) {
       promise.reject(ex)
     }

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

@@ -125,6 +125,11 @@ class CompressorModule(private val reactContext: ReactApplicationContext) : Comp
     uploader.upload(fileUrl, options, reactContext, promise)
   }
 
+  @ReactMethod
+  override fun cancelUpload(uuid: String,shouldCancelAll:Boolean) {
+    uploader.cancelUpload(uuid,shouldCancelAll)
+  }
+
   @ReactMethod
   override fun download(
     fileUrl: String,

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

@@ -0,0 +1,41 @@
+package com.reactnativecompressor.Utils
+
+import okhttp3.Call
+
+class HttpCallManager {
+  private var resumableCalls: MutableMap<String, Call?> = HashMap()
+
+  fun registerTask(call: Call, uuid: String) {
+    resumableCalls[uuid] = call
+  }
+
+  fun taskForId(uuid: String): Call? {
+    return resumableCalls[uuid]
+  }
+
+  // will use in future
+  fun downloadTaskForId(uuid: String): Call? {
+    return taskForId(uuid)
+  }
+
+  fun uploadTaskForId(uuid: String): Call? {
+    return taskForId(uuid)
+  }
+
+  fun taskPop(): Call? {
+    val lastUuid = resumableCalls.keys.lastOrNull()
+    val lastCall = resumableCalls.remove(lastUuid)
+    return lastCall
+  }
+
+  fun unregisterTask(uuid: String) {
+    resumableCalls.remove(uuid)
+  }
+
+  fun cancelAllTasks() {
+    for ((_, call) in resumableCalls) {
+      call?.cancel()
+    }
+    resumableCalls.clear()
+  }
+}

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

@@ -26,36 +26,45 @@ import java.net.URLConnection
 import java.util.concurrent.TimeUnit
 
 class Uploader(private val reactContext: ReactApplicationContext) {
-    val TAG = "asyncTaskUploader"
-    var client: OkHttpClient? = null
-    val MIN_EVENT_DT_MS: Long = 100
-
-    fun upload(fileUriString: String, _options: ReadableMap, reactContext: ReactApplicationContext, promise: Promise) {
-      val options:UploaderOptions=convertReadableMapToUploaderOptions(_options)
-      val url = options.url
-      val uuid = options.uuid
-      val progressListener: CountingRequestListener = object : CountingRequestListener {
-        private var mLastUpdate: Long = -1
-        override fun onProgress(bytesWritten: Long, contentLength: Long) {
-          val currentTime = System.currentTimeMillis()
-
-          // Throttle events. Sending too many events will block the JS event loop.
-          // Make sure to send the last event when we're at 100%.
-          if (currentTime > mLastUpdate + MIN_EVENT_DT_MS || bytesWritten == contentLength) {
-            mLastUpdate = currentTime
-            EventEmitterHandler.sendUploadProgressEvent(bytesWritten,contentLength,uuid)
-          }
+  val TAG = "asyncTaskUploader"
+  var client: OkHttpClient? = null
+  val MIN_EVENT_DT_MS: Long = 100
+  val httpCallManager = HttpCallManager()
+
+  fun upload(
+    fileUriString: String,
+    _options: ReadableMap,
+    reactContext: ReactApplicationContext,
+    promise: Promise
+  ) {
+    val options: UploaderOptions = convertReadableMapToUploaderOptions(_options)
+    val url = options.url
+    val uuid = options.uuid
+    val progressListener: CountingRequestListener = object : CountingRequestListener {
+      private var mLastUpdate: Long = -1
+      override fun onProgress(bytesWritten: Long, contentLength: Long) {
+        val currentTime = System.currentTimeMillis()
+
+        // Throttle events. Sending too many events will block the JS event loop.
+        // Make sure to send the last event when we're at 100%.
+        if (currentTime > mLastUpdate + MIN_EVENT_DT_MS || bytesWritten == contentLength) {
+          mLastUpdate = currentTime
+          EventEmitterHandler.sendUploadProgressEvent(bytesWritten, contentLength, uuid)
         }
       }
-      val request = createUploadRequest(
-        url, fileUriString, options
-      ) { requestBody -> CountingRequestBody(requestBody, progressListener) }
-
-      okHttpClient?.let {
-        it.newCall(request).enqueue(object : Callback {
+    }
+    val request = createUploadRequest(
+      url, fileUriString, options
+    ) { requestBody -> CountingRequestBody(requestBody, progressListener) }
+
+    okHttpClient?.let {
+      val call = it.newCall(request)
+      httpCallManager.registerTask(call,uuid)
+      call.enqueue(
+        object : Callback {
           override fun onFailure(call: Call, e: IOException) {
             Log.e(TAG, e.message.toString())
-            promise.reject(TAG, e.message, e)
+            promise.reject(TAG, e.message)
           }
 
           override fun onResponse(call: Call, response: Response) {
@@ -67,12 +76,12 @@ class Uploader(private val reactContext: ReactApplicationContext) {
             promise.resolve(param)
           }
         })
-      } ?: run {
-        promise.reject(UploaderOkHttpNullException())
-      }
-
+    } ?: run {
+      promise.reject(UploaderOkHttpNullException())
     }
 
+  }
+
   @get:Synchronized
   private val okHttpClient: OkHttpClient?
     get() {
@@ -87,7 +96,12 @@ class Uploader(private val reactContext: ReactApplicationContext) {
     }
 
   @Throws(IOException::class)
-  private fun createUploadRequest(url: String, fileUriString: String, options: UploaderOptions, decorator: RequestBodyDecorator): Request {
+  private fun createUploadRequest(
+    url: String,
+    fileUriString: String,
+    options: UploaderOptions,
+    decorator: RequestBodyDecorator
+  ): Request {
     val fileUri = Uri.parse(slashifyFilePath(fileUriString))
     fileUri.checkIfFileExists()
 
@@ -101,7 +115,11 @@ class Uploader(private val reactContext: ReactApplicationContext) {
   }
 
   @SuppressLint("NewApi")
-  private fun createRequestBody(options: UploaderOptions, decorator: RequestBodyDecorator, file: File): RequestBody {
+  private fun createRequestBody(
+    options: UploaderOptions,
+    decorator: RequestBodyDecorator,
+    file: File
+  ): RequestBody {
     return when (options.uploadType) {
       UploadType.BINARY_CONTENT -> {
         val mimeType: String? = if (options.mimeType?.isNotEmpty() == true) {
@@ -122,7 +140,11 @@ class Uploader(private val reactContext: ReactApplicationContext) {
         val mimeType: String = options.mimeType ?: URLConnection.guessContentTypeFromName(file.name)
 
         val fieldName = options.fieldName ?: file.name
-        bodyBuilder.addFormDataPart(fieldName, file.name, decorator.decorate(file.asRequestBody(mimeType.toMediaTypeOrNull())))
+        bodyBuilder.addFormDataPart(
+          fieldName,
+          file.name,
+          decorator.decorate(file.asRequestBody(mimeType.toMediaTypeOrNull()))
+        )
         bodyBuilder.build()
       }
     }
@@ -175,4 +197,19 @@ class Uploader(private val reactContext: ReactApplicationContext) {
     }
     return responseHeaders
   }
+
+  fun cancelUpload(uuid:String,shouldCancelAll:Boolean) {
+    if(shouldCancelAll)
+    {
+      httpCallManager.cancelAllTasks()
+    }
+    else if(uuid=="")
+    {
+      httpCallManager.taskPop()?.cancel()
+    }
+    else
+    {
+      httpCallManager.uploadTaskForId(uuid)?.cancel()
+    }
+  }
 }

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

@@ -8,7 +8,6 @@ import android.net.Uri
 import android.os.Build
 import android.text.TextUtils
 import android.webkit.URLUtil
-import androidx.annotation.RequiresApi
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.GuardedResultAsyncTask
 import com.facebook.react.bridge.Promise
@@ -39,7 +38,6 @@ class CreateVideoThumbnailClass(private val reactContext: ReactApplicationContex
             weakContext = WeakReference(reactContext.applicationContext)
         }
 
-        @RequiresApi(Build.VERSION_CODES.N)
         override fun doInBackgroundGuarded(): ReadableMap? {
             val format = "jpeg"
             val cacheName = if (options.hasKey("cacheName")) options.getString("cacheName") else ""

package/android/src/oldarch/CompressorSpec.kt

@@ -23,6 +23,7 @@ abstract class CompressorSpec(context: ReactApplicationContext?) : ReactContextB
     abstract fun compress(fileUrl: String, optionMap: ReadableMap, promise: Promise)
     abstract fun cancelCompression(uuid: String)
     abstract fun upload(fileUrl: String, options: ReadableMap, promise: Promise)
+    abstract fun cancelUpload(uuid: String, shouldCancelAll:Boolean)
 
     abstract fun download(fileUrl: String, options: ReadableMap, promise: Promise)
     abstract fun activateBackgroundTask(options: ReadableMap, promise: Promise)