react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,722 @@
+package com.customcamera
+
+import android.content.Context
+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.*
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * MediaStorageWorkflow orchestrates the complete media storage lifecycle:
+ * 1. Initial capture/selection -> Cache Directory
+ * 2. User confirms -> Move to Document Directory
+ * 3. Metadata persistence and tracking
+ * 4. Automatic cleanup of old cache files
+ *
+ * Thread-safe and optimized for responsive operation
+ */
+class MediaStorageWorkflow private constructor(private val context: Context) {
+
+  companion object {
+    private const val TAG = "MediaStorageWorkflow"
+    private const val MAX_RETRY_ATTEMPTS = 3
+
+    @Volatile
+    private var instance: MediaStorageWorkflow? = null
+
+    fun getInstance(context: Context): MediaStorageWorkflow {
+      return instance ?: synchronized(this) {
+        instance ?: MediaStorageWorkflow(context.applicationContext).also { instance = it }
+      }
+    }
+  }
+
+  private val cacheManager = MediaCacheManager.getInstance(context)
+  private val metadataStore = MediaMetadataStore.getInstance(context)
+  private val mediaPublisher = MediaPublisher.getInstance(context)
+  private val cleanupManager = CacheCleanupManager.getInstance(context)
+  private val coroutineScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+
+  private val activeTransfers = ConcurrentHashMap<String, TransferJob>()
+  private val failedTransfers = ConcurrentHashMap<String, FailedTransfer>()
+
+  /**
+   * Initialize the workflow - setup directories and load metadata
+   */
+  suspend fun initialize() {
+    withContext(Dispatchers.IO) {
+      // Runs at host-app startup. It must NEVER crash the app: catch Throwable (to also
+      // stop a StackOverflowError/OutOfMemoryError from persisted-state handling) and do
+      // NOT rethrow. Degrading to an empty/uninitialized store is always preferable to a
+      // launch crash — new captures and publishing still work regardless.
+      try {
+        ensureDirectoriesExist()
+        metadataStore.loadMetadata()
+        // Perform initial cleanup
+        cleanupManager.performCleanup()
+        Log.i(TAG, "Workflow initialized successfully")
+      } catch (t: Throwable) {
+        Log.e(TAG, "Failed to initialize workflow; continuing with degraded storage", t)
+      }
+    }
+  }
+
+  /**
+   * Start media capture workflow - save to cache initially
+   *
+   * @param allowMove set by capture paths whose [mediaUri] is a temp file they own and delete
+   *   immediately afterwards. It lets the file be moved into the cache rather than copied, which
+   *   for a long recording is the difference between an instant handoff and a full read+write
+   *   pass over hundreds of megabytes (plus the free space that second copy needs).
+   */
+  suspend fun startCaptureWorkflow(
+    mediaUri: Uri,
+    mediaType: String,
+    fileName: String? = null,
+    allowMove: Boolean = false
+  ): CacheMediaResult {
+    return withContext(Dispatchers.IO) {
+      try {
+        val cacheResult = cacheManager.cacheMediaForStorage(
+          uri = mediaUri,
+          fileType = mediaType,
+          fileName = fileName,
+          allowMove = allowMove
+        )
+
+        // Store metadata
+        if (cacheResult.isSuccess) {
+          metadataStore.addCachedMedia(
+            id = cacheResult.mediaId,
+            fileName = fileName ?: cacheResult.fileName,
+            cachePath = cacheResult.cachePath,
+            fileType = mediaType,
+            fileSize = cacheResult.fileSize,
+            width = cacheResult.width,
+            height = cacheResult.height,
+            duration = cacheResult.duration,
+            mimeType = cacheResult.mimeType,
+            fileHash = computeFileHash(File(cacheResult.cachePath))
+          )
+        }
+
+        cacheResult
+      } catch (e: Exception) {
+        Log.e(TAG, "Capture workflow failed", e)
+        CacheMediaResult(
+          isSuccess = false,
+          mediaId = "",
+          fileName = "",
+          cachePath = "",
+          error = e.message
+        )
+      }
+    }
+  }
+
+  /**
+   * Publish media to document directory (called when user sends media)
+   * Moves from cache to documents with metadata persistence
+   */
+  suspend fun publishMedia(
+    mediaId: String,
+    moveMode: Boolean = true // true = move, false = copy
+  ): PublishMediaResult {
+    return withContext(Dispatchers.IO) {
+      try {
+        // A recorded clip's aspect-crop re-encode now runs in the background after the editor opens
+        // (so the stop -> editor transition is instant — see CustomCameraActivity.scheduleBackgroundVideoCrop).
+        // If the user sends before that crop lands, wait for it here so the published file is the
+        // cropped clip, not the raw recording. No-op for images and any media without a pending crop.
+        PendingCaptureCrops.await(mediaId)
+
+        var metadata = metadataStore.getMediaMetadata(mediaId)
+          ?: return@withContext PublishMediaResult(
+            success = false,
+            mediaId = mediaId,
+            error = "Media metadata not found"
+          )
+
+        val cacheFile = File(metadata.cachePath)
+        if (!cacheFile.exists()) {
+          return@withContext PublishMediaResult(
+            success = false,
+            mediaId = mediaId,
+            error = "Cache file not found"
+          )
+        }
+
+        // Uniquify the published name when either (a) another tracked media already has these
+        // exact contents, or (b) something is already sitting at the target path.
+        //
+        // (b) is new, and it is what makes (a) safe to fix. isDuplicate used to match the media
+        // against ITS OWN signature — which is in the index from the moment it was cached — so it
+        // returned true for literally every publish and every file got a timestamp suffix. That
+        // masked the real collision question. Now (a) answers "same bytes, different media" and
+        // (b) independently guarantees a publish can never overwrite an unrelated file, which is
+        // the property the blanket rename was accidentally providing.
+        if (isDuplicate(cacheFile, metadata) ||
+          mediaPublisher.documentFileExists(metadata.fileName, metadata.fileType)
+        ) {
+          // Generate a unique file name by adding timestamp to avoid duplicates
+          val baseName = metadata.fileName
+          val lastDotIndex = baseName.lastIndexOf(".")
+          val extension = if (lastDotIndex >= 0) {
+            baseName.substring(lastDotIndex)
+          } else {
+            if (metadata.fileType == "video") ".mp4" else ".jpg"
+          }
+          val nameWithoutExtension = if (lastDotIndex >= 0) {
+            baseName.substring(0, lastDotIndex)
+          } else {
+            baseName
+          }
+          val timestamp = System.currentTimeMillis()
+          val uniqueFileName = "${nameWithoutExtension}_${timestamp}${extension}"
+
+          // Update metadata with unique file name
+          metadata = metadata.copy(fileName = uniqueFileName)
+          Log.i(TAG, "Handled duplicate file by generating unique name: $uniqueFileName")
+        }
+
+        // The signature was already computed when this media entered the cache, so hand it to the
+        // publisher instead of letting it read the whole file again. On a large clip that removes
+        // an entire redundant pass from the send path.
+        val knownHash = metadata.fileHash?.takeIf { it.isNotEmpty() }
+
+        val publishResult = if (moveMode) {
+          mediaPublisher.moveToDocuments(
+            sourceFile = cacheFile,
+            fileName = metadata.fileName,
+            mediaType = metadata.fileType,
+            metadata = metadata,
+            knownHash = knownHash
+          )
+        } else {
+          mediaPublisher.copyToDocuments(
+            sourceFile = cacheFile,
+            fileName = metadata.fileName,
+            mediaType = metadata.fileType,
+            metadata = metadata,
+            knownHash = knownHash
+          )
+        }
+
+        if (publishResult.success) {
+          // Update metadata with published info
+          metadataStore.updateMediaStatus(
+            mediaId = mediaId,
+            status = "published",
+            publishedUri = publishResult.targetUri,
+            publishedAt = System.currentTimeMillis(),
+            documentUri = publishResult.targetUri
+          )
+
+          // If move mode, remove from cache
+          if (moveMode) {
+            try {
+              cacheFile.delete()
+              metadataStore.removeFromCache(mediaId)
+            } catch (e: Exception) {
+              Log.w(TAG, "Failed to cleanup cache after publish", e)
+            }
+          }
+
+          Log.i(TAG, "Media $mediaId published successfully")
+        } else {
+          recordFailedTransfer(mediaId, publishResult.error ?: "Unknown error")
+        }
+
+        PublishMediaResult(
+          success = publishResult.success,
+          mediaId = mediaId,
+          targetUri = publishResult.targetUri,
+          fileHash = publishResult.fileHash,
+          error = publishResult.error
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "Publish workflow failed for media $mediaId", e)
+        recordFailedTransfer(mediaId, e.message ?: "Unknown error")
+        PublishMediaResult(
+          success = false,
+          mediaId = mediaId,
+          error = e.message
+        )
+      }
+    }
+  }
+
+  /**
+   * Publish media to the document directory starting from a known cache file.
+   *
+   * This guarantees a consistent lifecycle for BOTH images and videos even when
+   * an asset was never registered through [startCaptureWorkflow] (for example the
+   * video-capture fallback, which writes a raw temp file directly to the cache
+   * without metadata). If the media is not yet tracked, its cache file is
+   * registered here first; publishing then reuses [publishMedia] so the same
+   * move (cache -> documents), metadata update, and cache cleanup apply in every
+   * case — with correct path updates returned to the caller.
+   */
+  suspend fun publishMediaFile(
+    mediaId: String,
+    cachePath: String?,
+    fileName: String,
+    mediaType: String,
+    width: Int? = null,
+    height: Int? = null,
+    duration: Long? = null,
+    moveMode: Boolean = true
+  ): PublishMediaResult {
+    return withContext(Dispatchers.IO) {
+      try {
+        // Register the cache file so publishMedia can locate and move it when the
+        // asset is not already tracked in the metadata store.
+        if (metadataStore.getMediaMetadata(mediaId) == null) {
+          if (cachePath.isNullOrBlank()) {
+            return@withContext PublishMediaResult(
+              success = false,
+              mediaId = mediaId,
+              error = "Media metadata not found"
+            )
+          }
+          val cacheFile = File(cachePath)
+          if (!cacheFile.exists()) {
+            return@withContext PublishMediaResult(
+              success = false,
+              mediaId = mediaId,
+              error = "Cache file not found"
+            )
+          }
+          metadataStore.addCachedMedia(
+            id = mediaId,
+            fileName = if (fileName.isNotBlank()) fileName else cacheFile.name,
+            cachePath = cachePath,
+            fileType = mediaType,
+            fileSize = cacheFile.length(),
+            width = width,
+            height = height,
+            duration = duration,
+            // Read the container off the file being registered rather than assuming JPEG for
+            // every image, so a .gif published through this path is tracked as image/gif.
+            mimeType = MediaCacheManager.MediaFormat.ofFile(cacheFile, mediaType).mimeType,
+            fileHash = computeFileHash(cacheFile)
+          )
+        }
+
+        publishMedia(mediaId, moveMode)
+      } catch (e: Exception) {
+        Log.e(TAG, "publishMediaFile failed for media $mediaId", e)
+        recordFailedTransfer(mediaId, e.message ?: "Unknown error")
+        PublishMediaResult(
+          success = false,
+          mediaId = mediaId,
+          error = e.message
+        )
+      }
+    }
+  }
+
+  /**
+   * Publish multiple media files in batch (optimized for performance)
+   */
+  suspend fun publishBatch(
+    mediaIds: List<String>,
+    moveMode: Boolean = true
+  ): BatchPublishResult {
+    return withContext(Dispatchers.IO) {
+      try {
+        val results = mutableListOf<PublishMediaResult>()
+        var successCount = 0
+        var failureCount = 0
+
+        mediaIds.forEach { mediaId ->
+          val result = publishMedia(mediaId, moveMode)
+          results.add(result)
+          if (result.success) successCount++ else failureCount++
+        }
+
+        BatchPublishResult(
+          totalCount = mediaIds.size,
+          successCount = successCount,
+          failureCount = failureCount,
+          results = results,
+          timestamp = System.currentTimeMillis()
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "Batch publish failed", e)
+        BatchPublishResult(
+          totalCount = mediaIds.size,
+          successCount = 0,
+          failureCount = mediaIds.size,
+          results = emptyList(),
+          error = e.message,
+          timestamp = System.currentTimeMillis()
+        )
+      }
+    }
+  }
+
+  /**
+   * Get all cached media that hasn't been published yet
+   */
+  suspend fun getCachedMedia(): List<MediaStorageMetadata> {
+    return withContext(Dispatchers.IO) {
+      try {
+        metadataStore.getCachedMedia()
+      } catch (e: Exception) {
+        Log.e(TAG, "Failed to get cached media", e)
+        emptyList()
+      }
+    }
+  }
+
+  /**
+   * Get all published media
+   */
+  suspend fun getPublishedMedia(): List<MediaStorageMetadata> {
+    return withContext(Dispatchers.IO) {
+      try {
+        metadataStore.getPublishedMedia()
+      } catch (e: Exception) {
+        Log.e(TAG, "Failed to get published media", e)
+        emptyList()
+      }
+    }
+  }
+
+  /**
+   * Get storage statistics
+   */
+  suspend fun getStorageStats(): StorageStats {
+    return withContext(Dispatchers.IO) {
+      try {
+        val cacheDir = getCacheDir()
+        val documentDir = getDocumentDir()
+
+        val cacheUsedMB = cacheDir.totalSize() / (1024 * 1024)
+        val documentUsedMB = documentDir.totalSize() / (1024 * 1024)
+        val totalAvailableMB = getAvailableStorageMB()
+
+        val cachedItems = metadataStore.getCachedMedia()
+        val publishedItems = metadataStore.getPublishedMedia()
+        val duplicates = cachedItems.filter { it.isDuplicate == true }
+
+        val oldestAge = cachedItems.minOfOrNull { System.currentTimeMillis() - it.cacheCreatedAt } ?: 0
+        val newestAge = cachedItems.maxOfOrNull { System.currentTimeMillis() - it.cacheCreatedAt } ?: 0
+
+        StorageStats(
+          cacheUsedMB = cacheUsedMB,
+          documentUsedMB = documentUsedMB,
+          totalAvailableMB = totalAvailableMB,
+          cachedItemsCount = cachedItems.size,
+          publishedItemsCount = publishedItems.size,
+          duplicateItemsCount = duplicates.size,
+          oldestCacheItemAge = oldestAge,
+          newestCacheItemAge = newestAge
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "Failed to get storage stats", e)
+        StorageStats(
+          cacheUsedMB = 0,
+          documentUsedMB = 0,
+          totalAvailableMB = 0,
+          cachedItemsCount = 0,
+          publishedItemsCount = 0,
+          duplicateItemsCount = 0,
+          oldestCacheItemAge = 0,
+          newestCacheItemAge = 0
+        )
+      }
+    }
+  }
+
+  /**
+   * Cleanup old cache files
+   */
+  suspend fun cleanupOldCache(olderThanDays: Double = 7.0): CleanupOperationResult {
+    return withContext(Dispatchers.IO) {
+      try {
+        val days = olderThanDays.toInt().coerceAtLeast(0)
+        val result = cleanupManager.cleanupOldFiles(days)
+        Log.i(TAG, "Cleanup completed: ${result.filesRemoved} files removed, ${result.spaceFreedMB}MB freed")
+        CleanupOperationResult(
+          success = result.success,
+          filesRemoved = result.filesRemoved,
+          spaceFreedMB = result.spaceFreedMB,
+          error = result.error
+        )
+      } catch (e: Exception) {
+        Log.e(TAG, "Cleanup failed", e)
+        CleanupOperationResult(
+          success = false,
+          filesRemoved = 0,
+          spaceFreedMB = 0.0,
+          error = e.message
+        )
+      }
+    }
+  }
+
+  /**
+   * Securely delete a specific media (from cache or document).
+   *
+   * The file's bytes are overwritten with encrypted CSPRNG garbage and flushed to storage before
+   * it is unlinked, and every cached copy / derived variant / metadata reference for the id is
+   * swept — see [SecureMediaDeleter]. A plain `File.delete()` here would only detach the name,
+   * leaving the media recoverable from the raw partition.
+   *
+   * Returns true only when the file is actually gone. A file that was deleted but could NOT be
+   * securely overwritten returns true (it IS deleted) and logs the shortfall at ERROR — callers
+   * needing the security verdict should go through `CustomCameraModule.secureDeleteMedia`, which
+   * surfaces the full report instead of collapsing it.
+   */
+  suspend fun deleteMedia(mediaId: String): Boolean {
+    return withContext(Dispatchers.IO) {
+      try {
+        val metadata = metadataStore.getMediaMetadata(mediaId) ?: return@withContext false
+
+        // Prefer the published document as the primary, and hand the cache path over as an extra
+        // copy: a published item usually STILL has its cache file, and each of the two is a
+        // complete copy of the media, so erasing only one leaves the other recoverable.
+        val primaryUri = metadata.documentUri ?: metadata.cachePath
+          ?: return@withContext false
+        val extraUris = listOfNotNull(
+          metadata.cachePath?.takeIf { it != primaryUri }
+        )
+
+        val report = SecureMediaDeleter.secureDelete(
+          context = context,
+          uriString = primaryUri,
+          assetId = mediaId,
+          fileName = metadata.fileName,
+          extraUris = extraUris
+        )
+
+        if (!report.fullySecure) {
+          Log.e(
+            TAG,
+            "Media $mediaId was not securely erased — deleted=${report.deleted}, " +
+              "overwritten=${report.securelyOverwritten}, " +
+              "derivedFailures=${report.derivedFilesFailed}, error=${report.error ?: "none"}"
+          )
+        }
+
+        // secureDelete already clears this id's metadata; the explicit call covers the case where
+        // the record exists but its file did not, so a dangling entry cannot survive a delete.
+        if (report.deleted) {
+          metadataStore.removeMedia(mediaId)
+        }
+
+        report.deleted
+      } catch (e: Exception) {
+        Log.e(TAG, "Failed to delete media $mediaId", e)
+        false
+      }
+    }
+  }
+
+  /**
+   * Check if a file is a duplicate.
+   *
+   * Reuses the signature recorded when the media was cached rather than reading the file again.
+   * Publishing a long recording used to compute a whole-file SHA-256 here and then a second one
+   * inside the publisher, on top of the one already taken at capture — three full passes over the
+   * same gigabyte to answer one equality question. Only media that somehow reached this point
+   * without a signature pays for computing one.
+   *
+   * [metadataStore.getMediaByHash] resolves a hash back to its own entry, so a match against THIS
+   * media is not a duplicate; only a different id is.
+   */
+  private suspend fun isDuplicate(file: File, metadata: MediaStorageMetadata): Boolean {
+    return withContext(Dispatchers.IO) {
+      try {
+        val fileHash = metadata.fileHash?.takeIf { it.isNotEmpty() } ?: computeFileHash(file)
+        if (fileHash.isEmpty()) return@withContext false
+        val existingMedia = metadataStore.getMediaByHash(fileHash)
+        existingMedia != null && existingMedia.id != metadata.id
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to check for duplicates", e)
+        false
+      }
+    }
+  }
+
+  /**
+   * Content signature used for duplicate detection.
+   *
+   * Bounded for large files — see [MediaFileIo.contentSignature] for why a video is not hashed in
+   * full and why that is safe for de-duplication.
+   */
+  private fun computeFileHash(file: File): String = MediaFileIo.contentSignature(file)
+
+  /**
+   * Record a failed transfer for retry
+   */
+  private fun recordFailedTransfer(mediaId: String, error: String) {
+    failedTransfers[mediaId] = FailedTransfer(
+      mediaId = mediaId,
+      error = error,
+      failedAt = System.currentTimeMillis(),
+      retryCount = (failedTransfers[mediaId]?.retryCount ?: 0) + 1
+    )
+  }
+
+  /**
+   * Get failed transfers
+   */
+  suspend fun getFailedTransfers(): List<FailedTransfer> {
+    return withContext(Dispatchers.IO) {
+      failedTransfers.values.toList()
+    }
+  }
+
+  /**
+   * Retry failed transfers
+   */
+  suspend fun retryFailedTransfers(): List<PublishMediaResult> {
+    return withContext(Dispatchers.IO) {
+      val results = mutableListOf<PublishMediaResult>()
+      val failed = failedTransfers.keys.toList()
+
+      failed.forEach { mediaId ->
+        if (failedTransfers[mediaId]?.retryCount ?: 0 < MAX_RETRY_ATTEMPTS) {
+          try {
+            val result = publishMedia(mediaId, moveMode = true)
+            results.add(result)
+            if (result.success) {
+              failedTransfers.remove(mediaId)
+            }
+          } catch (e: Exception) {
+            Log.w(TAG, "Retry failed for $mediaId", e)
+          }
+        }
+      }
+      results
+    }
+  }
+
+  /**
+   * Ensure all required directories exist
+   */
+  private fun ensureDirectoriesExist() {
+    getCacheDir().mkdirs()
+    getDocumentDir().mkdirs()
+  }
+
+  /**
+   * Get cache directory
+   */
+  private fun getCacheDir(): File {
+    return File(context.cacheDir, "media_cache").apply { mkdirs() }
+  }
+
+  /**
+   * Get document directory
+   */
+  private fun getDocumentDir(): File {
+    return File(
+      context.getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS),
+      "media_documents"
+    ).apply { mkdirs() }
+  }
+
+  /**
+   * Get available storage in MB
+   */
+  private fun getAvailableStorageMB(): Long {
+    return try {
+      val stat = android.os.StatFs(Environment.getDataDirectory().absolutePath)
+      stat.availableBlocksLong * stat.blockSizeLong / (1024 * 1024)
+    } catch (e: Exception) {
+      0
+    }
+  }
+
+  /**
+   * Cleanup and shutdown
+   */
+  fun shutdown() {
+    coroutineScope.cancel()
+  }
+
+  data class CacheMediaResult(
+    val isSuccess: Boolean,
+    val mediaId: String,
+    val fileName: String,
+    val cachePath: String,
+    val fileSize: Long = 0,
+    val width: Int? = null,
+    val height: Int? = null,
+    val duration: Long? = null,
+    val mimeType: String? = null,
+    val error: String? = null
+  )
+
+  data class PublishMediaResult(
+    val success: Boolean,
+    val mediaId: String,
+    val targetUri: String? = null,
+    val fileHash: String? = null,
+    val error: String? = null,
+    val isDuplicate: Boolean = false
+  )
+
+  data class BatchPublishResult(
+    val totalCount: Int,
+    val successCount: Int,
+    val failureCount: Int,
+    val results: List<PublishMediaResult>,
+    val error: String? = null,
+    val timestamp: Long
+  )
+
+  data class FailedTransfer(
+    val mediaId: String,
+    val error: String,
+    val failedAt: Long,
+    val retryCount: Int
+  )
+
+  data class TransferJob(
+    val mediaId: String,
+    val status: String, // "pending", "in_progress", "completed", "failed"
+    val progress: Float = 0f,
+    val startedAt: Long = System.currentTimeMillis(),
+    val error: String? = null
+  )
+
+  data class StorageStats(
+    val cacheUsedMB: Long,
+    val documentUsedMB: Long,
+    val totalAvailableMB: Long,
+    val cachedItemsCount: Int,
+    val publishedItemsCount: Int,
+    val duplicateItemsCount: Int,
+    val oldestCacheItemAge: Long,
+    val newestCacheItemAge: Long
+  )
+
+  data class CleanupOperationResult(
+    val success: Boolean,
+    val filesRemoved: Int,
+    val spaceFreedMB: Double,
+    val error: String? = null,
+    val timestamp: Long = System.currentTimeMillis()
+  )
+
+}
+
+private fun File.totalSize(): Long {
+  return if (isDirectory) {
+    listFiles()?.sumOf { it.totalSize() } ?: 0L
+  } else {
+    length()
+  }
+}