@onekeyfe/react-native-image 3.0.104 → 3.0.106

package/OneKeyImage.podspec

@@ -12,8 +12,9 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => "https://github.com/OneKeyHQ/app-modules.git", :tag => "#{s.version}" }
 
-  s.source_files = ["ios/**/*.{swift,m,mm}", "cpp/**/*.{hpp,cpp}"]
+  s.source_files = ["ios/**/*.{h,swift,m,mm}", "cpp/**/*.{hpp,cpp}"]
   s.exclude_files = "ios/tests/**/*"
+  s.public_header_files = ["ios/OneKeyImageCoderBridge.h"]
 
   s.dependency "React-jsi"
   s.dependency "React-callinvoker"

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

@@ -0,0 +1,264 @@
+// OneKey patch: Render the versioned local avatar URI without a JS PNG payload.
+// Algorithm ported from ethereum-blockies-base64 1.0.2 by MyCrypto (MIT):
+// https://github.com/MyCryptoHQ/ethereum-blockies-base64
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package com.margelo.nitro.onekeyimage
+
+import java.io.ByteArrayOutputStream
+import java.io.DataOutputStream
+import java.nio.ByteBuffer
+import java.nio.charset.CodingErrorAction
+import java.util.concurrent.CancellationException
+import java.util.concurrent.FutureTask
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.zip.CRC32
+import java.util.zip.Deflater
+import java.util.zip.DeflaterOutputStream
+import java.util.zip.DataFormatException
+import java.util.zip.Inflater
+import kotlin.math.floor
+
+internal data class OneKeyBlockieAvatarModel(val uri: String)
+
+internal object OneKeyBlockieAvatar {
+  const val URI_PREFIX = "onekey-avatar://blockie/v1/"
+  const val SIZE = 128
+  const val MAX_PNG_BYTES = SIZE * (SIZE / 4 + 1) + 128
+
+  fun isAvatarUri(uri: String): Boolean = uri.startsWith("onekey-avatar:")
+
+  fun decodeSeed(uri: String, isCancelled: () -> Boolean = { false }): String {
+    require(uri.startsWith(URI_PREFIX)) { "Unsupported avatar URI version" }
+    val encoded = uri.substring(URI_PREFIX.length)
+    require(encoded.isNotEmpty()) { "Avatar seed is empty" }
+    val bytes = ByteArrayOutputStream(encoded.length)
+    var index = 0
+    while (index < encoded.length) {
+      if (index % 256 == 0 && isCancelled()) throw CancellationException("Avatar generation cancelled")
+      val char = encoded[index]
+      if (char == '%') {
+        require(index + 2 < encoded.length) { "Invalid avatar percent encoding" }
+        val high = encoded[index + 1].digitToIntOrNull(16)
+        val low = encoded[index + 2].digitToIntOrNull(16)
+        require(high != null && low != null) { "Invalid avatar percent encoding" }
+        bytes.write((high shl 4) or low)
+        index += 3
+      } else {
+        require(char in 'a'..'z' || char in 'A'..'Z' || char in '0'..'9' || char in "-_.!~*'()") {
+          "Invalid avatar URI component"
+        }
+        bytes.write(char.code)
+        index += 1
+      }
+    }
+    // The app already applies JavaScript lowercase; JVM Unicode casing differs.
+    return Charsets.UTF_8.newDecoder()
+      .onMalformedInput(CodingErrorAction.REPORT)
+      .onUnmappableCharacter(CodingErrorAction.REPORT)
+      .decode(ByteBuffer.wrap(bytes.toByteArray()))
+      .toString()
+  }
+
+  // Only our fixed v1 encoder format is accepted, never arbitrary user PNG data.
+  fun isValidPng(bytes: ByteArray, isCancelled: () -> Boolean = { false }): Boolean {
+    if (isCancelled()) throw CancellationException("Avatar cache read cancelled")
+    if (bytes.size !in 93..MAX_PNG_BYTES) return false
+    val input = ByteBuffer.wrap(bytes)
+    if (input.long != 0x89504e470d0a1a0aUL.toLong()) return false
+    fun chunk(expectedType: String, expectedLength: Int? = null): ByteArray? {
+      if (input.remaining() < 12) return null
+      val length = input.int
+      if (length < 0 || length > input.remaining() - 8) return null
+      if (expectedLength != null && length != expectedLength) return null
+      val type = ByteArray(4).also(input::get)
+      if (!type.contentEquals(expectedType.toByteArray(Charsets.US_ASCII))) return null
+      val data = ByteArray(length).also(input::get)
+      val crc = CRC32().apply { update(type); update(data) }
+      if (input.int != crc.value.toInt()) return null
+      return data
+    }
+    val header = chunk("IHDR", 13) ?: return false
+    if (!header.contentEquals(byteArrayOf(0, 0, 0, -128, 0, 0, 0, -128, 2, 3, 0, 0, 0))) return false
+    chunk("PLTE", 9) ?: return false
+    if (chunk("tRNS", 3)?.contentEquals(byteArrayOf(-1, -1, -1)) != true) return false
+    val compressed = chunk("IDAT") ?: return false
+    chunk("IEND", 0) ?: return false
+    if (input.hasRemaining()) return false
+
+    val expectedBytes = SIZE * (SIZE / 4 + 1)
+    val pixels = ByteArray(expectedBytes + 1)
+    val inflater = Inflater()
+    var count = 0
+    try {
+      inflater.setInput(compressed)
+      while (!inflater.finished() && count <= expectedBytes) {
+        if (isCancelled()) throw CancellationException("Avatar cache read cancelled")
+        val decoded = inflater.inflate(pixels, count, pixels.size - count)
+        if (decoded == 0) return false
+        count += decoded
+      }
+      if (!inflater.finished() || inflater.remaining != 0 || count != expectedBytes) return false
+    } catch (_: DataFormatException) {
+      return false
+    } finally {
+      inflater.end()
+    }
+    repeat(SIZE) { row ->
+      if (isCancelled()) throw CancellationException("Avatar cache read cancelled")
+      val offset = row * 33
+      if (pixels[offset] != 0.toByte()) return false
+      for (index in 1..32) {
+        val value = pixels[offset + index].toInt() and 0xff
+        if (
+          (value and 3) == 3 || ((value shr 2) and 3) == 3 ||
+          ((value shr 4) and 3) == 3 || ((value shr 6) and 3) == 3
+        ) return false
+      }
+    }
+    return true
+  }
+
+  fun png(uri: String, isCancelled: () -> Boolean = { false }): ByteArray {
+    fun checkCancelled() {
+      if (isCancelled()) throw CancellationException("Avatar generation cancelled")
+    }
+    checkCancelled()
+    val seed = decodeSeed(uri, isCancelled)
+    val state = IntArray(4)
+    seed.forEachIndexed { index, char ->
+      if (index % 256 == 0) checkCancelled()
+      val slot = index % 4
+      // Kotlin Int overflow and signed shr preserve JavaScript's bitwise PRNG.
+      state[slot] = (state[slot] shl 5) - state[slot] + char.code
+    }
+    fun random(): Double {
+      val t = state[0] xor (state[0] shl 11)
+      state[0] = state[1]
+      state[1] = state[2]
+      state[2] = state[3]
+      state[3] = state[3] xor (state[3] shr 19) xor t xor (t shr 8)
+      return (state[3].toLong() and 0xffffffffL).toDouble() / 2147483648.0
+    }
+    fun hue(p: Double, q: Double, value: Double): Double {
+      var t = value
+      if (t < 0) t += 1
+      if (t > 1) t -= 1
+      return when {
+        t < 1.0 / 6.0 -> p + (q - p) * 6 * t
+        t < 1.0 / 2.0 -> q
+        t < 2.0 / 3.0 -> p + (q - p) * (2.0 / 3.0 - t) * 6
+        else -> p
+      }
+    }
+    fun color(): ByteArray {
+      val h = floor(random() * 360) / 360
+      val saturation = (random() * 60 + 40) / 100
+      val lightness = ((random() + random() + random() + random()) * 25) / 100
+      val q = if (lightness < 0.5) lightness * (1 + saturation)
+        else lightness + saturation - lightness * saturation
+      val p = 2 * lightness - q
+      return doubleArrayOf(
+        hue(p, q, h + 1.0 / 3.0), hue(p, q, h), hue(p, q, h - 1.0 / 3.0),
+      ).map { floor(it * 255 + 0.5).toInt().toByte() }.toByteArray()
+    }
+    val foreground = color()
+    val background = color()
+    val spot = color()
+    val pixels = ByteArray(SIZE * 33)
+    repeat(8) { row ->
+      checkCancelled()
+      val line = ByteArray(33)
+      repeat(4) { column ->
+        val value = floor(random() * 2.3).toInt()
+        val paletteIndex = if (value == 0) 0 else if (value == 1) 1 else 2
+        val packed = (paletteIndex * 0x55).toByte()
+        line.fill(packed, 1 + column * 4, 1 + (column + 1) * 4)
+        line.fill(packed, 1 + (7 - column) * 4, 1 + (8 - column) * 4)
+      }
+      repeat(16) { line.copyInto(pixels, (row * 16 + it) * 33) }
+    }
+    val compressed = ByteArrayOutputStream()
+    val deflater = Deflater(Deflater.BEST_SPEED)
+    try {
+      DeflaterOutputStream(compressed, deflater).use { it.write(pixels) }
+    } finally {
+      deflater.end()
+    }
+    checkCancelled()
+    val result = ByteArrayOutputStream()
+    DataOutputStream(result).use { output ->
+      output.write(byteArrayOf(137.toByte(), 80, 78, 71, 13, 10, 26, 10))
+      fun chunk(type: String, data: ByteArray) {
+        val typeBytes = type.toByteArray(Charsets.US_ASCII)
+        output.writeInt(data.size)
+        output.write(typeBytes)
+        output.write(data)
+        val crc = CRC32().apply { update(typeBytes); update(data) }
+        output.writeInt(crc.value.toInt())
+      }
+      chunk("IHDR", byteArrayOf(0, 0, 0, 128.toByte(), 0, 0, 0, 128.toByte(), 2, 3, 0, 0, 0))
+      chunk("PLTE", background + foreground + spot)
+      chunk("tRNS", byteArrayOf(-1, -1, -1))
+      chunk("IDAT", compressed.toByteArray())
+      chunk("IEND", byteArrayOf())
+    }
+    return result.toByteArray()
+  }
+}
+
+/** Only overlapping source fetches are retained; Glide owns all lasting caches. */
+internal class OneKeyAvatarInFlight(
+  private val generate: (String, () -> Boolean) -> ByteArray,
+) {
+  internal class Work(uri: String, generate: (String, () -> Boolean) -> ByteArray) {
+    val cancelled = AtomicBoolean(false)
+    val task = FutureTask { generate(uri, cancelled::get) }
+    var references = 0
+  }
+
+  private val pending = mutableMapOf<String, Work>()
+
+  internal inner class Lease(private val uri: String, internal val work: Work) {
+    private val released = AtomicBoolean(false)
+
+    fun bytes(): ByteArray {
+      work.task.run()
+      return work.task.get()
+    }
+
+    fun release() {
+      if (!released.compareAndSet(false, true)) return
+      synchronized(pending) {
+        work.references -= 1
+        if (work.references == 0) {
+          if (pending[uri] === work) pending.remove(uri)
+          if (!work.task.isDone) {
+            work.cancelled.set(true)
+            work.task.cancel(false)
+          }
+        }
+      }
+    }
+  }
+
+  fun acquire(uri: String): Lease = synchronized(pending) {
+    val work = pending.getOrPut(uri) { Work(uri, generate) }
+    work.references += 1
+    Lease(uri, work)
+  }
+}

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

@@ -0,0 +1,173 @@
+package com.margelo.nitro.onekeyimage
+
+import com.bumptech.glide.Priority
+import com.bumptech.glide.load.DataSource
+import com.bumptech.glide.load.Option
+import com.bumptech.glide.load.Options
+import com.bumptech.glide.load.data.DataFetcher
+import com.bumptech.glide.load.engine.DiskCacheStrategy
+import com.bumptech.glide.load.model.ModelLoader
+import com.bumptech.glide.load.model.ModelLoaderFactory
+import com.bumptech.glide.load.model.MultiModelLoaderFactory
+import com.bumptech.glide.signature.ObjectKey
+import com.bumptech.glide.request.RequestOptions
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.IOException
+import java.nio.ByteBuffer
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.CancellationException
+
+// Only source PNGs are persisted; transformed resources can have other dimensions.
+internal fun oneKeyImageMemoryDiskStrategy(uri: String): DiskCacheStrategy =
+  if (OneKeyBlockieAvatar.isAvatarUri(uri)) DiskCacheStrategy.DATA else DiskCacheStrategy.AUTOMATIC
+
+internal val oneKeyAvatarCacheFileOption: Option<Boolean> =
+  Option.memory("onekey-image.blockie-source-cache-v1", false)
+
+internal fun RequestOptions.withOneKeyAvatarCache(uri: String): RequestOptions =
+  if (OneKeyBlockieAvatar.isAvatarUri(uri)) set(oneKeyAvatarCacheFileOption, true) else this
+
+internal class OneKeyAvatarCacheFileLoaderFactory : ModelLoaderFactory<File, ByteBuffer> {
+  override fun build(multiFactory: MultiModelLoaderFactory): ModelLoader<File, ByteBuffer> =
+    OneKeyAvatarCacheFileLoader()
+
+  override fun teardown() = Unit
+}
+
+private class OneKeyAvatarCacheFileLoader : ModelLoader<File, ByteBuffer> {
+  override fun handles(model: File): Boolean = true
+
+  override fun buildLoadData(
+    model: File,
+    width: Int,
+    height: Int,
+    options: Options,
+  ): ModelLoader.LoadData<ByteBuffer>? =
+    if (options.get(oneKeyAvatarCacheFileOption) == true) {
+      ModelLoader.LoadData(ObjectKey(model), OneKeyAvatarCacheFileFetcher(model))
+    } else null
+}
+
+// Serialize validation/removal so two failed reads cannot delete a newly repaired file.
+private val avatarCacheFileLock = Any()
+
+private class OneKeyAvatarCacheFileFetcher(private val file: File) : DataFetcher<ByteBuffer> {
+  @Volatile
+  private var cancelled = false
+
+  override fun loadData(priority: Priority, callback: DataFetcher.DataCallback<in ByteBuffer>) {
+    val bytes = try {
+      synchronized(avatarCacheFileLock) {
+        checkCancelled()
+        val bytes = readBounded()
+        if (bytes == null || !OneKeyBlockieAvatar.isValidPng(bytes) { cancelled }) {
+          checkCancelled()
+          if (file.exists() && !file.delete()) throw IOException("Cannot remove invalid avatar cache entry")
+          // Glide's journal sees the missing clean file; SOURCE can write it again.
+          throw IOException("Invalid avatar cache entry removed")
+        }
+        bytes
+      }
+    } catch (error: Exception) {
+      if (!cancelled) callback.onLoadFailed(error)
+      return
+    }
+    if (!cancelled) callback.onDataReady(ByteBuffer.wrap(bytes))
+  }
+
+  private fun readBounded(): ByteArray? {
+    if (file.length() > OneKeyBlockieAvatar.MAX_PNG_BYTES) return null
+    return file.inputStream().use { input ->
+      val output = ByteArrayOutputStream()
+      val buffer = ByteArray(1024)
+      while (true) {
+        checkCancelled()
+        val count = input.read(buffer)
+        if (count < 0) break
+        if (output.size() + count > OneKeyBlockieAvatar.MAX_PNG_BYTES) return null
+        output.write(buffer, 0, count)
+      }
+      output.toByteArray()
+    }
+  }
+
+  private fun checkCancelled() {
+    if (cancelled) throw CancellationException("Avatar cache read cancelled")
+  }
+
+  override fun cancel() { cancelled = true }
+  override fun cleanup() = cancel()
+  override fun getDataClass(): Class<ByteBuffer> = ByteBuffer::class.java
+  override fun getDataSource(): DataSource = DataSource.LOCAL
+}
+
+internal class OneKeyBlockieAvatarLoaderFactory : ModelLoaderFactory<OneKeyBlockieAvatarModel, ByteBuffer> {
+  override fun build(multiFactory: MultiModelLoaderFactory): ModelLoader<OneKeyBlockieAvatarModel, ByteBuffer> =
+    OneKeyBlockieAvatarLoader()
+
+  override fun teardown() = Unit
+}
+
+private val avatarRequests = OneKeyAvatarInFlight { uri, isCancelled ->
+  OneKeyImageSafety.requireEncodedLength(uri.length.toLong(), OneKeyImageSafety.MAX_DATA_URI_DECODED_BYTES)
+  val png = OneKeyBlockieAvatar.png(uri, isCancelled)
+  OneKeyImageSafety.requireEncodedLength(png.size.toLong(), OneKeyImageSafety.MAX_DATA_URI_DECODED_BYTES)
+  OneKeyEncodedImageInspector.inspect(ByteArrayInputStream(png))
+  png
+}
+
+private class OneKeyBlockieAvatarLoader : ModelLoader<OneKeyBlockieAvatarModel, ByteBuffer> {
+  override fun handles(model: OneKeyBlockieAvatarModel): Boolean = true
+
+  override fun buildLoadData(
+    model: OneKeyBlockieAvatarModel,
+    width: Int,
+    height: Int,
+    options: Options,
+  ): ModelLoader.LoadData<ByteBuffer> = ModelLoader.LoadData(
+    OneKeyImageSafetyVersionedKey(ObjectKey(model)),
+    OneKeyBlockieAvatarFetcher(model.uri),
+  )
+}
+
+internal class OneKeyBlockieAvatarFetcher(
+  private val uri: String,
+  private val requests: OneKeyAvatarInFlight = avatarRequests,
+) : DataFetcher<ByteBuffer> {
+  @Volatile
+  private var cancelled = false
+  private var lease: OneKeyAvatarInFlight.Lease? = null
+
+  override fun loadData(priority: Priority, callback: DataFetcher.DataCallback<in ByteBuffer>) {
+    val request = synchronized(this) {
+      if (cancelled) return
+      requests.acquire(uri).also { lease = it }
+    }
+    // Glide invokes loadData on its source executor, never on the UI thread.
+    val png = try {
+      request.bytes()
+    } catch (error: Exception) {
+      val cause = if (error is ExecutionException) error.cause else error
+      if (!cancelled) callback.onLoadFailed(cause as? Exception ?: IOException("Avatar generation failed"))
+      return
+    }
+    // Glide may cancel while holding its EngineJob lock; do not call back under ours.
+    if (!cancelled) callback.onDataReady(ByteBuffer.wrap(png))
+  }
+
+  override fun cancel() = release()
+  override fun cleanup() = release()
+
+  private fun release() {
+    val request = synchronized(this) {
+      cancelled = true
+      lease.also { lease = null }
+    }
+    request?.release()
+  }
+
+  override fun getDataClass(): Class<ByteBuffer> = ByteBuffer::class.java
+  override fun getDataSource(): DataSource = DataSource.LOCAL
+}

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

@@ -1,5 +1,6 @@
 package com.margelo.nitro.onekeyimage
 
+import android.app.Activity
 import android.content.Context
 import android.content.ContextWrapper
 import android.graphics.Canvas
@@ -9,7 +10,6 @@ import android.graphics.drawable.Animatable
 import android.graphics.drawable.Drawable
 import android.view.View
 import android.widget.ImageView
-import androidx.fragment.app.FragmentActivity
 import com.bumptech.glide.Glide
 import com.bumptech.glide.load.DataSource
 import com.bumptech.glide.load.engine.DiskCacheStrategy
@@ -25,15 +25,15 @@ import com.margelo.nitro.skeleton.OneKeySkeletonRenderer
 import com.margelo.nitro.views.RecyclableView
 import kotlin.math.ceil
 
-private fun Context.findFragmentActivity(): FragmentActivity? {
+private fun Context.findActivity(): Activity? {
   var currentContext: Context? = this
   while (currentContext is ContextWrapper) {
-    if (currentContext is FragmentActivity) return currentContext
+    if (currentContext is Activity) return currentContext
     val baseContext = currentContext.baseContext
     if (baseContext === currentContext) return null
     currentContext = baseContext
   }
-  return currentContext as? FragmentActivity
+  return currentContext as? Activity
 }
 
 private class OneKeyImageHostView(context: ThemedReactContext) : ImageView(context) {
@@ -139,10 +139,9 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
   private val hostView = OneKeyImageHostView(context)
   // The Activity outlives ScreenStack Fragments but still provides bounded
   // background and destruction lifecycle handling for image requests.
-  private val requestManager by lazy(LazyThreadSafetyMode.NONE) {
-    val activity = context.findFragmentActivity()
-      ?: (context.currentActivity as? FragmentActivity)
-    Glide.with(requireNotNull(activity) { "A FragmentActivity is required to load images" })
+  private val activityRequestManager by lazy(LazyThreadSafetyMode.NONE) {
+    val activity = context.findActivity() ?: context.currentActivity
+    Glide.with(requireNotNull(activity) { "An Activity is required to load images" })
   }
   private var loadRunnable: Runnable? = null
   private var currentTarget: CustomViewTarget<OneKeyImageHostView, Drawable>? = null
@@ -156,6 +155,18 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
   private var pendingDisplayGeneration: Long? = null
   private var fallbackRunnable: Runnable? = null
 
+  /**
+   * Native reusable containers own their request cleanup explicitly, so their
+   * requests must not inherit a transient React Native screen Fragment lifecycle.
+   */
+  internal var usesApplicationRequestManager = false
+
+  private fun requestManager() = if (usesApplicationRequestManager) {
+    Glide.with(context.applicationContext)
+  } else {
+    activityRequestManager
+  }
+
   override val view: View = hostView
 
   override var sourceUri: String? = null
@@ -470,10 +481,10 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
       }
     }
     currentTarget = target
-    requestManager
+    requestManager()
       .asDrawable()
       .load(OneKeyImageModel.build(requestUrl, headersJson))
-      .apply(requestOptions(policy))
+      .apply(requestOptions(policy, requestUrl))
       .override(decodeDimensions.width, decodeDimensions.height)
       .listener(object : RequestListener<Drawable> {
         override fun onLoadFailed(
@@ -501,12 +512,13 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
       .into(target)
   }
 
-  private fun requestOptions(policy: OneKeyImageCachePolicy): RequestOptions {
+  private fun requestOptions(policy: OneKeyImageCachePolicy, uri: String): RequestOptions {
     val options = RequestOptions()
+      .withOneKeyAvatarCache(uri)
       .dontTransform()
       .downsample(OneKeyImageSafeDownsampleStrategy)
     return when (policy) {
-      OneKeyImageCachePolicy.MEMORY_DISK -> options.diskCacheStrategy(DiskCacheStrategy.AUTOMATIC)
+      OneKeyImageCachePolicy.MEMORY_DISK -> options.diskCacheStrategy(oneKeyImageMemoryDiskStrategy(uri))
       OneKeyImageCachePolicy.MEMORY -> options.diskCacheStrategy(DiskCacheStrategy.NONE)
       OneKeyImageCachePolicy.DISK -> options
         .diskCacheStrategy(DiskCacheStrategy.DATA)
@@ -547,7 +559,7 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
     // Clear the field first so onResourceCleared from our own cancellation
     // cannot erase state belonging to the next generation/request.
     currentTarget = null
-    requestManager.clear(target)
+    requestManager().clear(target)
   }
 
   private fun scheduleOnDisplay(requestGeneration: Long) {

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

@@ -22,11 +22,12 @@ class HybridOneKeyImageCache : HybridOneKeyImageCacheSpec() {
         return@forEach
       }
       val baseOptions = RequestOptions()
+        .withOneKeyAvatarCache(source.uri)
         .dontTransform()
         .downsample(OneKeyImageSafeDownsampleStrategy)
       val options = when (source.cachePolicy ?: OneKeyImageCachePolicy.MEMORY_DISK) {
         OneKeyImageCachePolicy.MEMORY_DISK -> baseOptions
-          .diskCacheStrategy(DiskCacheStrategy.AUTOMATIC)
+          .diskCacheStrategy(oneKeyImageMemoryDiskStrategy(source.uri))
         OneKeyImageCachePolicy.MEMORY -> baseOptions
           .diskCacheStrategy(DiskCacheStrategy.NONE)
         OneKeyImageCachePolicy.DISK -> baseOptions

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

@@ -28,6 +28,7 @@ import com.github.penfeizhou.animation.glide.StreamAnimationDecoder
 import java.io.ByteArrayOutputStream
 import java.io.ByteArrayInputStream
 import java.io.IOException
+import java.io.File
 import java.io.InputStream
 import java.nio.ByteBuffer
 
@@ -50,6 +51,16 @@ internal object OneKeyImageGlideRegistry {
       val glide = Glide.get(appContext)
       val registry = glide.registry
 
+      registry.prepend(
+        File::class.java,
+        ByteBuffer::class.java,
+        OneKeyAvatarCacheFileLoaderFactory(),
+      )
+      registry.prepend(
+        OneKeyBlockieAvatarModel::class.java,
+        ByteBuffer::class.java,
+        OneKeyBlockieAvatarLoaderFactory(),
+      )
       registry.prepend(
         OneKeyImageDataUriModel::class.java,
         ByteBuffer::class.java,

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

@@ -25,6 +25,7 @@ internal object OneKeyImageModel {
   }
 
   fun build(uri: String, headersJson: String?): Any {
+    if (OneKeyBlockieAvatar.isAvatarUri(uri)) return OneKeyBlockieAvatarModel(uri)
     if (uri.startsWith("data:")) return OneKeyImageDataUriModel(uri)
     if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
       return OneKeyImageLocalModel(Uri.parse(uri))

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

@@ -0,0 +1,76 @@
+package com.margelo.nitro.onekeyimage
+
+import android.widget.FrameLayout
+import com.facebook.react.uimanager.ThemedReactContext
+
+/** A native-only OneKeyImage host for reusable container views such as list cells. */
+class OneKeyImageReusableView(context: ThemedReactContext) : FrameLayout(context) {
+  private val image = HybridOneKeyImage(context).apply {
+    usesApplicationRequestManager = true
+  }
+
+  init {
+    addView(
+      image.view,
+      LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT),
+    )
+    clipChildren = true
+  }
+
+  fun configure(
+    sourceUri: String?,
+    sourceHeadersJson: String?,
+    variant: String,
+    contentFit: String,
+    cachePolicy: String,
+    autoplay: Boolean,
+    recyclingKey: String,
+    optimizeTos: Boolean,
+    overscan: Double,
+    loadingStrategy: String,
+    onLoad: (() -> Unit)? = null,
+    onError: (() -> Unit)? = null,
+  ) {
+    // OneKey patch: Let reusable cells display their own success and fallback visuals.
+    image.onLoad = { _, _, _ -> onLoad?.invoke() }
+    image.onError = { _ -> onError?.invoke() }
+    image.sourceHeadersJson = sourceHeadersJson
+    image.variant = when (variant) {
+      "token" -> OneKeyImageVariant.TOKEN
+      "network" -> OneKeyImageVariant.NETWORK
+      "avatar" -> OneKeyImageVariant.AVATAR
+      else -> OneKeyImageVariant.GENERIC
+    }
+    image.contentFit = when (contentFit) {
+      "contain" -> OneKeyImageContentFit.CONTAIN
+      "fill" -> OneKeyImageContentFit.FILL
+      "center" -> OneKeyImageContentFit.CENTER
+      else -> OneKeyImageContentFit.COVER
+    }
+    image.cachePolicy = when (cachePolicy) {
+      "memory" -> OneKeyImageCachePolicy.MEMORY
+      "disk" -> OneKeyImageCachePolicy.DISK
+      "none" -> OneKeyImageCachePolicy.NONE
+      else -> OneKeyImageCachePolicy.MEMORY_DISK
+    }
+    image.autoplay = autoplay
+    image.recyclingKey = recyclingKey
+    image.optimizeTos = optimizeTos
+    image.overscan = overscan
+    image.loadingStrategy = when (loadingStrategy) {
+      "skeleton" -> OneKeyImageLoadingStrategy.SKELETON
+      "none" -> OneKeyImageLoadingStrategy.NONE
+      else -> OneKeyImageLoadingStrategy.STATIC
+    }
+    image.sourceUri = sourceUri
+    image.afterUpdate()
+  }
+
+  fun prepareForReuse() {
+    image.prepareForRecycle()
+  }
+
+  fun dispose() {
+    image.onDropView()
+  }
+}