react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,494 @@
+package com.customcamera
+
+import android.content.Context
+import android.net.Uri
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * MediaMetadataStore manages persistent metadata for all media files.
+ * Stores and retrieves metadata about cached and published media.
+ *
+ * Features:
+ * - Persistent JSON-based storage
+ * - In-memory caching for fast access
+ * - Thread-safe operations
+ * - Fast queries for cached/published/duplicate media
+ * - Automatic backup and recovery
+ */
+class MediaMetadataStore private constructor(private val context: Context) {
+
+  companion object {
+    private const val TAG = "MediaMetadataStore"
+    private const val METADATA_FILE = "media_metadata.json"
+    private const val METADATA_BACKUP_FILE = "media_metadata_backup.json"
+
+    @Volatile
+    private var instance: MediaMetadataStore? = null
+
+    fun getInstance(context: Context): MediaMetadataStore {
+      return instance ?: synchronized(this) {
+        instance ?: MediaMetadataStore(context.applicationContext).also { instance = it }
+      }
+    }
+  }
+
+  private val metadataDir = File(context.filesDir, "metadata").apply { mkdirs() }
+  private val metadataFile = File(metadataDir, METADATA_FILE)
+  private val backupFile = File(metadataDir, METADATA_BACKUP_FILE)
+
+  // In-memory cache for fast access
+  private val metadataCache = ConcurrentHashMap<String, MediaStorageMetadata>()
+  private val hashIndex = ConcurrentHashMap<String, String>() // hash -> mediaId
+
+  /**
+   * Load metadata from disk
+   */
+  suspend fun loadMetadata() {
+    withContext(Dispatchers.IO) {
+      // Loading persisted metadata runs at app startup (via MediaStorageWorkflow.initialize).
+      // If it throws, the host app crashes on launch AND on every relaunch — a permanent
+      // "app won't open" state — because the same corrupt file is re-read each time. This
+      // path is therefore made total: it NEVER throws, NEVER recurses, and on unrecoverable
+      // corruption it discards the bad files and starts empty. `catch (Throwable)` is
+      // deliberate — a StackOverflowError/OutOfMemoryError from a huge/corrupt file is an
+      // Error (not an Exception) and would otherwise escape and crash the process.
+      try {
+        // 1) Try the main file. 2) Fall back to the backup exactly ONCE (no recursion).
+        //    3) If neither is usable, reset to empty and delete the corrupt files so the
+        //    next launch is clean.
+        if (parseMetadataFile(metadataFile)) return@withContext
+
+        if (backupFile.exists() && parseMetadataFile(backupFile)) {
+          // Promote the good backup back into the main file for next time.
+          runCatching { backupFile.copyTo(metadataFile, overwrite = true) }
+          Log.i(TAG, "Recovered metadata from backup")
+          return@withContext
+        }
+
+        // Both missing/corrupt — start clean and remove the bad files so we can't loop.
+        metadataCache.clear()
+        hashIndex.clear()
+        runCatching { if (metadataFile.exists()) metadataFile.delete() }
+        runCatching { if (backupFile.exists()) backupFile.delete() }
+        Log.w(TAG, "No usable metadata file; starting with empty metadata")
+      } catch (t: Throwable) {
+        // Absolute backstop: a corrupt persisted file must never crash startup.
+        Log.e(TAG, "Metadata load failed; starting with empty metadata", t)
+        metadataCache.clear()
+        hashIndex.clear()
+      }
+    }
+  }
+
+  /**
+   * Parse [file] into the in-memory cache. Returns true when the file existed and was
+   * parsed (individual malformed entries are skipped), or false when the file is missing,
+   * blank, or has corrupt top-level JSON. Never throws on a corrupt file (returns false),
+   * so callers can try the backup without any risk of mutual recursion.
+   */
+  private fun parseMetadataFile(file: File): Boolean {
+    if (!file.exists()) return false
+    val json = runCatching { file.readText() }.getOrNull() ?: return false
+    if (json.isBlank()) return false
+    val jsonArray = try {
+      JSONArray(json)
+    } catch (e: JSONException) {
+      Log.w(TAG, "Corrupt metadata file ${file.name}", e)
+      return false
+    }
+
+    metadataCache.clear()
+    hashIndex.clear()
+    var skipped = 0
+    for (i in 0 until jsonArray.length()) {
+      try {
+        val metadata = MediaStorageMetadata.fromJson(jsonArray.getJSONObject(i))
+        metadataCache[metadata.id] = metadata
+        if (metadata.fileHash != null) {
+          hashIndex[metadata.fileHash] = metadata.id
+        }
+      } catch (e: JSONException) {
+        skipped++
+        Log.w(TAG, "Skipping malformed metadata entry at index $i", e)
+      }
+    }
+    Log.i(TAG, "Loaded ${metadataCache.size} metadata entries from ${file.name} (skipped $skipped)")
+    return true
+  }
+
+  /**
+   * Add cached media metadata
+   */
+  suspend fun addCachedMedia(
+    id: String,
+    fileName: String,
+    cachePath: String,
+    fileType: String,
+    fileSize: Long,
+    width: Int? = null,
+    height: Int? = null,
+    duration: Long? = null,
+    mimeType: String? = null,
+    fileHash: String? = null
+  ) {
+    withContext(Dispatchers.IO) {
+      try {
+        val metadata = MediaStorageMetadata(
+          id = id,
+          fileName = fileName,
+          cachePath = cachePath,
+          fileType = fileType,
+          fileSize = fileSize,
+          width = width,
+          height = height,
+          duration = duration,
+          mimeType = mimeType,
+          fileHash = fileHash,
+          status = "cached",
+          cacheCreatedAt = System.currentTimeMillis(),
+          cacheLastModified = System.currentTimeMillis(),
+          isDuplicate = fileHash != null && hashIndex.containsKey(fileHash)
+        )
+
+        metadataCache[id] = metadata
+        if (fileHash != null) {
+          hashIndex[fileHash] = id
+        }
+        
+        saveMetadata()
+        Log.i(TAG, "Cached media added: $id")
+      } catch (e: Exception) {
+        Log.e(TAG, "Error adding cached media", e)
+      }
+    }
+  }
+
+  /**
+   * Update media status when published
+   */
+  suspend fun updateMediaStatus(
+    mediaId: String,
+    status: String,
+    publishedUri: String? = null,
+    publishedAt: Long? = null,
+    documentUri: String? = null
+  ) {
+    withContext(Dispatchers.IO) {
+      try {
+        val metadata = metadataCache[mediaId] ?: return@withContext
+        
+        val updated = metadata.copy(
+          status = status,
+          documentUri = documentUri ?: metadata.documentUri,
+          publishedAt = publishedAt ?: metadata.publishedAt,
+          cacheLastModified = System.currentTimeMillis()
+        )
+        
+        metadataCache[mediaId] = updated
+        saveMetadata()
+        Log.i(TAG, "Media status updated: $mediaId -> $status")
+      } catch (e: Exception) {
+        Log.e(TAG, "Error updating media status", e)
+      }
+    }
+  }
+
+  /**
+   * Get cached media (not yet published)
+   */
+  suspend fun getCachedMedia(): List<MediaStorageMetadata> {
+    return withContext(Dispatchers.IO) {
+      metadataCache.values.filter { it.status == "cached" }
+    }
+  }
+
+  /**
+   * Get published media
+   */
+  suspend fun getPublishedMedia(): List<MediaStorageMetadata> {
+    return withContext(Dispatchers.IO) {
+      metadataCache.values.filter { it.status == "published" }
+    }
+  }
+
+  /**
+   * Get all media
+   */
+  suspend fun getAllMedia(): List<MediaStorageMetadata> {
+    return withContext(Dispatchers.IO) {
+      metadataCache.values.toList()
+    }
+  }
+
+  /**
+   * Get media by ID
+   */
+  suspend fun getMediaMetadata(mediaId: String): MediaStorageMetadata? {
+    return withContext(Dispatchers.IO) {
+      metadataCache[mediaId]
+    }
+  }
+
+  /**
+   * Get media by file hash (for duplicate detection)
+   */
+  suspend fun getMediaByHash(fileHash: String): MediaStorageMetadata? {
+    return withContext(Dispatchers.IO) {
+      val mediaId = hashIndex[fileHash] ?: return@withContext null
+      metadataCache[mediaId]
+    }
+  }
+
+  /**
+   * Remove media from cache (after successful publish)
+   */
+  suspend fun removeFromCache(mediaId: String) {
+    withContext(Dispatchers.IO) {
+      try {
+        val metadata = metadataCache[mediaId] ?: return@withContext
+        
+        val updated = metadata.copy(
+          cachePath = null,
+          status = "published"
+        )
+        
+        metadataCache[mediaId] = updated
+        saveMetadata()
+        Log.i(TAG, "Media removed from cache: $mediaId")
+      } catch (e: Exception) {
+        Log.e(TAG, "Error removing media from cache", e)
+      }
+    }
+  }
+
+  /**
+   * Remove media completely
+   */
+  suspend fun removeMedia(mediaId: String) {
+    withContext(Dispatchers.IO) {
+      try {
+        val metadata = metadataCache.remove(mediaId)
+        if (metadata?.fileHash != null) {
+          hashIndex.remove(metadata.fileHash)
+        }
+        
+        saveMetadata()
+        Log.i(TAG, "Media removed: $mediaId")
+      } catch (e: Exception) {
+        Log.e(TAG, "Error removing media", e)
+      }
+    }
+  }
+
+  /**
+   * Get duplicate media
+   */
+  suspend fun getDuplicateMedia(): List<MediaStorageMetadata> {
+    return withContext(Dispatchers.IO) {
+      metadataCache.values.filter { it.isDuplicate == true }
+    }
+  }
+
+  /**
+   * Check if hash exists
+   */
+  suspend fun hashExists(fileHash: String): Boolean {
+    return withContext(Dispatchers.IO) {
+      hashIndex.containsKey(fileHash)
+    }
+  }
+
+  /**
+   * Save metadata to disk
+   */
+  private suspend fun saveMetadata() {
+    withContext(Dispatchers.IO) {
+      try {
+        val jsonArray = JSONArray()
+        metadataCache.values.forEach { metadata ->
+          jsonArray.put(metadata.toJson())
+        }
+        val payload = jsonArray.toString(2)
+
+        // ATOMIC write: serialize to a temp file, fsync-then-rename into place. writeText
+        // directly onto metadataFile is NOT atomic — a crash/kill mid-write leaves a
+        // truncated, unparseable file, which is the root cause of the "app won't reopen"
+        // startup crash. rename() is atomic on the same filesystem, so a reader always sees
+        // either the old complete file or the new complete file, never a partial one.
+        val tmpFile = File(metadataDir, "$METADATA_FILE.tmp")
+        tmpFile.writeText(payload)
+
+        // Keep the last known-good file as a backup before swapping the new one in.
+        if (metadataFile.exists()) {
+          runCatching { metadataFile.copyTo(backupFile, overwrite = true) }
+        }
+
+        if (!tmpFile.renameTo(metadataFile)) {
+          // renameTo can fail on some devices/filesystems; fall back to copy + delete.
+          tmpFile.copyTo(metadataFile, overwrite = true)
+          runCatching { tmpFile.delete() }
+        }
+        Log.i(TAG, "Metadata saved: ${metadataCache.size} entries")
+      } catch (e: Exception) {
+        Log.e(TAG, "Error saving metadata", e)
+      }
+    }
+  }
+
+  /**
+   * Clear all metadata (use with caution)
+   */
+  suspend fun clearAll() {
+    withContext(Dispatchers.IO) {
+      try {
+        metadataCache.clear()
+        hashIndex.clear()
+        metadataFile.delete()
+        backupFile.delete()
+        Log.w(TAG, "All metadata cleared")
+      } catch (e: Exception) {
+        Log.e(TAG, "Error clearing metadata", e)
+      }
+    }
+  }
+
+  /**
+   * Export metadata as JSON
+   */
+  suspend fun exportMetadata(): String {
+    return withContext(Dispatchers.IO) {
+      try {
+        val jsonArray = JSONArray()
+        metadataCache.values.forEach { metadata ->
+          jsonArray.put(metadata.toJson())
+        }
+        jsonArray.toString(2)
+      } catch (e: Exception) {
+        Log.e(TAG, "Error exporting metadata", e)
+        "{}"
+      }
+    }
+  }
+
+  /**
+   * Import metadata from JSON
+   */
+  suspend fun importMetadata(json: String) {
+    withContext(Dispatchers.IO) {
+      try {
+        metadataCache.clear()
+        hashIndex.clear()
+
+        val jsonArray = JSONArray(json)
+        for (i in 0 until jsonArray.length()) {
+          val metadata = MediaStorageMetadata.fromJson(jsonArray.getJSONObject(i))
+          metadataCache[metadata.id] = metadata
+          if (metadata.fileHash != null) {
+            hashIndex[metadata.fileHash] = metadata.id
+          }
+        }
+
+        saveMetadata()
+        Log.i(TAG, "Metadata imported: ${metadataCache.size} entries")
+      } catch (e: Exception) {
+        Log.e(TAG, "Error importing metadata", e)
+      }
+    }
+  }
+}
+
+/**
+ * Data class for storing media metadata
+ */
+data class MediaStorageMetadata(
+  val id: String,
+  val fileName: String,
+  val cachePath: String?,
+  val fileType: String, // "photo" or "video"
+  val fileSize: Long,
+  val width: Int?,
+  val height: Int?,
+  val duration: Long?,
+  val mimeType: String?,
+  val fileHash: String?,
+  val dateTaken: Long? = null,
+  val status: String, // "cached", "published", etc.
+  val cacheCreatedAt: Long,
+  val cacheLastModified: Long,
+  val publishedAt: Long? = null,
+  val documentUri: String? = null,
+  val isDuplicate: Boolean = false,
+  val duplicateOf: String? = null,
+  val caption: String? = null,
+  val isEdited: Boolean = false,
+  val originalUri: String? = null
+) {
+  fun toJson(): JSONObject {
+    return JSONObject().apply {
+      put("id", id)
+      put("fileName", fileName)
+      put("cachePath", cachePath)
+      put("fileType", fileType)
+      put("fileSize", fileSize)
+      put("width", width)
+      put("height", height)
+      put("duration", duration)
+      put("mimeType", mimeType)
+      put("fileHash", fileHash)
+      put("dateTaken", dateTaken)
+      put("status", status)
+      put("cacheCreatedAt", cacheCreatedAt)
+      put("cacheLastModified", cacheLastModified)
+      put("publishedAt", publishedAt)
+      put("documentUri", documentUri)
+      put("isDuplicate", isDuplicate)
+      put("duplicateOf", duplicateOf)
+      put("caption", caption)
+      put("isEdited", isEdited)
+      put("originalUri", originalUri)
+    }
+  }
+
+  companion object {
+    fun fromJson(json: JSONObject): MediaStorageMetadata {
+      // Use opt* accessors (not get*) for EVERY field. get* throws JSONException on a
+      // missing key; because loadMetadata() parses entries in a loop inside a single
+      // try/catch that falls back to the backup file, one malformed/partial entry (e.g.
+      // written by an older app version, or a half-flushed save) would otherwise abort the
+      // whole parse and silently discard the user's ENTIRE persisted media library on the
+      // next launch. Reading defensively lets every well-formed entry survive; required
+      // string fields fall back to safe defaults so a single odd row is tolerated, not fatal.
+      return MediaStorageMetadata(
+        id = json.optString("id", null).takeIf { !it.isNullOrEmpty() }
+          ?: throw JSONException("metadata entry missing id"),
+        fileName = json.optString("fileName", "").ifEmpty { "media_${json.optString("id")}" },
+        cachePath = json.optString("cachePath", null).takeIf { it.isNotEmpty() },
+        fileType = json.optString("fileType", "").ifEmpty { "photo" },
+        fileSize = json.optLong("fileSize", 0L),
+        width = json.optInt("width", -1).takeIf { it != -1 },
+        height = json.optInt("height", -1).takeIf { it != -1 },
+        duration = json.optLong("duration", -1).takeIf { it != -1L },
+        mimeType = json.optString("mimeType", null).takeIf { it.isNotEmpty() },
+        fileHash = json.optString("fileHash", null).takeIf { it.isNotEmpty() },
+        dateTaken = json.optLong("dateTaken", -1).takeIf { it != -1L },
+        status = json.optString("status", "").ifEmpty { "cached" },
+        cacheCreatedAt = json.optLong("cacheCreatedAt", 0L),
+        cacheLastModified = json.optLong("cacheLastModified", 0L),
+        publishedAt = json.optLong("publishedAt", -1).takeIf { it != -1L },
+        documentUri = json.optString("documentUri", null).takeIf { it.isNotEmpty() },
+        isDuplicate = json.optBoolean("isDuplicate", false),
+        duplicateOf = json.optString("duplicateOf", null).takeIf { it.isNotEmpty() },
+        caption = json.optString("caption", null).takeIf { it.isNotEmpty() },
+        isEdited = json.optBoolean("isEdited", false),
+        originalUri = json.optString("originalUri", null).takeIf { it.isNotEmpty() }
+      )
+    }
+  }
+}