@onekeyfe/react-native-image 3.0.155 → 3.0.157

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

@@ -7,7 +7,9 @@ import android.content.ContextWrapper
 import android.content.res.Configuration
 import android.graphics.Canvas
 import android.graphics.Color
+import android.graphics.Outline
 import android.graphics.Paint
+import android.graphics.Path
 import android.graphics.drawable.Animatable
 import android.graphics.drawable.Drawable
 import android.os.Build
@@ -15,6 +17,7 @@ import android.os.Looper
 import android.os.SystemClock
 import android.provider.Settings
 import android.view.View
+import android.view.ViewOutlineProvider
 import android.view.animation.DecelerateInterpolator
 import android.widget.ImageView
 import com.bumptech.glide.Glide
@@ -44,6 +47,16 @@ private fun Context.findActivity(): Activity? {
 }
 
 private class OneKeyImageHostView(context: ThemedReactContext) : ImageView(context) {
+  private val roundClipPath = Path()
+  private val roundOutlineProvider = object : ViewOutlineProvider() {
+    override fun getOutline(view: View, outline: Outline) {
+      if (view.width > 0 && view.height > 0) {
+        outline.setOval(0, 0, view.width, view.height)
+      } else {
+        outline.setEmpty()
+      }
+    }
+  }
   private val fallbackPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
     color = Color.rgb(110, 110, 120)
     textAlign = Paint.Align.CENTER
@@ -52,6 +65,16 @@ private class OneKeyImageHostView(context: ThemedReactContext) : ImageView(conte
   var drawStateSymbol = false
   var stateSymbol = "◇"
   var autoplayEnabled = false
+  var round = false
+    set(value) {
+      if (field == value) return
+      field = value
+      outlineProvider = if (value) roundOutlineProvider else ViewOutlineProvider.BACKGROUND
+      clipToOutline = value
+      updateRoundClipPath()
+      invalidateOutline()
+      invalidate()
+    }
   private var aggregatedVisible = true
   var skeletonRequested = false
     set(value) {
@@ -65,9 +88,24 @@ private class OneKeyImageHostView(context: ThemedReactContext) : ImageView(conte
     super.onSizeChanged(w, h, oldw, oldh)
     skeleton.updateBounds(w, h)
     fallbackPaint.textSize = minOf(w, h) * 0.35f
+    if (round) {
+      updateRoundClipPath()
+      invalidateOutline()
+    }
     if (w > 0 && h > 0) onReadyForRequest?.invoke()
   }
 
+  override fun draw(canvas: Canvas) {
+    if (!round || roundClipPath.isEmpty) {
+      super.draw(canvas)
+      return
+    }
+    val saveCount = canvas.save()
+    canvas.clipPath(roundClipPath)
+    super.draw(canvas)
+    canvas.restoreToCount(saveCount)
+  }
+
   override fun onDraw(canvas: Canvas) {
     super.onDraw(canvas)
     if (drawStateSymbol) {
@@ -108,6 +146,13 @@ private class OneKeyImageHostView(context: ThemedReactContext) : ImageView(conte
     skeleton.updateBounds(width, height)
   }
 
+  private fun updateRoundClipPath() {
+    roundClipPath.reset()
+    if (round && width > 0 && height > 0) {
+      roundClipPath.addOval(0f, 0f, width.toFloat(), height.toFloat(), Path.Direction.CW)
+    }
+  }
+
   fun syncPlayback() {
     val canRun = isAttachedToWindow && aggregatedVisible
     if (skeletonRequested && canRun) skeleton.start() else skeleton.stop()
@@ -130,10 +175,12 @@ internal fun oneKeyImageRequestSignature(
   contentFit: OneKeyImageContentFit?,
   optimizeTos: Boolean?,
   overscan: Double?,
+  round: Boolean,
   width: Int,
   height: Int,
   density: Float,
   resizeWidth: Double? = null,
+  resizeHeight: Double? = null,
 ): String = listOf(
   rawUrl,
   sourceHeadersJson.orEmpty(),
@@ -142,7 +189,9 @@ internal fun oneKeyImageRequestSignature(
   (contentFit ?: OneKeyImageContentFit.COVER).name,
   optimizeTos.toString(),
   overscan.toString(),
+  round.toString(),
   resizeWidth.toString(),
+  resizeHeight.toString(),
   width.toString(),
   height.toString(),
   density.toString(),
@@ -241,6 +290,10 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
       field = value
       requestIdentityChanged()
     }
+  override var round: Boolean? = false
+    set(value) {
+      field = value
+    }
   override var overscan: Double? = 1.1
     set(value) {
       if (field == value) return
@@ -253,6 +306,14 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
       field = value
       requestIdentityChanged()
     }
+  // Layout hint pair with resizeWidth; only the iOS pre-layout memory probe
+  // consumes it today, Android keys the request on the measured view size.
+  override var resizeHeight: Double? = null
+    set(value) {
+      if (field == value) return
+      field = value
+      requestIdentityChanged()
+    }
   override var loadingStrategy: OneKeyImageLoadingStrategy? = OneKeyImageLoadingStrategy.STATIC
     set(value) {
       field = value
@@ -287,6 +348,10 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
 
   override fun afterUpdate() {
     super.afterUpdate()
+    // Fabric can reset `round` before clearing `sourceUri` while removing a view.
+    // Apply the shape once per committed prop batch so the outgoing frame keeps
+    // its clipping, while mounted and recycled views still receive the new value.
+    if (!sourceUri.isNullOrBlank()) hostView.round = round == true
     loadForCurrentLayout()
   }
 
@@ -346,7 +411,9 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
     autoplay = false
     recyclingKey = null
     optimizeTos = true
+    round = false
     resizeWidth = null
+    resizeHeight = null
     overscan = 1.1
     loadingStrategy = OneKeyImageLoadingStrategy.STATIC
     placeholderColor = null
@@ -416,10 +483,12 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
       contentFit = contentFit,
       optimizeTos = optimizeTos,
       overscan = overscan,
+      round = round == true,
       width = hostView.width,
       height = hostView.height,
       density = hostView.resources.displayMetrics.density,
       resizeWidth = resizeWidth,
+      resizeHeight = resizeHeight,
     )
     if (!force && signature == lastSignature) return
     lastSignature = signature
@@ -549,7 +618,7 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
     requestManager()
       .asDrawable()
       .load(OneKeyImageModel.build(requestUrl, headersJson))
-      .apply(requestOptions(policy, requestUrl))
+      .apply(requestOptions(policy, requestUrl, round == true))
       .override(decodeDimensions.width, decodeDimensions.height)
       .listener(object : RequestListener<Drawable> {
         override fun onLoadFailed(
@@ -577,11 +646,15 @@ class HybridOneKeyImage(private val context: ThemedReactContext) :
       .into(target)
   }
 
-  private fun requestOptions(policy: OneKeyImageCachePolicy, uri: String): RequestOptions {
+  private fun requestOptions(
+    policy: OneKeyImageCachePolicy,
+    uri: String,
+    round: Boolean,
+  ): RequestOptions {
     val options = RequestOptions()
       .withOneKeyAvatarCache(uri)
-      .dontTransform()
       .downsample(OneKeyImageSafeDownsampleStrategy)
+    if (round) options.circleCrop() else options.dontTransform()
     return when (policy) {
       OneKeyImageCachePolicy.MEMORY_DISK -> options.diskCacheStrategy(oneKeyImageMemoryDiskStrategy(uri))
       OneKeyImageCachePolicy.MEMORY -> options.diskCacheStrategy(DiskCacheStrategy.NONE)

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/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,

package/ios/OneKeyImage.swift

@@ -7,9 +7,13 @@ import UIKit
 private final class OneKeyImageHostView: SDAnimatedImageView {
   var onLayout: (() -> Void)?
   var onWindowChanged: ((Bool) -> Void)?
+  var round = false {
+    didSet { updateRoundMask() }
+  }
 
   override func layoutSubviews() {
     super.layoutSubviews()
+    updateRoundMask()
     onLayout?()
   }
 
@@ -17,6 +21,10 @@ private final class OneKeyImageHostView: SDAnimatedImageView {
     super.didMoveToWindow()
     onWindowChanged?(window != nil)
   }
+
+  private func updateRoundMask() {
+    layer.cornerRadius = round ? min(bounds.width, bounds.height) / 2 : 0
+  }
 }
 
 private final class OneKeyImageSkeletonView: UIView {
@@ -112,7 +120,9 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
   var view: UIView { hostView }
 
   var sourceUri: String? {
-    didSet { if sourceUri != oldValue { identityDidChange() } }
+    didSet {
+      if sourceUri != oldValue { identityDidChange() }
+    }
   }
   var sourceHeadersJson: String? {
     didSet { if sourceHeadersJson != oldValue { identityDidChange() } }
@@ -134,11 +144,17 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
   var optimizeTos: Bool? = true {
     didSet { if optimizeTos != oldValue { identityDidChange() } }
   }
+  var round: Bool? = false
   var resizeWidth: Double? {
     didSet {
       if !Self.equalOptionalDouble(resizeWidth, oldValue) { identityDidChange() }
     }
   }
+  var resizeHeight: Double? {
+    didSet {
+      if !Self.equalOptionalDouble(resizeHeight, oldValue) { identityDidChange() }
+    }
+  }
   var overscan: Double? = 1.1 {
     didSet {
       if !Self.equalOptionalDouble(overscan, oldValue) { identityDidChange() }
@@ -185,6 +201,12 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
   }
 
   func afterUpdate() {
+    // Fabric can reset `round` before clearing `sourceUri` while removing a view.
+    // Apply the shape once per committed prop batch so the outgoing frame keeps
+    // its clipping, while mounted and recycled views still receive the new value.
+    if let sourceUri, !sourceUri.isEmpty {
+      hostView.round = round == true
+    }
     scheduleLoad()
   }
 
@@ -245,7 +267,10 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
       lastRequestSignature = nil
       // A memory-cached image shown from `identityDidChange` before layout
       // stays up; layout re-runs this load with real bounds and confirms it.
-      if displayState != .image {
+      if !Self.shouldPreserveDisplayedImage(
+        isShowingImage: displayState == .image,
+        hasImage: hostView.image != nil
+      ) {
         showLoading(requestIsActive: false, letLibraryStartIndicator: false)
       }
       return
@@ -267,6 +292,7 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
       contentFit?.stringValue ?? "cover",
       String(optimizeTos ?? true),
       resizeWidth.map(String.init(describing:)) ?? "",
+      resizeHeight.map(String.init(describing:)) ?? "",
       String(overscan ?? 1.1),
       String(Int(hostView.bounds.width.rounded())),
       String(Int(hostView.bounds.height.rounded())),
@@ -282,7 +308,20 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     onLoadStart?()
     guard Self.isCurrentRequestGeneration(generation, current: requestGeneration) else { return }
     if showMemoryCachedImageIfAvailable(requestIsActive: true) { return }
-    showLoading(requestIsActive: true, letLibraryStartIndicator: true)
+    // The pre-layout probe may have shown this identity from another thumbnail
+    // key (a preload's, or an earlier layout size). Keep it on screen as the
+    // placeholder while the exact rendition loads: blanking to a skeleton and
+    // redrawing is worse than the skeleton it replaced.
+    let preservedImage =
+      Self.shouldPreserveDisplayedImage(
+        isShowingImage: displayState == .image,
+        hasImage: hostView.image != nil
+      ) ? hostView.image : nil
+    showLoading(
+      requestIsActive: true,
+      letLibraryStartIndicator: true,
+      preservedImage: preservedImage
+    )
 
     if let violation = OneKeyImageSafetyPolicy.preflight(source: rawString) {
       finishWithError(violation, generation: generation)
@@ -314,7 +353,8 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
       url: requestURL,
       rawURL: rawURL,
       generation: generation,
-      mayFallbackToRaw: requestURL != rawURL
+      mayFallbackToRaw: requestURL != rawURL,
+      placeholderImage: preservedImage
     )
   }
 
@@ -322,7 +362,8 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     url: URL,
     rawURL: URL,
     generation: UInt64,
-    mayFallbackToRaw: Bool
+    mayFallbackToRaw: Bool,
+    placeholderImage: UIImage? = nil
   ) {
     guard Self.isCurrentRequestGeneration(generation, current: requestGeneration) else { return }
     let rawScreenScale: CGFloat = hostView.window?.screen.scale ?? UIScreen.main.scale
@@ -350,7 +391,9 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     )
     hostView.sd_internalSetImage(
       with: url,
-      placeholderImage: nil,
+      // SDWebImage resets the image view when it starts a load; hand it the
+      // preserved image so the view keeps showing it until the load lands.
+      placeholderImage: placeholderImage,
       options: OneKeyImageRequestContext.renderOptions,
       context: context,
       setImageBlock: { [weak self] image, _, _, _ in
@@ -502,6 +545,7 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     autoplay = true
     recyclingKey = nil
     optimizeTos = true
+    round = false
     resizeWidth = nil
     overscan = 1.1
     loadingStrategy = .static
@@ -538,16 +582,32 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
 
   private func showLoading(
     requestIsActive: Bool,
-    letLibraryStartIndicator: Bool
+    letLibraryStartIndicator: Bool,
+    preservedImage: UIImage? = nil
   ) {
     displayState = .loading
     requestActive = requestIsActive
     resetImageTransition()
-    hostView.image = nil
     fallbackLayer.isHidden = true
+    if let preservedImage {
+      // Same identity, different thumbnail key: the image already on screen
+      // stands in for the placeholder, so no blank frame and no indicator.
+      hostView.image = preservedImage
+      skeletonIndicator.stopAnimatingIndicator()
+      hostView.backgroundColor = .clear
+      return
+    }
+    hostView.image = nil
     applyLoadingAppearance(letLibraryStartIndicator: letLibraryStartIndicator)
   }
 
+  /// Whether the image currently on screen should stay up while a load for the
+  /// SAME identity runs (bounds not laid out yet, or the laid-out request key
+  /// differs from the one the pre-layout probe hit). Pure for testability.
+  static func shouldPreserveDisplayedImage(isShowingImage: Bool, hasImage: Bool) -> Bool {
+    isShowingImage && hasImage
+  }
+
   private func showMemoryCachedImageIfAvailable(requestIsActive: Bool) -> Bool {
     // JS leaves `cachePolicy` unset for the common case and Fabric then hands
     // Nitro a nil, which the request path already treats as memory-disk; the
@@ -575,20 +635,21 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
         hasCustomIdentity: hasCustomIdentity
       )
       : rawURL
-    // Before layout the bounds are empty; fall back to the `resizeWidth` hint so
-    // the probe key matches the prewarm / post-layout request instead of
-    // missing on every mount frame.
-    let thumbnailPixelSize = OneKeyImageDecodeSizing.probeViewSize(
-      bounds: hostView.bounds.size,
-      resizeWidth: resizeWidth
-    ).flatMap {
-      OneKeyImageDecodeSizing.thumbnailPixelSize(
-        viewSize: $0,
+    // The thumbnail size is part of the cache key. Laid out, it is this view's
+    // own request key; before layout it comes from the resize hints, under
+    // this view's contentFit and under `.cover` (a preload's key). With no
+    // bounds and no hint the un-thumbnailed key is the only thing to try.
+    let thumbnailCandidates: [CGSize?] = {
+      let sizes = OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+        bounds: hostView.bounds.size,
+        resizeWidth: resizeWidth,
+        resizeHeight: resizeHeight,
         scale: screenScale,
         contentFit: contentFit ?? .cover
       )
-    }
-    func memoryCachedImage(for url: URL) -> UIImage? {
+      return sizes.isEmpty ? [nil] : sizes
+    }()
+    func memoryCachedImage(for url: URL, thumbnailPixelSize: CGSize?) -> UIImage? {
       let context = OneKeyImageRequestContext.make(
         headersJson: sourceHeadersJson,
         cachePolicy: cachePolicy ?? .memoryDisk,
@@ -603,6 +664,14 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
       }
       return cache.imageFromMemoryCache(forKey: key)
     }
+    func memoryCachedImage(for url: URL) -> UIImage? {
+      for thumbnailPixelSize in thumbnailCandidates {
+        if let image = memoryCachedImage(for: url, thumbnailPixelSize: thumbnailPixelSize) {
+          return image
+        }
+      }
+      return nil
+    }
     guard let image = memoryCachedImage(for: requestURL)
       ?? (requestURL == rawURL ? nil : memoryCachedImage(for: rawURL)) else {
       return false

package/ios/OneKeyImageRequestContext.swift

@@ -610,17 +610,42 @@ enum OneKeyImageDecodeSizing {
     }
   }
 
-  /// The logical size to probe the memory cache with. Before the first layout
-  /// the host view has no bounds, but the JS side already knows the display
-  /// size through `resizeWidth` (the same hint the prewarm used), so a square
-  /// from it yields the decode-thumbnail key the laid-out view will ask for.
-  /// A cached image can then show on the mount frame instead of a skeleton
-  /// until layout re-probes.
-  static func probeViewSize(bounds: CGSize, resizeWidth: Double?) -> CGSize? {
+  /// Decode-thumbnail sizes worth probing the memory cache with, most specific
+  /// first. The thumbnail size is part of the SDWebImage cache key, so a probe
+  /// only hits when it reproduces the key some earlier load stored under.
+  ///
+  /// - Laid out: exactly the size this view's own request uses (`bounds` +
+  ///   `contentFit`), nothing else.
+  /// - Before layout the bounds are empty, but the JS side already knows the
+  ///   display size through the `resizeWidth` / `resizeHeight` hints (the same
+  ///   fields a preload takes). Two keys can hold the image then: the one the
+  ///   laid-out request will ask for (hint + this view's `contentFit`) and the
+  ///   one a preload stored (hint + `.cover`, see `HybridOneKeyImageCache`).
+  ///   They coincide for a square hint or `.cover`; otherwise both are probed.
+  /// - No bounds and no usable hint: nothing to probe with.
+  static func probeThumbnailPixelSizes(
+    bounds: CGSize,
+    resizeWidth: Double?,
+    resizeHeight: Double?,
+    scale: CGFloat,
+    contentFit: OneKeyImageContentFit
+  ) -> [CGSize] {
     if bounds.width.isFinite, bounds.height.isFinite, bounds.width > 0, bounds.height > 0 {
-      return bounds
+      return thumbnailPixelSize(viewSize: bounds, scale: scale, contentFit: contentFit)
+        .map { [$0] } ?? []
+    }
+    guard let hint = logicalViewSize(width: resizeWidth, height: resizeHeight) else {
+      return []
+    }
+    var sizes: [CGSize] = []
+    for fit in [contentFit, .cover] {
+      if let size = thumbnailPixelSize(viewSize: hint, scale: scale, contentFit: fit),
+        !sizes.contains(size)
+      {
+        sizes.append(size)
+      }
     }
-    return logicalViewSize(width: resizeWidth, height: nil)
+    return sizes
   }
 
   static func thumbnailPixelSize(

package/ios/tests/OneKeyImageInfrastructureTests.swift

@@ -310,31 +310,89 @@ final class OneKeyImageInfrastructureTests: XCTestCase {
     )
   }
 
-  func testMemoryProbeFallsBackToResizeWidthBeforeLayout() throws {
-    // Laid out: the real bounds win, even with a hint.
+  // The pre-layout memory probe is only useful if it reproduces a key some
+  // earlier load stored under. These pin the probe against the two real key
+  // producers: the laid-out render request (bounds + contentFit) and the
+  // preload (logicalViewSize(resizeWidth, resizeHeight) + .cover).
+  private func renderKey(bounds: CGSize, fit: OneKeyImageContentFit) throws -> CGSize {
+    try XCTUnwrap(
+      OneKeyImageDecodeSizing.thumbnailPixelSize(viewSize: bounds, scale: 3, contentFit: fit)
+    )
+  }
+
+  private func preloadKey(width: Double?, height: Double?) throws -> CGSize {
+    try renderKey(
+      bounds: try XCTUnwrap(OneKeyImageDecodeSizing.logicalViewSize(width: width, height: height)),
+      fit: .cover
+    )
+  }
+
+  func testLaidOutProbeUsesExactlyTheRenderRequestKey() throws {
+    let bounds = CGSize(width: 40, height: 64)
+    for fit in [OneKeyImageContentFit.cover, .contain, .fill, .center] {
+      XCTAssertEqual(
+        OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+          bounds: bounds, resizeWidth: 32, resizeHeight: 48, scale: 3, contentFit: fit
+        ),
+        [try renderKey(bounds: bounds, fit: fit)],
+        "\(fit)"
+      )
+    }
+  }
+
+  func testPreLayoutSquareHintMatchesPreloadAndRenderKeys() throws {
+    // A token icon: resizeWidth only, laid out square, cover. One key, shared
+    // by the preload, the laid-out request and the probe.
+    let sizes = OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+      bounds: .zero, resizeWidth: 40, resizeHeight: nil, scale: 3, contentFit: .cover
+    )
+    XCTAssertEqual(sizes, [CGSize(width: 120, height: 120)])
+    XCTAssertEqual(sizes, [try preloadKey(width: 40, height: nil)])
+    XCTAssertEqual(sizes, [try renderKey(bounds: CGSize(width: 40, height: 40), fit: .cover)])
+  }
+
+  func testPreLayoutRectangularHintProbesRenderAndPreloadKeys() throws {
+    // The README preload shape (48x64 @3) under a non-cover view: the laid-out
+    // request key comes first, the preload's cover key second, no duplicates.
+    let sizes = OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+      bounds: .zero, resizeWidth: 48, resizeHeight: 64, scale: 3, contentFit: .contain
+    )
     XCTAssertEqual(
-      OneKeyImageDecodeSizing.probeViewSize(
-        bounds: CGSize(width: 40, height: 64),
-        resizeWidth: 32
+      sizes,
+      [
+        try renderKey(bounds: CGSize(width: 48, height: 64), fit: .contain),
+        try preloadKey(width: 48, height: 64),
+      ]
+    )
+    XCTAssertEqual(sizes, [CGSize(width: 144, height: 192), CGSize(width: 192, height: 192)])
+    // Under cover both collapse to the preload key.
+    XCTAssertEqual(
+      OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+        bounds: .zero, resizeWidth: 48, resizeHeight: 64, scale: 3, contentFit: .cover
       ),
-      CGSize(width: 40, height: 64)
+      [try preloadKey(width: 48, height: 64)]
     )
-    // Not laid out yet: a square from the hint, matching the prewarm key.
-    let probe = try XCTUnwrap(
-      OneKeyImageDecodeSizing.probeViewSize(bounds: .zero, resizeWidth: 40)
+  }
+
+  func testPreLayoutProbeWithoutHintHasNothingToTry() {
+    XCTAssertEqual(
+      OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+        bounds: .zero, resizeWidth: nil, resizeHeight: nil, scale: 3, contentFit: .cover
+      ),
+      []
     )
-    XCTAssertEqual(probe, CGSize(width: 40, height: 40))
     XCTAssertEqual(
-      OneKeyImageDecodeSizing.thumbnailPixelSize(viewSize: probe, scale: 3, contentFit: .cover),
-      OneKeyImageDecodeSizing.thumbnailPixelSize(
-        viewSize: try XCTUnwrap(OneKeyImageDecodeSizing.logicalViewSize(width: 40, height: nil)),
-        scale: 3,
-        contentFit: .cover
-      )
+      OneKeyImageDecodeSizing.probeThumbnailPixelSizes(
+        bounds: .zero, resizeWidth: 0, resizeHeight: -1, scale: 3, contentFit: .cover
+      ),
+      []
     )
-    // No bounds and no usable hint: nothing to probe with.
-    XCTAssertNil(OneKeyImageDecodeSizing.probeViewSize(bounds: .zero, resizeWidth: nil))
-    XCTAssertNil(OneKeyImageDecodeSizing.probeViewSize(bounds: .zero, resizeWidth: 0))
+  }
+
+  func testDisplayedImageIsPreservedOnlyWhileShowingOne() {
+    XCTAssertTrue(HybridOneKeyImage.shouldPreserveDisplayedImage(isShowingImage: true, hasImage: true))
+    XCTAssertFalse(HybridOneKeyImage.shouldPreserveDisplayedImage(isShowingImage: true, hasImage: false))
+    XCTAssertFalse(HybridOneKeyImage.shouldPreserveDisplayedImage(isShowingImage: false, hasImage: true))
   }
 
   func testNoSizePreloadUsesCappedDecodeTarget() {
@@ -592,4 +650,50 @@ final class OneKeyImageInfrastructureTests: XCTestCase {
     )
     XCTAssertTrue(imageView.clearBufferWhenStopped)
   }
+
+  func testRoundPropUpdatesNativeCornerRadius() throws {
+    let image = HybridOneKeyImage()
+    let imageView = try XCTUnwrap(image.view as? SDAnimatedImageView)
+    imageView.frame = CGRect(x: 0, y: 0, width: 40, height: 40)
+
+    image.sourceUri = "https://example.com/round.png"
+    image.round = true
+    image.afterUpdate()
+    imageView.layoutIfNeeded()
+    XCTAssertEqual(imageView.layer.cornerRadius, 20)
+
+    image.round = nil
+    image.afterUpdate()
+    XCTAssertEqual(imageView.layer.cornerRadius, 20)
+
+    image.round = false
+    image.afterUpdate()
+    XCTAssertEqual(imageView.layer.cornerRadius, 0)
+  }
+
+  func testRecycleKeepsRoundMaskUntilVisibleViewDetaches() throws {
+    let window = UIWindow(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
+    let image = HybridOneKeyImage()
+    let imageView = try XCTUnwrap(image.view as? SDAnimatedImageView)
+    imageView.frame = CGRect(x: 0, y: 0, width: 40, height: 40)
+    window.addSubview(imageView)
+    image.sourceUri = "https://example.com/round.png"
+    image.round = true
+    image.afterUpdate()
+    imageView.layoutIfNeeded()
+
+    // Fabric resets props in setter order before the view leaves the hierarchy.
+    image.round = false
+    image.sourceUri = nil
+    image.afterUpdate()
+    XCTAssertEqual(imageView.layer.cornerRadius, 20)
+
+    image.prepareForRecycle()
+
+    XCTAssertEqual(imageView.layer.cornerRadius, 20)
+
+    image.sourceUri = "https://example.com/reused.png"
+    image.afterUpdate()
+    XCTAssertEqual(imageView.layer.cornerRadius, 0)
+  }
 }