react-native-compressor 1.19.2 → 1.19.4

package/ios/Image/ImageCompressor.swift

@@ -44,7 +44,7 @@ class ImageCompressor {
     }
 
     
-    static func manualResize(_ image: UIImage, maxWidth: Int, maxHeight: Int) -> UIImage {
+    static func manualResize(_ image: UIImage, maxWidth: Int, maxHeight: Int) throws -> UIImage {
         let targetSize = findTargetSize(image, maxWidth: maxWidth, maxHeight: maxHeight)
 
         if let cgImage = image.cgImage {
@@ -82,6 +82,10 @@ class ImageCompressor {
                 free(&targetData)
                 let exception = NSException(name: NSExceptionName(rawValue: "drawing_error"), reason: "Problem while rendering your image", userInfo: nil)
                 exception.raise()
+                // Throw instead of raising an NSException (process abort no JS
+                // catch survives) — the caller rejects the promise.
+                throw NSError(domain: "drawing_error", code: 1,
+                              userInfo: [NSLocalizedDescriptionKey: "Problem while rendering your image"])
             }
 
             let targetContext = CGContext(data: &targetData,
@@ -164,7 +168,7 @@ class ImageCompressor {
         return destinationData as Data
     }
     
-    static func writeImage(_ image: UIImage, output: Int, quality: Float, outputExtension: String, isBase64: Bool, disablePngTransparency: Bool, isEnableAutoCompress: Bool, actualImagePath: String?)-> String {
+    static func writeImage(_ image: UIImage, output: Int, quality: Float, outputExtension: String, isBase64: Bool, disablePngTransparency: Bool, isEnableAutoCompress: Bool, actualImagePath: String?) throws -> String {
         var data: Data
         var exception: NSException?
         let normalizedQuality = CGFloat(min(max(quality, 0), 1))
@@ -212,14 +216,19 @@ class ImageCompressor {
             } catch {
                 exception = NSException(name: NSExceptionName(rawValue: "file_error"), reason: "Error writing file", userInfo: nil)
                 exception?.raise()
+                // Throw instead of raising an NSException: a raise inside a
+                // TurboModule invocation aborts the whole app and no JS catch
+                // can intercept it — the caller rejects the promise instead.
+                throw NSError(domain: "file_error", code: 1,
+                              userInfo: [NSLocalizedDescriptionKey: "Error writing file: \(error.localizedDescription)"])
             }
         }
         return ""
     }
 
     
-    static func manualCompress(_ image: UIImage, output: Int, quality: Float, outputExtension: String, isBase64: Bool, disablePngTransparency: Bool, actualImagePath: String?) -> String {
-        return writeImage(image, output: output, quality: quality, outputExtension: outputExtension, isBase64: isBase64, disablePngTransparency: disablePngTransparency, isEnableAutoCompress: false, actualImagePath: actualImagePath)
+    static func manualCompress(_ image: UIImage, output: Int, quality: Float, outputExtension: String, isBase64: Bool, disablePngTransparency: Bool, actualImagePath: String?) throws -> String {
+        return try writeImage(image, output: output, quality: quality, outputExtension: outputExtension, isBase64: isBase64, disablePngTransparency: disablePngTransparency, isEnableAutoCompress: false, actualImagePath: actualImagePath)
     }
 
     
@@ -288,7 +297,7 @@ class ImageCompressor {
     }
 
     
-    static func manualCompressHandler(imagePath: String?, base64: String?, options: ImageCompressorOptions) -> String {
+    static func manualCompressHandler(imagePath: String?, base64: String?, options: ImageCompressorOptions) throws -> String {
         var exception: NSException?
         var image: UIImage?
 
@@ -306,22 +315,28 @@ class ImageCompressor {
         if let _image = image {
             image = ImageCompressor.scaleAndRotateImage(_image)
             let outputExtension = ImageCompressorOptions.getOutputInString(options.output)
-            let resizedImage = ImageCompressor.manualResize(image!, maxWidth: options.maxWidth, maxHeight: options.maxHeight)
+            let resizedImage = try ImageCompressor.manualResize(image!, maxWidth: options.maxWidth, maxHeight: options.maxHeight)
             let isBase64 = options.returnableOutputType == .rbase64
-            return ImageCompressor.manualCompress(resizedImage, output: options.output.rawValue, quality: options.quality, outputExtension: outputExtension, isBase64: isBase64,disablePngTransparency: options.disablePngTransparency, actualImagePath: imagePath)
+            return try ImageCompressor.manualCompress(resizedImage, output: options.output.rawValue, quality: options.quality, outputExtension: outputExtension, isBase64: isBase64,disablePngTransparency: options.disablePngTransparency, actualImagePath: imagePath)
         } else {
             exception = NSException(name: NSExceptionName(rawValue: "unsupported_value"), reason: "Unsupported value type.", userInfo: nil)
             exception?.raise()
+            // Throw instead of raising an NSException (process abort no JS
+            // catch survives — e.g. a stored file path invalidated by an iOS
+            // container relocation boot-looped an app at startup). The caller
+            // rejects the promise with the same name/message.
+            throw NSError(domain: "unsupported_value", code: 1,
+                          userInfo: [NSLocalizedDescriptionKey: "Unsupported value type."])
         }
 
         return ""
     }
 
     
-    static func autoCompressHandler(imagePath: String?, base64: String?, options: ImageCompressorOptions) -> String {
+    static func autoCompressHandler(imagePath: String?, base64: String?, options: ImageCompressorOptions) throws -> String {
         var exception: NSException?
         var image: UIImage?
-        
+
         switch options.input {
         case .base64:
             if let _base64 = base64 {
@@ -332,11 +347,11 @@ class ImageCompressor {
                 image = ImageCompressor.loadImage(_imagePath)
             }
         }
-        
+
         if var image = image {
             image = ImageCompressor.scaleAndRotateImage(image)
             let outputExtension = ImageCompressorOptions.getOutputInString(options.output)
-            
+
             var actualHeight = image.size.height
             var actualWidth = image.size.width
             let maxHeight: CGFloat = CGFloat(options.maxHeight)
@@ -344,7 +359,7 @@ class ImageCompressor {
             var imgRatio = actualWidth / actualHeight
             let maxRatio = maxWidth / maxHeight
             let compressionQuality: CGFloat = CGFloat(options.quality)
-            
+
             if actualHeight > maxHeight || actualWidth > maxWidth {
                 if imgRatio < maxRatio {
                     imgRatio = maxHeight / actualHeight
@@ -359,20 +374,26 @@ class ImageCompressor {
                     actualWidth = maxWidth
                 }
             }
-            
+
             let rect = CGRect(x: 0.0, y: 0.0, width: actualWidth, height: actualHeight)
             UIGraphicsBeginImageContext(rect.size)
             image.draw(in: rect)
             let isBase64 = options.returnableOutputType == .rbase64
-            
+
             if let img = UIGraphicsGetImageFromCurrentImageContext() {
-                return writeImage(img, output: options.output.rawValue, quality: Float(compressionQuality), outputExtension: outputExtension, isBase64: isBase64, disablePngTransparency: options.disablePngTransparency, isEnableAutoCompress: true, actualImagePath: imagePath)
+                return try writeImage(img, output: options.output.rawValue, quality: Float(compressionQuality), outputExtension: outputExtension, isBase64: isBase64, disablePngTransparency: options.disablePngTransparency, isEnableAutoCompress: true, actualImagePath: imagePath)
             }
         } else {
             exception = NSException(name: NSExceptionName(rawValue: "unsupported_value"), reason: "Unsupported value type.", userInfo: nil)
             exception?.raise()
+            // Throw instead of raising an NSException (process abort no JS
+            // catch survives — e.g. a stored file path invalidated by an iOS
+            // container relocation boot-looped an app at startup). The caller
+            // rejects the promise with the same name/message.
+            throw NSError(domain: "unsupported_value", code: 1,
+                          userInfo: [NSLocalizedDescriptionKey: "Unsupported value type."])
         }
-        
+
         return ""
     }
     

package/ios/Image/ImageMain.swift

@@ -13,22 +13,32 @@ class ImageMain {
             
             if options.input != InputType.base64 {
                 ImageCompressor.getAbsoluteImagePath(value, options: options) { absoluteImagePath in
+                    // The escaping completion runs outside the outer do/catch,
+                    // so failures here need their own catch to reject.
+                    do {
+                        if options.autoCompress {
+                            let result = try ImageCompressor.autoCompressHandler(imagePath: absoluteImagePath, base64: nil, options: options)
+                            resolve(result)
+                        } else {
+                            let result = try ImageCompressor.manualCompressHandler(imagePath: absoluteImagePath, base64: nil, options: options)
+                            resolve(result)
+                        }
+                    } catch {
+                        reject((error as NSError).domain, error.localizedDescription, error)
+                    }
+                    MediaCache.removeCompletedImagePath(absoluteImagePath)
+                }
+            } else {
+                do {
                     if options.autoCompress {
-                        let result = ImageCompressor.autoCompressHandler(imagePath: absoluteImagePath, base64: nil, options: options)
+                        let result = try ImageCompressor.autoCompressHandler(imagePath: nil, base64: value, options: options)
                         resolve(result)
                     } else {
-                        let result = ImageCompressor.manualCompressHandler(imagePath: absoluteImagePath, base64: nil, options: options)
+                        let result = try ImageCompressor.manualCompressHandler(imagePath: nil, base64: value, options: options)
                         resolve(result)
                     }
-                    MediaCache.removeCompletedImagePath(absoluteImagePath)
-                }
-            } else {
-                if options.autoCompress {
-                    let result = ImageCompressor.autoCompressHandler(imagePath: nil, base64: value, options: options)
-                    resolve(result)
-                } else {
-                    let result = ImageCompressor.manualCompressHandler(imagePath: nil, base64: value, options: options)
-                    resolve(result)
+                } catch {
+                    reject((error as NSError).domain, error.localizedDescription, error)
                 }
             }
         } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-compressor",
-  "version": "1.19.2",
+  "version": "1.19.4",
   "description": "Compress Image, Video, and Audio same like Whatsapp & Auto/Manual Compression | Background Upload | Download File | Create Video Thumbnail",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

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

@@ -1,112 +0,0 @@
-package com.reactnativecompressor.Audio
-
-import android.annotation.SuppressLint
-import android.media.MediaCodec
-import android.media.MediaExtractor
-import android.media.MediaFormat
-import android.media.MediaMetadataRetriever
-import android.media.MediaMuxer
-import android.util.Log
-import java.io.IOException
-import java.nio.ByteBuffer
-
-
-class AudioExtractor {
-  /**
-   * @param srcPath  the path of source video file.
-   * @param dstPath  the path of destination video file.
-   * @param startMs  starting time in milliseconds for trimming. Set to
-   * negative if starting from beginning.
-   * @param endMs    end time for trimming in milliseconds. Set to negative if
-   * no trimming at the end.
-   * @param useAudio true if keep the audio track from the source.
-   * @param useVideo true if keep the video track from the source.
-   * @throws IOException
-   */
-  @SuppressLint("NewApi", "WrongConstant")
-  @Throws(IOException::class)
-  fun genVideoUsingMuxer(srcPath: String?, dstPath: String?, startMs: Int, endMs: Int, useAudio: Boolean, useVideo: Boolean) {
-    // Set up MediaExtractor to read from the source.
-    val extractor = MediaExtractor()
-    extractor.setDataSource(srcPath!!)
-    val trackCount = extractor.trackCount
-    // Set up MediaMuxer for the destination.
-    val muxer: MediaMuxer
-    muxer = MediaMuxer(dstPath!!, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
-    // Set up the tracks and retrieve the max buffer size for selected
-    // tracks.
-    val indexMap = HashMap<Int, Int>(trackCount)
-    var bufferSize = -1
-    for (i in 0 until trackCount) {
-      val format = extractor.getTrackFormat(i)
-      val mime = format.getString(MediaFormat.KEY_MIME)
-      var selectCurrentTrack = false
-      if (mime!!.startsWith("audio/") && useAudio) {
-        selectCurrentTrack = true
-      } else if (mime.startsWith("video/") && useVideo) {
-        selectCurrentTrack = true
-      }
-      if (selectCurrentTrack) {
-        extractor.selectTrack(i)
-        val dstIndex = muxer.addTrack(format)
-        indexMap[i] = dstIndex
-        if (format.containsKey(MediaFormat.KEY_MAX_INPUT_SIZE)) {
-          val newSize = format.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE)
-          bufferSize = if (newSize > bufferSize) newSize else bufferSize
-        }
-      }
-    }
-    if (bufferSize < 0) {
-      bufferSize = DEFAULT_BUFFER_SIZE
-    }
-    // Set up the orientation and starting time for extractor.
-    val retrieverSrc = MediaMetadataRetriever()
-    retrieverSrc.setDataSource(srcPath)
-    val degreesString = retrieverSrc.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION)
-    if (degreesString != null) {
-      val degrees = degreesString.toInt()
-      if (degrees >= 0) {
-        muxer.setOrientationHint(degrees)
-      }
-    }
-    if (startMs > 0) {
-      extractor.seekTo((startMs * 1000).toLong(), MediaExtractor.SEEK_TO_CLOSEST_SYNC)
-    }
-    // Copy the samples from MediaExtractor to MediaMuxer. We will loop
-    // for copying each sample and stop when we get to the end of the source
-    // file or exceed the end time of the trimming.
-    val offset = 0
-    var trackIndex = -1
-    val dstBuf = ByteBuffer.allocate(bufferSize)
-    val bufferInfo = MediaCodec.BufferInfo()
-    muxer.start()
-    while (true) {
-      bufferInfo.offset = offset
-      bufferInfo.size = extractor.readSampleData(dstBuf, offset)
-      if (bufferInfo.size < 0) {
-        Log.d(TAG, "Saw input EOS.")
-        bufferInfo.size = 0
-        break
-      } else {
-        bufferInfo.presentationTimeUs = extractor.sampleTime
-        if (endMs > 0 && bufferInfo.presentationTimeUs > endMs * 1000) {
-          Log.d(TAG, "The current sample is over the trim end time.")
-          break
-        } else {
-          bufferInfo.flags = extractor.sampleFlags
-          trackIndex = extractor.sampleTrackIndex
-          muxer.writeSampleData(indexMap[trackIndex]!!, dstBuf, bufferInfo)
-          extractor.advance()
-        }
-      }
-    }
-    muxer.stop()
-    muxer.release()
-    return
-  }
-
-  companion object {
-    private const val DEFAULT_BUFFER_SIZE = 1 * 1024 * 1024
-    private const val TAG = "AudioExtractorDecoder"
-  }
-}