@onekeyfe/react-native-image 3.0.105 → 3.0.107

package/ios/OneKeyAvatarImageLoader.swift

@@ -0,0 +1,217 @@
+// OneKey patch: Share local avatar work and persistent SDWebImage caching across
+// render/preload requests, including managers isolated for HTTP headers.
+import Foundation
+import SDWebImage
+import UIKit
+
+final class OneKeyAvatarImageLoader: NSObject, SDImageLoader {
+  static let shared = OneKeyAvatarImageLoader()
+  static let cache: SDImageCache = {
+    let config = SDImageCacheConfig()
+    config.maxDiskAge = 30 * 24 * 60 * 60
+    config.maxDiskSize = 32 * 1024 * 1024
+    config.maxMemoryCost = 8 * 1024 * 1024
+    config.maxMemoryCount = 128
+    return SDImageCache(namespace: "onekey-avatar-blockie-v1", diskCacheDirectory: nil, config: config)
+  }()
+
+  private final class Subscription: NSObject, SDWebImageOperation {
+    let id = UUID()
+    let options: SDWebImage.SDWebImageOptions
+    let context: [SDWebImageContextOption: Any]?
+    private let lock = NSLock()
+    private var completion: SDImageLoaderCompletedBlock?
+    private var cancellation: (() -> Void)?
+    private var terminal = false
+
+    init(options: SDWebImage.SDWebImageOptions, context: [SDWebImageContextOption: Any]?,
+      completion: SDImageLoaderCompletedBlock?) {
+      self.options = options; self.context = context; self.completion = completion
+    }
+
+    var isTerminal: Bool {
+      lock.lock(); defer { lock.unlock() }; return terminal
+    }
+
+    func onCancel(_ block: @escaping () -> Void) {
+      lock.lock()
+      let alreadyTerminal = terminal
+      if !alreadyTerminal { cancellation = block }
+      lock.unlock()
+      if alreadyTerminal { block() }
+    }
+
+    func finish(image: UIImage?, data: Data?, error: Error?) {
+      lock.lock()
+      guard !terminal else { lock.unlock(); return }
+      terminal = true
+      let callback = completion
+      completion = nil; cancellation = nil
+      lock.unlock()
+      callback?(image, data, error, true)
+    }
+
+    func cancel() {
+      lock.lock()
+      guard !terminal else { lock.unlock(); return }
+      terminal = true
+      let callback = completion, cancel = cancellation
+      completion = nil; cancellation = nil
+      lock.unlock()
+      cancel?()
+      // Preload's checked continuation must also terminate on cancellation.
+      DispatchQueue.global(qos: .userInitiated).async {
+        callback?(nil, nil, URLError(.cancelled), true)
+      }
+    }
+  }
+
+  private final class Flight {
+    let id = UUID()
+    let descriptor: OneKeyBlockieDescriptor
+    let url: URL
+    var subscriptions: [UUID: Subscription] = [:]
+    var operation: BlockOperation?
+    init(descriptor: OneKeyBlockieDescriptor, url: URL) {
+      self.descriptor = descriptor; self.url = url
+    }
+  }
+
+  private let state = DispatchQueue(label: "onekey.avatar.state")
+  private let workers: OperationQueue = {
+    let queue = OperationQueue()
+    queue.name = "onekey.avatar.generate"
+    queue.qualityOfService = .userInitiated
+    queue.maxConcurrentOperationCount = 2
+    return queue
+  }()
+  private var flights: [String: Flight] = [:]
+  private var diskWrites = 0
+
+  func canRequestImage(for url: URL?) -> Bool {
+    // Own invalid local-avatar URLs too: fail locally instead of using HTTP.
+    url?.scheme == "onekey-avatar"
+  }
+
+  func shouldBlockFailedURL(with url: URL, error: Error) -> Bool { false }
+
+  func requestImage(with url: URL?, options: SDWebImage.SDWebImageOptions,
+    context: [SDWebImageContextOption: Any]?, progress: SDImageLoaderProgressBlock?,
+    completed: SDImageLoaderCompletedBlock?) -> SDWebImageOperation? {
+    let subscriber = Subscription(options: options, context: context, completion: completed)
+    state.async {
+      guard !subscriber.isTerminal else { return }
+      guard let url, let descriptor = OneKeyBlockieDescriptor(url: url) else {
+        subscriber.finish(image: nil, data: nil, error: URLError(.badURL))
+        return
+      }
+      let key = descriptor.cacheKey
+      let flight = self.flights[key] ?? Flight(descriptor: descriptor, url: url)
+      self.flights[key] = flight
+      flight.subscriptions[subscriber.id] = subscriber
+      subscriber.onCancel { [weak self, weak flight] in
+        guard let self, let flight else { return }
+        self.state.async {
+          guard self.flights[key] === flight else { return }
+          flight.subscriptions.removeValue(forKey: subscriber.id)
+          if flight.subscriptions.isEmpty {
+            self.flights.removeValue(forKey: key)
+            flight.operation?.cancel()
+          }
+        }
+      }
+      guard flight.operation == nil else { return }
+      let operation = BlockOperation { [weak self, weak flight] in
+        guard let self, let flight else { return }
+        self.load(flight)
+      }
+      flight.operation = operation
+      self.workers.addOperation(operation)
+    }
+    return subscriber
+  }
+
+  private func load(_ flight: Flight) {
+    let key = flight.descriptor.cacheKey
+    let cancelled = { flight.operation?.isCancelled != false }
+    guard !cancelled() else { return }
+    let queryTypes = state.sync { cacheTypes(flight, field: .originalQueryCacheType) }
+    // Query again inside the merged worker to close the manager-cache-query vs
+    // completed previous flight race. These disk operations never run on UI.
+    var data: Data?
+    if queryTypes.memory, let image = Self.cache.imageFromMemoryCache(forKey: key) {
+      data = image.pngData()
+    }
+    if data == nil, queryTypes.disk { data = Self.cache.diskImageData(forKey: key) }
+    var original = data.flatMap { UIImage(data: $0) }
+    // A damaged persistent entry is a local cache miss, not a permanent avatar failure.
+    if original == nil {
+      data = OneKeyBlockie.png(seed: flight.descriptor.seed, isCancelled: cancelled)
+      original = data.flatMap { UIImage(data: $0) }
+    }
+    guard !cancelled() else { return }
+    guard let data, let original else {
+      finish(flight, data: nil, error: URLError(.cannotDecodeContentData)); return
+    }
+    // Synchronous store on this worker seals the cache-fill window before any
+    // subscriber (or a new isolated manager) can observe a completed flight.
+    var storedMemory = false, storedDisk = false
+    while !cancelled() {
+      var subscribers: [Subscription]?
+      let storeTypes = state.sync { () -> (memory: Bool, disk: Bool) in
+        guard flights[key] === flight else { subscribers = []; return (false, false) }
+        let required = cacheTypes(flight, field: .originalStoreCacheType)
+        if (!required.memory || storedMemory) && (!required.disk || storedDisk) {
+          flights.removeValue(forKey: key)
+          subscribers = Array(flight.subscriptions.values)
+        }
+        return required
+      }
+      if let subscribers { deliver(subscribers, flight: flight, data: data, error: nil); return }
+      if storeTypes.memory && !storedMemory {
+        Self.cache.storeImage(toMemory: original, forKey: key)
+        storedMemory = true
+      }
+      if storeTypes.disk && !storedDisk {
+        Self.cache.storeImageData(toDisk: data, forKey: key)
+        storedDisk = true
+        state.async {
+          self.diskWrites += 1
+          // SDWebImage also cleans on background/termination; bound active-session
+          // growth without scanning the directory after every small PNG write.
+          if self.diskWrites % 128 == 0 { Self.cache.deleteOldFiles(completionBlock: nil) }
+        }
+      }
+    }
+  }
+
+  private func cacheTypes(_ flight: Flight, field: SDWebImageContextOption) -> (memory: Bool, disk: Bool) {
+    var memory = false, disk = false
+    for subscriber in flight.subscriptions.values where !subscriber.isTerminal {
+      let raw = (subscriber.context?[field] as? NSNumber)?.intValue ?? SDImageCacheType.all.rawValue
+      memory = memory || raw == SDImageCacheType.memory.rawValue || raw == SDImageCacheType.all.rawValue
+      disk = disk || raw == SDImageCacheType.disk.rawValue || raw == SDImageCacheType.all.rawValue
+    }
+    return (memory, disk)
+  }
+
+  private func finish(_ flight: Flight, data: Data?, error: Error?) {
+    let subscribers: [Subscription] = state.sync {
+      guard flights[flight.descriptor.cacheKey] === flight else { return [] }
+      flights.removeValue(forKey: flight.descriptor.cacheKey)
+      return Array(flight.subscriptions.values)
+    }
+    deliver(subscribers, flight: flight, data: data, error: error)
+  }
+
+  private func deliver(_ subscribers: [Subscription], flight: Flight, data: Data?, error: Error?) {
+    for subscriber in subscribers where !subscriber.isTerminal {
+      let image: UIImage? = data.flatMap {
+        SDWebImage.SDImageLoaderDecodeImageData($0, flight.url,
+          .init(rawValue: subscriber.options.rawValue), subscriber.context)
+      }
+      subscriber.finish(image: image, data: data,
+        error: error ?? (image == nil ? URLError(.cannotDecodeContentData) : nil))
+    }
+  }
+}

package/ios/OneKeyBlockie.swift

@@ -0,0 +1,126 @@
+// 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.
+
+import CoreGraphics
+import Foundation
+import ImageIO
+
+struct OneKeyBlockieDescriptor {
+  let seed: String
+  let cacheKey: String
+
+  init?(url: URL) {
+    guard let parts = URLComponents(url: url, resolvingAgainstBaseURL: false),
+      parts.scheme == "onekey-avatar", parts.host == "blockie",
+      parts.user == nil, parts.password == nil, parts.port == nil,
+      parts.query == nil, parts.fragment == nil,
+      parts.percentEncodedPath.hasPrefix("/v1/")
+    else { return nil }
+    let encoded = String(parts.percentEncodedPath.dropFirst(4))
+    guard !encoded.contains("/"), let seed = encoded.removingPercentEncoding,
+      !seed.isEmpty
+    else { return nil }
+    // The caller already applied JS lowercase. ASCII keys preserve distinct
+    // UTF16 seeds that Swift String otherwise compares as canonically equal.
+    let allowed = CharacterSet(charactersIn:
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~*'()")
+    guard let canonical = seed.addingPercentEncoding(withAllowedCharacters: allowed) else { return nil }
+    self.seed = seed
+    cacheKey = "onekey-avatar://blockie/v1/\(canonical)"
+  }
+}
+
+enum OneKeyBlockie {
+  static let pixelSize = 128
+
+  private struct Random {
+    var state = [Int32](repeating: 0, count: 4)
+
+    init(seed: String) {
+      for (index, unit) in seed.utf16.enumerated() {
+        let slot = index % 4
+        state[slot] = (state[slot] &<< 5) &- state[slot] &+ Int32(unit)
+      }
+    }
+
+    mutating func next() -> Double {
+      let t = state[0] ^ (state[0] &<< 11)
+      state[0] = state[1]; state[1] = state[2]; state[2] = state[3]
+      state[3] = state[3] ^ (state[3] >> 19) ^ t ^ (t >> 8)
+      return Double(UInt32(bitPattern: state[3])) / 2_147_483_648
+    }
+
+    mutating func color() -> [UInt8] {
+      let h = floor(next() * 360) / 360
+      let s = (next() * 60 + 40) / 100
+      let l = ((next() + next() + next() + next()) * 25) / 100
+      let q = l < 0.5 ? l * (1 + s) : l + s - l * s
+      let p = 2 * l - q
+      func channel(_ value: Double) -> UInt8 {
+        var t = value
+        if t < 0 { t += 1 }
+        if t > 1 { t -= 1 }
+        let value: Double
+        if t < 1.0 / 6 { value = p + (q - p) * 6 * t }
+        else if t < 1.0 / 2 { value = q }
+        else if t < 2.0 / 3 { value = p + (q - p) * (2.0 / 3 - t) * 6 }
+        else { value = p }
+        return UInt8(truncatingIfNeeded: Int(floor(value * 255 + 0.5)))
+      }
+      return [channel(h + 1.0 / 3), channel(h), channel(h - 1.0 / 3), 255]
+    }
+  }
+
+  static func rgba(seed: String, isCancelled: () -> Bool = { false }) -> Data? {
+    var random = Random(seed: seed)
+    let foreground = random.color(), background = random.color(), spot = random.color()
+    var pixels = [UInt8](repeating: 0, count: pixelSize * pixelSize * 4)
+    for row in 0..<8 {
+      guard !isCancelled() else { return nil }
+      let half = (0..<4).map { _ in Int(floor(random.next() * 2.3)) }
+      let cells = half + half.reversed()
+      for column in 0..<8 {
+        let color = cells[column] == 0 ? background : cells[column] == 1 ? foreground : spot
+        for y in (row * 16)..<((row + 1) * 16) {
+          for x in (column * 16)..<((column + 1) * 16) {
+            let offset = (y * pixelSize + x) * 4
+            for channel in 0..<4 { pixels[offset + channel] = color[channel] }
+          }
+        }
+      }
+    }
+    return Data(pixels)
+  }
+
+  static func png(seed: String, isCancelled: () -> Bool = { false }) -> Data? {
+    guard let data = rgba(seed: seed, isCancelled: isCancelled), !isCancelled(),
+      let provider = CGDataProvider(data: data as CFData),
+      let image = CGImage(width: pixelSize, height: pixelSize, bitsPerComponent: 8,
+        bitsPerPixel: 32, bytesPerRow: pixelSize * 4, space: CGColorSpaceCreateDeviceRGB(),
+        bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.last.rawValue),
+        provider: provider, decode: nil, shouldInterpolate: false, intent: .defaultIntent)
+    else { return nil }
+    let output = NSMutableData()
+    guard let destination = CGImageDestinationCreateWithData(output, "public.png" as CFString, 1, nil)
+    else { return nil }
+    CGImageDestinationAddImage(destination, image, nil)
+    guard CGImageDestinationFinalize(destination), !isCancelled() else { return nil }
+    return output as Data
+  }
+}

package/ios/OneKeyImage.swift

@@ -121,6 +121,11 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
   var optimizeTos: Bool? = true {
     didSet { if optimizeTos != oldValue { identityDidChange() } }
   }
+  var resizeWidth: Double? {
+    didSet {
+      if !Self.equalOptionalDouble(resizeWidth, oldValue) { identityDidChange() }
+    }
+  }
   var overscan: Double? = 1.1 {
     didSet {
       if !Self.equalOptionalDouble(overscan, oldValue) { identityDidChange() }
@@ -241,6 +246,7 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
       cachePolicy?.stringValue ?? "memory-disk",
       contentFit?.stringValue ?? "cover",
       String(optimizeTos ?? true),
+      resizeWidth.map(String.init(describing:)) ?? "",
       String(overscan ?? 1.1),
       String(Int(hostView.bounds.width.rounded())),
       String(Int(hostView.bounds.height.rounded())),
@@ -270,11 +276,13 @@ 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 requestURL =
       (optimizeTos ?? true)
       ? OneKeyTosURL.optimized(
         rawURL: rawURL,
-        displaySize: max(hostView.bounds.width, hostView.bounds.height),
+        displaySize: displaySize,
         scale: screenScale,
         overscan: overscan ?? 1.1,
         hasCustomIdentity: hasCustomIdentity
@@ -313,7 +321,10 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
       cachePolicy: cachePolicy ?? .memoryDisk,
       thumbnailPixelSize: thumbnailPixelSize,
       safetyTracker: safetyHandle.tracker,
-      manager: safetyHandle.manager
+      // OneKey patch: Rendering and preload use the same local-avatar loader.
+      // manager: safetyHandle.manager
+      manager: safetyHandle.manager,
+      url: url
     )
     hostView.sd_setImage(
       with: url,
@@ -460,6 +471,7 @@ final class HybridOneKeyImage: HybridOneKeyImageSpec, RecyclableView {
     autoplay = true
     recyclingKey = nil
     optimizeTos = true
+    resizeWidth = nil
     overscan = 1.1
     loadingStrategy = .static
     onLoadStart = nil

package/ios/OneKeyImageCache.swift

@@ -74,6 +74,8 @@ final class HybridOneKeyImageCache: HybridOneKeyImageCacheSpec {
   func clearMemory() throws -> Promise<Void> {
     Promise.async {
       SDImageCache.shared.clearMemory()
+      // OneKey patch: Clear the dedicated local-avatar cache with public cache operations.
+      OneKeyAvatarImageLoader.cache.clearMemory()
     }
   }
 
@@ -82,11 +84,16 @@ final class HybridOneKeyImageCache: HybridOneKeyImageCacheSpec {
       await withCheckedContinuation { continuation in
         SDImageCache.shared.clearDisk { continuation.resume() }
       }
+      await withCheckedContinuation { continuation in
+        OneKeyAvatarImageLoader.cache.clearDisk { continuation.resume() }
+      }
     }
   }
 
   func clearAll() throws -> Promise<Void> {
     SDImageCache.shared.clearMemory()
+    // OneKey patch: The avatar cache is shared by render and preload requests.
+    OneKeyAvatarImageLoader.cache.clearMemory()
     return try clearDisk()
   }
 
@@ -154,7 +161,10 @@ final class HybridOneKeyImageCache: HybridOneKeyImageCacheSpec {
       cachePolicy: source.cachePolicy ?? .memoryDisk,
       thumbnailPixelSize: thumbnailPixelSize,
       safetyTracker: safetyHandle.tracker,
-      manager: safetyHandle.manager
+      // OneKey patch: Rendering and preload use the same local-avatar loader.
+      // manager: safetyHandle.manager
+      manager: safetyHandle.manager,
+      url: url
     )
     return await load(url: url, context: context, safetyHandle: safetyHandle)
   }

package/ios/OneKeyImageCoderBridge.h

@@ -0,0 +1,14 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+// Keep optional coder modules out of the Swift compilation unit so SDWebImage
+// Objective-C types are imported under a single Swift module identity.
+@interface OneKeyImageCoderBridge : NSObject
+
++ (void)addCodersToManager:(id)manager NS_SWIFT_NAME(addCoders(to:));
++ (void)ensureWebPCoderRegistered;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/OneKeyImageCoderBridge.m

@@ -0,0 +1,25 @@
+#import "OneKeyImageCoderBridge.h"
+
+#import <SDWebImage/SDWebImage.h>
+#import <SDWebImageSVGCoder/SDImageSVGCoder.h>
+#import <SDWebImageWebPCoder/SDImageWebPCoder.h>
+
+@implementation OneKeyImageCoderBridge
+
++ (void)addCodersToManager:(id)manager {
+  SDImageCodersManager *coderManager = (SDImageCodersManager *)manager;
+  [coderManager addCoder:SDImageSVGCoder.sharedCoder];
+  [coderManager addCoder:SDImageWebPCoder.sharedCoder];
+}
+
++ (void)ensureWebPCoderRegistered {
+  SDImageCodersManager *manager = SDImageCodersManager.sharedManager;
+  for (id<SDImageCoder> coder in manager.coders) {
+    if (coder == SDImageWebPCoder.sharedCoder) {
+      return;
+    }
+  }
+  [manager addCoder:SDImageWebPCoder.sharedCoder];
+}
+
+@end

package/ios/OneKeyImageRequestContext.swift

@@ -2,8 +2,6 @@ import CryptoKit
 import Foundation
 import ImageIO
 import SDWebImage
-import SDWebImageSVGCoder
-import SDWebImageWebPCoder
 import UIKit
 
 enum OneKeyImageSafetyViolation: LocalizedError, Equatable, Sendable {
@@ -467,28 +465,18 @@ enum OneKeyImageSafetyPolicy {
 }
 
 enum OneKeyImageCoderRegistry {
-  private static let svgCoder = SDImageSVGCoder.shared
-  private static let webPCoder = SDImageWebPCoder.shared
-
   static let coder: SDImageCodersManager = {
     // Keep OneKey's decoder set independent from Expo's global registrations.
     // SDImageCodersManager starts with ImageIO, GIF and APNG coders.
     let manager = SDImageCodersManager()
-    manager.addCoder(svgCoder)
-    manager.addCoder(webPCoder)
+    OneKeyImageCoderBridge.addCoders(to: manager)
     return manager
   }()
 
   private static let globalRegistration: Void = {
     // SDAnimatedImage resolves its animated coder through the global manager,
     // even when a request-local coder is provided in the SDWebImage context.
-    let global = SDImageCodersManager.shared
-    let isAlreadyRegistered = (global.coders ?? []).contains {
-      ($0 as AnyObject) === webPCoder
-    }
-    if !isAlreadyRegistered {
-      global.addCoder(webPCoder)
-    }
+    OneKeyImageCoderBridge.ensureWebPCoderRegistered()
   }()
 
   static func ensureWebPRegistered() {
@@ -697,7 +685,10 @@ enum OneKeyImageRequestContext {
     cachePolicy: OneKeyImageCachePolicy,
     thumbnailPixelSize: CGSize?,
     safetyTracker: OneKeyImageSafetyTracker?,
-    manager: SDWebImageManager
+    // OneKey patch: Scope local avatar routing to this request, preserving HTTP managers.
+    // manager: SDWebImageManager
+    manager: SDWebImageManager,
+    url: URL? = nil
   ) -> [SDWebImageContextOption: Any] {
     var context = baseContext
     context[.customManager] = manager
@@ -728,6 +719,14 @@ enum OneKeyImageRequestContext {
     context[.storeCacheType] = cacheType.rawValue
     context[.originalQueryCacheType] = cacheType.rawValue
     context[.originalStoreCacheType] = cacheType.rawValue
+    if url?.scheme == "onekey-avatar" {
+      context[.imageLoader] = OneKeyAvatarImageLoader.shared
+      context[.imageCache] = OneKeyAvatarImageLoader.cache
+      context[.originalImageCache] = OneKeyAvatarImageLoader.cache
+      context[.cacheKeyFilter] = SDWebImageCacheKeyFilter { url in
+        OneKeyBlockieDescriptor(url: url)?.cacheKey ?? url.absoluteString
+      }
+    }
     return context
   }
 

package/ios/OneKeyImageReusableView.swift

@@ -27,8 +27,13 @@ public final class OneKeyImageReusableView: UIView {
     recyclingKey: String,
     optimizeTos: Bool,
     overscan: Double,
-    loadingStrategy: String
+    loadingStrategy: String,
+    onLoad: (() -> Void)? = nil,
+    onError: (() -> Void)? = nil
   ) {
+    // OneKey patch: Let reusable cells display their own success and fallback visuals.
+    image.onLoad = { _, _, _ in onLoad?() }
+    image.onError = { _ in onError?() }
     image.sourceHeadersJson = sourceHeadersJson
     image.variant = OneKeyImageVariant(fromString: variant) ?? .generic
     image.contentFit = OneKeyImageContentFit(fromString: contentFit) ?? .cover

package/ios/OneKeyTosURL.swift

@@ -1,8 +1,10 @@
 import Foundation
 
 enum OneKeyTosURL {
-  static let widthBuckets = [
-    32, 40, 48, 64, 96, 128, 160, 200, 256, 320, 480, 640, 960, 1280,
+  // Select by layout size first. Density can only choose between this tier's renditions.
+  static let sizeTiers: [(maxDisplaySize: CGFloat, standard: Int, highDensity: Int)] = [
+    (48, 96, 160), (96, 192, 320), (192, 384, 640),
+    (384, 768, 1280), (.infinity, 1280, 1280),
   ]
 
   static func optimized(
@@ -24,19 +26,16 @@ enum OneKeyTosURL {
       return rawURL
     }
 
+    let tier = sizeTiers.first(where: { displaySize <= $0.maxDisplaySize })!
     let normalizedScale = scale.isFinite ? min(max(scale, 1), 3) : 1
-    let normalizedOverscan = overscan.isFinite ? max(overscan, 1) : 1
-    let requestedPixels = ceil(displaySize * normalizedScale * normalizedOverscan)
-    let bucket: Int
-    if !requestedPixels.isFinite || requestedPixels >= CGFloat(widthBuckets.last!) {
-      bucket = widthBuckets.last!
-    } else {
-      let requested = Int(requestedPixels)
-      bucket = widthBuckets.first(where: { $0 >= requested }) ?? widthBuckets.last!
-    }
-    var queryItems = components.queryItems ?? []
-    queryItems.append(URLQueryItem(name: "x-tos-process", value: "image/resize,w_\(bucket)"))
-    components.queryItems = queryItems
+    let normalizedOverscan = overscan.isFinite ? max(overscan, 1) : 1.1
+    // Fixed renditions already account for the default margin. Custom margins stay within the tier.
+    let density = normalizedScale * CGFloat(normalizedOverscan / 1.1)
+    let pixelWidth = density > 2 ? tier.highDensity : tier.standard
+    // Match Android and Web without rewriting the source URL's existing query.
+    let query = components.percentEncodedQuery ?? ""
+    let separator = query.isEmpty || query.hasSuffix("&") ? "" : "&"
+    components.percentEncodedQuery = "\(query)\(separator)x-tos-process=image%2Fresize%2Cw_\(pixelWidth)"
     return components.url ?? rawURL
   }
 

package/ios/tests/OneKeyAvatarImageTests.swift

@@ -0,0 +1,49 @@
+// OneKey patch: Protect request-local avatar routing and exact UTF16 identities.
+import Foundation
+import SDWebImage
+import XCTest
+
+@testable import OneKeyImage
+
+final class OneKeyAvatarImageTests: XCTestCase {
+  func testAvatarCacheIsSharedWithoutReplacingIsolatedHTTPManagers() throws {
+    let url = try XCTUnwrap(URL(string: "onekey-avatar://blockie/v1/synthetic-avatar"))
+    let first = OneKeyImagePipeline.makeIsolatedManager()
+    let second = OneKeyImagePipeline.makeIsolatedManager()
+    func context(_ manager: SDWebImageManager, headers: String) -> [SDWebImageContextOption: Any] {
+      OneKeyImageRequestContext.make(headersJson: headers, cachePolicy: .memoryDisk,
+        thumbnailPixelSize: CGSize(width: 96, height: 96), safetyTracker: nil,
+        manager: manager, url: url)
+    }
+    let a = context(first, headers: "{\"X-Test\":\"a\"}")
+    let b = context(second, headers: "{\"X-Test\":\"b\"}")
+    XCTAssertTrue(a[.customManager] as? SDWebImageManager === first)
+    XCTAssertTrue(b[.customManager] as? SDWebImageManager === second)
+    XCTAssertTrue(a[.imageLoader] as? OneKeyAvatarImageLoader === OneKeyAvatarImageLoader.shared)
+    XCTAssertTrue(b[.imageLoader] as? OneKeyAvatarImageLoader === OneKeyAvatarImageLoader.shared)
+    XCTAssertTrue(a[.imageCache] as? SDImageCache === b[.imageCache] as? SDImageCache)
+    XCTAssertTrue(a[.originalImageCache] as? SDImageCache === OneKeyAvatarImageLoader.cache)
+    let firstFilter = try XCTUnwrap(a[.cacheKeyFilter] as? SDWebImageCacheKeyFilter)
+    let secondFilter = try XCTUnwrap(b[.cacheKeyFilter] as? SDWebImageCacheKeyFilter)
+    XCTAssertEqual(firstFilter.cacheKey(for: url), secondFilter.cacheKey(for: url))
+    let remote = OneKeyImageRequestContext.make(headersJson: nil, cachePolicy: .memoryDisk,
+      thumbnailPixelSize: nil, safetyTracker: nil, manager: first,
+      url: URL(string: "https://example.com/image.png"))
+    XCTAssertNil(remote[.imageLoader])
+    XCTAssertNil(remote[.imageCache])
+    XCTAssertNil(remote[.originalImageCache])
+  }
+
+  func testURIDecodesExactlyOnceAndPreservesUTF16SeedIdentity() throws {
+    func descriptor(_ suffix: String) throws -> OneKeyBlockieDescriptor {
+      try XCTUnwrap(OneKeyBlockieDescriptor(url:
+        XCTUnwrap(URL(string: "onekey-avatar://blockie/v1/" + suffix))))
+    }
+    XCTAssertEqual(try descriptor("%2561").seed, "%61")
+    XCTAssertEqual(try descriptor("%61").cacheKey, try descriptor("a").cacheKey)
+    XCTAssertNotEqual(try descriptor("%C3%A9").cacheKey, try descriptor("e%CC%81").cacheKey)
+    XCTAssertEqual(try descriptor("%C4%B0").seed.utf16.count, 1)
+    XCTAssertNotEqual(OneKeyBlockie.rgba(seed: "é"), OneKeyBlockie.rgba(seed: "e\u{301}"))
+    XCTAssertNil(OneKeyBlockie.png(seed: "synthetic", isCancelled: { true }))
+  }
+}