react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,504 @@
+package com.customcamera
+
+import android.content.ContentValues
+import android.content.Context
+import android.util.Log
+import java.io.File
+
+/**
+ * One persisted compression: the on-disk output path plus every fact the request asks to record
+ * about the source and the encode. No video bytes live here — the file stays on disk under
+ * [CompressionCacheStore.outputDir]; this is only its index row.
+ *
+ * Identity is [sourceFingerprint] (a streaming content hash of the ORIGINAL clip, never its size)
+ * paired with [settingsSignature] (every knob that changes the encode), so the same content
+ * compressed with the same settings — even a brand-new asset with identical bytes after an app
+ * restart — resolves to the same row.
+ */
+data class CompressionCacheEntry(
+  val sourceFingerprint: String,
+  val settingsSignature: String,
+  val sourceSize: Long,
+  val sourceDurationMs: Long?,
+  val sourceWidth: Int?,
+  val sourceHeight: Int?,
+  val sourceFrameRate: Int?,
+  val sourceCodec: String?,
+  val compressionPercent: Int,
+  val profileName: String,
+  val bitrateScale: Float?,
+  val maxEncodedEdge: Int?,
+  val preferHevc: Boolean?,
+  val outputPath: String,
+  val outputSize: Long?,
+  val outputCodec: String?,
+  val createdAt: Long
+)
+
+/**
+ * The persistent compression index, abstracted from its storage so the composition rules can be
+ * unit-tested against an in-memory fake ([InMemoryCompressionCacheIndex]) without the SQLCipher
+ * native libraries, while production uses [SqlCipherCompressionCacheIndex].
+ *
+ * A lookup only ever returns an entry whose output file still exists on disk; a row whose file has
+ * gone (eviction, external cleanup) is dropped and reported as a miss, so a hit always means a
+ * reusable file is really there.
+ */
+interface CompressionCacheIndex {
+  /** The entry for this content+settings whose file still exists, or null (evicting a dead row). */
+  fun lookup(sourceFingerprint: String, settingsSignature: String): CompressionCacheEntry?
+
+  /** Insert or replace the row for [entry]'s (fingerprint, settings) key. */
+  fun put(entry: CompressionCacheEntry)
+
+  /** Drop every row (and delete every output file) built from [sourceFingerprint]. */
+  fun deleteByFingerprint(sourceFingerprint: String)
+
+  /** Drop the row pointing at [outputPath] (and delete that file). */
+  fun deleteByOutputPath(outputPath: String)
+
+  /** Drop rows whose output file no longer exists. */
+  fun pruneMissingFiles()
+
+  /** Age-prune (older than [maxAgeMs]) then size-prune to [maxTotalBytes], deleting evicted files. */
+  fun enforceLimits(maxTotalBytes: Long, maxAgeMs: Long)
+}
+
+/** The pure, storage-independent key composition. Tested directly. */
+object CompressionCacheKeys {
+  /**
+   * Bumped whenever [VideoRotationTranscoder.compress] changes what it PRODUCES for the same inputs,
+   * so outputs written by an older encoder are never served after an upgrade. Folded into the
+   * signature below, it makes every prior row a miss without touching its other components. Bumped
+   * to 2 for the "best quality per size" encode (full resolution kept, high-quality profile + VBR,
+   * raised quality floor) — files cached by the old downscaling encoder must not be reused. Bumped to
+   * 3 for the bits-per-pixel QUALITY FLOOR ([VideoRotationTranscoder.qualityFloorBitRate]): the heavy
+   * levels now encode at a higher rate than they used to, so a version-2 row for the same level holds
+   * a visibly worse file than the one that would be produced today.
+   */
+  private const val ENCODER_BEHAVIOR_VERSION = 3
+
+  /**
+   * Everything that changes the encode, folded into one string: the encoder-behaviour version, the
+   * level, the profile, and the three plan knobs that alter the OUTPUT ([bitrateScale],
+   * [maxEncodedEdge], [preferHevc]). A different device/profile produces a different signature, so
+   * an incompatible output is never reused. Deliberately excludes threading hints (priority/operating
+   * rate) — they change speed, not the resulting file.
+   */
+  fun settingsSignature(
+    percent: Int,
+    profileName: String,
+    bitrateScale: Float,
+    maxEncodedEdge: Int,
+    preferHevc: Boolean
+  ): String =
+    "enc=$ENCODER_BEHAVIOR_VERSION|p=$percent|profile=$profileName|bs=$bitrateScale|edge=$maxEncodedEdge|hevc=$preferHevc"
+}
+
+/**
+ * A storage-independent [CompressionCacheIndex] backed by a plain map. It applies EXACTLY the same
+ * lookup/eviction rules as the SQLCipher implementation, so a unit test can lock those rules down
+ * without the native SQLCipher libraries (which a bare JVM cannot load). File existence is checked
+ * with real [File.exists] calls, so a test drives "file went missing" by deleting a temp file.
+ */
+class InMemoryCompressionCacheIndex : CompressionCacheIndex {
+  private val rows = LinkedHashMap<String, CompressionCacheEntry>()
+
+  private fun keyOf(fingerprint: String, signature: String) = "$fingerprint@$signature"
+
+  override fun lookup(sourceFingerprint: String, settingsSignature: String): CompressionCacheEntry? {
+    val key = keyOf(sourceFingerprint, settingsSignature)
+    val entry = rows[key] ?: return null
+    if (!File(entry.outputPath).exists()) {
+      rows.remove(key)
+      return null
+    }
+    return entry
+  }
+
+  override fun put(entry: CompressionCacheEntry) {
+    rows[keyOf(entry.sourceFingerprint, entry.settingsSignature)] = entry
+  }
+
+  override fun deleteByFingerprint(sourceFingerprint: String) {
+    val gone = rows.values.filter { it.sourceFingerprint == sourceFingerprint }
+    gone.forEach { deleteFile(it.outputPath); rows.remove(keyOf(it.sourceFingerprint, it.settingsSignature)) }
+  }
+
+  override fun deleteByOutputPath(outputPath: String) {
+    val gone = rows.values.filter { it.outputPath == outputPath }
+    gone.forEach { deleteFile(it.outputPath); rows.remove(keyOf(it.sourceFingerprint, it.settingsSignature)) }
+  }
+
+  override fun pruneMissingFiles() {
+    rows.values.filter { !File(it.outputPath).exists() }
+      .forEach { rows.remove(keyOf(it.sourceFingerprint, it.settingsSignature)) }
+  }
+
+  override fun enforceLimits(maxTotalBytes: Long, maxAgeMs: Long) {
+    val now = System.currentTimeMillis()
+    // Age prune first…
+    rows.values.filter { now - it.createdAt > maxAgeMs }
+      .forEach { deleteFile(it.outputPath); rows.remove(keyOf(it.sourceFingerprint, it.settingsSignature)) }
+    // …then size prune, oldest first, until the total output footprint is under the cap.
+    var total = rows.values.sumOf { it.outputSize ?: 0L }
+    if (total <= maxTotalBytes) return
+    val oldestFirst = rows.values.sortedBy { it.createdAt }
+    for (entry in oldestFirst) {
+      if (total <= maxTotalBytes) break
+      deleteFile(entry.outputPath)
+      rows.remove(keyOf(entry.sourceFingerprint, entry.settingsSignature))
+      total -= entry.outputSize ?: 0L
+    }
+  }
+
+  private fun deleteFile(path: String) {
+    runCatching { File(path).takeIf { it.exists() }?.delete() }
+  }
+}
+
+/**
+ * The production [CompressionCacheIndex]: a SQLCipher-encrypted `video_compression_cache` table in
+ * its own `compression_cache.db`, opened with the Keystore-sealed passphrase. Every method is
+ * wrapped so a storage error degrades to "cache miss / no-op" rather than failing a compression —
+ * the cache is an optimisation, never a dependency.
+ *
+ * The output files themselves live on disk (no BLOBs); this only stores their paths + metadata.
+ */
+class SqlCipherCompressionCacheIndex(
+  context: Context,
+  passphrase: String
+) : CompressionCacheIndex {
+
+  private val helper = OpenHelper(context.applicationContext)
+  private val db: net.sqlcipher.database.SQLiteDatabase = helper.getWritableDatabase(passphrase)
+
+  override fun lookup(sourceFingerprint: String, settingsSignature: String): CompressionCacheEntry? {
+    return runCatching {
+      synchronized(db) {
+        db.query(
+          TABLE, null,
+          "$COL_FINGERPRINT = ? AND $COL_SIGNATURE = ?",
+          arrayOf(sourceFingerprint, settingsSignature),
+          null, null, null
+        ).use { cursor ->
+          if (!cursor.moveToFirst()) return@runCatching null
+          val entry = readEntry(cursor)
+          if (!File(entry.outputPath).exists()) {
+            db.delete(
+              TABLE, "$COL_FINGERPRINT = ? AND $COL_SIGNATURE = ?",
+              arrayOf(sourceFingerprint, settingsSignature)
+            )
+            return@runCatching null
+          }
+          entry
+        }
+      }
+    }.getOrElse {
+      Log.w(TAG, "Compression cache lookup failed", it)
+      null
+    }
+  }
+
+  override fun put(entry: CompressionCacheEntry) {
+    runCatching {
+      val values = ContentValues().apply {
+        put(COL_FINGERPRINT, entry.sourceFingerprint)
+        put(COL_SIGNATURE, entry.settingsSignature)
+        put(COL_SOURCE_SIZE, entry.sourceSize)
+        putOrNull(COL_SOURCE_DURATION, entry.sourceDurationMs)
+        putOrNull(COL_SOURCE_WIDTH, entry.sourceWidth)
+        putOrNull(COL_SOURCE_HEIGHT, entry.sourceHeight)
+        putOrNull(COL_SOURCE_FRAME_RATE, entry.sourceFrameRate)
+        put(COL_SOURCE_CODEC, entry.sourceCodec)
+        put(COL_PERCENT, entry.compressionPercent)
+        put(COL_PROFILE, entry.profileName)
+        putOrNull(COL_BITRATE_SCALE, entry.bitrateScale)
+        putOrNull(COL_MAX_EDGE, entry.maxEncodedEdge)
+        putOrNull(COL_PREFER_HEVC, entry.preferHevc?.let { if (it) 1 else 0 })
+        put(COL_OUTPUT_PATH, entry.outputPath)
+        putOrNull(COL_OUTPUT_SIZE, entry.outputSize)
+        put(COL_OUTPUT_CODEC, entry.outputCodec)
+        put(COL_CREATED_AT, entry.createdAt)
+      }
+      synchronized(db) {
+        db.insertWithOnConflict(
+          TABLE, null, values, net.sqlcipher.database.SQLiteDatabase.CONFLICT_REPLACE
+        )
+      }
+    }.onFailure { Log.w(TAG, "Compression cache put failed", it) }
+  }
+
+  override fun deleteByFingerprint(sourceFingerprint: String) {
+    runCatching {
+      synchronized(db) {
+        collectPaths("$COL_FINGERPRINT = ?", arrayOf(sourceFingerprint)).forEach(::deleteFile)
+        db.delete(TABLE, "$COL_FINGERPRINT = ?", arrayOf(sourceFingerprint))
+      }
+    }.onFailure { Log.w(TAG, "Compression cache deleteByFingerprint failed", it) }
+  }
+
+  override fun deleteByOutputPath(outputPath: String) {
+    runCatching {
+      synchronized(db) {
+        deleteFile(outputPath)
+        db.delete(TABLE, "$COL_OUTPUT_PATH = ?", arrayOf(outputPath))
+      }
+    }.onFailure { Log.w(TAG, "Compression cache deleteByOutputPath failed", it) }
+  }
+
+  override fun pruneMissingFiles() {
+    runCatching {
+      synchronized(db) {
+        collectPaths(null, null).filter { !File(it).exists() }.forEach { path ->
+          db.delete(TABLE, "$COL_OUTPUT_PATH = ?", arrayOf(path))
+        }
+      }
+    }.onFailure { Log.w(TAG, "Compression cache pruneMissingFiles failed", it) }
+  }
+
+  override fun enforceLimits(maxTotalBytes: Long, maxAgeMs: Long) {
+    runCatching {
+      synchronized(db) {
+        // Age prune: delete files then rows older than the cutoff.
+        val cutoff = System.currentTimeMillis() - maxAgeMs
+        collectPaths("$COL_CREATED_AT < ?", arrayOf(cutoff.toString())).forEach(::deleteFile)
+        db.delete(TABLE, "$COL_CREATED_AT < ?", arrayOf(cutoff.toString()))
+
+        // Size prune: walk oldest-first, deleting until the total output footprint fits the cap.
+        var total = db.rawQuery("SELECT COALESCE(SUM($COL_OUTPUT_SIZE), 0) FROM $TABLE", null)
+          .use { if (it.moveToFirst()) it.getLong(0) else 0L }
+        if (total <= maxTotalBytes) return@synchronized
+        db.query(
+          TABLE, arrayOf(COL_OUTPUT_PATH, COL_OUTPUT_SIZE),
+          null, null, null, null, "$COL_CREATED_AT ASC"
+        ).use { cursor ->
+          while (cursor.moveToNext() && total > maxTotalBytes) {
+            val path = cursor.getString(0)
+            val size = if (cursor.isNull(1)) 0L else cursor.getLong(1)
+            deleteFile(path)
+            db.delete(TABLE, "$COL_OUTPUT_PATH = ?", arrayOf(path))
+            total -= size
+          }
+        }
+      }
+    }.onFailure { Log.w(TAG, "Compression cache enforceLimits failed", it) }
+  }
+
+  /** Close the underlying database (used when the whole cache is being cleared). */
+  fun close() {
+    runCatching { synchronized(db) { db.close() } }
+  }
+
+  private fun collectPaths(where: String?, args: Array<String>?): List<String> {
+    val paths = ArrayList<String>()
+    db.query(TABLE, arrayOf(COL_OUTPUT_PATH), where, args, null, null, null).use { cursor ->
+      while (cursor.moveToNext()) paths.add(cursor.getString(0))
+    }
+    return paths
+  }
+
+  private fun deleteFile(path: String) {
+    runCatching { File(path).takeIf { it.exists() }?.delete() }
+  }
+
+  private fun readEntry(c: android.database.Cursor): CompressionCacheEntry = CompressionCacheEntry(
+    sourceFingerprint = c.getString(c.getColumnIndexOrThrow(COL_FINGERPRINT)),
+    settingsSignature = c.getString(c.getColumnIndexOrThrow(COL_SIGNATURE)),
+    sourceSize = c.getLong(c.getColumnIndexOrThrow(COL_SOURCE_SIZE)),
+    sourceDurationMs = c.longOrNull(COL_SOURCE_DURATION),
+    sourceWidth = c.intOrNull(COL_SOURCE_WIDTH),
+    sourceHeight = c.intOrNull(COL_SOURCE_HEIGHT),
+    sourceFrameRate = c.intOrNull(COL_SOURCE_FRAME_RATE),
+    sourceCodec = c.stringOrNull(COL_SOURCE_CODEC),
+    compressionPercent = c.getInt(c.getColumnIndexOrThrow(COL_PERCENT)),
+    profileName = c.getString(c.getColumnIndexOrThrow(COL_PROFILE)),
+    bitrateScale = c.floatOrNull(COL_BITRATE_SCALE),
+    maxEncodedEdge = c.intOrNull(COL_MAX_EDGE),
+    preferHevc = c.intOrNull(COL_PREFER_HEVC)?.let { it != 0 },
+    outputPath = c.getString(c.getColumnIndexOrThrow(COL_OUTPUT_PATH)),
+    outputSize = c.longOrNull(COL_OUTPUT_SIZE),
+    outputCodec = c.stringOrNull(COL_OUTPUT_CODEC),
+    createdAt = c.getLong(c.getColumnIndexOrThrow(COL_CREATED_AT))
+  )
+
+  private class OpenHelper(context: Context) : net.sqlcipher.database.SQLiteOpenHelper(
+    context, DB_NAME, null, DB_VERSION
+  ) {
+    override fun onCreate(db: net.sqlcipher.database.SQLiteDatabase) {
+      db.execSQL(CREATE_TABLE)
+      db.execSQL(CREATE_INDEX_CREATED_AT)
+      db.execSQL(CREATE_INDEX_FINGERPRINT)
+    }
+
+    override fun onUpgrade(db: net.sqlcipher.database.SQLiteDatabase, oldVersion: Int, newVersion: Int) {
+      // The table is a pure cache — nothing here is authoritative — so a schema bump can safely
+      // rebuild it. The output files it points at are cleaned up by the disk-side prune.
+      db.execSQL("DROP TABLE IF EXISTS $TABLE")
+      onCreate(db)
+    }
+  }
+
+  companion object {
+    private const val DB_NAME = "compression_cache.db"
+    private const val DB_VERSION = 1
+    private const val TABLE = "video_compression_cache"
+
+    private const val COL_FINGERPRINT = "source_fingerprint"
+    private const val COL_SIGNATURE = "settings_signature"
+    private const val COL_SOURCE_SIZE = "source_size"
+    private const val COL_SOURCE_DURATION = "source_duration_ms"
+    private const val COL_SOURCE_WIDTH = "source_width"
+    private const val COL_SOURCE_HEIGHT = "source_height"
+    private const val COL_SOURCE_FRAME_RATE = "source_frame_rate"
+    private const val COL_SOURCE_CODEC = "source_codec"
+    private const val COL_PERCENT = "compression_percent"
+    private const val COL_PROFILE = "profile_name"
+    private const val COL_BITRATE_SCALE = "bitrate_scale"
+    private const val COL_MAX_EDGE = "max_encoded_edge"
+    private const val COL_PREFER_HEVC = "prefer_hevc"
+    private const val COL_OUTPUT_PATH = "output_path"
+    private const val COL_OUTPUT_SIZE = "output_size"
+    private const val COL_OUTPUT_CODEC = "output_codec"
+    private const val COL_CREATED_AT = "created_at"
+
+    private val CREATE_TABLE = """
+      CREATE TABLE IF NOT EXISTS $TABLE (
+        $COL_FINGERPRINT TEXT NOT NULL,
+        $COL_SIGNATURE TEXT NOT NULL,
+        $COL_SOURCE_SIZE INTEGER NOT NULL,
+        $COL_SOURCE_DURATION INTEGER,
+        $COL_SOURCE_WIDTH INTEGER,
+        $COL_SOURCE_HEIGHT INTEGER,
+        $COL_SOURCE_FRAME_RATE INTEGER,
+        $COL_SOURCE_CODEC TEXT,
+        $COL_PERCENT INTEGER NOT NULL,
+        $COL_PROFILE TEXT NOT NULL,
+        $COL_BITRATE_SCALE REAL,
+        $COL_MAX_EDGE INTEGER,
+        $COL_PREFER_HEVC INTEGER,
+        $COL_OUTPUT_PATH TEXT NOT NULL,
+        $COL_OUTPUT_SIZE INTEGER,
+        $COL_OUTPUT_CODEC TEXT,
+        $COL_CREATED_AT INTEGER NOT NULL,
+        PRIMARY KEY ($COL_FINGERPRINT, $COL_SIGNATURE)
+      )
+    """.trimIndent()
+
+    private val CREATE_INDEX_CREATED_AT =
+      "CREATE INDEX IF NOT EXISTS idx_${TABLE}_created_at ON $TABLE ($COL_CREATED_AT)"
+    private val CREATE_INDEX_FINGERPRINT =
+      "CREATE INDEX IF NOT EXISTS idx_${TABLE}_fingerprint ON $TABLE ($COL_FINGERPRINT)"
+
+    private const val TAG = "CompressionCacheStore"
+  }
+}
+
+/**
+ * Process-wide entry point to the persistent compression cache. Opens the encrypted database lazily
+ * on first use (loading the SQLCipher native libs and the Keystore passphrase), runs an
+ * opportunistic prune, and thereafter serves lookups/puts. Every call degrades to a no-op / miss if
+ * the database could not be opened, so a device without the native lib simply never caches — it
+ * never crashes.
+ */
+object CompressionCacheStore {
+  private const val TAG = "CompressionCacheStore"
+  /** Mirrors [CacheCleanupManager]: 500 MB of compressed outputs kept, 7-day age cap. */
+  private const val MAX_TOTAL_BYTES = 500L * 1024L * 1024L
+  private const val MAX_AGE_MS = 7L * 24L * 60L * 60L * 1000L
+
+  private var index: CompressionCacheIndex? = null
+  private var attempted = false
+
+  /** The dedicated dir holding the persistent MASTER outputs. Never wiped by the editor's close(). */
+  fun outputDir(context: Context): File =
+    File(context.cacheDir, "compression_cache").apply { mkdirs() }
+
+  /** [CompressionCacheKeys.settingsSignature] — surfaced here so callers need one import. */
+  fun settingsSignature(
+    percent: Int, profileName: String, bitrateScale: Float, maxEncodedEdge: Int, preferHevc: Boolean
+  ): String = CompressionCacheKeys.settingsSignature(percent, profileName, bitrateScale, maxEncodedEdge, preferHevc)
+
+  @Synchronized
+  private fun index(context: Context): CompressionCacheIndex? {
+    index?.let { return it }
+    // A failed open (missing native lib, bad key) is permanent for this process — don't re-attempt
+    // and re-log on every compression.
+    if (attempted) return null
+    attempted = true
+    return try {
+      net.sqlcipher.database.SQLiteDatabase.loadLibs(context.applicationContext)
+      val key = SecureKeyModule.getOrCreateDatabaseKey(context)
+      val impl = SqlCipherCompressionCacheIndex(context.applicationContext, key)
+      // Opportunistic maintenance on first open.
+      impl.pruneMissingFiles()
+      impl.enforceLimits(MAX_TOTAL_BYTES, MAX_AGE_MS)
+      index = impl
+      impl
+    } catch (t: Throwable) {
+      Log.e(TAG, "Persistent compression cache disabled: could not open encrypted DB", t)
+      null
+    }
+  }
+
+  fun lookup(context: Context, sourceFingerprint: String, settingsSignature: String): CompressionCacheEntry? =
+    index(context)?.lookup(sourceFingerprint, settingsSignature)
+
+  fun put(context: Context, entry: CompressionCacheEntry) {
+    val idx = index(context) ?: return
+    idx.put(entry)
+    idx.enforceLimits(MAX_TOTAL_BYTES, MAX_AGE_MS)
+  }
+
+  fun deleteByFingerprint(context: Context, sourceFingerprint: String) {
+    index(context)?.deleteByFingerprint(sourceFingerprint)
+  }
+
+  /**
+   * Wipe the whole persistent cache — close and delete the database, and empty the output dir.
+   * Called from the plugin's cache-clear path so "clear cache" reclaims these files too. The next
+   * use re-opens a fresh, empty database.
+   */
+  @Synchronized
+  fun clearAll(context: Context) {
+    runCatching { (index as? SqlCipherCompressionCacheIndex)?.close() }
+    index = null
+    attempted = false
+    runCatching {
+      val ctx = context.applicationContext
+      ctx.deleteDatabase("compression_cache.db")
+      outputDir(ctx).listFiles()?.forEach { runCatching { it.delete() } }
+    }.onFailure { Log.w(TAG, "Failed to clear persistent compression cache", it) }
+  }
+}
+
+// ── ContentValues / Cursor nullable helpers ────────────────────────────────────────────────
+// File-private so both the store and any future SQLCipher-backed table can reuse them; kept at
+// top level (rather than as member extensions) so there is no dual-receiver resolution to reason
+// about at the call sites inside ContentValues { } blocks.
+
+private fun ContentValues.putOrNull(key: String, value: Long?) {
+  if (value == null) putNull(key) else put(key, value)
+}
+
+private fun ContentValues.putOrNull(key: String, value: Int?) {
+  if (value == null) putNull(key) else put(key, value)
+}
+
+private fun ContentValues.putOrNull(key: String, value: Float?) {
+  if (value == null) putNull(key) else put(key, value)
+}
+
+private fun android.database.Cursor.stringOrNull(name: String): String? =
+  getColumnIndex(name).let { if (it < 0 || isNull(it)) null else getString(it) }
+
+private fun android.database.Cursor.intOrNull(name: String): Int? =
+  getColumnIndex(name).let { if (it < 0 || isNull(it)) null else getInt(it) }
+
+private fun android.database.Cursor.longOrNull(name: String): Long? =
+  getColumnIndex(name).let { if (it < 0 || isNull(it)) null else getLong(it) }
+
+private fun android.database.Cursor.floatOrNull(name: String): Float? =
+  getColumnIndex(name).let { if (it < 0 || isNull(it)) null else getFloat(it) }
+
+

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

@@ -0,0 +1,7 @@
+package com.customcamera
+
+internal object CompressionFileNameUtils {
+  fun createUniqueFileName(prefix: String, extension: String): String {
+    return "${prefix}_${System.currentTimeMillis()}_${System.nanoTime()}.${extension.trimStart('.')}"
+  }
+}