react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,386 @@
+package com.customcamera
+
+import android.content.Context
+import android.os.Environment
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.util.concurrent.TimeUnit
+
+/**
+ * CacheCleanupManager handles automatic and manual cleanup of cache files.
+ *
+ * Features:
+ * - Automatic cleanup of old files (configurable age)
+ * - Size-based cleanup (when cache exceeds max size)
+ * - Cleanup of orphaned files (files without metadata)
+ * - Cleanup of duplicate files
+ * - Retry mechanism for failed deletions
+ * - Background scheduling support
+ */
+class CacheCleanupManager private constructor(private val context: Context) {
+
+  companion object {
+    private const val TAG = "CacheCleanupManager"
+
+    // Default cleanup configuration
+    private const val DEFAULT_MAX_CACHE_SIZE_MB = 500L
+    private const val DEFAULT_CLEANUP_AGE_DAYS = 7
+    private const val DEFAULT_ORPHAN_FILE_AGE_HOURS = 24
+
+    @Volatile
+    private var instance: CacheCleanupManager? = null
+
+    fun getInstance(context: Context): CacheCleanupManager {
+      return instance ?: synchronized(this) {
+        instance ?: CacheCleanupManager(context.applicationContext).also { instance = it }
+      }
+    }
+  }
+
+  private val metadataStore = MediaMetadataStore.getInstance(context)
+  private var maxCacheSizeMB = DEFAULT_MAX_CACHE_SIZE_MB
+  private var cleanupAgeDays = DEFAULT_CLEANUP_AGE_DAYS
+  private var orphanFileAgeHours = DEFAULT_ORPHAN_FILE_AGE_HOURS
+
+  /**
+   * Perform cleanup based on age
+   */
+  suspend fun cleanupOldFiles(olderThanDays: Int = cleanupAgeDays): CleanupResult {
+    return withContext(Dispatchers.IO) {
+      try {
+        val cacheDir = getCacheDir()
+        if (!cacheDir.exists()) {
+          return@withContext CleanupResult(
+            success = true,
+            filesRemoved = 0,
+            spaceFreedMB = 0.0
+          )
+        }
+
+        val cutoffTime = System.currentTimeMillis() - TimeUnit.DAYS.toMillis(olderThanDays.toLong())
+        var filesRemoved = 0
+        var spaceFreed = 0L
+        val erroredFiles = mutableListOf<ErroredFile>()
+
+        // Build a cachePath -> mediaId lookup ONCE up front instead of re-reading and
+        // re-scanning the entire metadata store for every deleted file (previously an
+        // O(files × metadata) pass that dominated cleanup on large caches). One O(metadata)
+        // build + O(1) lookups is equivalent in behaviour and far cheaper.
+        val pathToMediaId: Map<String, String> = metadataStore.getAllMedia()
+          .mapNotNull { m -> m.cachePath?.let { it to m.id } }
+          .toMap()
+
+        cacheDir.walkTopDown().forEach { file ->
+          if (file.isFile && file.lastModified() < cutoffTime) {
+            try {
+              spaceFreed += file.length()
+              if (file.delete()) {
+                filesRemoved++
+                // Remove from metadata by matching cachePath -> id
+                try {
+                  pathToMediaId[file.absolutePath]?.let { metadataStore.removeMedia(it) }
+                } catch (e: Exception) {
+                  Log.w(TAG, "Failed to remove metadata for deleted file: ${file.absolutePath}", e)
+                }
+              } else {
+                erroredFiles.add(ErroredFile(file.absolutePath, "Failed to delete"))
+              }
+            } catch (e: Exception) {
+              erroredFiles.add(ErroredFile(file.absolutePath, e.message ?: "Unknown error"))
+            }
+          }
+        }
+
+        Log.i(TAG, "Cleanup completed: $filesRemoved files removed, ${spaceFreed / (1024 * 1024)}MB freed")
+
+        CleanupResult(
+          success = true,
+          filesRemoved = filesRemoved,
+          spaceFreedMB = spaceFreed.toDouble() / (1024 * 1024),
+          erroredFiles = erroredFiles
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "Cleanup operation failed", e)
+        CleanupResult(
+          success = false,
+          filesRemoved = 0,
+          spaceFreedMB = 0.0,
+          erroredFiles = emptyList(),
+          error = e.message
+        )
+      }
+    }
+  }
+
+  /**
+   * Cleanup when cache size exceeds maximum
+   */
+  suspend fun cleanupBySize(maxSizeMB: Long = maxCacheSizeMB): CleanupResult {
+    return withContext(Dispatchers.IO) {
+      try {
+        val cacheDir = getCacheDir()
+        if (!cacheDir.exists()) {
+          return@withContext CleanupResult(
+            success = true,
+            filesRemoved = 0,
+            spaceFreedMB = 0.0
+          )
+        }
+
+        val currentSizeBytes = cacheDir.getTotalSize()
+        val maxSizeBytes = maxSizeMB * 1024 * 1024
+        
+        if (currentSizeBytes <= maxSizeBytes) {
+          return@withContext CleanupResult(
+            success = true,
+            filesRemoved = 0,
+            spaceFreedMB = 0.0
+          )
+        }
+
+        // Need to delete oldest files until size is below threshold
+        val targetSizeBytes = (maxSizeMB / 2) * 1024 * 1024 // Clean to 50% of max
+        val files = cacheDir.walkTopDown()
+          .filter { it.isFile }
+          .sortedBy { it.lastModified() } // Oldest first
+          .toMutableList()
+
+        var spaceFreed = 0L
+        var filesRemoved = 0
+        val erroredFiles = mutableListOf<ErroredFile>()
+
+        // One-time cachePath -> mediaId lookup (see cleanupOldFiles): avoids re-reading the
+        // whole metadata store for every file deleted in the size-eviction loop.
+        val pathToMediaId: Map<String, String> = metadataStore.getAllMedia()
+          .mapNotNull { m -> m.cachePath?.let { it to m.id } }
+          .toMap()
+
+        for (file in files) {
+          if (currentSizeBytes - spaceFreed <= targetSizeBytes) break
+
+          try {
+            spaceFreed += file.length()
+            if (file.delete()) {
+              filesRemoved++
+              try {
+                pathToMediaId[file.absolutePath]?.let { metadataStore.removeMedia(it) }
+              } catch (e: Exception) {
+                Log.w(TAG, "Failed to remove metadata for deleted file: ${file.absolutePath}", e)
+              }
+            } else {
+              erroredFiles.add(ErroredFile(file.absolutePath, "Failed to delete"))
+            }
+          } catch (e: Exception) {
+            erroredFiles.add(ErroredFile(file.absolutePath, e.message ?: "Unknown error"))
+          }
+        }
+
+        Log.i(TAG, "Size-based cleanup completed: $filesRemoved files removed, ${spaceFreed / (1024 * 1024)}MB freed")
+
+        CleanupResult(
+          success = true,
+          filesRemoved = filesRemoved,
+          spaceFreedMB = spaceFreed.toDouble() / (1024 * 1024),
+          erroredFiles = erroredFiles
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "Size-based cleanup failed", e)
+        CleanupResult(
+          success = false,
+          filesRemoved = 0,
+          spaceFreedMB = 0.0,
+          error = e.message
+        )
+      }
+    }
+  }
+
+  /**
+   * Cleanup orphaned files (files without metadata)
+   */
+  suspend fun cleanupOrphanedFiles(olderThanHours: Int = orphanFileAgeHours): CleanupResult {
+    return withContext(Dispatchers.IO) {
+      try {
+        val cacheDir = getCacheDir()
+        if (!cacheDir.exists()) {
+          return@withContext CleanupResult(
+            success = true,
+            filesRemoved = 0,
+            spaceFreedMB = 0.0
+          )
+        }
+
+        val allMetadata = metadataStore.getAllMedia()
+        val metadataFilePaths = allMetadata.mapNotNull { it.cachePath }.toSet()
+        val cutoffTime = System.currentTimeMillis() - TimeUnit.HOURS.toMillis(olderThanHours.toLong())
+
+        var filesRemoved = 0
+        var spaceFreed = 0L
+        val erroredFiles = mutableListOf<ErroredFile>()
+
+        cacheDir.walkTopDown().forEach { file ->
+          if (file.isFile && file.absolutePath !in metadataFilePaths && file.lastModified() < cutoffTime) {
+            try {
+              spaceFreed += file.length()
+              if (file.delete()) {
+                filesRemoved++
+              } else {
+                erroredFiles.add(ErroredFile(file.absolutePath, "Failed to delete"))
+              }
+            } catch (e: Exception) {
+              erroredFiles.add(ErroredFile(file.absolutePath, e.message ?: "Unknown error"))
+            }
+          }
+        }
+
+        Log.i(TAG, "Orphaned file cleanup completed: $filesRemoved files removed")
+
+        CleanupResult(
+          success = true,
+          filesRemoved = filesRemoved,
+          spaceFreedMB = spaceFreed.toDouble() / (1024 * 1024),
+          erroredFiles = erroredFiles
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "Orphaned file cleanup failed", e)
+        CleanupResult(
+          success = false,
+          filesRemoved = 0,
+          spaceFreedMB = 0.0,
+          error = e.message
+        )
+      }
+    }
+  }
+
+  /**
+   * Cleanup duplicate files (keep only one)
+   */
+  suspend fun cleanupDuplicates(): CleanupResult {
+    return withContext(Dispatchers.IO) {
+      try {
+        val duplicates = metadataStore.getDuplicateMedia()
+        
+        var filesRemoved = 0
+        var spaceFreed = 0L
+        val erroredFiles = mutableListOf<ErroredFile>()
+
+        // Group by hash
+        val hashGroups = duplicates.groupBy { it.fileHash }
+
+        hashGroups.forEach { (_, group) ->
+          if (group.size > 1) {
+            // Keep the first one, delete the rest
+            group.drop(1).forEach { duplicate ->
+              try {
+                val file = File(duplicate.cachePath ?: return@forEach)
+                if (file.exists()) {
+                  spaceFreed += file.length()
+                  if (file.delete()) {
+                    filesRemoved++
+                    metadataStore.removeMedia(duplicate.id)
+                  } else {
+                    erroredFiles.add(ErroredFile(file.absolutePath, "Failed to delete"))
+                  }
+                }
+              } catch (e: Exception) {
+                erroredFiles.add(ErroredFile(duplicate.cachePath ?: "unknown", e.message ?: "Unknown error"))
+              }
+            }
+          }
+        }
+
+        Log.i(TAG, "Duplicate cleanup completed: $filesRemoved duplicate files removed")
+
+        CleanupResult(
+          success = true,
+          filesRemoved = filesRemoved,
+          spaceFreedMB = spaceFreed.toDouble() / (1024 * 1024),
+          erroredFiles = erroredFiles
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "Duplicate cleanup failed", e)
+        CleanupResult(
+          success = false,
+          filesRemoved = 0,
+          spaceFreedMB = 0.0,
+          error = e.message
+        )
+      }
+    }
+  }
+
+  /**
+   * Perform comprehensive cleanup
+   */
+  suspend fun performCleanup(): CleanupResult {
+    return withContext(Dispatchers.IO) {
+      try {
+        val results = mutableListOf<CleanupResult>()
+
+        // Run cleanups in sequence
+        results.add(cleanupOrphanedFiles())
+        results.add(cleanupOldFiles())
+        results.add(cleanupDuplicates())
+
+        val totalRemoved = results.sumOf { it.filesRemoved }
+        val totalSpaceFreed = results.sumOf { it.spaceFreedMB }
+        val allErrors = results.flatMap { it.erroredFiles }
+
+        CleanupResult(
+          success = true,
+          filesRemoved = totalRemoved,
+          spaceFreedMB = totalSpaceFreed,
+          erroredFiles = allErrors
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "Comprehensive cleanup failed", e)
+        CleanupResult(
+          success = false,
+          filesRemoved = 0,
+          spaceFreedMB = 0.0,
+          error = e.message
+        )
+      }
+    }
+  }
+
+  /**
+   * Configure cleanup parameters
+   */
+  fun configure(maxCacheSizeMB: Long, cleanupAgeDays: Int, orphanFileAgeHours: Int) {
+    this.maxCacheSizeMB = maxCacheSizeMB
+    this.cleanupAgeDays = cleanupAgeDays
+    this.orphanFileAgeHours = orphanFileAgeHours
+  }
+
+  /**
+   * Get cache directory
+   */
+  private fun getCacheDir(): File {
+    return File(context.cacheDir, "media_cache").apply { mkdirs() }
+  }
+
+  data class CleanupResult(
+    val success: Boolean,
+    val filesRemoved: Int,
+    val spaceFreedMB: Double,
+    val erroredFiles: List<ErroredFile> = emptyList(),
+    val error: String? = null
+  )
+
+  data class ErroredFile(
+    val path: String,
+    val error: String
+  )
+}
+
+private fun File.getTotalSize(): Long {
+  return if (isDirectory) {
+    listFiles()?.sumOf { it.getTotalSize() } ?: 0L
+  } else {
+    length()
+  }
+}

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

@@ -0,0 +1,77 @@
+package com.customcamera
+
+object CameraAspectRatioMode {
+  const val ORIGINAL_LABEL = "Original"
+  const val FULL_LABEL = "Full"
+
+  data class Mode(val label: String, val ratio: Float)
+
+  private const val DEFAULT_RATIO = 720f / 1165f
+
+  fun availableLabels(): List<String> = listOf(ORIGINAL_LABEL, FULL_LABEL, "4:3", "16:9", "1:1", "9:16", "4:5")
+
+  fun fromLabel(label: String?, fallbackRatio: Float = DEFAULT_RATIO): Mode? = when (label) {
+    ORIGINAL_LABEL -> Mode(ORIGINAL_LABEL, fallbackRatio)
+    FULL_LABEL -> Mode(FULL_LABEL, fallbackRatio)
+    "4:3" -> Mode("4:3", 4f / 3f)
+    "16:9" -> Mode("16:9", 16f / 9f)
+    "1:1" -> Mode("1:1", 1f)
+    "9:16" -> Mode("9:16", 9f / 16f)
+    "4:5" -> Mode("4:5", 4f / 5f)
+    else -> null
+  }
+
+  fun resolveRatio(label: String?, screenAspectRatio: Float, fallbackRatio: Float = DEFAULT_RATIO): Float =
+    fromLabel(label, fallbackRatio)?.let { mode ->
+      if (mode.label == FULL_LABEL) screenAspectRatio else mode.ratio
+    } ?: fallbackRatio
+
+  private const val RATIO_16_9 = 16f / 9f
+
+  // Tolerance for classifying a preview-container ratio (derived from integer pixel dimensions,
+  // so it drifts a hair from the exact fraction) against a named aspect. Far tighter than the
+  // gap between any two selectable ratios (4:3 ≈ 1.333 vs 16:9 ≈ 1.778), so it never confuses
+  // one for another.
+  private const val LANDSCAPE_RATIO_MATCH_EPSILON = 0.02f
+
+  /**
+   * Whether a LANDSCAPE capture of [ratio] (the portrait-locked viewfinder box's width / height)
+   * must have BOTH its capture crop and its editor framing INVERTED to the box's inverse aspect,
+   * so the saved image/video reproduces EXACTLY the region the viewfinder framed — true WYSIWYG,
+   * with no camera content revealed outside the capture frame.
+   *
+   * A box held sideways frames its INVERSE aspect (its on-screen width axis points vertically in
+   * the world), so:
+   *   - every ratio <= 1 (9:16, 4:5, 1:1, Original, Full-on-portrait) inverts, and
+   *   - 16:9 inverts too: a wide "16:9" box held sideways frames a TALL upright region, so keeping
+   *     it wide pulled in extra left/right scene the viewfinder never showed.
+   * 4:3 is the sole remaining exception — it is deliberately KEPT WIDE for a landscape capture
+   * (fills the editor width), an accepted tradeoff. Portrait captures never invert (callers gate
+   * on their own rotatedToPortrait flag).
+   *
+   * This is the single source of truth shared by the capture crop (CustomCameraActivity's photo
+   * normalize + video crop-transcode) and the editor framing
+   * (MediaPreviewEditor.shouldInvertForLandscape), so the saved file and the editor box stay
+   * pixel-for-pixel consistent.
+   */
+  fun invertsForLandscape(ratio: Float): Boolean =
+    ratio > 0f && (ratio <= 1f || Math.abs(ratio - RATIO_16_9) <= LANDSCAPE_RATIO_MATCH_EPSILON)
+
+  /**
+   * User-facing full-word label for a popup-menu row. The [ORIGINAL_LABEL] / [FULL_LABEL]
+   * constants stay as stable internal identifiers (used for matching); this maps them to
+   * their localized display text. Ratio notation ("4:3", "16:9"…) is universal and passes
+   * through unchanged.
+   */
+  fun displayLabel(label: String?): String = when (label) {
+    ORIGINAL_LABEL, null -> Localization.getString("aspectRatioOriginal", "Original")
+    FULL_LABEL -> Localization.getString("aspectRatioFull", "Full")
+    else -> label
+  }
+
+  fun buttonLabel(label: String?): String = when (label) {
+    ORIGINAL_LABEL, null -> Localization.getString("aspectRatioOriginalShort", "Original")
+    FULL_LABEL -> Localization.getString("aspectRatioFull", "Full")
+    else -> label
+  }
+}

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

@@ -0,0 +1,211 @@
+package com.customcamera
+
+import android.content.Context
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import java.io.File
+
+data class CameraAsset(
+  val id: String,
+  val uri: Uri,
+  val type: String,
+  val fileName: String?,
+  val mimeType: String?,
+  val width: Int?,
+  val height: Int?,
+  val duration: Long?,
+  val size: Long?,
+  val dateTaken: Long?,
+  val caption: String? = null,
+  val cachePath: String? = null,
+  val isCached: Boolean = false,
+  val cacheCreatedAt: Long? = null,
+  val cacheLastModified: Long? = null,
+  val originalUri: String? = null,
+  val documentUri: String? = null,
+  /**
+   * The aspect ratio (width / height) of the live camera preview at the time of capture.
+   * Used to render the captured media with identical framing as the viewfinder — true WYSIWYG.
+   * Stored as a Float (e.g. 1.33f for 4:3, 1.78f for 16:9) or null if unknown.
+   */
+  val previewAspectRatio: Float? = null,
+  /**
+   * True when this photo was captured in landscape orientation. This helps distinguish
+   * between images natively captured in portrait (9:16 aspect ratio) versus landscape
+   * (captured while the device was held horizontally). Both are now cropped to the selected
+   * aspect ratio and stored with previewAspectRatio set, ensuring WYSIWYG behavior where
+   * the editor preview exactly matches the capture framing. This flag is provided for
+   * editor logic that may need to handle landscape and portrait captures differently.
+   */
+  val rotatedToPortrait: Boolean = false,
+  /**
+   * For videos: a content:// (or file://) URI of the user-selected cover frame, extracted as a
+   * JPEG in the editor. Purely a poster/thumbnail — the video file itself is unchanged. Surfaced
+   * to JS as `coverUri` and preferred by [ThumbnailLoader] for the in-app strip.
+   */
+  val coverUri: String? = null,
+
+  /** The exact container width (in pixels) used for the camera preview at capture time. */
+  val captureContainerWidth: Int? = null,
+
+  /** The exact container height (in pixels) used for the camera preview at capture time. */
+  val captureContainerHeight: Int? = null,
+
+  /**
+   * True when [size] is a DISPLAY convention rather than the exact bytes on disk. Set for a
+   * compressed video published from the editor: the file the encoder writes copies its audio and
+   * container through and so sits above the proportional figure the user picked, but the preview /
+   * Info screen must quote the SAME proportional size the compression dropdown and the completion
+   * toast quote (`original × (1 - percent/100)`). This flag tells JS ([refreshAssetMetadata]) to
+   * keep [size] as-is for that clip instead of re-statting the file and overwriting the convention.
+   * Everything without a compressed re-encode (originals, muted/trimmed clips, stills) leaves this
+   * false, so those still re-stat normally.
+   */
+  val sizeIsDisplayEstimate: Boolean = false
+) {
+  fun toBundle(): Bundle =
+    Bundle().apply {
+      putString("id", id)
+      putString("uri", uri.toString())
+      putString("type", type)
+      fileName?.let { putString("fileName", it) }
+      mimeType?.let { putString("mimeType", it) }
+      width?.let { putInt("width", it) }
+      height?.let { putInt("height", it) }
+      duration?.let { putDouble("duration", it.toDouble()) }
+      size?.let { putDouble("size", it.toDouble()) }
+      dateTaken?.let { putDouble("dateTaken", it.toDouble()) }
+      caption?.takeIf { it.isNotBlank() }?.let { putString("caption", it) }
+      cachePath?.let { putString("cachePath", it) }
+      putBoolean("isCached", isCached)
+      cacheCreatedAt?.let { putDouble("cacheCreatedAt", it.toDouble()) }
+      cacheLastModified?.let { putDouble("cacheLastModified", it.toDouble()) }
+      originalUri?.let { putString("originalUri", it) }
+      documentUri?.let { putString("documentUri", it) }
+      previewAspectRatio?.let { putFloat("previewAspectRatio", it) }
+      putBoolean("rotatedToPortrait", rotatedToPortrait)
+      coverUri?.let { putString("coverUri", it) }
+      captureContainerWidth?.let { putInt("captureContainerWidth", it) }
+      captureContainerHeight?.let { putInt("captureContainerHeight", it) }
+      putBoolean("sizeIsDisplayEstimate", sizeIsDisplayEstimate)
+    }
+
+  companion object {
+    fun fromBundle(bundle: Bundle): CameraAsset {
+      return CameraAsset(
+        id = bundle.getString("id") ?: "",
+        uri = Uri.parse(bundle.getString("uri")),
+        type = bundle.getString("type") ?: "photo",
+        fileName = bundle.getString("fileName"),
+        mimeType = bundle.getString("mimeType"),
+        width = if (bundle.containsKey("width")) bundle.getInt("width") else null,
+        height = if (bundle.containsKey("height")) bundle.getInt("height") else null,
+        duration = if (bundle.containsKey("duration")) bundle.getLong("duration") else null,
+        size = if (bundle.containsKey("size")) bundle.getLong("size") else null,
+        dateTaken = if (bundle.containsKey("dateTaken")) bundle.getLong("dateTaken") else null,
+        caption = bundle.getString("caption"),
+        cachePath = bundle.getString("cachePath"),
+        isCached = bundle.getBoolean("isCached", false),
+        cacheCreatedAt = if (bundle.containsKey("cacheCreatedAt")) bundle.getLong("cacheCreatedAt") else null,
+        cacheLastModified = if (bundle.containsKey("cacheLastModified")) bundle.getLong("cacheLastModified") else null,
+        originalUri = bundle.getString("originalUri"),
+        documentUri = bundle.getString("documentUri"),
+        previewAspectRatio = if (bundle.containsKey("previewAspectRatio")) bundle.getFloat("previewAspectRatio") else null,
+        rotatedToPortrait = bundle.getBoolean("rotatedToPortrait", false),
+        coverUri = bundle.getString("coverUri"),
+        captureContainerWidth = if (bundle.containsKey("captureContainerWidth")) bundle.getInt("captureContainerWidth") else null,
+        captureContainerHeight = if (bundle.containsKey("captureContainerHeight")) bundle.getInt("captureContainerHeight") else null,
+        sizeIsDisplayEstimate = bundle.getBoolean("sizeIsDisplayEstimate", false)
+      )
+    }
+
+    fun fromCacheMetadata(
+      metadata: MediaCacheManager.MediaCacheMetadata,
+      publishedUri: Uri? = null,
+      context: Context? = null
+    ): CameraAsset {
+      val uri = publishedUri ?: if (context != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        try {
+          androidx.core.content.FileProvider.getUriForFile(
+            context,
+            "${context.packageName}.camera.fileprovider",
+            File(metadata.cachePath)
+          )
+        } catch (e: Exception) {
+          Uri.fromFile(File(metadata.cachePath))
+        }
+      } else {
+        Uri.fromFile(File(metadata.cachePath))
+      }
+
+      return CameraAsset(
+        id = metadata.id,
+        uri = uri,
+        type = metadata.fileType,
+        fileName = metadata.fileName,
+        mimeType = metadata.mimeType,
+        width = metadata.width,
+        height = metadata.height,
+        duration = metadata.duration,
+        size = metadata.fileSize,
+        dateTaken = metadata.createdAt,
+        cachePath = metadata.cachePath,
+        isCached = true,
+        cacheCreatedAt = metadata.createdAt,
+        cacheLastModified = metadata.lastModified,
+        originalUri = metadata.originalUri,
+        documentUri = publishedUri?.toString(),
+        previewAspectRatio = null
+      )
+    }
+    fun fromCacheMediaResult(
+      result: MediaStorageWorkflow.CacheMediaResult,
+      fileType: String,
+      publishedUri: Uri? = null,
+      originalUri: String? = null,
+      context: Context? = null,
+      previewAspectRatio: Float? = null,
+      rotatedToPortrait: Boolean = false,
+      captureContainerWidth: Int? = null,
+      captureContainerHeight: Int? = null
+    ): CameraAsset {
+      val uri = publishedUri ?: if (context != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+        try {
+          androidx.core.content.FileProvider.getUriForFile(
+            context,
+            "${context.packageName}.camera.fileprovider",
+            File(result.cachePath)
+          )
+        } catch (e: Exception) {
+          Uri.fromFile(File(result.cachePath))
+        }
+      } else {
+        Uri.fromFile(File(result.cachePath))
+      }
+
+      return CameraAsset(
+        id = result.mediaId,
+        uri = uri,
+        type = fileType,
+        fileName = result.fileName,
+        mimeType = result.mimeType,
+        width = result.width,
+        height = result.height,
+        duration = result.duration,
+        size = result.fileSize,
+        dateTaken = System.currentTimeMillis(),
+        cachePath = result.cachePath,
+        isCached = true,
+        cacheCreatedAt = System.currentTimeMillis(),
+        cacheLastModified = System.currentTimeMillis(),
+        originalUri = originalUri,
+        documentUri = publishedUri?.toString(),
+        previewAspectRatio = previewAspectRatio,
+        rotatedToPortrait = rotatedToPortrait,
+        captureContainerWidth = captureContainerWidth,
+        captureContainerHeight = captureContainerHeight
+      )
+    }
+  }
+}