@onekeyfe/react-native-image 3.0.155 → 3.0.157-alpha.248

package/android/src/main/java/com/margelo/nitro/onekeyimage/OneKeyImageCache.kt

@@ -1,5 +1,7 @@
 package com.margelo.nitro.onekeyimage
 
+import android.graphics.drawable.Animatable
+import android.graphics.drawable.Drawable
 import com.bumptech.glide.Glide
 import com.bumptech.glide.load.engine.DiskCacheStrategy
 import com.bumptech.glide.request.RequestOptions
@@ -65,7 +67,8 @@ class HybridOneKeyImageCache : HybridOneKeyImageCacheSpec() {
       } else source.uri
 
       val succeeded = try {
-        load(context, requestUrl, source, options, decodeDimensions)
+        val resource = load(context, requestUrl, source, options, decodeDimensions)
+        recordMemoryVariant(source, requestUrl, decodeDimensions, resource)
         true
       } catch (optimizedError: Exception) {
         if (
@@ -75,7 +78,8 @@ class HybridOneKeyImageCache : HybridOneKeyImageCacheSpec() {
           false
         } else {
           try {
-            load(context, source.uri, source, options, decodeDimensions)
+            val resource = load(context, source.uri, source, options, decodeDimensions)
+            recordMemoryVariant(source, source.uri, decodeDimensions, resource)
             true
           } catch (_: Exception) {
             false
@@ -92,6 +96,7 @@ class HybridOneKeyImageCache : HybridOneKeyImageCacheSpec() {
       ?: throw IllegalStateException("React application context is unavailable")
     withContext(Dispatchers.Main) {
       Glide.get(context).clearMemory()
+      OneKeyImageMemoryVariantRegistry.clear()
     }
   }
 
@@ -106,6 +111,7 @@ class HybridOneKeyImageCache : HybridOneKeyImageCacheSpec() {
       ?: throw IllegalStateException("React application context is unavailable")
     withContext(Dispatchers.Main) {
       Glide.get(context).clearMemory()
+      OneKeyImageMemoryVariantRegistry.clear()
     }
     Glide.get(context).clearDiskCache()
   }
@@ -116,7 +122,7 @@ class HybridOneKeyImageCache : HybridOneKeyImageCacheSpec() {
     source: OneKeyImagePreloadSource,
     options: RequestOptions,
     decodeDimensions: OneKeyImageDecodeDimensions,
-  ) {
+  ): Drawable {
     val request = Glide.with(context)
       .asDrawable()
       .load(OneKeyImageModel.build(url, source.headersJson))
@@ -124,9 +130,33 @@ class HybridOneKeyImageCache : HybridOneKeyImageCacheSpec() {
       .override(decodeDimensions.width, decodeDimensions.height)
     val future = request.submit()
     try {
-      future.get()
+      return future.get()
     } finally {
       Glide.with(context).clear(future)
     }
   }
+
+  private fun recordMemoryVariant(
+    source: OneKeyImagePreloadSource,
+    requestUrl: String,
+    decodeDimensions: OneKeyImageDecodeDimensions,
+    resource: Drawable,
+  ) {
+    val policy = source.cachePolicy ?: OneKeyImageCachePolicy.MEMORY_DISK
+    if (
+      resource is Animatable ||
+      (policy != OneKeyImageCachePolicy.MEMORY && policy != OneKeyImageCachePolicy.MEMORY_DISK)
+    ) {
+      return
+    }
+    OneKeyImageMemoryVariantRegistry.record(
+      family = OneKeyImageMemoryFamilyKey.from(source.uri, source.headersJson),
+      variant = OneKeyImageMemoryVariant(
+        requestUrl = requestUrl,
+        width = decodeDimensions.width,
+        height = decodeDimensions.height,
+        round = false,
+      ),
+    )
+  }
 }

package/android/src/main/java/com/margelo/nitro/onekeyimage/OneKeyImageMemoryVariants.kt

@@ -0,0 +1,119 @@
+package com.margelo.nitro.onekeyimage
+
+import kotlin.math.max
+import kotlin.math.min
+
+internal data class OneKeyImageMemoryFamilyKey(
+  val rawUrl: String,
+  val headersDigest: String?,
+) {
+  companion object {
+    fun from(rawUrl: String, headersJson: String?): OneKeyImageMemoryFamilyKey =
+      OneKeyImageMemoryFamilyKey(
+        rawUrl = rawUrl,
+        headersDigest = OneKeyImageModel.remoteHeadersDigest(
+          OneKeyImageModel.headers(headersJson),
+        ),
+      )
+  }
+}
+
+internal data class OneKeyImageMemoryVariant(
+  val requestUrl: String,
+  val width: Int,
+  val height: Int,
+  val round: Boolean,
+) {
+  val area: Long
+    get() = width.toLong() * height.toLong()
+}
+
+/**
+ * A bounded index of size-specific Glide resources that may still be in memory.
+ *
+ * Glide remains the source of truth. Entries are only hints used to reproduce a
+ * candidate EngineKey; a synchronous cache miss removes the stale hint.
+ */
+internal object OneKeyImageMemoryVariantRegistry {
+  private const val MAX_FAMILIES = 1024
+  private const val MAX_VARIANTS_PER_FAMILY = 8
+  private const val MAX_ASPECT_RATIO_DRIFT = 1.1
+
+  private val variantsByFamily =
+    LinkedHashMap<OneKeyImageMemoryFamilyKey, MutableList<OneKeyImageMemoryVariant>>(
+      16,
+      0.75f,
+      true,
+    )
+
+  @Synchronized
+  fun record(family: OneKeyImageMemoryFamilyKey, variant: OneKeyImageMemoryVariant) {
+    if (variant.width <= 0 || variant.height <= 0) return
+    val variants = variantsByFamily.getOrPut(family) { mutableListOf() }
+    variants.remove(variant)
+    variants.add(variant)
+    while (variants.size > MAX_VARIANTS_PER_FAMILY) variants.removeAt(0)
+    while (variantsByFamily.size > MAX_FAMILIES) {
+      val eldest = variantsByFamily.entries.firstOrNull()?.key ?: break
+      variantsByFamily.remove(eldest)
+    }
+  }
+
+  @Synchronized
+  fun remove(family: OneKeyImageMemoryFamilyKey, variant: OneKeyImageMemoryVariant) {
+    val variants = variantsByFamily[family] ?: return
+    variants.remove(variant)
+    if (variants.isEmpty()) variantsByFamily.remove(family)
+  }
+
+  @Synchronized
+  fun candidates(
+    family: OneKeyImageMemoryFamilyKey,
+    target: OneKeyImageMemoryVariant,
+  ): List<OneKeyImageMemoryVariant> = orderedCandidates(
+    variants = variantsByFamily[family].orEmpty(),
+    target = target,
+  )
+
+  @Synchronized
+  fun clear() {
+    variantsByFamily.clear()
+  }
+
+  internal fun orderedCandidates(
+    variants: List<OneKeyImageMemoryVariant>,
+    target: OneKeyImageMemoryVariant,
+  ): List<OneKeyImageMemoryVariant> {
+    val compatible = variants
+      .asSequence()
+      .filter { it != target }
+      .filter { candidate -> target.round || !candidate.round }
+      .filter { candidate -> aspectRatioIsCompatible(candidate, target) }
+      .distinct()
+      .toList()
+
+    val larger = compatible
+      .filter { it.width >= target.width && it.height >= target.height }
+      .minWithOrNull(
+        compareBy<OneKeyImageMemoryVariant> { it.area }
+          .thenBy { if (it.round == target.round) 0 else 1 },
+      )
+    val smaller = compatible
+      .filter { it.width <= target.width && it.height <= target.height }
+      .maxWithOrNull(
+        compareBy<OneKeyImageMemoryVariant> { it.area }
+          .thenByDescending { if (it.round == target.round) 0 else 1 },
+      )
+    return listOfNotNull(larger, smaller).distinct()
+  }
+
+  private fun aspectRatioIsCompatible(
+    candidate: OneKeyImageMemoryVariant,
+    target: OneKeyImageMemoryVariant,
+  ): Boolean {
+    val candidateRatio = candidate.width.toDouble() / candidate.height.toDouble()
+    val targetRatio = target.width.toDouble() / target.height.toDouble()
+    return max(candidateRatio, targetRatio) / min(candidateRatio, targetRatio) <=
+      MAX_ASPECT_RATIO_DRIFT
+  }
+}

package/android/src/main/java/com/margelo/nitro/onekeyimage/OneKeyImageReusableView.kt

@@ -29,6 +29,7 @@ class OneKeyImageReusableView(context: ThemedReactContext) : FrameLayout(context
     overscan: Double,
     loadingStrategy: String,
     placeholderColor: String,
+    round: Boolean = false,
     onLoad: (() -> Unit)? = null,
     onError: (() -> Unit)? = null,
   ) {
@@ -57,6 +58,7 @@ class OneKeyImageReusableView(context: ThemedReactContext) : FrameLayout(context
     image.autoplay = autoplay
     image.recyclingKey = recyclingKey
     image.optimizeTos = optimizeTos
+    image.round = round
     image.overscan = overscan
     image.loadingStrategy = when (loadingStrategy) {
       "skeleton" -> OneKeyImageLoadingStrategy.SKELETON

package/android/src/test/java/com/margelo/nitro/onekeyimage/OneKeyImageMemoryVariantsTest.kt

@@ -0,0 +1,149 @@
+package com.margelo.nitro.onekeyimage
+
+import com.bumptech.glide.load.engine.DiskCacheStrategy
+import com.bumptech.glide.request.RequestOptions
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class OneKeyImageMemoryVariantsTest {
+  @Test
+  fun choosesNearestLargerThenNearestSmallerVariant() {
+    val target = variant(96)
+    val candidates = OneKeyImageMemoryVariantRegistry.orderedCandidates(
+      variants = listOf(variant(48), variant(72), variant(120), variant(144)),
+      target = target,
+    )
+
+    assertEquals(listOf(variant(120), variant(72)), candidates)
+  }
+
+  @Test
+  fun ignoresExactAndIncompatibleAspectRatios() {
+    val target = variant(96)
+    val candidates = OneKeyImageMemoryVariantRegistry.orderedCandidates(
+      variants = listOf(
+        target,
+        OneKeyImageMemoryVariant("wide", 120, 60, round = false),
+        variant(120),
+      ),
+      target = target,
+    )
+
+    assertEquals(listOf(variant(120)), candidates)
+  }
+
+  @Test
+  fun roundTargetCanPreviewUntransformedResourceButSquareTargetCannotUseRoundResource() {
+    val untransformed = variant(120, round = false)
+    val transformed = variant(120, round = true)
+
+    assertEquals(
+      listOf(untransformed),
+      OneKeyImageMemoryVariantRegistry.orderedCandidates(
+        variants = listOf(untransformed),
+        target = variant(96, round = true),
+      ),
+    )
+    assertEquals(
+      emptyList<OneKeyImageMemoryVariant>(),
+      OneKeyImageMemoryVariantRegistry.orderedCandidates(
+        variants = listOf(transformed),
+        target = variant(96, round = false),
+      ),
+    )
+  }
+
+  @Test
+  fun crossSizeCenterPreviewUsesTemporaryScaling() {
+    assertTrue(
+      shouldScaleCenterMemoryPreview(
+        contentFit = OneKeyImageContentFit.CENTER,
+        candidate = variant(48),
+        target = variant(96),
+      ),
+    )
+    assertTrue(
+      shouldScaleCenterMemoryPreview(
+        contentFit = OneKeyImageContentFit.CENTER,
+        candidate = variant(144),
+        target = variant(96),
+      ),
+    )
+    assertFalse(
+      shouldScaleCenterMemoryPreview(
+        contentFit = OneKeyImageContentFit.CENTER,
+        candidate = variant(96),
+        target = variant(96),
+      ),
+    )
+    assertFalse(
+      shouldScaleCenterMemoryPreview(
+        contentFit = OneKeyImageContentFit.COVER,
+        candidate = variant(48),
+        target = variant(96),
+      ),
+    )
+  }
+
+  @Test
+  fun missingPreviewDrawableAllowsSameFamilyProbeRetry() {
+    assertTrue(
+      shouldProbeMemoryPreview(
+        hasTarget = true,
+        sameFamily = true,
+        hasDrawable = false,
+      ),
+    )
+    assertFalse(
+      shouldProbeMemoryPreview(
+        hasTarget = true,
+        sameFamily = true,
+        hasDrawable = true,
+      ),
+    )
+  }
+
+  @Test
+  fun replacingMemoryPreviewSkipsWholeViewFade() {
+    assertFalse(
+      shouldAnimateLoadedImageTransition(
+        cacheType = OneKeyImageCacheType.DISK,
+        fadeDelayElapsed = true,
+        animationsEnabled = true,
+        replacingMemoryPreview = true,
+      ),
+    )
+    assertTrue(
+      shouldAnimateLoadedImageTransition(
+        cacheType = OneKeyImageCacheType.DISK,
+        fadeDelayElapsed = true,
+        animationsEnabled = true,
+        replacingMemoryPreview = false,
+      ),
+    )
+  }
+
+  @Test
+  fun memoryProbeKeepsMemoryEnabledAndDisablesDiskReads() {
+    val options = memoryProbeRequestOptions(
+      RequestOptions().diskCacheStrategy(DiskCacheStrategy.AUTOMATIC),
+    )
+
+    assertSame(DiskCacheStrategy.NONE, options.diskCacheStrategy)
+    assertTrue(options.onlyRetrieveFromCache)
+    assertTrue(options.isMemoryCacheable)
+  }
+
+  private fun variant(
+    size: Int,
+    round: Boolean = false,
+  ) = OneKeyImageMemoryVariant(
+    requestUrl = "https://example.com/image-$size.png",
+    width = size,
+    height = size,
+    round = round,
+  )
+}

package/android/src/test/java/com/margelo/nitro/onekeyimage/OneKeyImageRequestSignatureTest.kt

@@ -26,7 +26,19 @@ class OneKeyImageRequestSignatureTest {
     )
   }
 
-  private fun signature(contentFit: OneKeyImageContentFit?, resizeWidth: Double? = null): String = oneKeyImageRequestSignature(
+  @Test
+  fun roundParticipatesInRequestIdentity() {
+    assertNotEquals(
+      signature(OneKeyImageContentFit.COVER, round = false),
+      signature(OneKeyImageContentFit.COVER, round = true),
+    )
+  }
+
+  private fun signature(
+    contentFit: OneKeyImageContentFit?,
+    resizeWidth: Double? = null,
+    round: Boolean = false,
+  ): String = oneKeyImageRequestSignature(
     rawUrl = "https://example.com/image.png",
     sourceHeadersJson = null,
     recyclingKey = null,
@@ -34,6 +46,7 @@ class OneKeyImageRequestSignatureTest {
     contentFit = contentFit,
     optimizeTos = true,
     overscan = 1.1,
+    round = round,
     width = 200,
     height = 100,
     density = 2f,