react-native-video-trim 6.1.0 → 6.2.1

package/android/src/main/java/com/videotrim/enums/{ErrorCode.java → ErrorCode.kt}

@@ -1,6 +1,6 @@
-package com.videotrim.enums;
+package com.videotrim.enums
 
-public enum ErrorCode {
+enum class ErrorCode {
   TRIMMING_FAILED,
   FAIL_TO_GET_VIDEO_INFO,
   FAIL_TO_INITIALIZE_AUDIO_PLAYER,

package/android/src/main/java/com/videotrim/interfaces/IVideoTrimmerView.kt

@@ -0,0 +1,5 @@
+package com.videotrim.interfaces
+
+interface IVideoTrimmerView {
+  fun onDestroy()
+}

package/android/src/main/java/com/videotrim/interfaces/VideoTrimListener.kt

@@ -0,0 +1,16 @@
+package com.videotrim.interfaces
+
+import com.facebook.react.bridge.WritableMap
+import com.videotrim.enums.ErrorCode
+
+interface VideoTrimListener {
+  fun onLoad(duration: Int)
+  fun onTrimmingProgress(percentage: Int)
+  fun onFinishTrim(url: String, startMs: Long, endMs: Long, videoDuration: Int)
+  fun onCancelTrim()
+  fun onError(errorMessage: String?, errorCode: ErrorCode)
+  fun onCancel()
+  fun onSave()
+  fun onLog(log: WritableMap)
+  fun onStatistics(statistics: WritableMap)
+}

package/android/src/main/java/com/videotrim/utils/MediaMetadataUtil.kt

@@ -0,0 +1,84 @@
+package com.videotrim.utils
+
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.util.Log
+import java.io.IOException
+
+object MediaMetadataUtil {
+
+  private const val TAG = "MediaMetadataUtil"
+
+  fun getMediaMetadataRetriever(source: String): MediaMetadataRetriever? {
+    val retriever = MediaMetadataRetriever()
+    return try {
+      if (source.startsWith("http://") || source.startsWith("https://")) {
+        retriever.setDataSource(source, HashMap())
+      } else {
+        var filePath = source
+
+        if (!StorageUtil.isFileExists(filePath)) {
+          Log.e(TAG, "File does not exist, trying to parse as URI: $source")
+
+          val uri = Uri.parse(source)
+          filePath = uri.path ?: ""
+
+          if (!StorageUtil.isFileExists(filePath)) {
+            Log.e(TAG, "File does not exist at path: $filePath")
+            return null
+          }
+        }
+
+        retriever.setDataSource(filePath)
+      }
+      retriever
+    } catch (e: Exception) {
+      Log.e(TAG, "Error setting data source", e)
+      try {
+        retriever.release()
+      } catch (ee: Exception) {
+        Log.e(TAG, "Error releasing retriever", ee)
+      }
+      null
+    }
+  }
+
+  fun checkFileValidity(urlString: String, callback: FileValidityCallback) {
+    Thread {
+      val retriever = getMediaMetadataRetriever(urlString)
+      if (retriever == null) {
+        callback.onResult(false, "unknown", -1L)
+        return@Thread
+      }
+
+      val durationStr = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)
+      val duration = durationStr?.toLongOrNull() ?: -1L
+
+      var isValid = false
+      var fileType = "unknown"
+
+      val hasVideo = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_VIDEO)
+      if (hasVideo == "yes") {
+        fileType = "video"
+        isValid = true
+      } else {
+        val hasAudio = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_AUDIO)
+        if (hasAudio == "yes") {
+          fileType = "audio"
+          isValid = true
+        }
+      }
+
+      try {
+        retriever.release()
+      } catch (e: IOException) {
+        Log.e(TAG, "Error releasing retriever", e)
+      }
+      callback.onResult(isValid, fileType, if (isValid) duration else -1L)
+    }.start()
+  }
+
+  fun interface FileValidityCallback {
+    fun onResult(isValid: Boolean, fileType: String, duration: Long)
+  }
+}

package/android/src/main/java/com/videotrim/utils/StorageUtil.kt

@@ -0,0 +1,129 @@
+package com.videotrim.utils
+
+import android.content.ContentValues
+import android.content.Context
+import android.media.MediaScannerConnection
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import android.text.TextUtils
+import com.facebook.react.bridge.ReactApplicationContext
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.InputStream
+import java.io.OutputStream
+
+object StorageUtil {
+
+  fun getOutputPath(context: Context, outputExt: String): String {
+    val timestamp = System.currentTimeMillis() / 1000
+    val file = File(context.filesDir, "${VideoTrimmerUtil.FILE_PREFIX}_${timestamp}.$outputExt")
+    return file.absolutePath
+  }
+
+  fun isFileExists(filePath: String?): Boolean {
+    if (TextUtils.isEmpty(filePath)) return false
+    return File(filePath!!).exists()
+  }
+
+  fun listFiles(context: Context): Array<String> {
+    val filesDir = context.filesDir
+    val files = filesDir.listFiles { _, name -> name.startsWith(VideoTrimmerUtil.FILE_PREFIX) }
+
+    return files?.map { it.absolutePath }?.toTypedArray() ?: emptyArray()
+  }
+
+  fun deleteFile(path: String?): Boolean {
+    if (TextUtils.isEmpty(path)) return true
+    return deleteFile(File(path!!))
+  }
+
+  fun deleteFile(file: File?): Boolean {
+    if (file == null || !file.exists()) return true
+
+    if (file.isFile) return file.delete()
+
+    if (!file.isDirectory) return false
+
+    file.listFiles()?.forEach { f ->
+      if (f.isFile) {
+        f.delete()
+      } else if (f.isDirectory) {
+        deleteFile(f)
+      }
+    }
+    return file.delete()
+  }
+
+  @Throws(IOException::class)
+  fun saveVideoToGallery(context: ReactApplicationContext, videoFilePath: String?) {
+    val videoFile = File(videoFilePath!!)
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      saveVideoUsingMediaStore(context, videoFile)
+    } else {
+      try {
+        saveVideoUsingTraditionalStorage(context, videoFile)
+      } catch (e: IOException) {
+        throw RuntimeException(e)
+      }
+    }
+  }
+
+  private fun saveVideoUsingMediaStore(context: Context, videoFile: File) {
+    val values = ContentValues().apply {
+      put(MediaStore.Video.Media.TITLE, "My Video Title")
+      put(MediaStore.Video.Media.MIME_TYPE, "video/mp4")
+      put(MediaStore.Video.Media.RELATIVE_PATH, Environment.DIRECTORY_DCIM)
+    }
+    val uri: Uri? = context.contentResolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, values)
+
+    if (uri != null) {
+      try {
+        val outputStream = context.contentResolver.openOutputStream(uri)
+        copyFile(videoFile, outputStream!!)
+        MediaScannerConnection.scanFile(context, arrayOf(uri.toString()), arrayOf("video/*"), null)
+      } catch (e: IOException) {
+        e.printStackTrace()
+      }
+    }
+  }
+
+  @Throws(IOException::class)
+  private fun saveVideoUsingTraditionalStorage(context: Context, videoFile: File) {
+    val galleryDirectory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM)
+    val destinationFile = File(galleryDirectory, videoFile.name)
+    copyFile(videoFile, destinationFile)
+    MediaScannerConnection.scanFile(context, arrayOf(destinationFile.absolutePath), arrayOf("video/*"), null)
+  }
+
+  @Throws(IOException::class)
+  private fun copyFile(sourceFile: File, outputStream: OutputStream) {
+    val inputStream: InputStream = FileInputStream(sourceFile)
+    copyFile(inputStream, outputStream)
+  }
+
+  @Throws(IOException::class)
+  private fun copyFile(sourceFile: File, destFile: File) {
+    val inputStream: InputStream = FileInputStream(sourceFile)
+    val outputStream: OutputStream = FileOutputStream(destFile)
+    copyFile(inputStream, outputStream)
+  }
+
+  @Throws(IOException::class)
+  private fun copyFile(inputStream: InputStream, outputStream: OutputStream) {
+    try {
+      val buffer = ByteArray(1024)
+      var length: Int
+      while (inputStream.read(buffer).also { length = it } > 0) {
+        outputStream.write(buffer, 0, length)
+      }
+    } finally {
+      inputStream.close()
+      outputStream.close()
+    }
+  }
+}

package/android/src/main/java/com/videotrim/utils/VideoTrimmerUtil.kt

@@ -0,0 +1,163 @@
+package com.videotrim.utils
+
+import android.annotation.SuppressLint
+import android.graphics.Bitmap
+import android.media.MediaMetadataRetriever
+import android.util.Log
+import com.arthenica.ffmpegkit.FFmpegKit
+import com.arthenica.ffmpegkit.FFmpegSession
+import com.arthenica.ffmpegkit.ReturnCode
+import com.facebook.react.bridge.Arguments
+import com.videotrim.enums.ErrorCode
+import com.videotrim.interfaces.VideoTrimListener
+import iknow.android.utils.DeviceUtil
+import iknow.android.utils.UnitConverter
+import iknow.android.utils.callback.SingleCallback
+import iknow.android.utils.thread.BackgroundExecutor
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.TimeZone
+
+object VideoTrimmerUtil {
+
+  private val TAG: String = VideoTrimmerUtil::class.java.simpleName
+  const val FILE_PREFIX = "trimmedVideo"
+  const val MIN_SHOOT_DURATION = 1000L
+  const val VIDEO_MAX_TIME = 10
+  const val MAX_SHOOT_DURATION = VIDEO_MAX_TIME * 1000L
+  @JvmField var MAX_COUNT_RANGE = 10
+  @JvmField var SCREEN_WIDTH_FULL = DeviceUtil.getDeviceWidth()
+  @JvmField val RECYCLER_VIEW_PADDING = UnitConverter.dpToPx(35)
+  const val DEFAULT_AUDIO_EXTENSION = ".wav"
+  @JvmField var VIDEO_FRAMES_WIDTH = SCREEN_WIDTH_FULL - RECYCLER_VIEW_PADDING * 2
+  @JvmField var mThumbWidth = 0
+  @JvmField val THUMB_HEIGHT = UnitConverter.dpToPx(50)
+  @JvmField val THUMB_WIDTH = UnitConverter.dpToPx(25)
+  private const val THUMB_RESOLUTION_RES = 2
+
+  fun trim(
+    inputFile: String,
+    outputFile: String,
+    videoDuration: Int,
+    startMs: Long,
+    endMs: Long,
+    enableRotation: Boolean,
+    rotationAngle: Double,
+    callback: VideoTrimListener
+  ): FFmpegSession {
+    val currentDate = Date()
+    @SuppressLint("SimpleDateFormat")
+    val dateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ")
+    dateFormat.timeZone = TimeZone.getTimeZone("UTC")
+    val formattedDateTime = dateFormat.format(currentDate)
+
+    val cmds = mutableListOf<String>()
+    cmds.add("-ss")
+    cmds.add("${startMs}ms")
+    cmds.add("-to")
+    cmds.add("${endMs}ms")
+
+    if (enableRotation) {
+      cmds.add("-display_rotation")
+      cmds.add(rotationAngle.toString())
+    }
+
+    cmds.add("-i")
+    cmds.add(inputFile)
+    cmds.add("-c")
+    cmds.add("copy")
+    cmds.add("-metadata")
+    cmds.add("creation_time=$formattedDateTime")
+    cmds.add(outputFile)
+
+    val command = cmds.toTypedArray()
+    val cmdStr = "Command: ${command.joinToString(" ")}"
+
+    Log.d(TAG, cmdStr)
+
+    val m = Arguments.createMap()
+    m.putString("message", cmdStr)
+    callback.onLog(m)
+
+    return FFmpegKit.executeWithArgumentsAsync(command, { session ->
+      val state = session.state
+      val returnCode = session.returnCode
+      when {
+        ReturnCode.isSuccess(session.returnCode) -> {
+          callback.onFinishTrim(outputFile, startMs, endMs, videoDuration)
+        }
+        ReturnCode.isCancel(session.returnCode) -> {
+          callback.onCancelTrim()
+        }
+        else -> {
+          val errorMessage = "Command failed with state $state and rc $returnCode.${session.failStackTrace}"
+          callback.onError(errorMessage, ErrorCode.TRIMMING_FAILED)
+        }
+      }
+    }, { log ->
+      Log.d(TAG, "FFmpeg process started with log ${log.message}")
+
+      val map = Arguments.createMap()
+      map.putInt("level", log.level.value)
+      map.putString("message", log.message)
+      map.putDouble("sessionId", log.sessionId.toDouble())
+      map.putString("logStr", log.toString())
+      callback.onLog(map)
+    }, { statistics ->
+      val timeInMilliseconds = statistics.time.toInt()
+      if (timeInMilliseconds > 0) {
+        val completePercentage = (timeInMilliseconds * 100) / videoDuration
+        callback.onTrimmingProgress(completePercentage.coerceIn(0, 100))
+      }
+
+      val map = Arguments.createMap()
+      map.putDouble("sessionId", statistics.sessionId.toDouble())
+      map.putInt("videoFrameNumber", statistics.videoFrameNumber)
+      map.putDouble("videoFps", statistics.videoFps.toDouble())
+      map.putDouble("videoQuality", statistics.videoQuality.toDouble())
+      map.putDouble("size", statistics.size.toDouble())
+      map.putDouble("time", statistics.time)
+      map.putDouble("bitrate", statistics.bitrate.toDouble())
+      map.putDouble("speed", statistics.speed.toDouble())
+      map.putString("statisticsStr", statistics.toString())
+      callback.onStatistics(map)
+    })
+  }
+
+  fun shootVideoThumbInBackground(
+    mediaMetadataRetriever: MediaMetadataRetriever,
+    totalThumbsCount: Int,
+    startPosition: Long,
+    endPosition: Long,
+    callback: SingleCallback<Bitmap, Int>
+  ) {
+    BackgroundExecutor.execute(object : BackgroundExecutor.Task("", 0L, "") {
+      override fun execute() {
+        try {
+          val interval = (endPosition - startPosition) / (totalThumbsCount - 1)
+          for (i in 0 until totalThumbsCount) {
+            val frameTime = startPosition + interval * i
+
+            val bitmap: Bitmap? = try {
+              mediaMetadataRetriever.getFrameAtTime(frameTime * 1000, MediaMetadataRetriever.OPTION_CLOSEST_SYNC)
+            } catch (t: Throwable) {
+              t.printStackTrace()
+              break
+            }
+
+            if (bitmap == null) continue
+            val scaledBitmap = try {
+              Bitmap.createScaledBitmap(bitmap, mThumbWidth * THUMB_RESOLUTION_RES, THUMB_HEIGHT * THUMB_RESOLUTION_RES, false)
+            } catch (t: Throwable) {
+              t.printStackTrace()
+              bitmap
+            }
+            callback.onSingleCallback(scaledBitmap, interval.toInt())
+          }
+        } catch (e: Throwable) {
+          Thread.getDefaultUncaughtExceptionHandler()?.uncaughtException(Thread.currentThread(), e)
+        }
+      }
+    })
+  }
+}