@onekeyfe/react-native-image 3.0.157 → 3.0.158

package/ios/OneKeyImage.swift

@@ -115,6 +115,9 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
   private var requestActive = false
   private var isResetting = false
   private var displayState = DisplayState.loading
+  /// `.loading` with the previous image kept on screen as the placeholder
+  /// (see `showLoading(preservedImage:)`).
+  private var isPreservingDisplayedImage = false
   private var requestStartedAt: CFTimeInterval?
 
   var view: UIView { hostView }
@@ -337,8 +340,11 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     }
 
     let hasCustomIdentity = OneKeyImageRequestContext.headers(from: sourceHeadersJson) != nil
-    let displaySize = resizeWidth.flatMap { $0.isFinite && $0 > 0 ? CGFloat($0) : nil }
-      ?? max(hostView.bounds.width, hostView.bounds.height)
+    let displaySize = OneKeyImageDecodeSizing.tosDisplaySize(
+      bounds: hostView.bounds.size,
+      resizeWidth: resizeWidth,
+      resizeHeight: resizeHeight
+    ) ?? 0
     let requestURL =
       (optimizeTos ?? true)
       ? OneKeyTosURL.optimized(
@@ -439,6 +445,7 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
         guard self.claimTerminal(generation) else { return }
         self.requestActive = false
         self.displayState = .image
+        self.isPreservingDisplayedImage = false
         self.skeletonIndicator.stopAnimatingIndicator()
         self.fallbackLayer.isHidden = true
         self.hostView.backgroundColor = .clear
@@ -547,6 +554,7 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     optimizeTos = true
     round = false
     resizeWidth = nil
+    resizeHeight = nil
     overscan = 1.1
     loadingStrategy = .static
     placeholderColor = nil
@@ -577,6 +585,9 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     guard Self.isCurrentRequestGeneration(generation, current: requestGeneration) else {
       return
     }
+    // Also the placeholder write path (SDWebImage hands the preserved image
+    // back through setImageBlock when the load starts), so the preservation
+    // flag is NOT touched here; it ends with the terminal callbacks.
     hostView.image = image
   }
 
@@ -592,11 +603,19 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     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.
+      // The indicator is unmounted, not just stopped: SDWebImage restarts a
+      // mounted `sd_imageIndicator` when the load begins, and `applyVariant`
+      // must not reinstall it while this state lasts.
+      isPreservingDisplayedImage = true
       hostView.image = preservedImage
       skeletonIndicator.stopAnimatingIndicator()
+      if hostView.sd_imageIndicator != nil {
+        hostView.sd_imageIndicator = nil
+      }
       hostView.backgroundColor = .clear
       return
     }
+    isPreservingDisplayedImage = false
     hostView.image = nil
     applyLoadingAppearance(letLibraryStartIndicator: letLibraryStartIndicator)
   }
@@ -623,8 +642,11 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     let rawScreenScale: CGFloat = hostView.window?.screen.scale ?? UIScreen.main.scale
     let screenScale = min(max(rawScreenScale, 1), 3)
     let hasCustomIdentity = OneKeyImageRequestContext.headers(from: sourceHeadersJson) != nil
-    let displaySize = resizeWidth.flatMap { $0.isFinite && $0 > 0 ? CGFloat($0) : nil }
-      ?? max(hostView.bounds.width, hostView.bounds.height)
+    let displaySize = OneKeyImageDecodeSizing.tosDisplaySize(
+      bounds: hostView.bounds.size,
+      resizeWidth: resizeWidth,
+      resizeHeight: resizeHeight
+    ) ?? 0
     let requestURL =
       (optimizeTos ?? true)
       ? OneKeyTosURL.optimized(
@@ -679,6 +701,7 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     let generation = requestGeneration
     if requestIsActive, !claimTerminal(generation) { return true }
     displayState = .image
+    isPreservingDisplayedImage = false
     requestActive = false
     skeletonIndicator.stopAnimatingIndicator()
     fallbackLayer.isHidden = true
@@ -716,6 +739,7 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
   private func showTerminalState(_ state: DisplayState) {
     displayState = state
     requestActive = false
+    isPreservingDisplayedImage = false
     skeletonIndicator.stopAnimatingIndicator()
     resetImageTransition()
     hostView.image = nil
@@ -733,6 +757,9 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     case .image:
       break
     case .loading:
+      // A preserved image is the placeholder; re-applying the loading look
+      // would cover it with the skeleton / placeholder color again.
+      if isPreservingDisplayedImage { break }
       applyLoadingAppearance(letLibraryStartIndicator: false)
     case .error, .fallback:
       let hidesTerminalState = loadingStrategy == .none

package/ios/OneKeyImageRequestContext.swift

@@ -610,6 +610,23 @@ enum OneKeyImageDecodeSizing {
     }
   }
 
+  /// The logical display size the TOS rendition is picked for. A preload picks
+  /// it from the long edge of its `resizeWidth`/`resizeHeight` hint, so a view
+  /// carrying the same hint must do the same (before AND after layout) or its
+  /// request URL, and with it the cache key, diverges from what the preload
+  /// stored. Without a hint the laid-out bounds decide; nil before layout.
+  static func tosDisplaySize(
+    bounds: CGSize,
+    resizeWidth: Double?,
+    resizeHeight: Double?
+  ) -> CGFloat? {
+    if let hint = logicalViewSize(width: resizeWidth, height: resizeHeight) {
+      return max(hint.width, hint.height)
+    }
+    let edge = max(bounds.width, bounds.height)
+    return edge.isFinite && edge > 0 ? edge : nil
+  }
+
   /// 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.

package/ios/tests/OneKeyImageInfrastructureTests.swift

@@ -629,6 +629,55 @@ final class OneKeyImageInfrastructureTests: XCTestCase {
     )
   }
 
+  func testRecycledViewForgetsBothResizeHints() throws {
+    let image = HybridOneKeyImage()
+    image.sourceUri = "https://example.com/hinted.png"
+    image.resizeWidth = 48
+    image.resizeHeight = 64
+    image.prepareForRecycle()
+    XCTAssertNil(image.resizeWidth)
+    XCTAssertNil(image.resizeHeight)
+    XCTAssertNil(image.sourceUri)
+  }
+
+  func testViewAndPreloadPickTheSameTosRenditionForOneHint() throws {
+    // Preload: long edge of logicalViewSize(resizeWidth, resizeHeight).
+    // View: the same, before and after layout, so the request URL (and with it
+    // the cache key) is identical on both sides.
+    let raw = try XCTUnwrap(URL(string: "https://common.onekey-asset.com/token.png"))
+    let hint = try XCTUnwrap(OneKeyImageDecodeSizing.logicalViewSize(width: 48, height: 64))
+    let preloadDisplaySize = max(hint.width, hint.height)
+    for bounds in [CGSize.zero, CGSize(width: 48, height: 64), CGSize(width: 30, height: 30)] {
+      let viewDisplaySize = try XCTUnwrap(
+        OneKeyImageDecodeSizing.tosDisplaySize(bounds: bounds, resizeWidth: 48, resizeHeight: 64)
+      )
+      XCTAssertEqual(viewDisplaySize, preloadDisplaySize)
+      XCTAssertEqual(
+        OneKeyTosURL.optimized(
+          rawURL: raw, displaySize: viewDisplaySize, scale: 3, overscan: 1.1, hasCustomIdentity: false
+        ),
+        OneKeyTosURL.optimized(
+          rawURL: raw, displaySize: preloadDisplaySize, scale: 3, overscan: 1.1, hasCustomIdentity: false
+        )
+      )
+    }
+    // Width-only hint keeps the historical behaviour (the width itself).
+    XCTAssertEqual(
+      OneKeyImageDecodeSizing.tosDisplaySize(bounds: .zero, resizeWidth: 40, resizeHeight: nil),
+      40
+    )
+    // No hint: the laid-out bounds decide; nothing before layout.
+    XCTAssertEqual(
+      OneKeyImageDecodeSizing.tosDisplaySize(
+        bounds: CGSize(width: 40, height: 64), resizeWidth: nil, resizeHeight: nil
+      ),
+      64
+    )
+    XCTAssertNil(
+      OneKeyImageDecodeSizing.tosDisplaySize(bounds: .zero, resizeWidth: nil, resizeHeight: nil)
+    )
+  }
+
   func testSupersededRequestNeverPaintsRecycledView() throws {
     let image = HybridOneKeyImage()
     let imageView = try XCTUnwrap(image.view as? SDAnimatedImageView)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-image",
-  "version": "3.0.157",
+  "version": "3.0.158",
   "description": "High-performance native image view for OneKey",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -81,7 +81,7 @@
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
-    "@onekeyfe/react-native-skeleton": "3.0.157",
+    "@onekeyfe/react-native-skeleton": "3.0.158",
     "react": "*",
     "react-native": "*",
     "react-native-nitro-modules": "0.37.0"