react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,88 @@
+package com.customcamera
+
+import kotlinx.coroutines.Job
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Tracks the best-effort aspect-crop re-encode of a just-recorded clip, keyed by the media id the
+ * clip was cached under.
+ *
+ * The crop used to run on the stop -> editor critical path (and on the main thread), freezing the
+ * camera screen for the whole re-encode. It now runs in the background: the editor opens
+ * immediately on the finalized clip (which already renders the captured framing via its COVER crop,
+ * MediaPreviewEditor.captureFrameDisplayAspect), and the physical crop swaps the cached file in
+ * place when it finishes. This registry lets the send/publish path wait for that swap so a clip
+ * sent within the crop window is still the cropped file, not the raw recording.
+ *
+ * It also remembers the RECORDED clip's byte length (the size the on-screen recording counter was
+ * approaching when the user hit stop), keyed the same way. The aspect crop replaces the cached file
+ * with a smaller re-encode, so a fresh stat of the clip after the swap no longer matches what the
+ * recording screen showed. The editor's "Original video" row is meant to be the clip the user just
+ * recorded and is watching, so it reads this remembered length instead of re-statting the (now
+ * cropped) file. Unlike [jobs], the recorded length must OUTLIVE the crop — it is looked up long
+ * after the swap has completed — so [complete] leaves it in place; it is dropped only when the clip
+ * is edited into a genuinely new file (see [forgetRecordedOriginal]).
+ */
+internal object PendingCaptureCrops {
+  private val jobs = ConcurrentHashMap<String, Job>()
+  private val recordedBytesById = ConcurrentHashMap<String, Long>()
+
+  /**
+   * Record the crop [job] for [mediaId], and (when known and positive) the [recordedBytes] length of
+   * the raw recording the crop is about to shrink. Called before the editor can open, so a send
+   * always sees the job and the editor always sees the recorded size.
+   */
+  fun register(mediaId: String, job: Job, recordedBytes: Long = 0L) {
+    if (mediaId.isBlank()) return
+    jobs[mediaId] = job
+    if (recordedBytes > 0L) recordedBytesById[mediaId] = recordedBytes
+  }
+
+  /**
+   * Drop [mediaId]'s crop [jobs] entry once the crop has finished (success, skip, failure, or
+   * cancellation). The remembered recorded length is deliberately KEPT — the editor looks it up
+   * after the crop lands — and is cleared separately by [forgetRecordedOriginal].
+   */
+  fun complete(mediaId: String) {
+    jobs.remove(mediaId)
+  }
+
+  /**
+   * The byte length of the raw clip recorded under [mediaId], or 0 when none was remembered (an
+   * un-cropped capture, an imported/gallery clip, a still, or a clip that has since been edited into
+   * a new file). The editor quotes this as the "Original video" size so it matches the recording
+   * screen's counter rather than the smaller cropped re-encode now on disk.
+   */
+  fun recordedOriginalBytes(mediaId: String): Long =
+    if (mediaId.isBlank()) 0L else recordedBytesById[mediaId] ?: 0L
+
+  /**
+   * Forget [mediaId]'s remembered recorded length. Called when the clip is rewritten into a new file
+   * in the editor (a trim/crop replaces the recording), so the editor stops quoting the pre-edit
+   * recording's size and measures the edited clip's own honest length instead.
+   */
+  fun forgetRecordedOriginal(mediaId: String) {
+    if (mediaId.isNotBlank()) recordedBytesById.remove(mediaId)
+  }
+
+  /**
+   * Whether a crop for [mediaId] is still in flight, i.e. whether the bytes currently cached under
+   * it are about to be replaced.
+   *
+   * Lets a caller that must not read a stale file decide up front whether it can work on this frame
+   * or has to go asynchronous and [await] the swap first — the compression dropdown measures the
+   * clip it is about to quote sizes for, and measuring the raw recording seconds before the cropped
+   * file lands in its place is exactly the stale reading it must not show.
+   */
+  fun isPending(mediaId: String): Boolean = mediaId.isNotBlank() && jobs.containsKey(mediaId)
+
+  /**
+   * Suspend until the crop for [mediaId] has finished, if one is still in flight. Returns
+   * immediately when there is no pending crop (images, un-cropped captures, or a crop that already
+   * finished). join() returns normally for a cancelled job, so a torn-down crop never blocks a send.
+   */
+  suspend fun await(mediaId: String) {
+    if (mediaId.isBlank()) return
+    jobs[mediaId]?.join()
+  }
+}