react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,378 @@
+package com.customcamera
+
+import android.content.ContentResolver
+import android.content.ContentUris
+import android.database.ContentObserver
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.provider.MediaStore
+
+class MediaStoreRepository(
+  private val contentResolver: ContentResolver
+) {
+  private val mediaUri: Uri = MediaStore.Files.getContentUri("external")
+
+  fun queryRecent(
+    mediaTypes: String,
+    limit: Int,
+    offset: Int
+  ): List<CameraAsset> {
+    val selection = buildSelection(mediaTypes)
+    val projection = arrayOf(
+      MediaStore.Files.FileColumns._ID,
+      MediaStore.Files.FileColumns.MEDIA_TYPE,
+      MediaStore.MediaColumns.DISPLAY_NAME,
+      MediaStore.MediaColumns.MIME_TYPE,
+      MediaStore.MediaColumns.WIDTH,
+      MediaStore.MediaColumns.HEIGHT,
+      MediaStore.MediaColumns.SIZE,
+      MediaStore.MediaColumns.DATE_TAKEN,
+      MediaStore.MediaColumns.DATE_MODIFIED,
+      MediaStore.Video.VideoColumns.DURATION
+    )
+
+    // MediaProvider validates sort-order SQL, and how strictly it does so varies by OEM and API
+    // level. If the COALESCE expression is ever rejected, fall back to the plain column sort
+    // rather than letting the whole media list fail to load — a degraded ordering is recoverable,
+    // an empty gallery is not.
+    val cursor = runQuery(projection, selection, SORT_ORDER, limit, offset)
+      ?: runQuery(projection, selection, FALLBACK_SORT_ORDER, limit, offset)
+
+    cursor?.use {
+      val idColumn = it.getColumnIndexOrThrow(MediaStore.Files.FileColumns._ID)
+      val mediaTypeColumn = it.getColumnIndexOrThrow(MediaStore.Files.FileColumns.MEDIA_TYPE)
+      val displayNameColumn = it.getColumnIndexOrThrow(MediaStore.MediaColumns.DISPLAY_NAME)
+      val mimeTypeColumn = it.getColumnIndexOrThrow(MediaStore.MediaColumns.MIME_TYPE)
+      val widthColumn = it.getColumnIndex(MediaStore.MediaColumns.WIDTH)
+      val heightColumn = it.getColumnIndex(MediaStore.MediaColumns.HEIGHT)
+      val sizeColumn = it.getColumnIndex(MediaStore.MediaColumns.SIZE)
+      val dateTakenColumn = it.getColumnIndex(MediaStore.MediaColumns.DATE_TAKEN)
+      val dateModifiedColumn = it.getColumnIndex(MediaStore.MediaColumns.DATE_MODIFIED)
+      val durationColumn = it.getColumnIndex(MediaStore.Video.VideoColumns.DURATION)
+      val assets = mutableListOf<CameraAsset>()
+
+      while (it.moveToNext()) {
+        val id = it.getLong(idColumn)
+        val mediaType = it.getInt(mediaTypeColumn)
+        val mime = it.getNullableString(mimeTypeColumn)
+        // Map the MediaStore MEDIA_TYPE (and, for documents, the MIME type) onto the
+        // app-wide asset type vocabulary: "photo", "video", "audio", "document".
+        val type = when (mediaType) {
+          MediaStore.Files.FileColumns.MEDIA_TYPE_VIDEO -> "video"
+          MediaStore.Files.FileColumns.MEDIA_TYPE_AUDIO -> "audio"
+          MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE -> "photo"
+          // Anything else is decided by the dedicated document media type (value 6,
+          // API 30+) and the MIME family — never blindly defaulted to "photo", which
+          // is what made documents surface under the Photos filter. A non-image/
+          // video/audio file with no better signal is treated as a document.
+          else -> when {
+            mediaType == MEDIA_TYPE_DOCUMENT -> "document"
+            isDocumentMime(mime) -> "document"
+            mime != null && mime.startsWith("audio/") -> "audio"
+            mime != null && mime.startsWith("video/") -> "video"
+            ImageFormatSupport.isImageMimeType(mime) -> "photo"
+            // No usable MIME type: fall back to the file extension before giving up, which is
+            // what rescues rows scanned without a type at all (common for files another app
+            // wrote into its own Android/media directory).
+            ImageFormatSupport.fromFileName(it.getNullableString(displayNameColumn)) != null ->
+              "photo"
+            else -> "document"
+          }
+        }
+        // Build a type-appropriate, openable content URI. The typed collections (Images/Video/
+        // Audio) are used only when MediaStore itself filed the row under that MEDIA_TYPE — an
+        // id from the Files collection is not guaranteed to resolve inside a typed collection,
+        // so a row recognised as an image purely by its MIME type keeps the generic Files URI
+        // it is known to be addressable by. Documents likewise resolve through Files.
+        val contentUri = when {
+          mediaType == MediaStore.Files.FileColumns.MEDIA_TYPE_VIDEO ->
+            ContentUris.withAppendedId(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, id)
+          mediaType == MediaStore.Files.FileColumns.MEDIA_TYPE_AUDIO ->
+            ContentUris.withAppendedId(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, id)
+          mediaType == MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE ->
+            ContentUris.withAppendedId(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, id)
+          else -> ContentUris.withAppendedId(mediaUri, id)
+        }
+        val dateTaken = it.getNullableLong(dateTakenColumn)
+          ?: (it.getNullableLong(dateModifiedColumn)?.times(1000))
+
+        assets.add(
+          CameraAsset(
+            id = id.toString(),
+            uri = contentUri,
+            type = type,
+            fileName = it.getNullableString(displayNameColumn),
+            mimeType = mime,
+            width = it.getNullableInt(widthColumn),
+            height = it.getNullableInt(heightColumn),
+            duration = it.getNullableLong(durationColumn),
+            size = it.getNullableLong(sizeColumn),
+            dateTaken = dateTaken
+          )
+        )
+      }
+
+      return assets
+    }
+
+    return emptyList()
+  }
+
+  /**
+   * Run the paged media query with [sortOrder], returning null if the provider rejects it so the
+   * caller can retry with a simpler ordering. Only a *rejected query* yields null — a query that
+   * legitimately matches nothing still returns an empty cursor, so an empty gallery never
+   * triggers a pointless second round trip.
+   */
+  private fun runQuery(
+    projection: Array<String>,
+    selection: String,
+    sortOrder: String,
+    limit: Int,
+    offset: Int
+  ): android.database.Cursor? =
+    runCatching {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        contentResolver.query(
+          mediaUri,
+          projection,
+          Bundle().apply {
+            putString(ContentResolver.QUERY_ARG_SQL_SELECTION, selection)
+            putStringArray(ContentResolver.QUERY_ARG_SQL_SELECTION_ARGS, emptyArray<String>())
+            putString(ContentResolver.QUERY_ARG_SQL_SORT_ORDER, sortOrder)
+            putInt(ContentResolver.QUERY_ARG_LIMIT, limit)
+            putInt(ContentResolver.QUERY_ARG_OFFSET, offset)
+          },
+          null
+        )
+      } else {
+        @Suppress("DEPRECATION")
+        contentResolver.query(
+          mediaUri,
+          projection,
+          selection,
+          emptyArray<String>(),
+          "$sortOrder LIMIT $limit OFFSET $offset"
+        )
+      }
+    }.getOrNull()
+
+  fun registerObserver(onChanged: () -> Unit): ContentObserver {
+    val observer =
+      object : ContentObserver(Handler(Looper.getMainLooper())) {
+        override fun onChange(selfChange: Boolean) {
+          onChanged()
+        }
+
+        override fun onChange(selfChange: Boolean, uri: Uri?) {
+          onChanged()
+        }
+      }
+    contentResolver.registerContentObserver(
+      MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
+      true,
+      observer
+    )
+    contentResolver.registerContentObserver(
+      MediaStore.Video.Media.EXTERNAL_CONTENT_URI,
+      true,
+      observer
+    )
+    contentResolver.registerContentObserver(
+      MediaStore.Files.getContentUri("external"),
+      true,
+      observer
+    )
+    return observer
+  }
+
+  fun unregisterObserver(observer: ContentObserver) {
+    contentResolver.unregisterContentObserver(observer)
+  }
+
+  fun assetFromUri(uri: Uri, type: String): CameraAsset =
+    queryAsset(uri, type)
+      ?: CameraAsset(
+        id = uri.lastPathSegment ?: uri.toString(),
+        uri = uri,
+        type = type,
+        fileName = null,
+        mimeType = null,
+        width = null,
+        height = null,
+        duration = null,
+        size = null,
+        dateTaken = System.currentTimeMillis()
+      )
+
+  private fun queryAsset(uri: Uri, type: String): CameraAsset? {
+    val baseProjection = arrayOf(
+      MediaStore.MediaColumns._ID,
+      MediaStore.MediaColumns.DISPLAY_NAME,
+      MediaStore.MediaColumns.MIME_TYPE,
+      MediaStore.MediaColumns.WIDTH,
+      MediaStore.MediaColumns.HEIGHT,
+      MediaStore.MediaColumns.SIZE,
+      MediaStore.MediaColumns.DATE_TAKEN,
+      MediaStore.MediaColumns.DATE_MODIFIED
+    )
+    val projection =
+      if (type == "video") {
+        baseProjection + MediaStore.Video.VideoColumns.DURATION
+      } else {
+        baseProjection
+      }
+
+    contentResolver.query(uri, projection, null, null, null)?.use {
+      if (!it.moveToFirst()) {
+        return null
+      }
+
+      val idColumn = it.getColumnIndex(MediaStore.MediaColumns._ID)
+      val displayNameColumn = it.getColumnIndex(MediaStore.MediaColumns.DISPLAY_NAME)
+      val mimeTypeColumn = it.getColumnIndex(MediaStore.MediaColumns.MIME_TYPE)
+      val widthColumn = it.getColumnIndex(MediaStore.MediaColumns.WIDTH)
+      val heightColumn = it.getColumnIndex(MediaStore.MediaColumns.HEIGHT)
+      val sizeColumn = it.getColumnIndex(MediaStore.MediaColumns.SIZE)
+      val dateTakenColumn = it.getColumnIndex(MediaStore.MediaColumns.DATE_TAKEN)
+      val dateModifiedColumn = it.getColumnIndex(MediaStore.MediaColumns.DATE_MODIFIED)
+      val durationColumn = it.getColumnIndex(MediaStore.Video.VideoColumns.DURATION)
+      val id = it.getNullableLong(idColumn)?.toString() ?: (uri.lastPathSegment ?: uri.toString())
+      val dateTaken = it.getNullableLong(dateTakenColumn)
+        ?: (it.getNullableLong(dateModifiedColumn)?.times(1000))
+
+      return CameraAsset(
+        id = id,
+        uri = uri,
+        type = type,
+        fileName = it.getNullableString(displayNameColumn),
+        mimeType = it.getNullableString(mimeTypeColumn),
+        width = it.getNullableInt(widthColumn),
+        height = it.getNullableInt(heightColumn),
+        duration = it.getNullableLong(durationColumn),
+        size = it.getNullableLong(sizeColumn),
+        dateTaken = dateTaken ?: System.currentTimeMillis()
+      )
+    }
+
+    return null
+  }
+
+  private fun buildSelection(mediaTypes: String): String {
+    val videoType = MediaStore.Files.FileColumns.MEDIA_TYPE_VIDEO
+    val audioType = MediaStore.Files.FileColumns.MEDIA_TYPE_AUDIO
+    val typeCol = MediaStore.Files.FileColumns.MEDIA_TYPE
+    return when (mediaTypes) {
+      // "image" is the gallery-filter alias for the app's internal "photo" type.
+      "photo", "image" -> buildImageSelection()
+      "video" -> "$typeCol = $videoType"
+      "audio" -> "$typeCol = $audioType"
+      "document" -> buildDocumentSelection()
+      // Default ("all"/"Recent"): images + videos, matching the prior behaviour.
+      else -> "(${buildImageSelection()} OR $typeCol = $videoType)"
+    }
+  }
+
+  /**
+   * Images are matched on MEDIA_TYPE **or** an `image/…` MIME type.
+   *
+   * MEDIA_TYPE alone is not sufficient in practice. Files written by other apps into their own
+   * `Android/media/…` directory (WhatsApp being the common case) are indexed by a scan that
+   * sometimes lands them under MEDIA_TYPE_NONE while still recording the correct MIME type — so
+   * a MEDIA_TYPE-only filter silently hid every one of them. Matching the MIME family as well
+   * recovers those rows, and covers every image container the platform knows — including the
+   * HEIF and AVIF files that motivated this — without enumerating formats here.
+   */
+  private fun buildImageSelection(): String {
+    val typeCol = MediaStore.Files.FileColumns.MEDIA_TYPE
+    val mimeCol = MediaStore.MediaColumns.MIME_TYPE
+    val imageType = MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE
+    return "($typeCol = $imageType OR $mimeCol LIKE 'image/%')"
+  }
+
+  /**
+   * Documents are not a single MediaStore MEDIA_TYPE across all Android versions, so match
+   * on both the dedicated document media type (value 6, added in API 30) and a curated list
+   * of document MIME types (PDF, Word, Excel, PowerPoint, text, etc.). The literal 6 is used
+   * so the selection compiles and runs on every supported API level.
+   */
+  private fun buildDocumentSelection(): String {
+    val typeCol = MediaStore.Files.FileColumns.MEDIA_TYPE
+    val mimeCol = MediaStore.MediaColumns.MIME_TYPE
+    val mimeList = DOCUMENT_MIME_TYPES.joinToString(",") { "'$it'" }
+    return "($typeCol = $MEDIA_TYPE_DOCUMENT OR $mimeCol IN ($mimeList))"
+  }
+
+  private fun isDocumentMime(mime: String?): Boolean {
+    if (mime == null) return false
+    return DOCUMENT_MIME_TYPES.contains(mime)
+  }
+
+  companion object {
+    // MediaStore.Files.FileColumns.MEDIA_TYPE_DOCUMENT — the dedicated document media
+    // type added in API 30. Referenced as a literal so the code compiles and the
+    // selection/classification agree on every supported API level.
+    private const val MEDIA_TYPE_DOCUMENT = 6
+
+    /**
+     * Newest-first ordering that treats an undated row as being as old as its file, instead of
+     * as having no date at all.
+     *
+     * DATE_TAKEN is populated from EXIF/container metadata, so it is NULL for a large share of
+     * real-world images — anything stripped of EXIF in transit, which includes essentially every
+     * photo received through WhatsApp. Ordering by `DATE_TAKEN DESC` alone sorts those NULLs
+     * *after* every dated row in SQLite, so they were pushed past the paging window (and far
+     * past the strip's 80-item cap) and appeared nowhere at all — the reported "images don't
+     * show up" bug.
+     *
+     * COALESCE falls back to DATE_MODIFIED (stored in seconds, hence ×1000) so undated files
+     * interleave by their real recency. This mirrors the per-row `dateTaken` fallback the
+     * cursor read already performed, which is why the list and its ordering disagreed.
+     */
+    private val SORT_ORDER =
+      "COALESCE(${MediaStore.MediaColumns.DATE_TAKEN}, " +
+        "${MediaStore.MediaColumns.DATE_MODIFIED} * 1000) DESC, " +
+        "${MediaStore.Files.FileColumns._ID} DESC"
+
+    /**
+     * Ordering used only if a provider refuses [SORT_ORDER]'s COALESCE expression. DATE_MODIFIED
+     * leads because, unlike DATE_TAKEN, it is populated for every row — so undated images still
+     * appear in a sensible position instead of being banished to the end of the list.
+     */
+    private val FALLBACK_SORT_ORDER =
+      "${MediaStore.MediaColumns.DATE_MODIFIED} DESC, " +
+        "${MediaStore.Files.FileColumns._ID} DESC"
+
+    // Supported document MIME types for the "Document" gallery filter. Kept in sync with
+    // buildDocumentSelection() so the SQL filter and the per-row type mapping agree.
+    private val DOCUMENT_MIME_TYPES = setOf(
+      "application/pdf",
+      "application/msword",
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      "application/vnd.ms-excel",
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      "application/vnd.ms-powerpoint",
+      "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      "text/plain",
+      "text/csv",
+      "application/rtf",
+      "text/rtf",
+      "application/vnd.oasis.opendocument.text",
+      "application/vnd.oasis.opendocument.spreadsheet",
+      "application/vnd.oasis.opendocument.presentation",
+      "application/epub+zip"
+    )
+  }
+}
+
+private fun android.database.Cursor.getNullableString(index: Int): String? =
+  if (index < 0 || isNull(index)) null else getString(index)
+
+private fun android.database.Cursor.getNullableInt(index: Int): Int? =
+  if (index < 0 || isNull(index)) null else getInt(index)
+
+private fun android.database.Cursor.getNullableLong(index: Int): Long? =
+  if (index < 0 || isNull(index)) null else getLong(index)

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

@@ -0,0 +1,286 @@
+package com.customcamera
+
+import android.content.Context
+import android.net.Uri
+import android.widget.ImageView
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+/**
+ * ReactNative view manager for media-list thumbnails.
+ *
+ * A JS `<Image>` can only show a still that Fresco can decode: a video file renders nothing at
+ * all (there is no frame to read without an extractor), and HEIF/AVIF need the platform decoders.
+ * Both cases used to leave the row with an empty tile, so list rows fell back to a generic
+ * file-style placeholder. This view hands the work to [ThumbnailLoader] — the same loader the
+ * native camera strip and grid already use — so a row shows the media's OWN first usable frame:
+ * the user-picked cover if the clip has one, else an extracted video frame, else the decoded
+ * image, all downsampled to the tile and served from a shared bitmap cache.
+ *
+ * Prop contract mirrors [AnimatedImageViewManager]: `src` with a same-request guard so a recycled
+ * FlatList cell never keeps the previous row's frame, plus the few asset fields the loader needs
+ * to pick a decode path.
+ */
+class MediaThumbnailViewManager : SimpleViewManager<MediaThumbnailView>() {
+  override fun getName() = "CustomMediaThumbnail"
+
+  override fun createViewInstance(reactContext: ThemedReactContext): MediaThumbnailView =
+    MediaThumbnailView(reactContext)
+
+  override fun onDropViewInstance(view: MediaThumbnailView) {
+    view.release()
+    super.onDropViewInstance(view)
+  }
+
+  /**
+   * ReactNative applies props one setter at a time and in no guaranteed order, so a setter must
+   * only RECORD its value — the decode is started once here, when the whole batch has landed.
+   *
+   * Requesting from the setters instead made the request identity depend on which props happened
+   * to have arrived: a `src` that landed before `mimeType`/`fileName` pinned the decode to a
+   * format-hint-less asset, and the later hints — being absent from the request key — never
+   * triggered a retry. Video frames never noticed (MediaMetadataRetriever reads the container
+   * itself), but every still goes through [ImageFormatSupport], which answers "can this device
+   * decode it" and "does it carry alpha" from exactly those two fields.
+   */
+  protected override fun onAfterUpdateTransaction(view: MediaThumbnailView) {
+    super.onAfterUpdateTransaction(view)
+    view.onPropsApplied()
+  }
+
+  /** The media's own URI (`content://`, `file://` or a plain path). */
+  @ReactProp(name = "src")
+  fun setSrc(view: MediaThumbnailView, src: String?) {
+    view.setSrc(src)
+  }
+
+  /**
+   * `video` selects frame extraction; anything else is decoded as a still. Both the JS
+   * (`photo`) and database (`image`) spellings mean the same thing here.
+   */
+  @ReactProp(name = "mediaType")
+  fun setMediaType(view: MediaThumbnailView, mediaType: String?) {
+    view.setMediaType(mediaType)
+  }
+
+  /** Cached copy of the file, read in preference to the URI when it still exists on disk. */
+  @ReactProp(name = "cachePath")
+  fun setCachePath(view: MediaThumbnailView, cachePath: String?) {
+    view.setCachePath(cachePath)
+  }
+
+  /** A video's user-selected cover frame; overrides frame extraction when present. */
+  @ReactProp(name = "coverUri")
+  fun setCoverUri(view: MediaThumbnailView, coverUri: String?) {
+    view.setCoverUri(coverUri)
+  }
+
+  /** Used to decide decodability and alpha handling — see ImageFormatSupport. */
+  @ReactProp(name = "mimeType")
+  fun setMimeType(view: MediaThumbnailView, mimeType: String?) {
+    view.setMimeType(mimeType)
+  }
+
+  /** Fallback format hint for assets that arrived without a MIME type. */
+  @ReactProp(name = "fileName")
+  fun setFileName(view: MediaThumbnailView, fileName: String?) {
+    view.setFileName(fileName)
+  }
+
+  /** `cover` (default) or `contain`, matching the `resizeMode` names used on the JS side. */
+  @ReactProp(name = "resizeMode")
+  fun setResizeMode(view: MediaThumbnailView, resizeMode: String?) {
+    view.setResizeMode(resizeMode)
+  }
+
+  /**
+   * Decode target in pixels, for the rare case a consumer wants a sharper (or cheaper) bitmap
+   * than the tile's own measured size. 0 (the default) means "use the measured size".
+   */
+  @ReactProp(name = "thumbnailSize", defaultInt = 0)
+  fun setThumbnailSize(view: MediaThumbnailView, thumbnailSize: Int) {
+    view.setThumbnailSize(thumbnailSize)
+  }
+}
+
+/**
+ * An [ImageView] that paints the asset's own thumbnail, decoded off the main thread by the
+ * shared [ThumbnailLoader].
+ *
+ * Nothing here writes to the file: every path is a read-only decode.
+ */
+class MediaThumbnailView(context: Context) : ImageView(context) {
+  private var src: String? = null
+  private var mediaType: String? = null
+  private var cachePath: String? = null
+  private var coverUri: String? = null
+  private var mimeType: String? = null
+  private var fileName: String? = null
+  private var requestedSize = 0
+
+  /**
+   * Identity of the request currently painted or in flight, so a re-layout or a prop update that
+   * changes nothing the loader reads does not re-decode. It carries every field that CAN change
+   * the decode — source, kind, cache copy, format hints and target size — because a field left
+   * out of it is a field whose later arrival looks like a repeat of the request already made.
+   */
+  private var currentKey: String? = null
+
+  /**
+   * Bumped on every request. A decode that finishes after its row was recycled compares its
+   * captured value against this and drops the bitmap instead of painting it into the wrong row.
+   */
+  private var generation = 0
+
+  init {
+    scaleType = ScaleType.CENTER_CROP
+    adjustViewBounds = false
+    cropToPadding = true
+  }
+
+  // Every setter only records its value; the decode starts from onPropsApplied() once the whole
+  // prop batch has landed — see MediaThumbnailViewManager.onAfterUpdateTransaction.
+  fun setSrc(src: String?) {
+    this.src = src
+  }
+
+  fun setMediaType(mediaType: String?) {
+    this.mediaType = mediaType
+  }
+
+  fun setCachePath(cachePath: String?) {
+    this.cachePath = cachePath
+  }
+
+  fun setCoverUri(coverUri: String?) {
+    this.coverUri = coverUri
+  }
+
+  fun setMimeType(mimeType: String?) {
+    this.mimeType = mimeType
+  }
+
+  fun setFileName(fileName: String?) {
+    this.fileName = fileName
+  }
+
+  fun setResizeMode(resizeMode: String?) {
+    scaleType = if (resizeMode == "contain") ScaleType.FIT_CENTER else ScaleType.CENTER_CROP
+    adjustViewBounds = false
+    cropToPadding = true
+  }
+
+  fun setThumbnailSize(thumbnailSize: Int) {
+    this.requestedSize = thumbnailSize
+  }
+
+  /** Every prop in this update has been applied — decode against the complete set. */
+  fun onPropsApplied() {
+    requestThumbnail()
+  }
+
+  /** Drop the frame and orphan any in-flight decode; called when ReactNative discards the view. */
+  fun release() {
+    generation++
+    currentKey = null
+    setImageDrawable(null)
+  }
+
+  // The tile's decode size is its own measured size, so the request usually can't be made until
+  // the first layout pass. Props set before then leave `currentKey` null and land here instead.
+  override fun onSizeChanged(width: Int, height: Int, oldWidth: Int, oldHeight: Int) {
+    super.onSizeChanged(width, height, oldWidth, oldHeight)
+    requestThumbnail()
+  }
+
+  private fun requestThumbnail() {
+    val source = src
+    if (source.isNullOrEmpty()) {
+      generation++
+      currentKey = null
+      setImageDrawable(null)
+      return
+    }
+
+    val size = decodeSize()
+    if (size <= 0) return
+
+    // Parsed before the request is claimed, so an unusable URI leaves `currentKey` untouched and
+    // a later, valid prop update is not mistaken for a repeat of this one.
+    val uri = runCatching { Uri.parse(source) }.getOrNull() ?: return
+
+    // Identity of the decode, not of the file: every field the loader reads belongs here, or a
+    // later prop update that genuinely changes the result is mistaken for a repeat of this one.
+    val key = "${coverUri ?: source}|${normalizedType()}|$cachePath|$mimeType|$fileName|$size"
+    if (key == currentKey) return
+    currentKey = key
+
+    generation++
+    val token = generation
+    // Clear first: a recycled cell must never show the previous row's frame while this one
+    // decodes.
+    setImageDrawable(null)
+
+    val asset = CameraAsset(
+      id = key,
+      uri = uri,
+      type = normalizedType(),
+      fileName = fileName,
+      mimeType = mimeType,
+      width = null,
+      height = null,
+      duration = null,
+      size = null,
+      dateTaken = null,
+      cachePath = cachePath,
+      coverUri = coverUri
+    )
+
+    sharedLoader(context).requestBitmap(asset, size) { bitmap ->
+      if (token == generation) {
+        setImageBitmap(bitmap)
+      }
+    }
+  }
+
+  /** The tile's measured size wins; the prop is only a fallback for a not-yet-laid-out view. */
+  private fun decodeSize(): Int {
+    val measured = maxOf(width, height)
+    return if (measured > 0) measured else requestedSize
+  }
+
+  /** [ThumbnailLoader] only distinguishes `video` from everything else. */
+  private fun normalizedType(): String = if (mediaType == "video") "video" else "photo"
+
+  companion object {
+    /**
+     * One loader for every thumbnail view in the app: its LruCache is what makes scrolling back
+     * up a list free, and a per-view loader would cache nothing and start a coroutine scope per
+     * row. Sized against the heap and bounded by [ThumbnailLoader], so it is never cleared —
+     * `clear()` would cancel the scope shared by every other row.
+     */
+    @Volatile
+    private var loader: ThumbnailLoader? = null
+
+    private fun sharedLoader(context: Context): ThumbnailLoader =
+      loader ?: synchronized(this) {
+        loader ?: ThumbnailLoader(context.applicationContext.contentResolver)
+          .also { loader = it }
+      }
+
+    /**
+     * Drop any cached bitmap decoded from [source] on the shared loader.
+     *
+     * Used by [SecureMediaDeleter]: a decoded thumbnail outlives the file it came from, so a
+     * securely erased photo would keep rendering in the media list from cache — and that bitmap
+     * is a real, if downscaled, copy of media the user asked to be destroyed. A no-op when no
+     * thumbnail has been requested yet in this process (the loader is created lazily), which is
+     * correct: an unbuilt cache holds nothing to evict.
+     */
+    fun evictFromSharedCache(source: String?) {
+      if (source.isNullOrEmpty()) return
+      loader?.evictSource(source)
+    }
+  }
+}