@onekeyfe/react-native-image 3.0.98

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

@@ -0,0 +1,131 @@
+package com.margelo.nitro.onekeyimage
+
+import com.bumptech.glide.Glide
+import com.bumptech.glide.load.engine.DiskCacheStrategy
+import com.bumptech.glide.request.RequestOptions
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlin.math.ceil
+import kotlin.math.max
+
+class HybridOneKeyImageCache : HybridOneKeyImageCacheSpec() {
+  override fun preload(sources: Array<OneKeyImagePreloadSource>): Promise<Boolean> = Promise.async {
+    val context = NitroModules.applicationContext
+      ?: throw IllegalStateException("React application context is unavailable")
+    OneKeyImageGlideRegistry.ensureRegistered(context)
+    var allSucceeded = true
+    sources.forEach { source ->
+      if (source.uri.isBlank()) {
+        allSucceeded = false
+        return@forEach
+      }
+      val baseOptions = RequestOptions()
+        .dontTransform()
+        .downsample(OneKeyImageSafeDownsampleStrategy())
+      val options = when (source.cachePolicy ?: OneKeyImageCachePolicy.MEMORY_DISK) {
+        OneKeyImageCachePolicy.MEMORY_DISK -> baseOptions
+          .diskCacheStrategy(DiskCacheStrategy.AUTOMATIC)
+        OneKeyImageCachePolicy.MEMORY -> baseOptions
+          .diskCacheStrategy(DiskCacheStrategy.NONE)
+        OneKeyImageCachePolicy.DISK -> baseOptions
+          .diskCacheStrategy(DiskCacheStrategy.DATA)
+          .skipMemoryCache(true)
+        OneKeyImageCachePolicy.NONE -> baseOptions
+          .diskCacheStrategy(DiskCacheStrategy.NONE)
+          .skipMemoryCache(true)
+      }
+      val displayWidth = source.resizeWidth?.takeIf { it.isFinite() && it > 0.0 }
+      val displayHeight = source.resizeHeight?.takeIf { it.isFinite() && it > 0.0 }
+      val displaySize = when {
+        displayWidth != null && displayHeight != null -> max(displayWidth, displayHeight)
+        displayWidth != null -> displayWidth
+        else -> displayHeight
+      }
+      val density = (source.pixelRatio ?: context.resources.displayMetrics.density.toDouble())
+        .takeIf { it.isFinite() }
+        ?.coerceAtLeast(1.0)
+        ?: 1.0
+      val decodeDimensions = OneKeyImageDecodeDimensions.forPreload(
+        displayWidth,
+        displayHeight,
+        density,
+      )
+      val hasCustomIdentity = OneKeyImageModel.headers(source.headersJson).isNotEmpty()
+      val requestUrl = if (source.optimizeTos != false && displaySize != null) {
+        OneKeyTosUrl.optimized(
+          source.uri,
+          ceil(displaySize).toInt(),
+          density.toFloat(),
+          source.overscan ?: 1.1,
+          hasCustomIdentity,
+        )
+      } else source.uri
+
+      val succeeded = try {
+        load(context, requestUrl, source, options, decodeDimensions)
+        true
+      } catch (optimizedError: Exception) {
+        if (
+          requestUrl == source.uri ||
+          OneKeyImageSafety.isSafetyFailure(optimizedError)
+        ) {
+          false
+        } else {
+          try {
+            load(context, source.uri, source, options, decodeDimensions)
+            true
+          } catch (_: Exception) {
+            false
+          }
+        }
+      }
+      allSucceeded = allSucceeded && succeeded
+    }
+    allSucceeded
+  }
+
+  override fun clearMemory(): Promise<Unit> = Promise.async {
+    val context = NitroModules.applicationContext
+      ?: throw IllegalStateException("React application context is unavailable")
+    withContext(Dispatchers.Main) {
+      Glide.get(context).clearMemory()
+    }
+  }
+
+  override fun clearDisk(): Promise<Unit> = Promise.async {
+    val context = NitroModules.applicationContext
+      ?: throw IllegalStateException("React application context is unavailable")
+    Glide.get(context).clearDiskCache()
+  }
+
+  override fun clearAll(): Promise<Unit> = Promise.async {
+    val context = NitroModules.applicationContext
+      ?: throw IllegalStateException("React application context is unavailable")
+    withContext(Dispatchers.Main) {
+      Glide.get(context).clearMemory()
+    }
+    Glide.get(context).clearDiskCache()
+  }
+
+  private fun load(
+    context: android.content.Context,
+    url: String,
+    source: OneKeyImagePreloadSource,
+    options: RequestOptions,
+    decodeDimensions: OneKeyImageDecodeDimensions,
+  ) {
+    val request = Glide.with(context)
+      .asDrawable()
+      .load(OneKeyImageModel.build(url, source.headersJson))
+      .apply(options)
+      .override(decodeDimensions.width, decodeDimensions.height)
+    val future = request.submit()
+    try {
+      future.get()
+    } finally {
+      Glide.with(context).clear(future)
+    }
+  }
+}

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

@@ -0,0 +1,169 @@
+package com.margelo.nitro.onekeyimage
+
+import com.bumptech.glide.load.resource.bitmap.DownsampleStrategy
+import kotlin.math.ceil
+import kotlin.math.floor
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.sqrt
+
+/**
+ * Physical decode dimensions constrained to one 16 MiB ARGB_8888 bitmap.
+ *
+ * The same calculation is shared by render and preload so Glide's size-dependent
+ * cache identity cannot drift between the two paths.
+ */
+internal data class OneKeyImageDecodeDimensions(
+  val width: Int,
+  val height: Int,
+) {
+  val estimatedBytes: Long
+    get() = width.toLong() * height.toLong() * BYTES_PER_PIXEL
+
+  companion object {
+    internal const val MAX_DECODE_BYTES = 16L * 1024L * 1024L
+    internal const val MAX_SQUARE_SIDE = 2048
+    private const val BYTES_PER_PIXEL = 4L
+    private const val MAX_PIXELS = MAX_DECODE_BYTES / BYTES_PER_PIXEL
+
+    fun forRender(width: Int, height: Int): OneKeyImageDecodeDimensions =
+      constrained(width.coerceAtLeast(1), height.coerceAtLeast(1))
+
+    fun forPreload(
+      logicalWidth: Double?,
+      logicalHeight: Double?,
+      pixelRatio: Double,
+    ): OneKeyImageDecodeDimensions {
+      val width = logicalWidth?.takeIf { it.isFinite() && it > 0.0 }
+      val height = logicalHeight?.takeIf { it.isFinite() && it > 0.0 }
+      val density = pixelRatio.takeIf { it.isFinite() }?.coerceAtLeast(1.0) ?: 1.0
+      val physicalWidth = width?.let { physicalPixels(it, density) }
+      val physicalHeight = height?.let { physicalPixels(it, density) }
+
+      return when {
+        physicalWidth != null && physicalHeight != null ->
+          constrained(physicalWidth, physicalHeight)
+        physicalWidth != null -> constrained(physicalWidth, physicalWidth)
+        physicalHeight != null -> constrained(physicalHeight, physicalHeight)
+        else -> OneKeyImageDecodeDimensions(MAX_SQUARE_SIDE, MAX_SQUARE_SIDE)
+      }
+    }
+
+    /**
+     * Desired size passed to APNG4Android's uniform power-of-two sampler.
+     * Returns null only when the source aspect ratio is so extreme that the
+     * decoder cannot satisfy the cap without reducing one dimension below 1px.
+     */
+    fun forAnimatedDecoder(
+      sourceWidth: Int,
+      sourceHeight: Int,
+      targetWidth: Int,
+      targetHeight: Int,
+    ): OneKeyImageDecodeDimensions? {
+      if (sourceWidth <= 0 || sourceHeight <= 0) return null
+      val safeTarget = forRender(targetWidth, targetHeight)
+      val widthRatio = sourceWidth / safeTarget.width
+      val heightRatio = sourceHeight / safeTarget.height
+      var sampleSize = highestPowerOfTwoAtMost(min(widthRatio, heightRatio).coerceAtLeast(1))
+
+      while (
+        ceil(sourceWidth / sampleSize.toDouble()) *
+          ceil(sourceHeight / sampleSize.toDouble()) > MAX_PIXELS
+      ) {
+        if (sampleSize > Int.MAX_VALUE / 2) return null
+        sampleSize *= 2
+      }
+      if (sampleSize > min(sourceWidth, sourceHeight)) return null
+      return OneKeyImageDecodeDimensions(
+        (sourceWidth / sampleSize).coerceAtLeast(1),
+        (sourceHeight / sampleSize).coerceAtLeast(1),
+      )
+    }
+
+    fun safeStaticScaleFactor(
+      sourceWidth: Int,
+      sourceHeight: Int,
+      requestedWidth: Int,
+      requestedHeight: Int,
+    ): Float {
+      if (sourceWidth <= 0 || sourceHeight <= 0) return 1f
+      OneKeyImageSafety.requireStaticDimensions(sourceWidth, sourceHeight)
+      val targetScale = max(
+        requestedWidth.toDouble() / sourceWidth,
+        requestedHeight.toDouble() / sourceHeight,
+      ).coerceAtMost(1.0)
+      val sourcePixels = sourceWidth.toDouble() * sourceHeight.toDouble()
+      val safetyScale = sqrt(MAX_PIXELS.toDouble() / sourcePixels).coerceAtMost(1.0)
+      val resolvedScale = min(targetScale, safetyScale)
+      return if (resolvedScale < 1.0) {
+        // A Double -> Float conversion may round upward and cross the hard
+        // byte boundary by a few pixels.
+        java.lang.Math.nextDown(resolvedScale.toFloat())
+      } else {
+        1f
+      }
+    }
+
+    private fun highestPowerOfTwoAtMost(value: Int): Int {
+      var result = 1
+      while (result <= value / 2) result *= 2
+      return result
+    }
+
+    private fun physicalPixels(logicalSize: Double, pixelRatio: Double): Int {
+      val pixels = ceil(logicalSize * pixelRatio)
+      return when {
+        !pixels.isFinite() || pixels >= Int.MAX_VALUE.toDouble() -> Int.MAX_VALUE
+        else -> pixels.toInt().coerceAtLeast(1)
+      }
+    }
+
+    private fun constrained(width: Int, height: Int): OneKeyImageDecodeDimensions {
+      val area = width.toDouble() * height.toDouble()
+      if (area <= MAX_PIXELS.toDouble()) {
+        return OneKeyImageDecodeDimensions(width, height)
+      }
+
+      val scale = sqrt(MAX_PIXELS.toDouble() / area)
+      var constrainedWidth = floor(width * scale).toInt().coerceAtLeast(1)
+      var constrainedHeight = floor(height * scale).toInt().coerceAtLeast(1)
+
+      // Floating-point rounding should already stay below the limit. Keep this
+      // final guard so the hard cap remains true for every Int input.
+      if (constrainedWidth.toLong() * constrainedHeight.toLong() > MAX_PIXELS) {
+        if (constrainedWidth >= constrainedHeight) {
+          constrainedWidth = (MAX_PIXELS / constrainedHeight).toInt().coerceAtLeast(1)
+        } else {
+          constrainedHeight = (MAX_PIXELS / constrainedWidth).toInt().coerceAtLeast(1)
+        }
+      }
+      return OneKeyImageDecodeDimensions(constrainedWidth, constrainedHeight)
+    }
+  }
+}
+
+/**
+ * Downsamples static bitmaps for the target while independently enforcing the
+ * 16 MiB area cap. `override()` alone cannot enforce an area cap for very wide
+ * or tall sources because Glide's default strategy follows target edges.
+ */
+internal class OneKeyImageSafeDownsampleStrategy : DownsampleStrategy() {
+  override fun getScaleFactor(
+    sourceWidth: Int,
+    sourceHeight: Int,
+    requestedWidth: Int,
+    requestedHeight: Int,
+  ): Float = OneKeyImageDecodeDimensions.safeStaticScaleFactor(
+    sourceWidth,
+    sourceHeight,
+    requestedWidth,
+    requestedHeight,
+  )
+
+  override fun getSampleSizeRounding(
+    sourceWidth: Int,
+    sourceHeight: Int,
+    requestedWidth: Int,
+    requestedHeight: Int,
+  ): SampleSizeRounding = SampleSizeRounding.MEMORY
+}

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

@@ -0,0 +1,285 @@
+package com.margelo.nitro.onekeyimage
+
+import android.content.Context
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.PictureDrawable
+import android.util.Base64
+import com.bumptech.glide.Glide
+import com.bumptech.glide.Priority
+import com.bumptech.glide.integration.avif.AvifGlideModule
+import com.bumptech.glide.load.DataSource
+import com.bumptech.glide.load.Options
+import com.bumptech.glide.load.ResourceDecoder
+import com.bumptech.glide.load.data.DataFetcher
+import com.bumptech.glide.load.engine.Resource
+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.load.resource.SimpleResource
+import com.bumptech.glide.load.resource.transcode.ResourceTranscoder
+import com.bumptech.glide.signature.ObjectKey
+import com.caverock.androidsvg.SVG
+import com.caverock.androidsvg.SVGParseException
+import com.facebook.react.modules.network.OkHttpClientProvider
+import com.github.penfeizhou.animation.decode.FrameSeqDecoder
+import com.github.penfeizhou.animation.glide.ByteBufferAnimationDecoder
+import com.github.penfeizhou.animation.glide.GlideAnimationModule
+import com.github.penfeizhou.animation.glide.StreamAnimationDecoder
+import java.io.ByteArrayOutputStream
+import java.io.ByteArrayInputStream
+import java.io.IOException
+import java.io.InputStream
+import java.nio.ByteBuffer
+
+/**
+ * Registers the small set of Glide integrations required by OneKeyImage.
+ *
+ * Registration is explicit instead of declaring another AppGlideModule. Android
+ * applications may only contain one AppGlideModule, and expo-image owns it while
+ * the two image modules coexist during migration.
+ */
+internal object OneKeyImageGlideRegistry {
+  @Volatile
+  private var registered = false
+
+  fun ensureRegistered(context: Context) {
+    if (registered) return
+    synchronized(this) {
+      if (registered) return
+      val appContext = context.applicationContext
+      val glide = Glide.get(appContext)
+      val registry = glide.registry
+
+      registry.prepend(
+        OneKeyImageDataUriModel::class.java,
+        ByteBuffer::class.java,
+        OneKeyDataUriModelLoaderFactory(),
+      )
+      registry.prepend(
+        OneKeyImageLocalModel::class.java,
+        InputStream::class.java,
+        OneKeyImageLocalModelLoaderFactory(appContext),
+      )
+      val imageHttpClient = OkHttpClientProvider.createClient()
+        .newBuilder()
+        .addInterceptor(OneKeyImageEncodedDataInterceptor())
+        .build()
+      registry.prepend(
+        OneKeyImageRemoteModel::class.java,
+        InputStream::class.java,
+        OneKeyImageRemoteModelLoaderFactory(imageHttpClient),
+      )
+      registry.append(
+        InputStream::class.java,
+        SVG::class.java,
+        OneKeySvgDecoder(),
+      )
+      registry.register(
+        SVG::class.java,
+        Drawable::class.java,
+        OneKeySvgDrawableTranscoder(),
+      )
+
+      // These dependencies also ship LibraryGlideModules. Calling them directly
+      // keeps the feature available after expo-image (and its AppGlideModule) is
+      // removed, while remaining harmless when Expo registered them already.
+      AvifGlideModule().registerComponents(appContext, glide, registry)
+      GlideAnimationModule().registerComponents(appContext, glide, registry)
+      val animationDecoder = OneKeySafeAnimationDecoder()
+      registry.prepend(
+        InputStream::class.java,
+        FrameSeqDecoder::class.java,
+        OneKeySafeStreamAnimationDecoder(animationDecoder),
+      )
+      registry.prepend(
+        ByteBuffer::class.java,
+        FrameSeqDecoder::class.java,
+        animationDecoder,
+      )
+      registered = true
+    }
+  }
+}
+
+private class OneKeySafeAnimationDecoder : ResourceDecoder<ByteBuffer, FrameSeqDecoder<*, *>> {
+  private val delegate = ByteBufferAnimationDecoder()
+
+  override fun handles(source: ByteBuffer, options: Options): Boolean =
+    delegate.handles(source, options)
+
+  override fun decode(
+    source: ByteBuffer,
+    width: Int,
+    height: Int,
+    options: Options,
+  ): Resource<FrameSeqDecoder<*, *>>? {
+    val resource = delegate.decode(source, width, height, options) ?: return null
+    return OneKeyResourceCleanup.recycleOnException(resource::recycle) {
+      val decoder = resource.get()
+      val bounds = decoder.bounds
+      val desired = OneKeyImageDecodeDimensions.forAnimatedDecoder(
+        bounds.width(),
+        bounds.height(),
+        width,
+        height,
+      ) ?: throw OneKeyImageSafetyException(
+        "Animated image cannot fit the 16 MiB target decode limit",
+      )
+      decoder.setDesiredSize(desired.width, desired.height)
+      @Suppress("UNCHECKED_CAST")
+      resource as Resource<FrameSeqDecoder<*, *>>
+    }
+  }
+}
+
+internal object OneKeyResourceCleanup {
+  fun <T> recycleOnException(recycle: () -> Unit, block: () -> T): T = try {
+    block()
+  } catch (error: Exception) {
+    try {
+      recycle()
+    } catch (cleanupError: Exception) {
+      error.addSuppressed(cleanupError)
+    }
+    throw error
+  }
+}
+
+/** Penfeizhou's stream decoder swallows IOExceptions while buffering the input. */
+private class OneKeySafeStreamAnimationDecoder(
+  private val byteBufferDecoder: ResourceDecoder<ByteBuffer, FrameSeqDecoder<*, *>>,
+) : ResourceDecoder<InputStream, FrameSeqDecoder<*, *>> {
+  private val handlesDelegate = StreamAnimationDecoder(byteBufferDecoder)
+
+  override fun handles(source: InputStream, options: Options): Boolean =
+    handlesDelegate.handles(source, options)
+
+  override fun decode(
+    source: InputStream,
+    width: Int,
+    height: Int,
+    options: Options,
+  ): Resource<FrameSeqDecoder<*, *>>? {
+    val output = ByteArrayOutputStream(16 * 1024)
+    val buffer = ByteArray(16 * 1024)
+    while (true) {
+      val count = source.read(buffer)
+      if (count < 0) break
+      if (count == 0) continue
+      OneKeyImageSafety.requireEncodedLength(
+        output.size().toLong() + count.toLong(),
+        OneKeyImageSafety.MAX_ANIMATED_ENCODED_BYTES,
+      )
+      output.write(buffer, 0, count)
+    }
+    return byteBufferDecoder.decode(ByteBuffer.wrap(output.toByteArray()), width, height, options)
+  }
+}
+
+private class OneKeyDataUriModelLoader : ModelLoader<OneKeyImageDataUriModel, ByteBuffer> {
+  override fun handles(model: OneKeyImageDataUriModel): Boolean = true
+
+  override fun buildLoadData(
+    model: OneKeyImageDataUriModel,
+    width: Int,
+    height: Int,
+    options: Options,
+  ): ModelLoader.LoadData<ByteBuffer> =
+    ModelLoader.LoadData(
+      OneKeyImageSafetyVersionedKey(ObjectKey(model)),
+      OneKeyDataUriFetcher(model.dataUri),
+    )
+}
+
+private class OneKeyDataUriModelLoaderFactory :
+  ModelLoaderFactory<OneKeyImageDataUriModel, ByteBuffer> {
+  override fun build(
+    multiFactory: MultiModelLoaderFactory,
+  ): ModelLoader<OneKeyImageDataUriModel, ByteBuffer> =
+    OneKeyDataUriModelLoader()
+
+  override fun teardown() = Unit
+}
+
+private class OneKeyDataUriFetcher(private val dataUri: String) : DataFetcher<ByteBuffer> {
+  override fun cleanup() = Unit
+  override fun cancel() = Unit
+  override fun getDataClass(): Class<ByteBuffer> = ByteBuffer::class.java
+  override fun getDataSource(): DataSource = DataSource.LOCAL
+
+  override fun loadData(
+    priority: Priority,
+    callback: DataFetcher.DataCallback<in ByteBuffer>,
+  ) {
+    try {
+      val comma = dataUri.indexOf(',')
+      require(comma >= 0 && dataUri.substring(0, comma).contains(";base64")) {
+        "Only base64 image data URIs are supported"
+      }
+      val payloadStart = comma + 1
+      val decodedByteCount = OneKeyImageSafety.dataUriDecodedByteCount(dataUri, payloadStart)
+      OneKeyImageSafety.requireEncodedLength(
+        decodedByteCount,
+        OneKeyImageSafety.MAX_DATA_URI_DECODED_BYTES,
+      )
+      val decoded = Base64.decode(dataUri.substring(payloadStart), Base64.DEFAULT)
+      OneKeyImageSafety.requireEncodedLength(
+        decoded.size.toLong(),
+        OneKeyImageSafety.MAX_DATA_URI_DECODED_BYTES,
+      )
+      val metadata = OneKeyEncodedImageInspector.inspect(ByteArrayInputStream(decoded))
+      if (metadata.animated) {
+        OneKeyImageSafety.requireEncodedLength(
+          decoded.size.toLong(),
+          OneKeyImageSafety.MAX_ANIMATED_ENCODED_BYTES,
+        )
+        val format = metadata.animatedFormat
+          ?: throw OneKeyImageSafetyException("Animated image format is unavailable")
+        OneKeyAnimationTimelineInspector.validate(format, decoded)
+      }
+      callback.onDataReady(ByteBuffer.wrap(decoded))
+    } catch (error: Exception) {
+      callback.onLoadFailed(error)
+    }
+  }
+}
+
+private class OneKeySvgDecoder : ResourceDecoder<InputStream, SVG> {
+  override fun handles(source: InputStream, options: Options): Boolean = true
+
+  @Throws(IOException::class)
+  override fun decode(
+    source: InputStream,
+    width: Int,
+    height: Int,
+    options: Options,
+  ): Resource<SVG> {
+    val svg = try {
+      SVG.getFromInputStream(source)
+    } catch (error: SVGParseException) {
+      throw IOException("Cannot decode SVG", error)
+    }
+    if (svg.documentViewBox == null) {
+      val documentWidth = svg.documentWidth
+      val documentHeight = svg.documentHeight
+      if (documentWidth > 0f && documentHeight > 0f) {
+        svg.setDocumentViewBox(0f, 0f, documentWidth, documentHeight)
+      }
+    }
+
+    val viewBox = svg.documentViewBox
+    if (viewBox != null && viewBox.width() > 0f && viewBox.height() > 0f) {
+      val scale = minOf(width.toFloat() / viewBox.width(), height.toFloat() / viewBox.height())
+      if (scale.isFinite() && scale > 0f) {
+        svg.documentWidth = viewBox.width() * scale
+        svg.documentHeight = viewBox.height() * scale
+      }
+    }
+    return SimpleResource(svg)
+  }
+}
+
+private class OneKeySvgDrawableTranscoder : ResourceTranscoder<SVG, Drawable> {
+  override fun transcode(toTranscode: Resource<SVG>, options: Options): Resource<Drawable> =
+    SimpleResource(PictureDrawable(toTranscode.get().renderToPicture()))
+}

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

@@ -0,0 +1,68 @@
+package com.margelo.nitro.onekeyimage
+
+import android.net.Uri
+import com.bumptech.glide.load.model.GlideUrl
+import com.bumptech.glide.load.model.LazyHeaders
+import org.json.JSONObject
+import java.nio.ByteBuffer
+import java.security.MessageDigest
+import java.util.Locale
+
+internal object OneKeyImageModel {
+  fun headers(json: String?): Map<String, String> {
+    if (json.isNullOrBlank()) return emptyMap()
+    return try {
+      val objectValue = JSONObject(json)
+      buildMap {
+        objectValue.keys().forEach { key ->
+          val value = objectValue.opt(key)
+          if (value is String) put(key, value)
+        }
+      }
+    } catch (_: Exception) {
+      emptyMap()
+    }
+  }
+
+  fun build(uri: String, headersJson: String?): Any {
+    if (uri.startsWith("data:")) return OneKeyImageDataUriModel(uri)
+    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+      return OneKeyImageLocalModel(Uri.parse(uri))
+    }
+    val parsedHeaders = headers(headersJson)
+    val headerBuilder = LazyHeaders.Builder()
+    parsedHeaders.forEach { (name, value) -> headerBuilder.addHeader(name, value) }
+    val headers = headerBuilder.build()
+    return OneKeyImageRemoteModel(
+      glideUrl = GlideUrl(uri, headers),
+      headersDigest = remoteHeadersDigest(parsedHeaders),
+    )
+  }
+
+  internal fun remoteHeadersDigest(headers: Map<String, String>): String? {
+    if (headers.isEmpty()) return null
+    val digest = MessageDigest.getInstance("SHA-256")
+    headers.entries
+      .map { it.key.lowercase(Locale.ROOT) to it.value }
+      .sortedWith(compareBy<Pair<String, String>>({ it.first }, { it.second }))
+      .forEach { (name, value) ->
+        updateLengthPrefixed(digest, name.toByteArray(Charsets.UTF_8))
+        updateLengthPrefixed(digest, value.toByteArray(Charsets.UTF_8))
+      }
+    return digest.digest().joinToString("") { "%02x".format(Locale.ROOT, it.toInt() and 0xff) }
+  }
+
+  private fun updateLengthPrefixed(digest: MessageDigest, value: ByteArray) {
+    digest.update(ByteBuffer.allocate(Int.SIZE_BYTES).putInt(value.size).array())
+    digest.update(value)
+  }
+}
+
+internal data class OneKeyImageRemoteModel(
+  val glideUrl: GlideUrl,
+  val headersDigest: String?,
+)
+
+internal data class OneKeyImageLocalModel(val uri: Uri)
+
+internal data class OneKeyImageDataUriModel(val dataUri: String)

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

@@ -0,0 +1,28 @@
+package com.margelo.nitro.onekeyimage
+
+import com.facebook.react.BaseReactPackage
+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.HybridOneKeyImageManager
+
+class OneKeyImagePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+    ReactModuleInfoProvider { HashMap() }
+
+  override fun createViewManagers(
+    reactContext: ReactApplicationContext,
+  ): List<ViewManager<*, *>> {
+    OneKeyImageGlideRegistry.ensureRegistered(reactContext)
+    return listOf(HybridOneKeyImageManager())
+  }
+
+  companion object {
+    init {
+      System.loadLibrary("onekeyimage")
+    }
+  }
+}