@onekeyfe/react-native-image 6.7.0-alpha.415 → 6.7.0-alpha.421

package/README.md

@@ -95,3 +95,15 @@ pod 'SDWebImage', '5.21.7', :modular_headers => true
 pod 'SDWebImageWebPCoder', '0.14.6', :modular_headers => true
 pod 'SDWebImageSVGCoder', '1.7.0', :modular_headers => true
 ```
+
+## Named icon resource ownership
+
+The host owns canonical SVG artwork and build output. Native builds supply a
+`OneKeyIcons.bundle` on iOS and `assets/icons` on Android, including the manifest.
+Web builds alias `#onekey-icon-assets` to a generated module exporting
+`iconResourceHref(name: string): string | undefined`; the default SDK provider
+is empty. `OneKeyIcon` props are unchanged. See [the resource contract](docs/SPEC.md#16-host-owned-icon-resources--implemented-sdk-fixture-runtime-verified).
+
+The SDK example carries 63 independent test samples. `icons:check` and
+`icons:test` are repository maintenance commands that require the example
+fixtures; npm consumers do not receive those samples or the complete catalog.

package/android/build.gradle

@@ -63,7 +63,9 @@ android {
     targetCompatibility JavaVersion.VERSION_1_8
   }
   sourceSets {
-    main { java.srcDirs += ["generated/java", "generated/jni"] }
+    main {
+      java.srcDirs += ["generated/java", "generated/jni"]
+    }
   }
 }
 

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

@@ -0,0 +1,93 @@
+package com.margelo.nitro.onekeyimage
+
+import android.content.Context
+import android.content.res.Configuration
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffColorFilter
+import android.widget.ImageView
+import com.facebook.react.uimanager.ThemedReactContext
+import com.margelo.nitro.views.RecyclableView
+import java.lang.ref.WeakReference
+
+private class OneKeyIconHost(context: Context) : ImageView(context) {
+  var changed: (() -> Unit)? = null
+  var attached = false
+    private set
+  init { scaleType = ScaleType.FIT_CENTER }
+  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+    super.onSizeChanged(w, h, oldw, oldh)
+    changed?.invoke()
+  }
+  override fun onAttachedToWindow() { super.onAttachedToWindow(); attached = true; changed?.invoke() }
+  override fun onDetachedFromWindow() { attached = false; super.onDetachedFromWindow(); changed?.invoke() }
+  override fun onConfigurationChanged(newConfig: Configuration) { super.onConfigurationChanged(newConfig); changed?.invoke() }
+}
+
+class HybridOneKeyIcon(context: ThemedReactContext) : HybridOneKeyIconSpec(), RecyclableView {
+  private val host = OneKeyIconHost(context)
+  private val owner = Any()
+  private var generation = 0L
+  private var identity: String? = null
+  private var displayedGeometry: String? = null
+  private var displayed: OneKeyNamedSVG.RenderResult? = null
+  override val view: ImageView get() = host
+  override var iconName: String? = null
+  override var resolvedColor: String? = null
+  init { host.changed = { refresh() } }
+
+  override fun afterUpdate() { super.afterUpdate(); refresh() }
+
+  private fun clearImage() {
+    displayed = null; displayedGeometry = null
+    host.colorFilter = null; host.setImageDrawable(null)
+  }
+
+  private fun applyTint(result: OneKeyNamedSVG.RenderResult, color: String) {
+    host.colorFilter = result.tintColor(color)?.let { PorterDuffColorFilter(it, PorterDuff.Mode.SRC_IN) }
+  }
+
+  private fun refresh() {
+    val scale = host.resources.displayMetrics.density
+    val next = "$iconName|$resolvedColor|${host.width}|${host.height}|$scale|${host.attached}"
+    if (identity == next) return
+    identity = next; generation++
+    val revision = generation
+    OneKeyNamedSVG.cancel(owner)
+    val name = iconName
+    val color = resolvedColor
+    if (!host.attached || host.width !in 1..4096 || host.height !in 1..4096 ||
+      host.width.toLong() * host.height > 4194304 || name.isNullOrEmpty() || color == null ||
+      !OneKeyNamedSVG.isValidColor(color)) { clearImage(); return }
+    val geometry = "$name|${host.width}|${host.height}|$scale"
+    val ready = displayed
+    if (displayedGeometry == geometry && ready != null && host.drawable != null) {
+      if (ready.canTint(color)) { applyTint(ready, color); return }
+    } else clearImage()
+    OneKeyNamedSVG.cachedRender(name, color, host.width, host.height, scale)?.let { hit ->
+      displayed = hit; displayedGeometry = geometry
+      applyTint(hit, color)
+      host.setImageBitmap(hit.bitmap)
+      return
+    }
+    val weakHost = WeakReference(host)
+    val weakSelf = WeakReference(this)
+    OneKeyNamedSVG.requestRender(owner, host.context.applicationContext.assets, name, color,
+      host.width, host.height, scale) { result ->
+      val current = weakSelf.get()
+      val target = weakHost.get()
+      if (current?.generation != revision || target?.attached != true) return@requestRender
+      if (result == null) { current.clearImage(); return@requestRender }
+      current.displayed = result; current.displayedGeometry = geometry
+      current.applyTint(result, color)
+      target.setImageBitmap(result.bitmap)
+    }
+  }
+
+  override fun prepareForRecycle() {
+    iconName = null
+    resolvedColor = null
+    refresh()
+  }
+  override fun onDropView() { prepareForRecycle(); super.onDropView() }
+  override fun dispose() { prepareForRecycle(); host.changed = null; super.dispose() }
+}

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

@@ -266,7 +266,7 @@ private class OneKeySvgDecoder : ResourceDecoder<InputStream, SVG> {
     options: Options,
   ): Resource<SVG> {
     val svg = try {
-      SVG.getFromInputStream(source)
+      OneKeySVG.parse(source)
     } catch (error: SVGParseException) {
       throw IOException("Cannot decode SVG", error)
     }

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

@@ -5,6 +5,7 @@ import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
+import com.margelo.nitro.onekeyimage.views.HybridOneKeyIconManager
 import com.margelo.nitro.onekeyimage.views.HybridOneKeyImageManager
 
 class OneKeyImagePackage : BaseReactPackage() {
@@ -17,7 +18,7 @@ class OneKeyImagePackage : BaseReactPackage() {
     reactContext: ReactApplicationContext,
   ): List<ViewManager<*, *>> {
     OneKeyImageGlideRegistry.ensureRegistered(reactContext)
-    return listOf(HybridOneKeyImageManager())
+    return listOf(HybridOneKeyImageManager(), HybridOneKeyIconManager())
   }
 
   companion object {

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

@@ -0,0 +1,217 @@
+package com.margelo.nitro.onekeyimage
+
+import android.content.res.AssetManager
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffColorFilter
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import org.json.JSONObject
+import java.util.concurrent.Executors
+import kotlin.math.roundToInt
+
+/** Process-owned named resources; no React runtime or Activity is retained. */
+object OneKeyNamedSVG {
+  enum class RecolorMode { FIXED, SINGLE, MULTIPLE, RASTER }
+  data class IconMetadata(
+    val width: Float,
+    val height: Float,
+    val mode: RecolorMode,
+  )
+  data class RenderResult(val bitmap: Bitmap, val mode: RecolorMode,
+    val sourceIdentity: String, val maskAlpha: Int) {
+    fun canTint(color: String): Boolean {
+      val value = parseColor(color) ?: return false
+      return mode == RecolorMode.FIXED || mode == RecolorMode.SINGLE ||
+        (mode == RecolorMode.MULTIPLE && Color.alpha(value) == maskAlpha)
+    }
+    fun tintColor(color: String): Int? {
+      val value = parseColor(color) ?: return null
+      return when(mode) {
+        RecolorMode.SINGLE -> value
+        RecolorMode.MULTIPLE -> value or (0xff shl 24)
+        else -> null
+      }
+    }
+    internal fun finalBitmap(color: String): Bitmap {
+      val tint = tintColor(color) ?: return bitmap
+      if (tint == Color.BLACK) return bitmap
+      val output = Bitmap.createBitmap(bitmap.width, bitmap.height, Bitmap.Config.ARGB_8888)
+      val paint = Paint().apply { colorFilter = PorterDuffColorFilter(tint, PorterDuff.Mode.SRC_IN) }
+      Canvas(output).drawBitmap(bitmap, 0f, 0f, paint)
+      return output
+    }
+  }
+
+  private data class Request(val assets: AssetManager, val name: String, val color: String,
+    val width: Int, val height: Int, val scale: Float, val finalColor: Boolean, val complete: (RenderResult?) -> Unit)
+  private val lock = Any()
+  private val pending = LinkedHashMap<Any, Request>()
+  private val cache = LinkedHashMap<String, RenderResult>(128, 0.75f, true)
+  private var cacheBytes = 0L
+  private var activeWorkers = 0
+  private var manifest: JSONObject? = null
+  private val manifestLock = Any()
+  private val workers = Executors.newFixedThreadPool(2)
+  private val main = Handler(Looper.getMainLooper())
+  private val colorPattern = Regex("rgba\\(\\d{1,3},\\d{1,3},\\d{1,3},(?:0(?:\\.\\d+)?|1(?:\\.0+)?)\\)")
+
+  private var manifestMissingLogged = false
+
+  fun cancel(owner: Any) { synchronized(lock) { pending.remove(owner) } }
+
+  /** Caller holds manifestLock. Hosts own the resources, so a miss is logged once. */
+  private fun loadManifestLocked(assets: AssetManager): JSONObject? {
+    manifest?.let { return it }
+    return try {
+      assets.open("icons/manifest.json").bufferedReader().use { JSONObject(it.readText()) }
+        .also { manifest = it }
+    } catch (error: Exception) {
+      if (!manifestMissingLogged) {
+        manifestMissingLogged = true
+        Log.w("OneKeyIcon", "assets/icons/manifest.json is missing or invalid; named icons will not render", error)
+      }
+      null
+    }
+  }
+
+  private fun modeOf(metadata: JSONObject): RecolorMode = try {
+    RecolorMode.valueOf(metadata.optString("recolorMode", "raster").uppercase())
+  } catch (_: IllegalArgumentException) {
+    RecolorMode.RASTER
+  }
+
+  private data class RenderKey(val identity: String, val key: String, val maskAlpha: Int)
+
+  private fun renderKey(name: String, digest: String, width: Int, height: Int, scale: Float,
+    mode: RecolorMode, requestColor: String, color: Int): RenderKey {
+    val identity = "$name|$digest|$width|$height|$scale"
+    val maskAlpha = if (mode == RecolorMode.MULTIPLE) Color.alpha(color) else 255
+    val colorKey = when(mode) {
+      RecolorMode.RASTER -> requestColor
+      RecolorMode.MULTIPLE -> maskAlpha.toString()
+      else -> ""
+    }
+    return RenderKey(identity, "$identity|$mode|$colorKey", maskAlpha)
+  }
+
+  /**
+   * Main-thread fast path: returns an already-decoded result without asset I/O or
+   * manifest loading, so remounted and recycled views paint in the same frame.
+   */
+  fun cachedRender(name: String, color: String, width: Int, height: Int, scale: Float): RenderResult? {
+    val value = parseColor(color) ?: return null
+    val metadata = synchronized(manifestLock) { manifest?.optJSONObject(name) } ?: return null
+    val digest = metadata.optString("digest").takeIf { it.isNotEmpty() } ?: return null
+    val key = renderKey(name, digest, width, height, scale, modeOf(metadata), color, value).key
+    return synchronized(lock) { cache[key] }
+  }
+
+  fun iconMetadata(assets: AssetManager, name: String): IconMetadata? {
+    val trimmed = name.trim()
+    if (trimmed.isEmpty()) return null
+    val metadata = try {
+      synchronized(manifestLock) {
+        loadManifestLocked(assets)?.optJSONObject(trimmed)
+      }
+    } catch (_: Exception) {
+      null
+    } ?: return null
+    val mode = modeOf(metadata)
+    val viewBox = metadata.optJSONArray("viewBox")
+    val vbWidth = if (viewBox != null && viewBox.length() >= 4) viewBox.optDouble(2, 24.0).toFloat() else 24f
+    val vbHeight = if (viewBox != null && viewBox.length() >= 4) viewBox.optDouble(3, 24.0).toFloat() else 24f
+    val width = if (vbWidth > 0f) vbWidth else 24f
+    val height = if (vbHeight > 0f) vbHeight else 24f
+    return IconMetadata(width = width, height = height, mode = mode)
+  }
+
+  fun request(owner: Any, assets: AssetManager, name: String, color: String,
+    width: Int, height: Int, scale: Float, complete: (Bitmap?) -> Unit) {
+    enqueue(owner, assets, name, color, width, height, scale, true) { complete(it?.bitmap) }
+  }
+
+  fun requestRender(owner: Any, assets: AssetManager, name: String, color: String,
+    width: Int, height: Int, scale: Float, complete: (RenderResult?) -> Unit) {
+    enqueue(owner, assets, name, color, width, height, scale, false, complete)
+  }
+
+  private fun enqueue(owner: Any, assets: AssetManager, name: String, color: String,
+    width: Int, height: Int, scale: Float, finalColor: Boolean, complete: (RenderResult?) -> Unit) {
+    synchronized(lock) {
+      pending[owner] = Request(assets, name, color, width, height, scale, finalColor, complete)
+      while (activeWorkers < 2 && activeWorkers < pending.size) {
+        activeWorkers++
+        workers.execute { drain() }
+      }
+    }
+  }
+
+  private fun parseColor(color: String): Int? {
+    if (!colorPattern.matches(color)) return null
+    val channels = color.removePrefix("rgba(").removeSuffix(")").split(',')
+    val rgb = channels.take(3).map { it.toInt() }
+    if (rgb.any { it !in 0..255 }) return null
+    val alpha = (channels[3].toDouble() * 255).roundToInt()
+    return Color.argb(alpha, rgb[0], rgb[1], rgb[2])
+  }
+  fun isValidColor(color: String): Boolean = parseColor(color) != null
+
+  private fun drain() {
+    while (true) {
+      val request = synchronized(lock) {
+        val first = pending.entries.firstOrNull()
+        if (first == null) { activeWorkers--; null }
+        else { pending.remove(first.key); first.value }
+      } ?: return
+      val bitmap = try {
+        decode(request)?.let { result ->
+          if (request.finalColor) result.copy(bitmap = result.finalBitmap(request.color), mode = RecolorMode.RASTER)
+          else result
+        }
+      } catch (_: Throwable) { null } // OOM must not strand activeWorkers.
+      main.post { request.complete(bitmap) }
+    }
+  }
+
+  private fun decode(request: Request): RenderResult? {
+    if (request.width !in 1..4096 || request.height !in 1..4096 ||
+      request.width.toLong() * request.height > 4194304 || !request.scale.isFinite() ||
+      request.scale <= 0) return null
+    val color = parseColor(request.color) ?: return null
+    val metadata = synchronized(manifestLock) {
+      loadManifestLocked(request.assets)?.optJSONObject(request.name)
+    } ?: return null
+    val mode = modeOf(metadata)
+    val (sourceIdentity, key, maskAlpha) = renderKey(request.name, metadata.getString("digest"),
+      request.width, request.height, request.scale, mode, request.color, color)
+    val paintColor = when(mode) {
+      RecolorMode.FIXED, RecolorMode.SINGLE -> Color.BLACK
+      RecolorMode.MULTIPLE -> Color.argb(maskAlpha, 0, 0, 0)
+      RecolorMode.RASTER -> color
+    }
+    synchronized(lock) { cache[key]?.let { return it } }
+    // AndroidSVG rgba quantizes with 256; SVG hex alpha preserves the exact CSS 8-bit channel.
+    val svgColor = listOf(Color.red(paintColor), Color.green(paintColor), Color.blue(paintColor), Color.alpha(paintColor))
+      .joinToString(separator = "", prefix = "#") { it.toString(16).padStart(2, '0') }
+    val xml = request.assets.open("icons/${request.name}.svg").bufferedReader().use { it.readText() }
+      .replace(Regex("((?:fill|stroke)\\s*=\\s*[\"'])currentColor([\"'])"), "$1${svgColor}$2")
+    val bitmap = OneKeySVG.decode(xml.byteInputStream()).render(request.width, request.height)
+    val result = RenderResult(bitmap, mode, sourceIdentity, maskAlpha)
+    val bytes = bitmap.allocationByteCount.toLong()
+    if (bytes <= 8388608) synchronized(lock) {
+      cache.put(key, result)?.let { cacheBytes -= it.bitmap.allocationByteCount }
+      cacheBytes += bytes
+      while (cache.size > 128 || cacheBytes > 8388608) {
+        val first = cache.entries.first()
+        cacheBytes -= first.value.bitmap.allocationByteCount
+        cache.remove(first.key)
+      }
+    }
+    return result
+  }
+}

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

@@ -0,0 +1,31 @@
+package com.margelo.nitro.onekeyimage
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import com.caverock.androidsvg.SVG
+import java.io.InputStream
+
+/** Synchronous per-request document; loaders retain scheduling and cancellation. */
+object OneKeySVG {
+  fun decode(source: InputStream): OneKeySVGDocument = OneKeySVGDocument(parse(source))
+  internal fun parse(source: InputStream): SVG = SVG.getFromInputStream(source)
+}
+
+class OneKeySVGDocument internal constructor(private val svg: SVG) {
+  val viewBoxWidth: Float? = svg.documentViewBox?.width()
+  val viewBoxHeight: Float? = svg.documentViewBox?.height()
+  val intrinsicWidth: Float = svg.documentWidth
+  val intrinsicHeight: Float = svg.documentHeight
+
+  fun render(width: Int, height: Int): Bitmap {
+    require(width > 0 && height > 0)
+    if (svg.documentViewBox == null && intrinsicWidth > 0 && intrinsicHeight > 0) {
+      svg.setDocumentViewBox(0f, 0f, intrinsicWidth, intrinsicHeight)
+    }
+    svg.setDocumentWidth(width.toFloat())
+    svg.setDocumentHeight(height.toFloat())
+    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    svg.renderToCanvas(Canvas(bitmap))
+    return bitmap
+  }
+}

package/ios/OneKeyIcon.swift

@@ -0,0 +1,90 @@
+import NitroModules
+import UIKit
+
+private final class OneKeyIconHost: UIImageView {
+  var changed: (() -> Void)?
+  override func layoutSubviews() { super.layoutSubviews(); changed?() }
+  override func didMoveToWindow() { super.didMoveToWindow(); changed?() }
+  override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
+    super.traitCollectionDidChange(previousTraitCollection)
+    if previousTraitCollection?.displayScale != traitCollection.displayScale { changed?() }
+  }
+}
+
+final class HybridOneKeyIcon: HybridOneKeyIconSpec, RecyclableView {
+  private let host = OneKeyIconHost()
+  private let owner = NSObject()
+  private var generation: UInt64 = 0
+  private var identity: String?
+  private var displayedGeometry: String?
+  private var displayed: OneKeyNamedSVG.RenderResult?
+  var iconName: String?
+  var resolvedColor: String?
+  var view: UIView { host }
+
+  override init() {
+    super.init()
+    host.contentMode = .scaleAspectFit
+    host.changed = { [weak self] in self?.refresh() }
+  }
+
+  func afterUpdate() { refresh() }
+
+  private func clearImage() {
+    displayed = nil; displayedGeometry = nil; host.image = nil
+  }
+
+  private func apply(_ result: OneKeyNamedSVG.RenderResult, color: String) {
+    displayed = result
+    if let tint = result.tintColor(color) {
+      host.image = result.image.withRenderingMode(.alwaysTemplate)
+      host.tintColor = tint
+    } else {
+      host.image = result.image.withRenderingMode(.alwaysOriginal)
+    }
+  }
+
+  private func refresh() {
+    let scale = host.window?.screen.scale ?? 1
+    let width = ceil(host.bounds.width * scale), height = ceil(host.bounds.height * scale)
+    let attached = host.window != nil
+    let next = "\(iconName ?? "")|\(resolvedColor ?? "")|\(width)|\(height)|\(scale)|\(attached)"
+    guard next != identity else { return }
+    identity = next; generation &+= 1
+    let revision = generation
+    OneKeyNamedSVG.shared.cancel(owner: owner)
+    guard attached, width.isFinite, height.isFinite,
+          width > 0, height > 0, width <= 4096, height <= 4096, width * height <= 4_194_304,
+          let name = iconName, !name.isEmpty,
+          let color = resolvedColor, OneKeyNamedSVG.isValidColor(color) else { clearImage(); return }
+    let geometry = "\(name)|\(width)|\(height)|\(scale)"
+    if displayedGeometry == geometry, let result = displayed, host.image != nil {
+      if result.canTint(color) {
+        if let tint = result.tintColor(color) { host.tintColor = tint }
+        return
+      }
+      // Keep only a successful same-source/geometry raster while new color decodes.
+    } else { clearImage() }
+    if let hit = OneKeyNamedSVG.shared.cachedRender(name: name, color: color,
+      width: Int(width), height: Int(height), scale: scale) {
+      displayedGeometry = geometry
+      apply(hit, color: color)
+      return
+    }
+    OneKeyNamedSVG.shared.requestRender(owner: owner, name: name, color: color,
+      width: Int(width), height: Int(height), scale: scale) { [weak self] result in
+      guard let self, self.generation == revision, self.host.window != nil else { return }
+      guard let result else { self.clearImage(); return }
+      self.displayedGeometry = geometry
+      self.apply(result, color: color)
+    }
+  }
+
+  func prepareForRecycle() {
+    iconName = nil; resolvedColor = nil; refresh()
+  }
+
+  func onDropView() { prepareForRecycle() }
+
+  deinit { OneKeyNamedSVG.shared.cancel(owner: owner) }
+}

package/ios/OneKeyImageCoderBridge.h

@@ -1,4 +1,5 @@
 #import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
 
 NS_ASSUME_NONNULL_BEGIN
 
@@ -8,6 +9,9 @@ NS_ASSUME_NONNULL_BEGIN
 
 + (void)addCodersToManager:(id)manager NS_SWIFT_NAME(addCoders(to:));
 + (void)ensureWebPCoderRegistered;
+// A zero target preserves the decoder's intrinsic/vector result.
++ (nullable UIImage *)decodeSVGData:(NSData *)data pixelSize:(CGSize)pixelSize
+  NS_SWIFT_NAME(decodeSVG(_:pixelSize:));
 
 @end
 

package/ios/OneKeyImageCoderBridge.m

@@ -6,6 +6,15 @@
 
 @implementation OneKeyImageCoderBridge
 
++ (UIImage *)decodeSVGData:(NSData *)data pixelSize:(CGSize)pixelSize {
+  NSDictionary *options = nil;
+  if (isfinite(pixelSize.width) && isfinite(pixelSize.height) && pixelSize.width > 0 && pixelSize.height > 0) {
+    options = @{SDImageCoderDecodeThumbnailPixelSize: [NSValue valueWithCGSize:pixelSize],
+                SDImageCoderDecodePreserveAspectRatio: @YES};
+  }
+  return [SDImageSVGCoder.sharedCoder decodedImageWithData:data options:options];
+}
+
 + (void)addCodersToManager:(id)manager {
   SDImageCodersManager *coderManager = (SDImageCodersManager *)manager;
   [coderManager addCoder:SDImageSVGCoder.sharedCoder];