react-native-compressor 1.8.10 → 1.8.12

package/README.md

@@ -287,6 +287,17 @@ const uploadResult = await backgroundUpload(
     console.log(written, total);
   }
 );
+
+//OR
+
+const uploadResult = await backgroundUpload(
+  url,
+  fileUrl,
+  { uploadType: UploadType.MULTIPART, httpMethod: 'POST', headers },
+  (written, total) => {
+    console.log(written, total);
+  }
+);
 ```
 
 ### Download File
@@ -351,7 +362,12 @@ await clearCache(); // this will clear cache of thumbnails cache directory
 
 - ###### `output: OutputType` (default: jpg)
 
-  Can be either `jpg` or `png`, defines the output image format.
+  The quality modifier for the `JPEG` file format, can be specified when output is `PNG` but will be ignored. if you wanna apply quality modifier then you can enable `disablePngTransparency:true`,
+  **Note:** if you png image have no transparent background then enable `disablePngTransparency:true` modifier is recommended
+
+- ###### `disablePngTransparency: boolean` (default: false)
+
+  when user add `output:'png'` then by default compressed image will have transparent background, and quality will be ignored, if you wanna apply quality then you have to disablePngTransparency like `disablePngTransparency:true`, it will convert transparent background to white
 
 - ###### `returnableOutputType: ReturnableOutputType` (default: uri)
   Can be either `uri` or `base64`, defines the Returnable output image format.
@@ -406,28 +422,50 @@ await clearCache(); // this will clear cache of thumbnails cache directory
 
 ## Background Upload
 
-- ###### backgroundUpload: (url: string, fileUrl: string, options: FileSystemUploadOptions, onProgress?: ((writtem: number, total: number) => void) | undefined) => Promise< any >
+- ###### backgroundUpload: (url: string, fileUrl: string, options: UploaderOptions, onProgress?: ((writtem: number, total: number) => void) | undefined) => Promise< any >
 
-- ###### ` FileSystemUploadOptions`
+- ###### ` UploaderOptions`
 
 ```js
-type FileSystemUploadOptions = (
+export enum UploadType {
+  BINARY_CONTENT = 0,
+  MULTIPART = 1,
+}
+
+export enum UploaderHttpMethod {
+  POST = 'POST',
+  PUT = 'PUT',
+  PATCH = 'PATCH',
+}
+
+export declare type HTTPResponse = {
+  status: number;
+  headers: Record<string, string>;
+  body: string;
+};
+
+export declare type HttpMethod = 'POST' | 'PUT' | 'PATCH';
+
+export declare type UploaderOptions = (
   | {
-      uploadType?: FileSystemUploadType.BINARY_CONTENT,
+      uploadType?: UploadType.BINARY_CONTENT;
+      mimeType?: string;
     }
   | {
-      uploadType: FileSystemUploadType.MULTIPART, // will add soon
-      fieldName?: string, // will add soon
-      mimeType?: string,
-      parameters?: Record<string, string>,
+      uploadType: UploadType.MULTIPART;
+      fieldName?: string;
+      mimeType?: string;
+      parameters?: Record<string, string>;
     }
 ) & {
-  headers?: Record<string, string>,
-  httpMethod?: FileSystemAcceptedUploadHttpMethod,
-  sessionType?: FileSystemSessionType,
+  headers?: Record<string, string>;
+  httpMethod?: UploaderHttpMethod;
 };
 ```
 
+**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)
+
 ### Download
 
 - ##### download: ( fileUrl: string, downloadProgress?: (progress: number) => void, progressDivider?: number ) => Promise< string >

package/android/build.gradle

@@ -115,7 +115,6 @@ dependencies {
   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.banketree:AndroidLame-kotlin:v0.0.1'
   implementation 'javazoom:jlayer:1.0.1'
 }

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

@@ -15,12 +15,14 @@ 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.Utils.convertReadableMapToUploaderOptions
 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)
+  private val uploader: Uploader = Uploader(reactContext)
   private val videoThumbnail: CreateVideoThumbnailClass = CreateVideoThumbnailClass(reactContext)
 
   override fun initialize() {
@@ -120,7 +122,7 @@ class CompressorModule(private val reactContext: ReactApplicationContext) : Comp
     fileUrl: String,
     options: ReadableMap,
     promise: Promise) {
-    Uploader.upload(fileUrl, options, reactContext, promise)
+    uploader.upload(fileUrl, options, reactContext, promise)
   }
 
   @ReactMethod

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

@@ -10,7 +10,9 @@ import android.media.ExifInterface
 import android.net.Uri
 import android.util.Base64
 import com.facebook.react.bridge.ReactApplicationContext
+import com.reactnativecompressor.Utils.MediaCache
 import com.reactnativecompressor.Utils.Utils.generateCacheFilePath
+import com.reactnativecompressor.Utils.Utils.slashifyFilePath
 import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.FileOutputStream
@@ -71,20 +73,20 @@ object ImageCompressor {
     }
 
     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
+      val size = findActualSize(image, maxWidth, maxHeight)
+      val scaledImage = Bitmap.createBitmap(size.width, size.height, Bitmap.Config.ARGB_8888)
+      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 {
+    fun compress(image: Bitmap?, output: ImageCompressorOptions.OutputType, quality: Float,disablePngTransparency:Boolean): ByteArrayOutputStream {
       var stream = ByteArrayOutputStream()
       if (output === ImageCompressorOptions.OutputType.jpg)
       {
@@ -92,12 +94,15 @@ object ImageCompressor {
       }
       else
       {
-        val pngStream = ByteArrayOutputStream()
-        image!!.compress(CompressFormat.JPEG, Math.round(100 * quality), stream)
-        val byteArray: ByteArray = stream.toByteArray()
-        stream=ByteArrayOutputStream()
-        val bitmap = BitmapFactory.decodeByteArray(byteArray, 0, byteArray.size)
-        bitmap.compress(CompressFormat.PNG, 100, stream)
+        var bitmap = image
+        if(disablePngTransparency)
+        {
+          image!!.compress(CompressFormat.JPEG, Math.round(100 * quality), stream)
+          val byteArray: ByteArray = stream.toByteArray()
+          stream=ByteArrayOutputStream()
+          bitmap = BitmapFactory.decodeByteArray(byteArray, 0, byteArray.size)
+        }
+        bitmap!!.compress(CompressFormat.PNG, 100, stream)
       }
       return stream
     }
@@ -105,14 +110,36 @@ object ImageCompressor {
     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 imageDataByteArrayOutputStream = compress(resizedImage, options.output, options.quality,options.disablePngTransparency)
         val isBase64 = options.returnableOutputType === ImageCompressorOptions.ReturnableOutputType.base64
         return encodeImage(imageDataByteArrayOutputStream, isBase64, options.output.toString(), reactContext)
     }
 
+  fun isCompressedSizeLessThanActualFile(sourceFileUrl: String,compressedFileUrl: String?): Boolean {
+    try {
+      val sourceUri = Uri.parse(sourceFileUrl)
+      val sourcePath = sourceUri.path
+      val sourcefile = File(sourcePath)
+      val sizeInBytesForSourceFile = sourcefile.length().toFloat()
+
+      val compressedUri = Uri.parse(compressedFileUrl)
+      val compressedPath = compressedUri.path
+      val compressedfile = File(compressedPath)
+      val sizeInBytesForcompressedFile = compressedfile.length().toFloat()
+
+      if(sizeInBytesForcompressedFile<=sizeInBytesForSourceFile)
+      {
+        return true
+      }
+      return false
+    } catch (exception: OutOfMemoryError) {
+      exception.printStackTrace()
+      return true
+    }
+  }
+
     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
@@ -152,7 +179,7 @@ object ImageCompressor {
             exception.printStackTrace()
         }
         try {
-            scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.RGB_565)
+            scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.ARGB_8888)
         } catch (exception: OutOfMemoryError) {
             exception.printStackTrace()
         }
@@ -169,8 +196,14 @@ object ImageCompressor {
             bmp.recycle()
         }
         scaledBitmap = correctImageOrientation(scaledBitmap, imagePath)
-        val imageDataByteArrayOutputStream = compress(scaledBitmap, compressorOptions.output, compressorOptions.quality)
-        return encodeImage(imageDataByteArrayOutputStream, isBase64, compressorOptions.output.toString(), reactContext)
+        val imageDataByteArrayOutputStream = compress(scaledBitmap, compressorOptions.output, compressorOptions.quality,compressorOptions.disablePngTransparency)
+        val compressedImagePath=encodeImage(imageDataByteArrayOutputStream, isBase64, compressorOptions.output.toString(), reactContext)
+        if(isCompressedSizeLessThanActualFile(imagePath!!,compressedImagePath))
+        {
+        return  compressedImagePath
+        }
+       MediaCache.deleteFile(compressedImagePath!!)
+       return slashifyFilePath(imagePath)
     }
 
     fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int {

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

@@ -32,6 +32,7 @@ class ImageCompressorOptions {
     var output = OutputType.jpg
     var uuid: String? = ""
     var returnableOutputType = ReturnableOutputType.uri
+    var disablePngTransparency:Boolean = false
 
     companion object {
         fun fromMap(map: ReadableMap): ImageCompressorOptions {
@@ -49,6 +50,7 @@ class ImageCompressorOptions {
                     "output" -> options.output = OutputType.valueOf(map.getString(key)!!)
                     "returnableOutputType" -> options.returnableOutputType = ReturnableOutputType.valueOf(map.getString(key)!!)
                     "uuid" -> options.uuid = map.getString(key)
+                    "disablePngTransparency" -> options.disablePngTransparency = map.getBoolean(key)
                 }
             }
             return options

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

@@ -58,4 +58,19 @@ object MediaCache {
         }
         completedImagePaths.clear()
     }
+
+  fun deleteFile(filePath: String) {
+    val _filePath = filePath.replace("file://", "")
+    val file = File(_filePath)
+
+    if (file.exists()) {
+      if (file.delete()) {
+        println("File deleted successfully.")
+      } else {
+        println("File couldn't be deleted.")
+      }
+    } else {
+      println("File not found.")
+    }
+  }
 }

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

@@ -1,117 +1,178 @@
 package com.reactnativecompressor.Utils
 
+import android.annotation.SuppressLint
+import android.content.ContentResolver
+import android.net.Uri
 import android.util.Log
+import android.webkit.MimeTypeMap
 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 com.reactnativecompressor.Utils.Utils.slashifyFilePath
 import okhttp3.Call
 import okhttp3.Callback
-import okhttp3.MediaType
+import okhttp3.Headers
 import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.MultipartBody
 import okhttp3.OkHttpClient
-import okhttp3.Request.Builder
+import okhttp3.Request
 import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.asRequestBody
 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() == 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
+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 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)
-            }
+      }
+      val request = createUploadRequest(
+        url, fileUriString, options
+      ) { requestBody -> CountingRequestBody(requestBody, progressListener) }
+
+      okHttpClient?.let {
+        it.newCall(request).enqueue(object : Callback {
+          override fun onFailure(call: Call, e: IOException) {
+            Log.e(TAG, e.message.toString())
+            promise.reject(TAG, e.message, e)
+          }
+
+          override fun onResponse(call: Call, response: Response) {
+            val param = Arguments.createMap()
+            param.putInt("status", response.code)
+            param.putString("body", response.body?.string())
+            param.putMap("headers", translateHeaders(response.headers))
+            response.close()
+            promise.resolve(param)
+          }
         })
+      } ?: run {
+        promise.reject(UploaderOkHttpNullException())
+      }
+
     }
-}
 
+  @get:Synchronized
+  private val okHttpClient: OkHttpClient?
+    get() {
+      if (client == null) {
+        val builder = OkHttpClient.Builder()
+          .connectTimeout(60, TimeUnit.SECONDS)
+          .readTimeout(60, TimeUnit.SECONDS)
+          .writeTimeout(60, TimeUnit.SECONDS)
+        client = builder.build()
+      }
+      return client
+    }
+
+  @Throws(IOException::class)
+  private fun createUploadRequest(url: String, fileUriString: String, options: UploaderOptions, decorator: RequestBodyDecorator): Request {
+    val fileUri = Uri.parse(slashifyFilePath(fileUriString))
+    fileUri.checkIfFileExists()
+
+    val requestBuilder = Request.Builder().url(url)
+    options.headers?.let {
+      it.forEach { (key, value) -> requestBuilder.addHeader(key, value) }
+    }
+
+    val body = createRequestBody(options, decorator, fileUri.toFile())
+    return options.httpMethod.let { requestBuilder.method(it.value, body).build() }
+  }
+
+  @SuppressLint("NewApi")
+  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) {
+          options.mimeType
+        } else {
+          getContentType(reactContext, file) ?: "application/octet-stream"
+        }
+        val contentType = mimeType?.toMediaTypeOrNull()
+        decorator.decorate(file.asRequestBody(contentType))
+      }
 
-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)
+      UploadType.MULTIPART -> {
+        val bodyBuilder = MultipartBody.Builder().setType(MultipartBody.FORM)
+        options.parameters?.let {
+          (it as Map<String, Any>)
+            .forEach { (key, value) -> bodyBuilder.addFormDataPart(key, value.toString()) }
         }
+        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.build()
+      }
+    }
+  }
+
+  fun getContentType(context: ReactApplicationContext, file: File): String? {
+    val contentResolver: ContentResolver = context.contentResolver
+    val fileUri = Uri.fromFile(file)
+
+    // Try to get the MIME type from the ContentResolver
+    val mimeType = contentResolver.getType(fileUri)
+
+    // If the ContentResolver couldn't determine the MIME type, try to infer it from the file extension
+    if (mimeType == null) {
+      val fileExtension = MimeTypeMap.getFileExtensionFromUrl(fileUri.toString())
+      if (fileExtension != null) {
+        return MimeTypeMap.getSingleton().getMimeTypeFromExtension(fileExtension.toLowerCase())
+      }
+    }
+
+    return mimeType
+  }
+
+  @Throws(IOException::class)
+  private fun Uri.checkIfFileExists() {
+    val file = this.toFile()
+    if (!file.exists()) {
+      throw IOException("Directory for '${file.path}' doesn't exist.")
+    }
+  }
+
+  // extension functions of Uri class
+  private fun Uri.toFile() = if (this.path != null) {
+    File(this.path!!)
+  } else {
+    throw IOException("Invalid Uri: $this")
+  }
+
+  private fun translateHeaders(headers: Headers): ReadableMap {
+    val responseHeaders = Arguments.createMap()
+    for (i in 0 until headers.size) {
+      val headerName = headers.name(i)
+      // multiple values for the same header
+      if (responseHeaders.hasKey(headerName)) {
+        val existingValue = responseHeaders.getString(headerName)
+        responseHeaders.putString(headerName, "$existingValue, ${headers.value(i)}")
+      } else {
+        responseHeaders.putString(headerName, headers.value(i))
       }
-      return options
     }
+    return responseHeaders
   }
 }