react-native-ensys-camera-x 1.0.7

package/android/src/main/java/com/customcamera/MediaPublisher.kt

@@ -0,0 +1,423 @@
+package com.customcamera
+
+import android.content.Context
+import android.content.ContentResolver
+import android.content.ContentValues
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.FileInputStream
+import java.io.IOException
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+/**
+ * MediaPublisher handles moving and copying media from cache to document/gallery directories.
+ * Manages file operations, URI generation, and metadata preservation.
+ *
+ * Supports:
+ * - Atomic move operations (cache -> documents)
+ * - Copy operations (cache -> documents, keeping original)
+ * - URI generation compatible with all Android versions
+ * - File hash computation for duplicate detection
+ * - Error handling and recovery
+ */
+class MediaPublisher private constructor(private val context: Context) {
+
+  companion object {
+    private const val TAG = "MediaPublisher"
+
+    @Volatile
+    private var instance: MediaPublisher? = null
+
+    fun getInstance(context: Context): MediaPublisher {
+      return instance ?: synchronized(this) {
+        instance ?: MediaPublisher(context.applicationContext).also { instance = it }
+      }
+    }
+
+    private const val BUFFER_SIZE = MediaFileIo.COPY_BUFFER_BYTES
+
+    /**
+     * Head-room kept free when sizing a publish. Filling a volume to the last byte is what makes
+     * the NEXT write (metadata, thumbnail, the following capture) the one that fails.
+     */
+    private const val SPACE_MARGIN_BYTES = 32L * 1024L * 1024L
+  }
+
+  private val contentResolver: ContentResolver = context.contentResolver
+
+  /**
+   * Move media from cache to documents directory.
+   *
+   * @param knownHash the signature already recorded for this media, when the caller has one.
+   *   Supplying it skips a full read of the file — see [computeFileHash].
+   */
+  suspend fun moveToDocuments(
+    sourceFile: File,
+    fileName: String,
+    mediaType: String,
+    metadata: MediaStorageMetadata,
+    knownHash: String? = null
+  ): PublishResult = withContext(Dispatchers.IO) {
+    try {
+      if (!sourceFile.exists()) {
+        return@withContext PublishResult(
+          success = false,
+          error = "Source file does not exist: ${sourceFile.absolutePath}"
+        )
+      }
+
+      val targetFile = getDocumentFile(fileName, mediaType)
+      val fileHash = knownHash?.takeIf { it.isNotEmpty() } ?: computeFileHash(sourceFile)
+
+      try {
+        // A genuine move: renamed when cache and documents share a volume (no bytes read or
+        // written at all, whatever the clip's size), streamed and then unlinked when they do not.
+        // This used to be a full byte-for-byte copy followed by the caller deleting the source,
+        // which for a long recording meant re-writing hundreds of megabytes on the send path.
+        //
+        // relocate() checks free space itself, and ONLY on the path that actually writes bytes —
+        // a rename must stay possible on a device too full to hold a second copy.
+        when (MediaFileIo.relocate(sourceFile, targetFile, SPACE_MARGIN_BYTES)) {
+          MediaFileIo.Outcome.RENAMED, MediaFileIo.Outcome.COPIED -> Unit
+          MediaFileIo.Outcome.INSUFFICIENT_SPACE ->
+            return@withContext PublishResult(
+              success = false,
+              error = "Not enough storage space to save this media"
+            )
+          MediaFileIo.Outcome.FAILED ->
+            return@withContext PublishResult(
+              success = false,
+              error = "Failed to copy file to documents"
+            )
+        }
+
+        // Update metadata on target file
+        updateFileMetadata(targetFile, metadata)
+
+        // Generate URI for the target file
+        val targetUri = generateUri(targetFile, mediaType)
+
+        // Verify the target file exists and is readable
+        if (!targetFile.exists() || !targetFile.canRead()) {
+          targetFile.delete()
+          return@withContext PublishResult(
+            success = false,
+            error = "Target file not readable after copy"
+          )
+        }
+
+        Log.i(TAG, "Media moved successfully from ${sourceFile.absolutePath} to ${targetFile.absolutePath}")
+
+        PublishResult(
+          success = true,
+          targetUri = targetUri,
+          fileHash = fileHash,
+          targetPath = targetFile.absolutePath
+        )
+      } catch (e: IOException) {
+        Log.e(TAG, "IO error during move operation", e)
+        targetFile.delete() // Cleanup partial file
+        PublishResult(
+          success = false,
+          error = "IO error: ${e.message}"
+        )
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Unexpected error in moveToDocuments", e)
+      PublishResult(
+        success = false,
+        error = "Unexpected error: ${e.message}"
+      )
+    }
+  }
+
+  /**
+   * Copy media from cache to documents directory (keeping original)
+   *
+   * @param knownHash see [moveToDocuments].
+   */
+  suspend fun copyToDocuments(
+    sourceFile: File,
+    fileName: String,
+    mediaType: String,
+    metadata: MediaStorageMetadata,
+    knownHash: String? = null
+  ): PublishResult = withContext(Dispatchers.IO) {
+    try {
+      if (!sourceFile.exists()) {
+        return@withContext PublishResult(
+          success = false,
+          error = "Source file does not exist: ${sourceFile.absolutePath}"
+        )
+      }
+
+      val targetFile = getDocumentFile(fileName, mediaType)
+      val fileHash = knownHash?.takeIf { it.isNotEmpty() } ?: computeFileHash(sourceFile)
+
+      try {
+        // Unlike moveToDocuments this ALWAYS writes a second copy, so duplicate()'s space check is
+        // unconditional. Running the volume dry here used to leave a truncated file behind that
+        // looked like a real published asset to everything downstream.
+        when (MediaFileIo.duplicate(sourceFile, targetFile, SPACE_MARGIN_BYTES)) {
+          MediaFileIo.Outcome.RENAMED, MediaFileIo.Outcome.COPIED -> Unit
+          MediaFileIo.Outcome.INSUFFICIENT_SPACE ->
+            return@withContext PublishResult(
+              success = false,
+              error = "Not enough storage space to save this media"
+            )
+          MediaFileIo.Outcome.FAILED ->
+            return@withContext PublishResult(
+              success = false,
+              error = "Failed to copy file to documents"
+            )
+        }
+
+        // Update metadata on target file
+        updateFileMetadata(targetFile, metadata)
+
+        // Generate URI for the target file
+        val targetUri = generateUri(targetFile, mediaType)
+
+        Log.i(TAG, "Media copied successfully from ${sourceFile.absolutePath} to ${targetFile.absolutePath}")
+
+        PublishResult(
+          success = true,
+          targetUri = targetUri,
+          fileHash = fileHash,
+          targetPath = targetFile.absolutePath
+        )
+      } catch (e: IOException) {
+        Log.e(TAG, "IO error during copy operation", e)
+        targetFile.delete() // Cleanup partial file
+        PublishResult(
+          success = false,
+          error = "IO error: ${e.message}"
+        )
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Unexpected error in copyToDocuments", e)
+      PublishResult(
+        success = false,
+        error = "Unexpected error: ${e.message}"
+      )
+    }
+  }
+
+  /**
+   * Move media to gallery (MediaStore)
+   */
+  suspend fun moveToGallery(
+    sourceFile: File,
+    fileName: String,
+    mediaType: String,
+    metadata: MediaStorageMetadata
+  ): PublishResult = withContext(Dispatchers.IO) {
+    try {
+      if (!sourceFile.exists()) {
+        return@withContext PublishResult(
+          success = false,
+          error = "Source file does not exist"
+        )
+      }
+
+      val fileHash = computeFileHash(sourceFile)
+      val contentUri = getMediaStoreUri(mediaType)
+
+      val contentValues = ContentValues().apply {
+        put(MediaStore.MediaColumns.DISPLAY_NAME, fileName)
+        put(MediaStore.MediaColumns.MIME_TYPE, getMimeType(mediaType, fileName))
+        put(MediaStore.MediaColumns.RELATIVE_PATH, getRelativePath(mediaType))
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+          put(MediaStore.MediaColumns.DATE_TAKEN, metadata.dateTaken ?: System.currentTimeMillis())
+        }
+      }
+
+      try {
+        val newUri = contentResolver.insert(contentUri, contentValues)
+          ?: return@withContext PublishResult(
+            success = false,
+            error = "Failed to insert into MediaStore"
+          )
+
+        // Copy file content to MediaStore
+        val outputStream = contentResolver.openOutputStream(newUri)
+          ?: return@withContext PublishResult(
+            success = false,
+            error = "Failed to open output stream"
+          )
+
+        val inputStream = FileInputStream(sourceFile)
+        inputStream.use { input ->
+          outputStream.use { output ->
+            input.copyTo(output, BUFFER_SIZE)
+          }
+        }
+
+        Log.i(TAG, "Media moved to gallery successfully: $newUri")
+
+        PublishResult(
+          success = true,
+          targetUri = newUri.toString(),
+          fileHash = fileHash
+        )
+      } catch (e: IOException) {
+        Log.e(TAG, "IO error during MediaStore operation", e)
+        PublishResult(
+          success = false,
+          error = "IO error: ${e.message}"
+        )
+      }
+    } catch (e: Exception) {
+      Log.e(TAG, "Unexpected error in moveToGallery", e)
+      PublishResult(
+        success = false,
+        error = "Unexpected error: ${e.message}"
+      )
+    }
+  }
+
+  /**
+   * Content signature for duplicate detection.
+   *
+   * Bounded for large files, so publishing a long recording no longer reads the whole clip just to
+   * produce a value that is only compared for equality — see [MediaFileIo.contentSignature].
+   * Callers that already hold the signature should pass it in rather than reach this at all.
+   */
+  private fun computeFileHash(file: File): String = MediaFileIo.contentSignature(file)
+
+  /**
+   * Update file metadata (timestamps, permissions)
+   */
+  private fun updateFileMetadata(file: File, metadata: MediaStorageMetadata) {
+    try {
+      if (metadata.dateTaken != null) {
+        file.setLastModified(metadata.dateTaken)
+      }
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to update file metadata", e)
+    }
+  }
+
+  /**
+   * True when a published document with this name already occupies the target path.
+   *
+   * Callers use it to uniquify a name BEFORE publishing, so a publish can never silently overwrite
+   * an unrelated file. Cheap — one stat, no read of the media itself.
+   */
+  fun documentFileExists(fileName: String, mediaType: String): Boolean =
+    runCatching { getDocumentFile(fileName, mediaType).exists() }.getOrDefault(false)
+
+  /**
+   * Get document directory file
+   */
+  private fun getDocumentFile(fileName: String, mediaType: String): File {
+    val baseDir = context.getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS)
+      ?: context.filesDir
+
+    val mediaDir = File(baseDir, "media_documents").apply { mkdirs() }
+    val typeDir = File(mediaDir, when (mediaType) {
+      "video" -> "videos"
+      "audio" -> "audio"
+      else    -> "photos"
+    }).apply { mkdirs() }
+
+    return File(typeDir, fileName)
+  }
+
+  /**
+   * Generate unique file name with timestamp if needed
+   */
+  private fun getUniqueFileName(baseFileName: String): String {
+    val file = File(baseFileName)
+    if (!file.exists()) return baseFileName
+
+    val name = file.nameWithoutExtension
+    val ext = file.extension
+    val parent = file.parentFile
+
+    val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
+    val newName = "${name}_$timestamp.$ext"
+
+    return File(parent, newName).absolutePath
+  }
+
+  /**
+   * Generate media-compatible URI
+   */
+  private fun generateUri(file: File, mediaType: String): String {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+      try {
+        androidx.core.content.FileProvider.getUriForFile(
+          context,
+          "${context.packageName}.camera.fileprovider",
+          file
+        ).toString()
+      } catch (e: Exception) {
+        Log.w(TAG, "FileProvider failed, falling back to file:// URI", e)
+        Uri.fromFile(file).toString()
+      }
+    } else {
+      // For Android versions before N, we can use file:// URIs
+      Uri.fromFile(file).toString()
+    }
+  }
+
+  /**
+   * Get MediaStore URI based on media type
+   */
+  private fun getMediaStoreUri(mediaType: String): Uri {
+    return if (mediaType == "video") {
+      MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+    } else {
+      MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+    }
+  }
+
+  /**
+   * Get relative path for MediaStore
+   */
+  private fun getRelativePath(mediaType: String): String {
+    return if (mediaType == "video") {
+      "${Environment.DIRECTORY_MOVIES}/CustomCamera/"
+    } else {
+      "${Environment.DIRECTORY_PICTURES}/CustomCamera/"
+    }
+  }
+
+  /**
+   * Get MIME type for media.
+   *
+   * Derived from [fileName]'s extension so a non-JPEG image keeps its real type when it is
+   * inserted into MediaStore — declaring image/jpeg for a GIF makes the gallery store (and every
+   * app that later reads) a mislabelled file. Falls back to the per-type default when the name
+   * carries no recognised extension.
+   */
+  private fun getMimeType(mediaType: String, fileName: String? = null): String {
+    if (mediaType == "video") {
+      // Container table for video lives in MediaExportFormats, so an exported .webm / .3gp is
+      // inserted into MediaStore as what it actually is instead of as video/mp4.
+      return MediaExportFormats.videoContainerFromFileName(fileName)?.mimeType ?: "video/mp4"
+    }
+    // Container table lives in ImageFormatSupport so publishing, caching and editor export can
+    // never disagree about what a given extension means — publishing a HEIF/AVIF as image/jpeg
+    // would make MediaStore describe bytes it does not have.
+    return ImageFormatSupport.fromFileName(fileName)?.mimeType ?: "image/jpeg"
+  }
+
+  data class PublishResult(
+    val success: Boolean,
+    val targetUri: String? = null,
+    val fileHash: String? = null,
+    val targetPath: String? = null,
+    val error: String? = null
+  )
+}