react-native-compressor 1.7.2 → 1.8.1

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()
+    }
+}

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

@@ -0,0 +1,125 @@
+package com.reactnativecompressor.Video
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.os.Handler
+import android.os.PowerManager
+import android.os.PowerManager.WakeLock
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.reactnativecompressor.Utils.EventEmitterHandler
+import com.reactnativecompressor.Utils.Utils
+import java.util.UUID
+
+class VideoCompressorHelper {
+    enum class CompressionMethod {
+        auto,
+        manual
+    }
+
+    var compressionMethod = CompressionMethod.auto
+    var bitrate = 0f
+    var uuid: String? = ""
+    var maxSize = 640.0f
+    var progressDivider: Int? = 0
+    var minimumFileSizeForCompress = 0.0f
+
+    companion object {
+        private var _reactContext: ReactApplicationContext? = null
+        private var backgroundId: String? = null
+        private var handler: Handler? = null
+        private var runnable: Runnable? = null
+        private var powerManager: PowerManager? = null
+        private var wakeLock: WakeLock? = null
+        private val listener: LifecycleEventListener = object : LifecycleEventListener {
+            override fun onHostResume() {}
+            override fun onHostPause() {}
+            override fun onHostDestroy() {
+                if (wakeLock!!.isHeld) {
+                    wakeLock!!.release()
+                  EventEmitterHandler.emitBackgroundTaskExpired(backgroundId)
+
+                }
+            }
+        }
+
+        @SuppressLint("InvalidWakeLockTag")
+        fun video_activateBackgroundTask_helper(options: ReadableMap?, reactContext: ReactApplicationContext): String {
+            _reactContext = reactContext
+            backgroundId = UUID.randomUUID().toString()
+            powerManager = reactContext.getSystemService(Context.POWER_SERVICE) as PowerManager
+            wakeLock = powerManager!!.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "bg_wakelock")
+            reactContext.addLifecycleEventListener(listener)
+            if (!wakeLock!!.isHeld()) {
+                wakeLock!!.acquire()
+            }
+            handler = Handler()
+            runnable = Runnable { }
+            handler!!.post(runnable!!)
+            return ""
+        }
+
+        fun video_deactivateBackgroundTask_helper(options: ReadableMap?, reactContext: ReactApplicationContext?): String {
+            if (wakeLock!!.isHeld) wakeLock!!.release()
+
+            // avoid null pointer exceptio when stop is called without start
+            if (handler != null) handler!!.removeCallbacks(runnable!!)
+            backgroundId = ""
+            return ""
+        }
+
+        fun fromMap(map: ReadableMap): VideoCompressorHelper {
+            val options = VideoCompressorHelper()
+            val iterator = map.keySetIterator()
+            while (iterator.hasNextKey()) {
+                val key = iterator.nextKey()
+                when (key) {
+                    "compressionMethod" -> options.compressionMethod = CompressionMethod.valueOf(map.getString(key)!!)
+                    "maxSize" -> options.maxSize = map.getDouble(key).toFloat()
+                    "uuid" -> options.uuid = map.getString(key)
+                    "minimumFileSizeForCompress" -> options.minimumFileSizeForCompress = map.getDouble(key).toFloat()
+                    "bitrate" -> options.bitrate = map.getDouble(key).toFloat()
+                    "progressDivider" -> options.progressDivider = map.getInt(key)
+                }
+            }
+            return options
+        }
+        fun VideoCompressManual(fileUrl: String?, options: VideoCompressorHelper, promise: Promise, reactContext: ReactApplicationContext?) {
+            try {
+                val uri = Uri.parse(fileUrl)
+                val srcPath = uri.path
+                val destinationPath = Utils.generateCacheFilePath("mp4", reactContext!!)
+                val metaRetriever = MediaMetadataRetriever()
+                metaRetriever.setDataSource(srcPath)
+                var height = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)!!.toInt()
+                var width = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)!!.toInt()
+                val bitrate = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE)!!.toInt()
+                val isPortrait = height > width
+                val maxSize = options.maxSize.toInt()
+                if (isPortrait && height > maxSize) {
+                    width = (maxSize.toFloat() / height * width).toInt()
+                    height = maxSize
+                } else if (width > maxSize) {
+                    height = (maxSize.toFloat() / width * height).toInt()
+                    width = maxSize
+                } else {
+                    if (options.bitrate == 0f) {
+                        options.bitrate = (bitrate * 0.8).toInt().toFloat()
+                    }
+                }
+                val videoBitRate = if (options.bitrate > 0) options.bitrate else (height * width * 1.5).toFloat()
+                Utils.compressVideo(srcPath!!, destinationPath, width, height, videoBitRate, options.uuid!!,options.progressDivider!!, promise, reactContext)
+            } catch (ex: Exception) {
+                promise.reject(ex)
+            }
+        }
+
+        fun VideoCompressAuto(fileUrl: String?, options: VideoCompressorHelper?, promise: Promise?, reactContext: ReactApplicationContext?) {
+            AutoVideoCompression.createCompressionSettings(fileUrl, options!!, promise!!, reactContext)
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+package com.reactnativecompressor.Video
+
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+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 com.reactnativecompressor.Utils.Utils
+import com.reactnativecompressor.Video.VideoCompressorHelper.Companion.video_activateBackgroundTask_helper
+import com.reactnativecompressor.Video.VideoCompressorHelper.Companion.video_deactivateBackgroundTask_helper
+import java.io.File
+
+class VideoMain(private val reactContext: ReactApplicationContext) {
+    //Video
+    fun compress(
+            fileUrl: String,
+            optionMap: ReadableMap,
+            promise: Promise) {
+        var fileUrl: String? = fileUrl
+        val options = VideoCompressorHelper.fromMap(optionMap)
+        fileUrl = Utils.getRealPath(fileUrl, reactContext, options.uuid,options.progressDivider)
+        if (options.compressionMethod === VideoCompressorHelper.CompressionMethod.auto) {
+            VideoCompressorHelper.VideoCompressAuto(fileUrl, options, promise, reactContext)
+        } else {
+            VideoCompressorHelper.VideoCompressManual(fileUrl, options, promise, reactContext)
+        }
+    }
+
+    fun cancelCompression(
+            uuid: String) {
+        Utils.cancelCompressionHelper(uuid)
+        Log.d("cancelCompression", uuid)
+    }
+
+     fun activateBackgroundTask(
+            options: ReadableMap,
+            promise: Promise) {
+        try {
+            val response: String = video_activateBackgroundTask_helper(options, reactContext)
+            promise.resolve(response)
+        } catch (ex: Exception) {
+            promise.reject(ex)
+        }
+    }
+
+   fun deactivateBackgroundTask(
+            options: ReadableMap,
+            promise: Promise) {
+        try {
+            val response: String = video_deactivateBackgroundTask_helper(options, reactContext)
+            promise.resolve(response)
+        } catch (ex: Exception) {
+            promise.reject(ex)
+        }
+    }
+
+  fun getVideoMetaData(filePath: String, promise: Promise) {
+    var filePath: String? = filePath
+    try {
+      filePath = Utils.getRealPath(filePath, reactContext)
+      val uri = Uri.parse(filePath)
+      val srcPath = uri.path
+      val metaRetriever = MediaMetadataRetriever()
+      metaRetriever.setDataSource(srcPath)
+      val file = File(srcPath)
+      val sizeInKBs = (file.length() / 1024).toFloat()
+      val actualHeight = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)!!.toInt()
+      val actualWidth = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)!!.toInt()
+      val duration = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)!!.toLong()
+      val creationTime = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DATE)
+      val extension = filePath!!.substring(filePath.lastIndexOf(".") + 1)
+      val params = Arguments.createMap()
+      params.putString("size", sizeInKBs.toString())
+      params.putString("width", actualWidth.toString())
+      params.putString("height", actualHeight.toString())
+      params.putString("duration", (duration / 1000).toString())
+      params.putString("extension", extension)
+      params.putString("creationTime", creationTime.toString())
+      promise.resolve(params)
+    } catch (e: Exception) {
+      promise.reject(e)
+    }
+  }
+}

package/android/src/newarch/CompressorSpec.kt

@@ -0,0 +1,5 @@
+package com.reactnativecompressor
+
+import com.facebook.react.bridge.ReactApplicationContext
+
+abstract class CompressorSpec(context: ReactApplicationContext?) : NativeCompressorSpec(context)

package/android/src/oldarch/CompressorSpec.kt

@@ -0,0 +1,34 @@
+package com.reactnativecompressor
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReadableMap
+
+abstract class CompressorSpec(context: ReactApplicationContext?) : ReactContextBaseJavaModule(context) {
+    abstract fun image_compress(
+            imagePath: String,
+            optionMap: ReadableMap,
+            promise: Promise)
+
+    abstract fun compress_audio(
+            fileUrl: String,
+            optionMap: ReadableMap,
+            promise: Promise)
+
+    abstract fun generateFilePath(_extension: String, promise: Promise)
+    abstract fun getRealPath(path: String, type: String, promise: Promise)
+    abstract fun getVideoMetaData(filePath: String, promise: Promise)
+    abstract fun getFileSize(filePath: String, promise: Promise)
+    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 download(fileUrl: String, options: ReadableMap, promise: Promise)
+    abstract fun activateBackgroundTask(options: ReadableMap, promise: Promise)
+    abstract fun deactivateBackgroundTask(options: ReadableMap, promise: Promise)
+    abstract fun createVideoThumbnail(fileUrl: String?, options: ReadableMap?, promise: Promise)
+    abstract fun clearCache(cacheDir: String?, promise: com.facebook.react.bridge.Promise?)
+    abstract fun addListener(eventName: String)
+    abstract fun removeListeners(count: Double)
+}

package/ios/Audio/AudioMain.swift

@@ -0,0 +1,115 @@
+//
+//  AudioMain.swift
+//  react-native-compressor
+//
+//  Created by Numan on 10/09/2023.
+//
+
+import Foundation
+import AVFoundation
+let AlAsset_Library_Scheme = "assets-library"
+class AudioMain{
+    static func compress_audio(_ fileUrl: String, optionMap: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            var fileUrl = fileUrl
+            if fileUrl.hasPrefix("file://") {
+                fileUrl = fileUrl.replacingOccurrences(of: "file://", with: "")
+            }
+            let fileManager = FileManager.default
+            var isDir: ObjCBool = false
+            if !fileManager.fileExists(atPath: fileUrl, isDirectory: &isDir) || isDir.boolValue {
+                let err = NSError(domain: "file not found", code: -15, userInfo: nil)
+                reject(String(err.code), err.localizedDescription, err)
+                return
+            }
+            
+            let assetOptions: [String: Any] = [AVURLAssetPreferPreciseDurationAndTimingKey: true]
+            let asset = AVURLAsset(url: URL(fileURLWithPath: fileUrl), options: assetOptions)
+            let quality = optionMap["quality"] as? String ?? ""
+            let qualityConstant = getAudioQualityConstant(quality)
+            auto_compress_helper(asset, qualityConstant: qualityConstant) { mp3Path, finished in
+                if finished {
+                    resolve("file://\(mp3Path ?? "")")
+                } else {
+                    reject("Error", "Something went wrong", nil)
+                }
+            }
+        } catch {
+            reject(error.localizedDescription, error.localizedDescription, nil)
+        }
+    }
+    
+    static func getAudioQualityConstant(_ quality: String) -> String {
+        let audioQualityArray = ["low", "medium", "high"]
+        if let index = audioQualityArray.firstIndex(of: quality) {
+            switch index {
+            case 0:
+                return AVAssetExportPresetLowQuality
+            case 1:
+                return AVAssetExportPresetMediumQuality
+            case 2:
+                return AVAssetExportPresetHighestQuality
+            default:
+                return AVAssetExportPresetMediumQuality
+            }
+        }
+        return AVAssetExportPresetMediumQuality
+    }
+    
+    static func auto_compress_helper(_ avAsset: AVURLAsset, qualityConstant: String, complete completeCallback: @escaping (_ mp3Path: String?, _ finished: Bool) -> Void) {
+        var path: String
+        if avAsset.url.scheme == AlAsset_Library_Scheme {
+            path = avAsset.url.query ?? ""
+            if path.isEmpty {
+                completeCallback(nil, false)
+                return
+            }
+        } else {
+            path = avAsset.url.path
+            if path.isEmpty || !FileManager.default.fileExists(atPath: path) {
+                completeCallback(nil, false)
+                return
+            }
+        }
+        
+        let mp3Path = Utils.generateCacheFilePath("m4a")
+        
+        if FileManager.default.fileExists(atPath: mp3Path) {
+            completeCallback(mp3Path, true)
+            return
+        }
+        
+        let compatiblePresets = AVAssetExportSession.exportPresets(compatibleWith: avAsset)
+        
+        if compatiblePresets.contains(qualityConstant) {
+            let exportSession = AVAssetExportSession(asset: avAsset, presetName: AVAssetExportPresetAppleM4A)
+            
+            let mp3Url = URL(fileURLWithPath: mp3Path)
+            exportSession?.outputURL = mp3Url
+            exportSession?.shouldOptimizeForNetworkUse = true
+            exportSession?.outputFileType = .m4a
+            
+            exportSession?.exportAsynchronously(completionHandler: {
+                var finished = false
+                switch exportSession?.status {
+                case .failed:
+                    print("AVAssetExportSessionStatusFailed, error: \(exportSession?.error?.localizedDescription ?? "").")
+                case .cancelled:
+                    print("AVAssetExportSessionStatusCancelled.")
+                case .completed:
+                    print("AVAssetExportSessionStatusCompleted.")
+                    finished = true
+                case .unknown:
+                    print("AVAssetExportSessionStatusUnknown")
+                case .waiting:
+                    print("AVAssetExportSessionStatusWaiting")
+                case .exporting:
+                    print("AVAssetExportSessionStatusExporting")
+                default:
+                    break
+                }
+                completeCallback(mp3Path, finished)
+            })
+        }
+    }
+}

package/ios/Compressor-Bridging-Header.h

@@ -3,5 +3,4 @@
 //
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
-#import "ImageCompressor.h"
-#import "MediaCache.h"
+#import <Foundation/Foundation.h>

package/ios/Compressor.h

@@ -2,12 +2,4 @@
 
 #ifdef RCT_NEW_ARCH_ENABLED
 #import "RNCompressorSpec.h"
-
-@interface Compressor : RCTEventEmitter <NativeCompressorSpec>
-#else
-#import <React/RCTBridgeModule.h>
-
-@interface Compressor : RCTEventEmitter <RCTBridgeModule>
 #endif
-
-@end