react-native-ensys-camera-x 1.0.7

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

@@ -0,0 +1,455 @@
+package com.customcamera
+
+import android.content.ContentResolver
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Color
+import android.graphics.ImageDecoder
+import android.graphics.drawable.ColorDrawable
+import android.media.MediaMetadataRetriever
+import android.os.Build
+import android.util.LruCache
+import android.util.Size
+import android.widget.ImageView
+import java.io.File
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class ThumbnailLoader(
+  private val contentResolver: ContentResolver
+) {
+  var lowMemoryMode: Boolean = false
+
+  private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+  private val cache = object : LruCache<String, Bitmap>(cacheSizeKb()) {
+    override fun sizeOf(key: String, value: Bitmap): Int = value.byteCount / 1024
+  }
+
+  fun load(asset: CameraAsset, imageView: ImageView, sizePx: Int) {
+    val actualSizePx = if (lowMemoryMode) sizePx / 2 else sizePx
+    val key = "${asset.coverUri ?: asset.uri}@$actualSizePx"
+    imageView.tag = key
+    val placeholderColor = CameraTheme.get(imageView.context)
+      .componentColor("mediaGrid", "thumbnailPlaceholder", 0xFF111111.toInt())
+    imageView.setImageDrawable(ColorDrawable(placeholderColor))
+
+    cache.get(key)?.let {
+      imageView.setImageBitmap(it)
+      return
+    }
+
+    scope.launch {
+      val bitmap = loadBitmap(asset, actualSizePx)
+      if (bitmap != null) {
+        cache.put(key, bitmap)
+        withContext(Dispatchers.Main) {
+          if (imageView.tag == key) {
+            imageView.setImageBitmap(bitmap)
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Callback variant of [load] for hosts that own their view's tag.
+   *
+   * [load] stores its cache key in `imageView.tag`, which is exactly where ReactNative's
+   * BaseViewManager writes `testID` — a RN-hosted thumbnail must therefore not go through it.
+   * Same cache, same decode path (cover frame → video frame → resolver thumbnail → decoder);
+   * [onReady] is invoked on the main thread and only when a bitmap was produced, so a format
+   * this device cannot decode simply leaves the caller's placeholder in place.
+   */
+  fun requestBitmap(asset: CameraAsset, sizePx: Int, onReady: (Bitmap) -> Unit) {
+    val actualSizePx = if (lowMemoryMode) sizePx / 2 else sizePx
+    val key = "${asset.coverUri ?: asset.uri}@$actualSizePx"
+
+    cache.get(key)?.let {
+      onReady(it)
+      return
+    }
+
+    scope.launch {
+      val bitmap = loadBitmap(asset, actualSizePx) ?: return@launch
+      cache.put(key, bitmap)
+      withContext(Dispatchers.Main) { onReady(bitmap) }
+    }
+  }
+
+  fun preload(asset: CameraAsset, sizePx: Int) {
+    if (lowMemoryMode) return
+    val key = "${asset.coverUri ?: asset.uri}@$sizePx"
+    if (cache.get(key) != null) return
+
+    scope.launch {
+      val bitmap = loadBitmap(asset, sizePx) ?: return@launch
+      cache.put(key, bitmap)
+    }
+  }
+
+  fun clearCache() {
+    cache.evictAll()
+  }
+
+  /**
+   * Drop every cached bitmap decoded from [source] — one media file, at any decode size.
+   *
+   * Cache keys are `"<coverUri ?: uri>@<sizePx>"`, so one file can hold several entries (the grid
+   * tile, the strip, a full-width poster) and each must go. Called when media is DELETED: without
+   * it the LruCache keeps serving a decoded copy of the file, so a securely erased photo carries
+   * on rendering in the list — and that bitmap is itself a recoverable, if downscaled, copy of the
+   * media the user asked to have destroyed.
+   *
+   * `snapshot()` is copied before iterating because [LruCache.remove] mutates the map.
+   */
+  fun evictSource(source: String) {
+    if (source.isEmpty()) return
+    val prefix = "$source@"
+    cache.snapshot().keys
+      .filter { it.startsWith(prefix) }
+      .forEach { cache.remove(it) }
+  }
+
+  fun putOverride(key: String, bitmap: Bitmap) {
+    cache.put(key, bitmap)
+  }
+
+  fun clear() {
+    cache.evictAll()
+    scope.cancel()
+  }
+
+  private fun loadBitmap(asset: CameraAsset, sizePx: Int): Bitmap? {
+    // A user-selected cover overrides frame extraction — decode that JPEG directly.
+    asset.coverUri?.let { cover ->
+      loadCoverBitmap(cover, sizePx)?.let { return it }
+    }
+
+    if (asset.type == "video") {
+      loadVideoFrame(asset, sizePx)?.let { return it }
+    }
+
+    // Try ContentResolver thumbnail API for content:// URIs on Q+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && asset.uri.scheme == "content") {
+      val thumb = runCatching {
+        contentResolver.loadThumbnail(asset.uri, Size(sizePx, sizePx), null)
+      }.getOrNull()
+      if (thumb != null && !thumb.isMostlyBlack()) return thumb
+      thumb?.recycle()
+    }
+
+    return if (asset.type == "video") {
+      loadVideoFrame(asset, sizePx)
+    } else {
+      loadImageBitmap(asset, sizePx)
+    }
+  }
+
+  /** Decode a user-selected cover frame (content:// or file:// URI string) at [sizePx]. */
+  private fun loadCoverBitmap(coverUri: String, sizePx: Int): Bitmap? =
+    runCatching {
+      val uri = android.net.Uri.parse(coverUri)
+      val filePath = if (uri.scheme == "file") uri.path else null
+      if (filePath != null && File(filePath).exists()) {
+        val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+        BitmapFactory.decodeFile(filePath, bounds)
+        val options = BitmapFactory.Options().apply {
+          inSampleSize = bounds.calculateSampleSize(sizePx)
+          // Halves thumbnail memory on small-heap devices — see decodeConfig().
+          inPreferredConfig = decodeConfig()
+        }
+        return@runCatching BitmapFactory.decodeFile(filePath, options)
+      }
+      val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+      contentResolver.openInputStream(uri)?.use { stream ->
+        BitmapFactory.decodeStream(stream, null, bounds)
+      }
+      contentResolver.openInputStream(uri)?.use { stream ->
+        val options = BitmapFactory.Options().apply {
+          inSampleSize = bounds.calculateSampleSize(sizePx)
+          // Halves thumbnail memory on small-heap devices — see decodeConfig().
+          inPreferredConfig = decodeConfig()
+        }
+        BitmapFactory.decodeStream(stream, null, options)
+      }
+    }.getOrNull()
+
+  /**
+   * Decode a still thumbnail for an image asset.
+   *
+   * BitmapFactory decodes the FIRST frame of an animated GIF, which is exactly what a grid or
+   * strip tile wants: one static, cheap frame, no decoder kept alive, no per-tile animation
+   * competing with the scroll. The same call therefore covers GIF, PNG, WebP and JPEG — and, on
+   * devices whose platform decoders support them, HEIF (API 28+) and AVIF (API 31+). The only
+   * format-specific decision is the bitmap config (see [decodeConfig]).
+   *
+   * Where BitmapFactory returns nothing, [decodeViaImageDecoder] retries through ImageDecoder,
+   * which handles some HEIF/AVIF variants BitmapFactory declines. A device too old to decode the
+   * format at all yields null, and the caller shows the placeholder rather than a black tile.
+   */
+  private fun loadImageBitmap(asset: CameraAsset, sizePx: Int): Bitmap? {
+    // Formats the platform cannot decode on this API level (HEIF < 28, AVIF < 31) would waste a
+    // full decode attempt per tile on every bind. The asset is still listed and still sendable —
+    // only its pixels are unavailable here.
+    if (!ImageFormatSupport.isDecodable(asset)) return null
+
+    return runCatching {
+      val config = decodeConfig(mayHaveAlpha = asset.mayHaveAlphaChannel())
+      // For file:// URIs or assets with cachePath, read directly from the file
+      val filePath = asset.cachePath ?: asset.uri.path
+      if (filePath != null && File(filePath).exists()) {
+        val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+        BitmapFactory.decodeFile(filePath, bounds)
+        val options = BitmapFactory.Options().apply {
+          inSampleSize = bounds.calculateSampleSize(sizePx)
+          // Halves thumbnail memory on small-heap devices — see decodeConfig().
+          inPreferredConfig = config
+        }
+        return@runCatching BitmapFactory.decodeFile(filePath, options)
+      }
+
+      // Fallback to ContentResolver for content:// URIs
+      val bounds = BitmapFactory.Options().apply {
+        inJustDecodeBounds = true
+      }
+      contentResolver.openInputStream(asset.uri)?.use { stream ->
+        BitmapFactory.decodeStream(stream, null, bounds)
+      }
+
+      contentResolver.openInputStream(asset.uri)?.use { stream ->
+        val options = BitmapFactory.Options().apply {
+          inSampleSize = bounds.calculateSampleSize(sizePx)
+          // Halves thumbnail memory on small-heap devices — see decodeConfig().
+          inPreferredConfig = config
+        }
+        BitmapFactory.decodeStream(stream, null, options)
+      }
+    }.getOrNull() ?: decodeViaImageDecoder(asset, sizePx)
+  }
+
+  /**
+   * Last-resort decode through ImageDecoder (API 28+), which reads some HEIF/AVIF files that
+   * BitmapFactory refuses. Downsamples during decode so a full-resolution frame is never
+   * materialised just to be scaled down for a tile.
+   */
+  private fun decodeViaImageDecoder(asset: CameraAsset, sizePx: Int): Bitmap? {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) return null
+    return runCatching {
+      val filePath = asset.cachePath ?: asset.uri.path
+      val source = if (filePath != null && File(filePath).exists()) {
+        ImageDecoder.createSource(File(filePath))
+      } else {
+        ImageDecoder.createSource(contentResolver, asset.uri)
+      }
+      ImageDecoder.decodeBitmap(source) { decoder, info, _ ->
+        val maxDimension = maxOf(info.size.width, info.size.height)
+        if (maxDimension > sizePx && sizePx > 0) {
+          val scale = sizePx.toFloat() / maxDimension.toFloat()
+          decoder.setTargetSize(
+            (info.size.width * scale).toInt().coerceAtLeast(1),
+            (info.size.height * scale).toInt().coerceAtLeast(1)
+          )
+        }
+        // ImageDecoder yields a HARDWARE bitmap by default, which cannot be read back by
+        // isMostlyBlack()'s getPixel() and cannot be cached safely alongside software bitmaps.
+        decoder.allocator = ImageDecoder.ALLOCATOR_SOFTWARE
+      }
+    }.getOrNull()
+  }
+
+  private fun loadVideoFrame(asset: CameraAsset, sizePx: Int): Bitmap? =
+    runCatching {
+      val retriever = MediaMetadataRetriever()
+      try {
+        val filePath = asset.cachePath ?: asset.uri.path
+        if (filePath != null && File(filePath).exists()) {
+          retriever.setDataSource(filePath)
+        } else {
+          contentResolver.openAssetFileDescriptor(asset.uri, "r")?.use { descriptor ->
+            retriever.setDataSource(
+              descriptor.fileDescriptor,
+              descriptor.startOffset,
+              descriptor.length
+            )
+          } ?: return@runCatching null
+        }
+
+        val durationMs =
+          retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toLongOrNull() ?: 0L
+        val candidateTimesUs = buildList {
+          add(1_000L)
+          add(100_000L)
+          add(500_000L)
+          add(1_000_000L)
+          if (durationMs > 0) {
+            add((durationMs * 500).coerceAtLeast(1_000L))
+          }
+        }
+
+        for (timeUs in candidateTimesUs) {
+          val frame = extractFrame(retriever, timeUs, MediaMetadataRetriever.OPTION_CLOSEST_SYNC, sizePx)
+            ?: extractFrame(retriever, timeUs, MediaMetadataRetriever.OPTION_CLOSEST, sizePx)
+          if (frame != null) {
+            if (!frame.isMostlyBlack()) {
+              return@runCatching downscaleBitmap(frame, sizePx)
+            }
+            frame.recycle()
+          }
+        }
+
+        extractFrame(retriever, 0, MediaMetadataRetriever.OPTION_CLOSEST_SYNC, sizePx)?.let { fallback ->
+          downscaleBitmap(fallback, sizePx)
+        }
+      } finally {
+        retriever.release()
+      }
+    }.getOrNull()
+
+  /**
+   * Pull one frame, scaled DURING extraction wherever the platform allows it.
+   *
+   * `getFrameAtTime` always hands back a frame at the clip's coded resolution — 8 MB for 1080p,
+   * ~33 MB for 4K — which is then thrown away by [downscaleBitmap] to produce a 68 or 120 dp tile.
+   * The loop above tries several timestamps, so a single video thumbnail could allocate and
+   * discard that full-resolution buffer five times over, and several tiles decoding at once (the
+   * grid, the strip, and a just-recorded clip's own preloads) is a realistic way to run a
+   * small-heap device out of memory on nothing but thumbnails.
+   *
+   * `getScaledFrameAtTime` (API 27+) asks the decoder for the size we actually want, so the big
+   * intermediate never exists. Below API 27 the old behaviour is unavoidable and is kept.
+   *
+   * OutOfMemoryError is caught rather than allowed to propagate: it is an Error, so the
+   * `runCatching` in the caller would NOT contain it, and a thumbnail that cannot be decoded must
+   * degrade to a placeholder instead of taking the process down.
+   */
+  private fun extractFrame(
+    retriever: MediaMetadataRetriever,
+    timeUs: Long,
+    option: Int,
+    sizePx: Int
+  ): Bitmap? = try {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1 && sizePx > 0) {
+      val videoW = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)?.toIntOrNull()
+      val videoH = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)?.toIntOrNull()
+      if (videoW != null && videoH != null && videoW > 0 && videoH > 0) {
+        val scale = sizePx.toFloat() / maxOf(videoW, videoH).toFloat()
+        val targetW = (videoW * scale).toInt().coerceAtLeast(1)
+        val targetH = (videoH * scale).toInt().coerceAtLeast(1)
+        retriever.getScaledFrameAtTime(timeUs, option, targetW, targetH)
+      } else {
+        retriever.getScaledFrameAtTime(timeUs, option, sizePx, sizePx)
+      }
+    } else {
+      retriever.getFrameAtTime(timeUs, option)
+    }
+  } catch (e: Exception) {
+    null
+  } catch (e: OutOfMemoryError) {
+    null
+  }
+
+  companion object {
+    /**
+     * Size the in-memory thumbnail cache as a fraction of the app's actual heap budget
+     * instead of a fixed 24 MB. A fixed cap is simultaneously too big for a low-RAM device
+     * (it competes with decode buffers and invites OOM/eviction thrash) and needlessly small
+     * on a high-end one. Using 1/8 of the max heap follows the standard Android bitmap-cache
+     * guidance and adapts automatically: a 512 MB-heap device gets ~64 MB, while a low-end
+     * 64 MB-heap device gets ~8 MB. Runtime.maxMemory() needs no Context, so the constructor
+     * signature is unchanged. Clamped to a sane floor/ceiling for predictability.
+     */
+    private fun cacheSizeKb(): Int {
+      val maxHeapKb = (Runtime.getRuntime().maxMemory() / 1024L)
+      val eighthKb = (maxHeapKb / 8L)
+      return eighthKb.coerceIn(6 * 1024L, 48 * 1024L).toInt()
+    }
+
+    /**
+     * On small-heap (≤128 MB) devices decode grid/list thumbnails as RGB_565: 2 bytes per
+     * pixel instead of ARGB_8888's 4, halving both decode allocation and cache footprint —
+     * so the same LruCache holds twice the thumbnails with zero extra memory. Thumbnails
+     * are small photographic previews; the 565 banding is not visible at these sizes.
+     * Full-size preview/editor decodes elsewhere keep ARGB_8888 fidelity.
+     */
+    val PREFER_565: Boolean =
+      Runtime.getRuntime().maxMemory() <= 128L * 1024L * 1024L
+
+    /**
+     * [mayHaveAlpha] opts a format out of the RGB_565 saving. RGB_565 has no alpha channel, so a
+     * transparent GIF/PNG/WebP/HEIF/AVIF decoded into it loses its transparency to solid BLACK —
+     * the tile renders as a black square on exactly the low-RAM devices the optimisation targets.
+     * Formats that can carry transparency are worth the extra 2 bytes/pixel; opaque JPEG (every
+     * camera capture and every cover frame) still takes the cheap path.
+     */
+    fun decodeConfig(mayHaveAlpha: Boolean = false): Bitmap.Config =
+      if (PREFER_565 && !mayHaveAlpha) Bitmap.Config.RGB_565 else Bitmap.Config.ARGB_8888
+
+    /**
+     * Whether this asset's container can hold transparency. Delegates to [ImageFormatSupport],
+     * which reads the MIME type first and the file name / URI extension second, so an asset that
+     * arrived without a MIME type is still classified correctly — and so adding a format there
+     * automatically fixes its alpha handling here.
+     */
+    internal fun CameraAsset.mayHaveAlphaChannel(): Boolean =
+      ImageFormatSupport.mayHaveAlpha(this)
+  }
+}
+
+private fun downscaleBitmap(source: Bitmap, targetSize: Int): Bitmap {
+  val maxDimension = maxOf(source.width, source.height)
+  if (maxDimension <= targetSize) return source
+
+  val scale = targetSize.toFloat() / maxDimension.toFloat()
+  val width = (source.width * scale).toInt().coerceAtLeast(1)
+  val height = (source.height * scale).toInt().coerceAtLeast(1)
+  val scaled = Bitmap.createScaledBitmap(source, width, height, true)
+  if (scaled !== source) {
+    source.recycle()
+  }
+  return scaled
+}
+
+/**
+ * Heuristic for "the frame extractor gave us nothing usable" — a thumbnail that is black at
+ * almost every sample point. Transparent pixels are deliberately NOT counted: a transparent
+ * GIF/PNG reads as (0,0,0,0) at every sample, which would condemn a perfectly good thumbnail
+ * as a failed decode and send it round the fallback path for the same result.
+ */
+private fun Bitmap.isMostlyBlack(): Boolean {
+  if (width <= 0 || height <= 0) return true
+
+  val samplePoints = listOf(
+    width / 2 to height / 2,
+    width / 4 to height / 4,
+    (width * 3) / 4 to height / 4,
+    width / 4 to (height * 3) / 4,
+    (width * 3) / 4 to (height * 3) / 4
+  )
+
+  var darkSamples = 0
+  for ((x, y) in samplePoints) {
+    val pixel = getPixel(x.coerceIn(0, width - 1), y.coerceIn(0, height - 1))
+    if (Color.alpha(pixel) < 16) continue
+    if (Color.red(pixel) < 20 && Color.green(pixel) < 20 && Color.blue(pixel) < 20) {
+      darkSamples++
+    }
+  }
+
+  return darkSamples >= samplePoints.size - 1
+}
+
+private fun BitmapFactory.Options.calculateSampleSize(targetSize: Int): Int {
+  var sampleSize = 1
+  val halfHeight = outHeight / 2
+  val halfWidth = outWidth / 2
+
+  while (halfHeight / sampleSize >= targetSize && halfWidth / sampleSize >= targetSize) {
+    sampleSize *= 2
+  }
+
+  return sampleSize.coerceAtLeast(1)
+}