react-native-video-trim 7.1.0 → 8.0.0

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

@@ -25,23 +25,39 @@ object StorageUtil {
     return file.absolutePath
   }
 
+  // Headless API outputs (compress, toGif, merge, extractAudio, getFrameAt) go to the
+  // cache directory. The OS may purge these files under storage pressure when the app is
+  // not running, which avoids unbounded storage growth from repeated headless operations.
+  fun getCacheOutputPath(context: Context, outputExt: String): String {
+    val timestamp = System.currentTimeMillis() / 1000
+    val file = File(context.cacheDir, "${VideoTrimmerUtil.FILE_PREFIX}_${timestamp}.$outputExt")
+    return file.absolutePath
+  }
+
   fun isFileExists(filePath: String?): Boolean {
     if (TextUtils.isEmpty(filePath)) return false
     return File(filePath!!).exists()
   }
 
+  // Scans both the persistent directory (showEditor/trim outputs) and the cache
+  // directory (headless API outputs) for files matching our prefix.
   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()
+    val dirs = listOf(context.filesDir, context.cacheDir)
+    return dirs.flatMap { dir ->
+      dir.listFiles { _, name -> name.startsWith(VideoTrimmerUtil.FILE_PREFIX) }?.toList() ?: emptyList()
+    }.map { it.absolutePath }.toTypedArray()
   }
 
+  // Path-restricted delete: only allows deletion of files inside our filesDir or cacheDir
+  // to prevent accidental deletion of arbitrary files on the device.
   fun deleteFile(path: String?): Boolean {
     if (TextUtils.isEmpty(path)) return true
     val file = File(path!!).canonicalFile
-    val allowedDir = BaseUtils.getContext().filesDir.canonicalFile
-    if (!file.path.startsWith(allowedDir.path)) return false
+    val allowedDirs = listOf(
+      BaseUtils.getContext().filesDir.canonicalFile,
+      BaseUtils.getContext().cacheDir.canonicalFile,
+    )
+    if (allowedDirs.none { file.path.startsWith(it.path) }) return false
     return deleteFile(file)
   }
 
@@ -62,46 +78,89 @@ object StorageUtil {
     return file.delete()
   }
 
-  @Throws(IOException::class)
-  fun saveVideoToGallery(context: ReactApplicationContext, videoFilePath: String?) {
-    val videoFile = File(videoFilePath!!)
+  private val IMAGE_EXTENSIONS = setOf("jpg", "jpeg", "png", "gif", "webp", "bmp", "heic", "heif")
 
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-      saveVideoUsingMediaStore(context, videoFile)
+  fun isImageFile(file: File): Boolean {
+    val ext = file.extension.lowercase()
+    return ext in IMAGE_EXTENSIONS
+  }
+
+  // Dispatches to the correct MediaStore collection (Images vs Video) based on file
+  // extension. Using the wrong collection causes the Photos app to misidentify the file.
+  @Throws(IOException::class)
+  fun saveToGallery(context: ReactApplicationContext, filePath: String?) {
+    val file = File(filePath!!)
+    if (isImageFile(file)) {
+      saveImageToGallery(context, file)
     } else {
-      try {
-        saveVideoUsingTraditionalStorage(context, videoFile)
-      } catch (e: IOException) {
-        throw RuntimeException(e)
-      }
+      saveVideoToGallery(context, file)
     }
   }
 
-  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()
+  // On Android Q+ (API 29+), uses the IS_PENDING pattern: the MediaStore entry is
+  // created as pending (invisible to other apps), the file is copied, then IS_PENDING
+  // is cleared to make it visible. This prevents partial files from appearing in the
+  // gallery during the write.
+  @Throws(IOException::class)
+  private fun saveVideoToGallery(context: ReactApplicationContext, videoFile: File) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      val values = ContentValues().apply {
+        put(MediaStore.Video.Media.DISPLAY_NAME, videoFile.name)
+        put(MediaStore.Video.Media.MIME_TYPE, "video/mp4")
+        put(MediaStore.Video.Media.RELATIVE_PATH, Environment.DIRECTORY_DCIM)
+        put(MediaStore.Video.Media.IS_PENDING, 1)
+      }
+      val resolver = context.contentResolver
+      val uri = resolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, values)
+      if (uri != null) {
+        resolver.openOutputStream(uri)?.use { os -> copyFile(videoFile, os) }
+        values.clear()
+        values.put(MediaStore.Video.Media.IS_PENDING, 0)
+        resolver.update(uri, values, null, null)
       }
+    } else {
+      val galleryDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM)
+      val dest = File(galleryDir, videoFile.name)
+      copyFile(videoFile, dest)
+      MediaScannerConnection.scanFile(context, arrayOf(dest.absolutePath), arrayOf("video/*"), null)
     }
   }
 
+  // Same IS_PENDING pattern as saveVideoToGallery but targets MediaStore.Images.Media
+  // and Environment.DIRECTORY_PICTURES. MIME type is inferred from the file extension.
   @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)
+  private fun saveImageToGallery(context: ReactApplicationContext, imageFile: File) {
+    val ext = imageFile.extension.lowercase()
+    val mimeType = when (ext) {
+      "png" -> "image/png"
+      "gif" -> "image/gif"
+      "webp" -> "image/webp"
+      "bmp" -> "image/bmp"
+      "heic", "heif" -> "image/heic"
+      else -> "image/jpeg"
+    }
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+      val values = ContentValues().apply {
+        put(MediaStore.Images.Media.DISPLAY_NAME, imageFile.name)
+        put(MediaStore.Images.Media.MIME_TYPE, mimeType)
+        put(MediaStore.Images.Media.RELATIVE_PATH, Environment.DIRECTORY_PICTURES)
+        put(MediaStore.Images.Media.IS_PENDING, 1)
+      }
+      val resolver = context.contentResolver
+      val uri = resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)
+      if (uri != null) {
+        resolver.openOutputStream(uri)?.use { os -> copyFile(imageFile, os) }
+        values.clear()
+        values.put(MediaStore.Images.Media.IS_PENDING, 0)
+        resolver.update(uri, values, null, null)
+      }
+    } else {
+      val picturesDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES)
+      val dest = File(picturesDir, imageFile.name)
+      copyFile(imageFile, dest)
+      MediaScannerConnection.scanFile(context, arrayOf(dest.absolutePath), arrayOf(mimeType), null)
+    }
   }
 
   @Throws(IOException::class)

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

@@ -38,6 +38,21 @@ object VideoTrimmerUtil {
   @JvmField val THUMB_WIDTH = UnitConverter.dpToPx(25)
   private const val THUMB_RESOLUTION_RES = 2
 
+  internal fun buildAtempoChain(speed: Double): String {
+    var remaining = speed
+    val filters = mutableListOf<String>()
+    while (remaining < 0.5) {
+      filters.add("atempo=0.5")
+      remaining /= 0.5
+    }
+    while (remaining > 2.0) {
+      filters.add("atempo=2.0")
+      remaining /= 2.0
+    }
+    filters.add("atempo=$remaining")
+    return filters.joinToString(",")
+  }
+
   fun trim(
     inputFile: String,
     outputFile: String,
@@ -51,6 +66,8 @@ object VideoTrimmerUtil {
     videoHeight: Int,
     videoBitrate: Long,
     enablePreciseTrimming: Boolean,
+    removeAudio: Boolean,
+    speed: Double,
     callback: VideoTrimListener
   ): FFmpegSession {
     val currentDate = Date()
@@ -67,9 +84,9 @@ object VideoTrimmerUtil {
 
     val hasUserTransform = userRotationCount != 0 || userIsFlipped
     // Re-encode is required when: (1) user applied flip/rotate, (2) user cropped, or
-    // (3) enablePreciseTrimming is on. In all three cases, -c copy won't work because
-    // either we need video filters or we need frame-accurate cut points.
-    val needsReEncode = hasUserTransform || cropNormalized != null || enablePreciseTrimming
+    // (3) enablePreciseTrimming is on, or (4) speed != 1.0. In those cases, -c copy
+    // won't work because either we need video filters or we need frame-accurate cut points.
+    val needsReEncode = hasUserTransform || cropNormalized != null || enablePreciseTrimming || speed != 1.0
 
     if (needsReEncode) {
       val videoFilters = mutableListOf<String>()
@@ -105,6 +122,10 @@ object VideoTrimmerUtil {
         }
       }
 
+      if (speed != 1.0) {
+        videoFilters.add("setpts=${1.0 / speed}*PTS")
+      }
+
       val filterString = videoFilters.joinToString(",")
       // Preserve source quality by matching the original bitrate. Falls back to 10 Mbps.
       val bitrateStr = if (videoBitrate > 0) "$videoBitrate" else "10M"
@@ -118,21 +139,22 @@ object VideoTrimmerUtil {
       // h264_mediacodec: Android's hardware H.264 encoder — fast and energy-efficient.
       // Note: Android FFmpegKit auto-rotates by default, so no -noautorotate is needed.
       // The transpose filters above only handle user-initiated rotation, not source metadata.
-      cmds.addAll(listOf(
-        "-c:v", "h264_mediacodec",
-        "-b:v", bitrateStr,
-        "-c:a", "copy",
-        "-metadata", "creation_time=$formattedDateTime",
-        outputFile
-      ))
+      cmds.addAll(listOf("-c:v", "h264_mediacodec", "-b:v", bitrateStr))
+      when {
+        removeAudio -> cmds.add("-an")
+        speed != 1.0 -> cmds.addAll(listOf("-af", buildAtempoChain(speed)))
+        else -> cmds.addAll(listOf("-c:a", "copy"))
+      }
+      cmds.addAll(listOf("-metadata", "creation_time=$formattedDateTime", outputFile))
     } else {
       // Stream copy: no re-encoding, extremely fast but only cuts at keyframes.
-      cmds.addAll(listOf(
-        "-i", inputFile,
-        "-c", "copy",
-        "-metadata", "creation_time=$formattedDateTime",
-        outputFile
-      ))
+      cmds.addAll(listOf("-i", inputFile))
+      if (removeAudio) {
+        cmds.addAll(listOf("-c:v", "copy", "-an"))
+      } else {
+        cmds.addAll(listOf("-c", "copy"))
+      }
+      cmds.addAll(listOf("-metadata", "creation_time=$formattedDateTime", outputFile))
     }
 
     val command = cmds.toTypedArray()
@@ -204,7 +226,7 @@ object VideoTrimmerUtil {
     endPosition: Long,
     callback: SingleCallback<Bitmap, Int>
   ) {
-    BackgroundExecutor.execute(object : BackgroundExecutor.Task("", 0L, "") {
+    BackgroundExecutor.execute(object : BackgroundExecutor.Task("initial_thumbs", 0L, "") {
       override fun execute() {
         try {
           val interval = (endPosition - startPosition) / (totalThumbsCount - 1)

package/android/src/main/java/com/videotrim/widgets/AudioWaveformView.kt

@@ -0,0 +1,92 @@
+package com.videotrim.widgets
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.RectF
+import android.util.AttributeSet
+import android.view.View
+
+/**
+ * Custom View that draws an audio waveform as a row of vertical rounded-rect bars.
+ *
+ * Each bar's height is driven by a normalized amplitude value in [0, 1].
+ * The view recalculates bar count from its own width and maps the amplitudes
+ * array proportionally, so it works correctly regardless of whether the
+ * amplitudes array has more or fewer entries than the visible bar count.
+ *
+ * The background color (set via [View.setBackgroundColor]) provides the
+ * waveform track color; the bars are drawn on top with [barColor].
+ */
+class AudioWaveformView @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
+) : View(context, attrs, defStyleAttr) {
+
+    var amplitudes: FloatArray = FloatArray(0)
+        private set
+    private val barPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        color = Color.WHITE
+        style = Paint.Style.FILL
+    }
+    private val barRect = RectF()
+
+    var barColor: Int
+        get() = barPaint.color
+        set(value) {
+            barPaint.color = value
+            invalidate()
+        }
+
+    var barWidthPx: Float = 0f
+        set(value) {
+            field = value
+            invalidate()
+        }
+
+    var barGapPx: Float = 0f
+        set(value) {
+            field = value
+            invalidate()
+        }
+
+    var barCornerRadiusPx: Float = 0f
+        set(value) {
+            field = value
+            invalidate()
+        }
+
+    fun setAmplitudes(data: FloatArray) {
+        amplitudes = data
+        invalidate()
+    }
+
+    override fun onDraw(canvas: Canvas) {
+        super.onDraw(canvas)
+        if (amplitudes.isEmpty()) return
+
+        val totalHeight = height.toFloat()
+        val step = barWidthPx + barGapPx
+        if (step <= 0f) return
+        val barCount = (width.toFloat() / step).toInt()
+        if (barCount <= 0) return
+
+        // Keep bars from touching the container edges
+        val verticalPadding = barWidthPx * 1.5f
+        val drawableHeight = totalHeight - verticalPadding * 2f
+        if (drawableHeight <= 0f) return
+        val minBarHeight = barWidthPx
+
+        for (i in 0 until barCount) {
+            val ampIndex = (i * amplitudes.size / barCount).coerceIn(0, amplitudes.size - 1)
+            val amp = amplitudes[ampIndex]
+            val barHeight = (amp * drawableHeight).coerceAtLeast(minBarHeight)
+            val x = i * step
+            val y = verticalPadding + (drawableHeight - barHeight) / 2f
+            barRect.set(x, y, x + barWidthPx, y + barHeight)
+            canvas.drawRoundRect(barRect, barCornerRadiusPx, barCornerRadiusPx, barPaint)
+        }
+    }
+}