react-native-photo-video-editor 0.1.0

package/android/src/main/java/com/photovideoeditor/stickers/OpenMojiCatalog.kt

@@ -0,0 +1,172 @@
+package com.photovideoeditor.stickers
+
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.concurrent.Executors
+
+/** One entry from OpenMoji's `data/openmoji.json` index. */
+data class OpenMojiEntry(
+  val emoji: String,
+  val hexcode: String,
+  val group: String,
+  val annotation: String,
+  val tags: String
+)
+
+/**
+ * Fetches and disk-caches the OpenMoji catalog index (CC BY-SA 4.0, https://openmoji.org),
+ * exposing search/filter helpers plus the CDN URL builders for thumbnail/full-res assets.
+ *
+ * Networking uses plain [HttpURLConnection] on a background executor (this codebase has no
+ * networking dependency and shouldn't gain one for a simple GET) and parses with
+ * [org.json.JSONArray]/[org.json.JSONObject], matching the JSON style already used elsewhere
+ * (e.g. `PhotoVideoEditorActivity`'s `stickerAssets` parsing).
+ */
+object OpenMojiCatalog {
+  private const val INDEX_URL =
+    "https://cdn.jsdelivr.net/gh/hfg-gmuend/openmoji@master/data/openmoji.json"
+  private const val CACHE_FILE_NAME = "openmoji_index.json"
+  private const val CACHE_TIMESTAMP_PREFS = "openmoji_cache"
+  private const val CACHE_TIMESTAMP_KEY = "fetched_at"
+  private val CACHE_TTL_MS = 7L * 24L * 60L * 60L * 1000L
+
+  /** Fixed, sensible display order for the "All" chip row; unknown groups are appended after. */
+  private val GROUP_DISPLAY_ORDER = listOf(
+    "smileys-emotion",
+    "people-body",
+    "animals-nature",
+    "food-drink",
+    "travel-places",
+    "activities",
+    "objects",
+    "symbols",
+    "flags"
+  )
+
+  private val executor = Executors.newSingleThreadExecutor { task -> Thread(task, "openmoji-catalog") }
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  @Volatile private var cachedEntries: List<OpenMojiEntry>? = null
+
+  /**
+   * Loads the catalog (memory -> disk cache -> network, falling back to any cached copy on
+   * network failure), delivering the result on the main thread.
+   */
+  fun load(context: Context, onResult: (entries: List<OpenMojiEntry>?, error: Exception?) -> Unit) {
+    val inMemory = cachedEntries
+    if (inMemory != null) {
+      mainHandler.post { onResult(inMemory, null) }
+      return
+    }
+    val appContext = context.applicationContext
+    executor.execute {
+      try {
+        val entries = loadBlocking(appContext)
+        cachedEntries = entries
+        mainHandler.post { onResult(entries, null) }
+      } catch (e: Exception) {
+        mainHandler.post { onResult(null, e) }
+      }
+    }
+  }
+
+  private fun loadBlocking(context: Context): List<OpenMojiEntry> {
+    val cacheFile = File(context.cacheDir, CACHE_FILE_NAME)
+    val cacheAgeMs = cacheAgeMs(context)
+    val cacheFresh = cacheFile.exists() && cacheAgeMs != null && cacheAgeMs < CACHE_TTL_MS
+
+    if (cacheFresh) {
+      return parse(cacheFile.readText())
+    }
+
+    return try {
+      val json = fetch(INDEX_URL)
+      cacheFile.writeText(json)
+      markCacheTimestamp(context)
+      parse(json)
+    } catch (e: Exception) {
+      // Network failed: fall back to any cached copy, regardless of age, per spec.
+      if (cacheFile.exists()) parse(cacheFile.readText()) else throw e
+    }
+  }
+
+  private fun fetch(urlString: String): String {
+    val connection = URL(urlString).openConnection() as HttpURLConnection
+    connection.instanceFollowRedirects = true
+    connection.connectTimeout = 15_000
+    connection.readTimeout = 30_000
+    connection.requestMethod = "GET"
+    try {
+      val code = connection.responseCode
+      if (code !in 200..299) throw java.io.IOException("HTTP $code fetching $urlString")
+      return connection.inputStream.bufferedReader().use { it.readText() }
+    } finally {
+      connection.disconnect()
+    }
+  }
+
+  private fun parse(json: String): List<OpenMojiEntry> {
+    val array = JSONArray(json)
+    val result = ArrayList<OpenMojiEntry>(array.length())
+    for (i in 0 until array.length()) {
+      val obj: JSONObject = array.optJSONObject(i) ?: continue
+      val hexcode = obj.optString("hexcode").takeIf { it.isNotBlank() } ?: continue
+      result.add(
+        OpenMojiEntry(
+          emoji = obj.optString("emoji"),
+          hexcode = hexcode,
+          group = obj.optString("group"),
+          annotation = obj.optString("annotation"),
+          tags = obj.optString("tags")
+        )
+      )
+    }
+    return result
+  }
+
+  private fun cacheAgeMs(context: Context): Long? {
+    val prefs = context.getSharedPreferences(CACHE_TIMESTAMP_PREFS, Context.MODE_PRIVATE)
+    val fetchedAt = prefs.getLong(CACHE_TIMESTAMP_KEY, -1L)
+    if (fetchedAt < 0) return null
+    return System.currentTimeMillis() - fetchedAt
+  }
+
+  private fun markCacheTimestamp(context: Context) {
+    context.getSharedPreferences(CACHE_TIMESTAMP_PREFS, Context.MODE_PRIVATE)
+      .edit()
+      .putLong(CACHE_TIMESTAMP_KEY, System.currentTimeMillis())
+      .apply()
+  }
+
+  fun groups(): List<String> {
+    val entries = cachedEntries ?: return emptyList()
+    val present = entries.map { it.group }.distinct()
+    val ordered = GROUP_DISPLAY_ORDER.filter { it in present }
+    val rest = present.filter { it !in GROUP_DISPLAY_ORDER }.sorted()
+    return ordered + rest
+  }
+
+  fun byGroup(group: String): List<OpenMojiEntry> =
+    cachedEntries?.filter { it.group == group } ?: emptyList()
+
+  fun search(query: String): List<OpenMojiEntry> {
+    val entries = cachedEntries ?: return emptyList()
+    val needle = query.trim().lowercase()
+    if (needle.isEmpty()) return entries
+    return entries.filter {
+      it.annotation.lowercase().contains(needle) || it.tags.lowercase().contains(needle)
+    }
+  }
+
+  fun thumbnailUrl(hexcode: String): String =
+    "https://cdn.jsdelivr.net/gh/hfg-gmuend/openmoji@master/color/72x72/$hexcode.png"
+
+  fun fullUrl(hexcode: String): String =
+    "https://cdn.jsdelivr.net/gh/hfg-gmuend/openmoji@master/color/618x618/$hexcode.png"
+}

package/android/src/main/java/com/photovideoeditor/stickers/RemoteImageLoader.kt

@@ -0,0 +1,110 @@
+package com.photovideoeditor.stickers
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.os.Handler
+import android.os.Looper
+import android.util.LruCache
+import android.widget.ImageView
+import java.io.File
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.MessageDigest
+import java.util.concurrent.Executors
+
+/**
+ * Small async image pipeline for the online-stickers sheet: thumbnails for the grid (memory LRU
+ * + disk cache) and full-res download-on-tap for the sticker that gets inserted as a layer.
+ *
+ * No image library dependency (Glide/Coil/Picasso) is used, matching this codebase's
+ * dependency-light approach elsewhere.
+ */
+object RemoteImageLoader {
+  private val executor = Executors.newFixedThreadPool(4) { task -> Thread(task, "openmoji-image") }
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  private val memoryCache = object : LruCache<String, Bitmap>(8 * 1024 * 1024) {
+    override fun sizeOf(key: String, value: Bitmap): Int = value.byteCount
+  }
+
+  private fun diskCacheDir(context: Context): File =
+    File(context.cacheDir, "openmoji").apply { mkdirs() }
+
+  private fun cacheFileFor(context: Context, url: String): File {
+    val name = MessageDigest.getInstance("MD5").digest(url.toByteArray())
+      .joinToString("") { "%02x".format(it) }
+    return File(diskCacheDir(context), "$name.png")
+  }
+
+  /**
+   * Loads [url] into [imageView], tagging the view with the URL being loaded so a recycled
+   * RecyclerView cell doesn't get a stale bitmap set on it after the fact.
+   */
+  fun loadThumbnail(context: Context, url: String, imageView: ImageView) {
+    imageView.tag = url
+    val memoryHit = memoryCache.get(url)
+    if (memoryHit != null) {
+      imageView.setImageBitmap(memoryHit)
+      return
+    }
+    imageView.setImageDrawable(null)
+    val appContext = context.applicationContext
+    executor.execute {
+      val bitmap = try {
+        val cacheFile = cacheFileFor(appContext, url)
+        if (cacheFile.exists()) {
+          BitmapFactory.decodeFile(cacheFile.absolutePath)
+        } else {
+          val bytes = download(url)
+          cacheFile.writeBytes(bytes)
+          BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+        }
+      } catch (_: Exception) {
+        null
+      }
+      if (bitmap != null) {
+        memoryCache.put(url, bitmap)
+        mainHandler.post {
+          if (imageView.tag == url) imageView.setImageBitmap(bitmap)
+        }
+      }
+    }
+  }
+
+  /**
+   * Downloads (or returns the cached copy of) the full-res sticker image, delivering the local
+   * file path on the main thread.
+   */
+  fun downloadFull(context: Context, url: String, onResult: (localFilePath: String?, error: Exception?) -> Unit) {
+    val appContext = context.applicationContext
+    executor.execute {
+      try {
+        val cacheFile = cacheFileFor(appContext, url)
+        if (!cacheFile.exists()) {
+          val bytes = download(url)
+          FileOutputStream(cacheFile).use { it.write(bytes) }
+        }
+        mainHandler.post { onResult(cacheFile.absolutePath, null) }
+      } catch (e: Exception) {
+        mainHandler.post { onResult(null, e) }
+      }
+    }
+  }
+
+  private fun download(urlString: String): ByteArray {
+    val connection = URL(urlString).openConnection() as HttpURLConnection
+    connection.instanceFollowRedirects = true
+    connection.connectTimeout = 15_000
+    connection.readTimeout = 30_000
+    connection.requestMethod = "GET"
+    try {
+      val code = connection.responseCode
+      if (code !in 200..299) throw java.io.IOException("HTTP $code fetching $urlString")
+      return connection.inputStream.use { it.readBytes() }
+    } finally {
+      connection.disconnect()
+    }
+  }
+}

package/android/src/main/java/com/photovideoeditor/ui/DesignTokens.kt

@@ -0,0 +1,93 @@
+package com.photovideoeditor.ui
+
+import android.graphics.Color
+
+/**
+ * Default values for the "Studio Violet" design system used by the native editor
+ * shell, matching the Stitch-exported mockups under
+ * stitch_react_native_photo_editor_sdk/studio_violet_creative_sdk/DESIGN.md.
+ * These are FALLBACKS only — every color a consumer can already override via
+ * `EditorOptions.theme` (see `PhotoVideoEditorActivity.themeColor`) still wins;
+ * this object just changes what the editor looks like when no override is given.
+ */
+object DesignTokens {
+  // Surface hierarchy
+  const val surfaceDim = 0xFF131316.toInt()
+  const val surface = 0xFF131316.toInt()
+  const val surfaceContainerLowest = 0xFF0E0E11.toInt()
+  const val surfaceContainerLow = 0xFF1B1B1E.toInt()
+  const val surfaceContainer = 0xFF1F1F22.toInt()
+  const val surfaceContainerHigh = 0xFF2A2A2D.toInt()
+  const val surfaceContainerHighest = 0xFF353438.toInt()
+  const val surfaceVariant = 0xFF353438.toInt()
+  const val surfaceBright = 0xFF39393C.toInt()
+
+  // Content
+  const val onSurface = 0xFFE4E1E6.toInt()
+  const val onSurfaceVariant = 0xFFCCC3D8.toInt()
+  const val outline = 0xFF958DA1.toInt()
+  const val outlineVariant = 0xFF4A4455.toInt()
+
+  // Accents
+  const val primary = 0xFFD2BBFF.toInt()
+  const val onPrimary = 0xFF3F008E.toInt()
+  const val primaryContainer = 0xFF7C3AED.toInt()
+  const val onPrimaryContainer = 0xFFEDE0FF.toInt()
+  const val secondary = 0xFFC0C1FF.toInt()
+  const val tertiary = 0xFFD0BCFF.toInt()
+  const val error = 0xFFFFB4AB.toInt()
+  const val errorContainer = 0xFF93000A.toInt()
+
+  // Literal Stitch accent hexes (DESIGN.md "Primary Accents & Active States"), used by the
+  // new EditorUI components below where the exact mockup hue matters more than the M3 mapping.
+  const val accentViolet = 0xFF7C3AED.toInt()
+  const val accentIndigo = 0xFF6366F1.toInt()
+  const val accentHighlightViolet = 0xFF8B5CF6.toInt()
+
+  // Literal Stitch surface hexes (DESIGN.md "Canvas & Surface Hierarchy").
+  const val canvasViewport = 0xFF09090B.toInt()
+  const val editorSurface = 0xFF121214.toInt()
+  const val elevatedPanel = 0xFF18181B.toInt()
+  const val interactiveNeutral = 0xFF27272A.toInt()
+  const val mutedBorderColor = 0xFF3F3F46.toInt()
+
+  // Literal Stitch text hexes (DESIGN.md "Typography & Content Grayscale").
+  const val textPrimary = 0xFFFFFFFF.toInt()
+  const val textSecondary = 0xFFA1A1AA.toInt()
+  const val textSubtle = 0xFF71717A.toInt()
+
+  // Backwards-compatible aliases matching the flatter names `themeColor()` fallbacks used before this pass.
+  const val toolbarColor = surfaceContainerLow
+  const val backgroundColor = surfaceContainerLowest
+  const val textColor = onSurface
+  const val primaryColor = primaryContainer
+
+  /** [color] at [alphaPercent]% opacity (0..100), matching the mockups' translucent surface tiers. */
+  fun withAlphaPercent(color: Int, alphaPercent: Int): Int {
+    val alpha = ((alphaPercent.coerceIn(0, 100)) * 255 / 100)
+    return Color.argb(alpha, Color.red(color), Color.green(color), Color.blue(color))
+  }
+
+  // Spacing (dp), matching DESIGN.md's `space-*` scale.
+  const val spaceXs = 4
+  const val spaceSm = 8
+  const val spaceMd = 12
+  const val spaceLg = 16
+  const val spaceXl = 20
+  const val space2xl = 24
+  const val space3xl = 32
+  const val touchTargetMin = 44
+
+  // Corner radii (dp)
+  const val radiusSm = 4
+  const val radiusMd = 8
+  const val radiusLg = 12
+  const val radiusXl = 16
+  const val radiusSheet = 24
+
+  // Elevation tiers (DESIGN.md "Elevation & Depth"): background color + opacity percent
+  // to composite persistent chrome / floating trays / popovers over the canvas.
+  object ElevationTier1 { const val color = editorSurface; const val opacityPercent = 92 }
+  object ElevationTier2 { const val color = elevatedPanel; const val opacityPercent = 88 }
+  object ElevationTier3 { const val color = interactiveNeutral; const val opacityPercent = 100 }
+}

package/android/src/main/java/com/photovideoeditor/ui/components/EditorComponents.kt

@@ -0,0 +1,119 @@
+package com.photovideoeditor.ui.components
+
+import android.content.Context
+import android.graphics.Typeface
+import android.graphics.drawable.GradientDrawable
+import android.view.Gravity
+import android.view.MotionEvent
+import android.view.View
+import android.widget.FrameLayout
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.TextView
+import com.photovideoeditor.ui.DesignTokens
+
+/**
+ * Shared "Studio Violet" UI primitives (DESIGN.md), reused across the photo/video editor shell
+ * instead of hand-rolling styling per screen. Kept as small factory functions rather than View
+ * subclasses to match this codebase's existing `create*`/`actionButton` builder style.
+ */
+
+fun dpToPx(dp: Int, context: Context): Int = (dp * context.resources.displayMetrics.density).toInt()
+
+fun roundedDrawable(
+  color: Int,
+  radiusDp: Int,
+  context: Context,
+  strokeColor: Int? = null,
+  strokeWidthDp: Int = 1
+): GradientDrawable = GradientDrawable().apply {
+  cornerRadius = dpToPx(radiusDp, context).toFloat()
+  setColor(color)
+  if (strokeColor != null) setStroke(dpToPx(strokeWidthDp, context).coerceAtLeast(1), strokeColor)
+}
+
+/**
+ * Tactile press feedback (scale 1.0 -> 0.97) matching DESIGN.md's "Tactile Instrument Feel".
+ * Returns false so the view's own click handling (existing `setOnClickListener`) still fires.
+ */
+fun View.applyPressScale(pressedScale: Float = 0.97f) {
+  setOnTouchListener { v, event ->
+    when (event.actionMasked) {
+      MotionEvent.ACTION_DOWN -> v.animate().scaleX(pressedScale).scaleY(pressedScale).setDuration(80).start()
+      MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL ->
+        v.animate().scaleX(1f).scaleY(1f).setDuration(120).start()
+    }
+    false
+  }
+}
+
+/** Elevated rounded container (DESIGN.md "Elevated Panels & Tiles"), used for cards/tiles/sheets. */
+fun editorCard(
+  context: Context,
+  radiusDp: Int = DesignTokens.radiusLg,
+  backgroundColor: Int = DesignTokens.elevatedPanel,
+  borderColor: Int? = DesignTokens.interactiveNeutral
+): FrameLayout = FrameLayout(context).apply {
+  background = roundedDrawable(backgroundColor, radiusDp, context, strokeColor = borderColor)
+}
+
+/** Pill chip for quick actions / filter tags (DESIGN.md "Chips & Filter Presets"). */
+fun editorChip(context: Context, text: String, selected: Boolean, onClick: () -> Unit): TextView =
+  TextView(context).apply {
+    this.text = text
+    textSize = 12f
+    gravity = Gravity.CENTER
+    minHeight = dpToPx(32, context)
+    setTextColor(if (selected) DesignTokens.textPrimary else DesignTokens.textSecondary)
+    background = roundedDrawable(
+      color = if (selected) DesignTokens.accentViolet else DesignTokens.elevatedPanel,
+      radiusDp = 16,
+      context = context,
+      strokeColor = if (selected) null else DesignTokens.interactiveNeutral
+    )
+    val padH = dpToPx(DesignTokens.spaceLg, context)
+    setPadding(padH, dpToPx(DesignTokens.spaceXs, context), padH, dpToPx(DesignTokens.spaceXs, context))
+    isClickable = true
+    isFocusable = true
+    setOnClickListener { onClick() }
+    applyPressScale()
+  }
+
+/**
+ * Primary Export CTA (DESIGN.md "Primary Export Button"): solid violet fill, 44dp min height,
+ * 12px radius, subtle elevation glow, 0.97 press scale.
+ */
+fun editorPrimaryButton(
+  context: Context,
+  text: String,
+  iconRes: Int? = null,
+  fillColor: Int = DesignTokens.accentViolet,
+  textColor: Int = DesignTokens.textPrimary,
+  onClick: () -> Unit
+): LinearLayout = LinearLayout(context).apply {
+  orientation = LinearLayout.HORIZONTAL
+  gravity = Gravity.CENTER
+  background = roundedDrawable(fillColor, DesignTokens.radiusLg, context)
+  elevation = dpToPx(4, context).toFloat()
+  minimumHeight = dpToPx(DesignTokens.touchTargetMin, context)
+  setPadding(dpToPx(DesignTokens.spaceLg, context), 0, dpToPx(DesignTokens.spaceLg, context), 0)
+  isClickable = true
+  isFocusable = true
+  if (iconRes != null) {
+    addView(
+      ImageView(context).apply {
+        setImageResource(iconRes)
+        setColorFilter(textColor)
+      },
+      LinearLayout.LayoutParams(dpToPx(18, context), dpToPx(18, context)).apply { marginEnd = dpToPx(DesignTokens.spaceXs, context) }
+    )
+  }
+  addView(TextView(context).apply {
+    this.text = text
+    setTextColor(textColor)
+    textSize = 13f
+    setTypeface(typeface, Typeface.BOLD)
+  })
+  setOnClickListener { onClick() }
+  applyPressScale()
+}

package/android/src/main/java/com/photovideoeditor/validation/EditorRequestValidator.kt

@@ -0,0 +1,11 @@
+package com.photovideoeditor.validation
+
+import com.photovideoeditor.model.EditorRequest
+
+internal object EditorRequestValidator {
+  fun validate(request: EditorRequest): String? = when {
+    request.uri.isBlank() -> "E_INVALID_URI"
+    request.mediaType != "photo" && request.mediaType != "video" -> "E_UNSUPPORTED_MEDIA_TYPE"
+    else -> null
+  }
+}

package/android/src/main/java/com/photovideoeditor/video/cache/TimelineThumbnailRepository.kt

@@ -0,0 +1,130 @@
+package com.photovideoeditor.video.cache
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.os.Build
+import android.util.LruCache
+import java.io.File
+import java.security.MessageDigest
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
+
+object TimelineThumbnailKey {
+  fun create(mediaId: String, timestampMs: Long, width: Int, height: Int): String =
+    "timeline_${mediaId.sha256()}_${timestampMs}_${width}x$height"
+
+  private fun String.sha256(): String = MessageDigest.getInstance("SHA-256")
+    .digest(toByteArray()).take(12).joinToString("") { "%02x".format(it) }
+}
+
+/** Bounded memory -> disk -> decoder pipeline for timeline thumbnails. */
+class TimelineThumbnailRepository(
+  context: Context,
+  private val maxDiskBytes: Long = 96L * 1024L * 1024L,
+) {
+  class Request internal constructor() {
+    private val cancelled = AtomicBoolean(false)
+    fun cancel() { cancelled.set(true) }
+    internal fun isCancelled() = cancelled.get()
+  }
+
+  private val appContext = context.applicationContext
+  private val cacheDir = File(appContext.cacheDir, "pve_timeline_thumbnails").apply { mkdirs() }
+  private val executor = Executors.newFixedThreadPool(2) { task ->
+    Thread(task, "timeline-thumbnail").apply { priority = Thread.NORM_PRIORITY - 1 }
+  }
+  private val requests = ConcurrentHashMap.newKeySet<Request>()
+  private val memoryLimitKb = (Runtime.getRuntime().maxMemory() / 16 / 1024)
+    .coerceIn(4L * 1024L, 64L * 1024L).toInt()
+  private val memory = object : LruCache<String, Bitmap>(memoryLimitKb) {
+    override fun sizeOf(key: String, value: Bitmap): Int = value.allocationByteCount / 1024
+  }
+
+  fun load(
+    mediaId: String,
+    uri: Uri,
+    durationMs: Long,
+    count: Int,
+    width: Int,
+    height: Int,
+    onThumbnail: (index: Int, bitmap: Bitmap) -> Unit,
+    onComplete: () -> Unit,
+  ): Request {
+    val request = Request()
+    requests.add(request)
+    executor.execute {
+      val retriever = MediaMetadataRetriever()
+      try {
+        retriever.setDataSource(appContext, uri)
+        val safeCount = count.coerceIn(1, 24)
+        val step = durationMs.coerceAtLeast(1) / safeCount
+        for (index in 0 until safeCount) {
+          if (request.isCancelled()) break
+          val timestampMs = index * step + step / 2
+          val key = TimelineThumbnailKey.create(mediaId, timestampMs, width, height)
+          val bitmap = memory.get(key) ?: readDisk(key) ?: decode(retriever, timestampMs, width, height)?.also {
+            memory.put(key, it)
+            writeDisk(key, it)
+          }
+          if (bitmap != null && !request.isCancelled()) onThumbnail(index, bitmap)
+        }
+        if (!request.isCancelled()) onComplete()
+      } catch (_: Exception) {
+        if (!request.isCancelled()) onComplete()
+      } finally {
+        retriever.release()
+        requests.remove(request)
+        trimDisk()
+      }
+    }
+    return request
+  }
+
+  private fun decode(retriever: MediaMetadataRetriever, timestampMs: Long, width: Int, height: Int): Bitmap? {
+    val frame = if (Build.VERSION.SDK_INT >= 27) {
+      retriever.getScaledFrameAtTime(timestampMs * 1000, MediaMetadataRetriever.OPTION_CLOSEST_SYNC, width, height)
+    } else {
+      retriever.getFrameAtTime(timestampMs * 1000, MediaMetadataRetriever.OPTION_CLOSEST_SYNC)?.let {
+        Bitmap.createScaledBitmap(it, width, height, true).also { scaled -> if (scaled !== it) it.recycle() }
+      }
+    }
+    return frame
+  }
+
+  private fun readDisk(key: String): Bitmap? {
+    val file = diskFile(key).takeIf { it.isFile } ?: return null
+    return BitmapFactory.decodeFile(file.absolutePath)?.also {
+      memory.put(key, it)
+      file.setLastModified(System.currentTimeMillis())
+    }
+  }
+
+  private fun writeDisk(key: String, bitmap: Bitmap) {
+    runCatching { diskFile(key).outputStream().buffered().use { bitmap.compress(Bitmap.CompressFormat.JPEG, 82, it) } }
+  }
+
+  private fun trimDisk() {
+    val files = cacheDir.listFiles()?.sortedBy { it.lastModified() } ?: return
+    var bytes = files.sumOf { it.length() }
+    for (file in files) {
+      if (bytes <= maxDiskBytes) break
+      bytes -= file.length()
+      file.delete()
+    }
+  }
+
+  private fun diskFile(key: String) = File(cacheDir, "$key.jpg")
+
+  fun clearMemory() = memory.evictAll()
+
+  fun close() {
+    requests.forEach(Request::cancel)
+    requests.clear()
+    executor.shutdownNow()
+    memory.evictAll()
+  }
+}