@onekeyfe/react-native-image 3.0.98

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

@@ -0,0 +1,93 @@
+package com.margelo.nitro.onekeyimage
+
+import java.net.URI
+import java.net.URLDecoder
+import java.nio.charset.StandardCharsets
+import kotlin.math.ceil
+
+internal object OneKeyTosUrl {
+  internal val widthBuckets = intArrayOf(
+    32, 40, 48, 64, 96, 128, 160, 200, 256, 320, 480, 640, 960, 1280,
+  )
+
+  fun optimized(
+    rawUrl: String,
+    displaySize: Int,
+    density: Float,
+    overscan: Double,
+    hasCustomIdentity: Boolean,
+  ): String {
+    if (hasCustomIdentity || displaySize <= 0) return rawUrl
+    val uri = try {
+      URI(rawUrl)
+    } catch (_: Exception) {
+      return rawUrl
+    }
+    val host = uri.host?.lowercase() ?: return rawUrl
+    if (host !in ALLOWED_HOSTS) return rawUrl
+    if (unsupportedExtension(uri.path.orEmpty())) return rawUrl
+    if (hasProtectedQuery(uri.rawQuery)) return rawUrl
+
+    val bucket = selectWidthBucket(displaySize, density, overscan)
+    val fragmentIndex = rawUrl.indexOf('#')
+    val base = if (fragmentIndex >= 0) rawUrl.substring(0, fragmentIndex) else rawUrl
+    val fragment = if (fragmentIndex >= 0) rawUrl.substring(fragmentIndex) else ""
+    val separator = when {
+      uri.rawQuery == null -> "?"
+      base.endsWith("?") || base.endsWith("&") -> ""
+      else -> "&"
+    }
+    return "$base${separator}x-tos-process=image%2Fresize%2Cw_$bucket$fragment"
+  }
+
+  internal fun selectWidthBucket(displaySize: Int, density: Float, overscan: Double): Int {
+    val normalizedDensity = if (density.isFinite()) density.coerceIn(1f, MAX_DPR) else 1f
+    val normalizedOverscan = if (overscan.isFinite()) overscan.coerceAtLeast(1.0) else 1.0
+    val requestedPixels = ceil(displaySize * normalizedDensity * normalizedOverscan)
+    if (!requestedPixels.isFinite() || requestedPixels >= widthBuckets.last()) {
+      return widthBuckets.last()
+    }
+    val requested = requestedPixels.toInt()
+    return widthBuckets.firstOrNull { it >= requested } ?: widthBuckets.last()
+  }
+
+  private fun unsupportedExtension(path: String): Boolean {
+    val extension = path.substringAfterLast('.', "").lowercase()
+    return extension in UNSUPPORTED_EXTENSIONS
+  }
+
+  internal fun hasProtectedQuery(rawQuery: String?): Boolean {
+    if (rawQuery.isNullOrEmpty()) return false
+    return rawQuery.split('&').any { pair ->
+      val rawName = pair.substringBefore('=')
+      val name = try {
+        URLDecoder.decode(rawName, StandardCharsets.UTF_8.name())
+      } catch (_: Exception) {
+        rawName
+      }.lowercase()
+      name in PROTECTED_QUERY_KEYS || PROTECTED_QUERY_PREFIXES.any(name::startsWith)
+    }
+  }
+
+  private val ALLOWED_HOSTS = setOf(
+    "app-assets.onekey.so",
+    "common.onekey-asset.com",
+    "asset.onekey-asset.com",
+    "uni.onekey-asset.com",
+    "uni-test.onekey-asset.com",
+  )
+
+  private val PROTECTED_QUERY_KEYS = setOf(
+    "expires",
+    "policy",
+    "signature",
+    "token",
+    "auth_key",
+    "accesskeyid",
+    "ossaccesskeyid",
+    "security-token",
+  )
+  private val PROTECTED_QUERY_PREFIXES = arrayOf("x-amz-", "x-oss-", "x-tos-")
+  private val UNSUPPORTED_EXTENSIONS = setOf("svg", "mp4", "webm", "m4v", "mov", "avi")
+  private const val MAX_DPR = 3f
+}

package/android/src/test/java/com/margelo/nitro/onekeyimage/OneKeyAnimationTimelineInspectorTest.kt

@@ -0,0 +1,210 @@
+package com.margelo.nitro.onekeyimage
+
+import org.junit.Assert.assertThrows
+import org.junit.Test
+import java.io.ByteArrayOutputStream
+
+class OneKeyAnimationTimelineInspectorTest {
+  @Test
+  fun acceptsFrameAndDurationBoundariesForEveryAnimatedFormat() {
+    validate(OneKeyAnimatedFormat.GIF, gif(1000, delayCentiseconds = 6))
+    validate(OneKeyAnimatedFormat.WEBP, webp(1000, durationMs = 60))
+    validate(OneKeyAnimatedFormat.APNG, apng(1000, delayNumerator = 6))
+  }
+
+  @Test
+  fun rejectsFrameCountsAboveLimitForEveryAnimatedFormat() {
+    assertUnsafe(OneKeyAnimatedFormat.GIF, gif(1001, delayCentiseconds = 1))
+    assertUnsafe(OneKeyAnimatedFormat.WEBP, webp(1001, durationMs = 1))
+    assertUnsafe(OneKeyAnimatedFormat.APNG, apng(1001, delayNumerator = 1))
+  }
+
+  @Test
+  fun zeroDelayUsesDecoderMinimumForDurationLimit() {
+    assertUnsafe(OneKeyAnimatedFormat.GIF, gif(601, delayCentiseconds = 0))
+    assertUnsafe(
+      OneKeyAnimatedFormat.GIF,
+      gif(601, delayCentiseconds = 0, writeControlEveryFrame = false),
+    )
+    assertUnsafe(OneKeyAnimatedFormat.WEBP, webp(601, durationMs = 0))
+    assertUnsafe(OneKeyAnimatedFormat.APNG, apng(601, delayNumerator = 0))
+  }
+
+  @Test
+  fun rejectsDurationsAboveLimitForEveryAnimatedFormat() {
+    assertUnsafe(OneKeyAnimatedFormat.GIF, gif(1000, delayCentiseconds = 7))
+    assertUnsafe(OneKeyAnimatedFormat.WEBP, webp(1000, durationMs = 61))
+    assertUnsafe(OneKeyAnimatedFormat.APNG, apng(1000, delayNumerator = 7))
+  }
+
+  @Test
+  fun rejectsTruncatedDataForEveryAnimatedFormat() {
+    val gif = gif(1, delayCentiseconds = 1)
+    val webp = webp(1, durationMs = 1)
+    val apng = apng(1, delayNumerator = 1)
+
+    assertUnsafe(OneKeyAnimatedFormat.GIF, gif.copyOf(gif.size - 1))
+    assertUnsafe(OneKeyAnimatedFormat.WEBP, webp.copyOf(webp.size - 1))
+    assertUnsafe(OneKeyAnimatedFormat.APNG, apng.copyOf(apng.size - 1))
+  }
+
+  @Test
+  fun rejectsInvalidCanvasesAndAcceptsMinimumAnimatedWebpCanvas() {
+    assertUnsafe(OneKeyAnimatedFormat.GIF, gif(1, 1, width = 0, height = 1))
+    assertUnsafe(OneKeyAnimatedFormat.APNG, apng(1, 1, width = 1, height = 0))
+    validate(OneKeyAnimatedFormat.WEBP, webp(1, 1, width = 1, height = 1))
+    assertUnsafe(OneKeyAnimatedFormat.WEBP, webp(1, 1, width = 8193, height = 1))
+  }
+
+  private fun validate(format: OneKeyAnimatedFormat, bytes: ByteArray) {
+    OneKeyAnimationTimelineInspector.validate(format, bytes)
+  }
+
+  private fun assertUnsafe(format: OneKeyAnimatedFormat, bytes: ByteArray) {
+    assertThrows(OneKeyImageSafetyException::class.java) {
+      OneKeyAnimationTimelineInspector.validate(format, bytes)
+    }
+  }
+
+  private fun gif(
+    frameCount: Int,
+    delayCentiseconds: Int,
+    width: Int = 2,
+    height: Int = 2,
+    writeControlEveryFrame: Boolean = true,
+  ): ByteArray = ByteArrayOutputStream().apply {
+    write("GIF89a".toByteArray())
+    writeU16Le(this, width)
+    writeU16Le(this, height)
+    write(byteArrayOf(0, 0, 0))
+    repeat(frameCount) { index ->
+      if (writeControlEveryFrame || index == 0) {
+        write(byteArrayOf(0x21, 0xf9.toByte(), 4, 0))
+        writeU16Le(this, delayCentiseconds)
+        write(byteArrayOf(0, 0))
+      }
+      write(0x2c)
+      writeU16Le(this, 0)
+      writeU16Le(this, 0)
+      writeU16Le(this, width)
+      writeU16Le(this, height)
+      write(0)
+      write(byteArrayOf(2, 1, 0, 0))
+    }
+    write(0x3b)
+  }.toByteArray()
+
+  private fun webp(
+    frameCount: Int,
+    durationMs: Int,
+    width: Int = 2,
+    height: Int = 2,
+  ): ByteArray {
+    val chunks = ByteArrayOutputStream().apply {
+      val vp8x = ByteArray(10).also { payload ->
+        payload[0] = 0x02
+        writeU24Le(payload, 4, width - 1)
+        writeU24Le(payload, 7, height - 1)
+      }
+      writeWebpChunk(this, "VP8X", vp8x)
+      writeWebpChunk(this, "ANIM", ByteArray(6))
+      repeat(frameCount) {
+        val frame = ByteArray(16).also { payload ->
+          writeU24Le(payload, 6, width - 1)
+          writeU24Le(payload, 9, height - 1)
+          writeU24Le(payload, 12, durationMs)
+        }
+        writeWebpChunk(this, "ANMF", frame)
+      }
+    }.toByteArray()
+    val body = ByteArrayOutputStream().apply {
+      write("WEBP".toByteArray())
+      write(chunks)
+    }.toByteArray()
+    return ByteArrayOutputStream().apply {
+      write("RIFF".toByteArray())
+      writeU32Le(this, body.size.toLong())
+      write(body)
+    }.toByteArray()
+  }
+
+  private fun apng(
+    frameCount: Int,
+    delayNumerator: Int,
+    width: Int = 2,
+    height: Int = 2,
+  ): ByteArray = ByteArrayOutputStream().apply {
+    write(byteArrayOf(0x89.toByte(), 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a))
+    val ihdr = ByteArrayOutputStream().apply {
+      writeU32Be(this, width.toLong())
+      writeU32Be(this, height.toLong())
+      write(byteArrayOf(8, 6, 0, 0, 0))
+    }.toByteArray()
+    writePngChunk(this, "IHDR", ihdr)
+    val actl = ByteArrayOutputStream().apply {
+      writeU32Be(this, frameCount.toLong())
+      writeU32Be(this, 0)
+    }.toByteArray()
+    writePngChunk(this, "acTL", actl)
+    repeat(frameCount) { index ->
+      val fctl = ByteArrayOutputStream().apply {
+        writeU32Be(this, (index * 2).toLong())
+        writeU32Be(this, width.toLong())
+        writeU32Be(this, height.toLong())
+        writeU32Be(this, 0)
+        writeU32Be(this, 0)
+        writeU16Be(this, delayNumerator)
+        writeU16Be(this, 100)
+        write(byteArrayOf(0, 0))
+      }.toByteArray()
+      writePngChunk(this, "fcTL", fctl)
+      if (index == 0) {
+        writePngChunk(this, "IDAT", byteArrayOf())
+      } else {
+        val fdat = ByteArrayOutputStream().apply {
+          writeU32Be(this, (index * 2 + 1).toLong())
+        }.toByteArray()
+        writePngChunk(this, "fdAT", fdat)
+      }
+    }
+    writePngChunk(this, "IEND", byteArrayOf())
+  }.toByteArray()
+
+  private fun writeWebpChunk(output: ByteArrayOutputStream, type: String, payload: ByteArray) {
+    output.write(type.toByteArray())
+    writeU32Le(output, payload.size.toLong())
+    output.write(payload)
+    if (payload.size and 1 != 0) output.write(0)
+  }
+
+  private fun writePngChunk(output: ByteArrayOutputStream, type: String, payload: ByteArray) {
+    writeU32Be(output, payload.size.toLong())
+    output.write(type.toByteArray())
+    output.write(payload)
+    output.write(byteArrayOf(0, 0, 0, 0))
+  }
+
+  private fun writeU16Le(output: ByteArrayOutputStream, value: Int) {
+    output.write(value and 0xff)
+    output.write((value ushr 8) and 0xff)
+  }
+
+  private fun writeU16Be(output: ByteArrayOutputStream, value: Int) {
+    output.write((value ushr 8) and 0xff)
+    output.write(value and 0xff)
+  }
+
+  private fun writeU24Le(bytes: ByteArray, offset: Int, value: Int) {
+    bytes[offset] = value.toByte()
+    bytes[offset + 1] = (value ushr 8).toByte()
+    bytes[offset + 2] = (value ushr 16).toByte()
+  }
+
+  private fun writeU32Le(output: ByteArrayOutputStream, value: Long) {
+    repeat(4) { shift -> output.write(((value ushr (shift * 8)) and 0xffL).toInt()) }
+  }
+
+  private fun writeU32Be(output: ByteArrayOutputStream, value: Long) {
+    for (shift in 3 downTo 0) output.write(((value ushr (shift * 8)) and 0xffL).toInt())
+  }
+}

package/android/src/test/java/com/margelo/nitro/onekeyimage/OneKeyImageCacheTypeTest.kt

@@ -0,0 +1,16 @@
+package com.margelo.nitro.onekeyimage
+
+import com.bumptech.glide.load.DataSource
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class OneKeyImageCacheTypeTest {
+  @Test
+  fun exposesOnlyThePublicCacheTypeSemantics() {
+    assertEquals(OneKeyImageCacheType.MEMORY, DataSource.MEMORY_CACHE.toOneKeyImageCacheType())
+    assertEquals(OneKeyImageCacheType.DISK, DataSource.DATA_DISK_CACHE.toOneKeyImageCacheType())
+    assertEquals(OneKeyImageCacheType.DISK, DataSource.RESOURCE_DISK_CACHE.toOneKeyImageCacheType())
+    assertEquals(OneKeyImageCacheType.NONE, DataSource.LOCAL.toOneKeyImageCacheType())
+    assertEquals(OneKeyImageCacheType.NONE, DataSource.REMOTE.toOneKeyImageCacheType())
+  }
+}

package/android/src/test/java/com/margelo/nitro/onekeyimage/OneKeyImageDecodeDimensionsTest.kt

@@ -0,0 +1,70 @@
+package com.margelo.nitro.onekeyimage
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class OneKeyImageDecodeDimensionsTest {
+  @Test
+  fun keepsRenderDimensionsWithinSixteenMiB() {
+    val dimensions = OneKeyImageDecodeDimensions.forRender(1200, 800)
+
+    assertEquals(1200, dimensions.width)
+    assertEquals(800, dimensions.height)
+    assertTrue(dimensions.estimatedBytes <= OneKeyImageDecodeDimensions.MAX_DECODE_BYTES)
+  }
+
+  @Test
+  fun constrainsLargeRenderDimensionsAndPreservesAspectRatio() {
+    val dimensions = OneKeyImageDecodeDimensions.forRender(4000, 2000)
+
+    assertTrue(dimensions.estimatedBytes <= OneKeyImageDecodeDimensions.MAX_DECODE_BYTES)
+    assertEquals(2.0, dimensions.width.toDouble() / dimensions.height, 0.01)
+  }
+
+  @Test
+  fun constrainsExtremeAspectRatiosWithoutOverflow() {
+    val dimensions = OneKeyImageDecodeDimensions.forRender(Int.MAX_VALUE, 1)
+
+    assertTrue(dimensions.estimatedBytes <= OneKeyImageDecodeDimensions.MAX_DECODE_BYTES)
+    assertEquals(1, dimensions.height)
+  }
+
+  @Test
+  fun preloadUsesBothLogicalDimensionsAndPhysicalPixelRatio() {
+    val dimensions = OneKeyImageDecodeDimensions.forPreload(40.0, 64.0, 2.5)
+
+    assertEquals(100, dimensions.width)
+    assertEquals(160, dimensions.height)
+  }
+
+  @Test
+  fun unsizedPreloadStillHasAHardDecodeCap() {
+    val dimensions = OneKeyImageDecodeDimensions.forPreload(null, null, 3.0)
+
+    assertEquals(2048, dimensions.width)
+    assertEquals(2048, dimensions.height)
+    assertEquals(
+      OneKeyImageDecodeDimensions.MAX_DECODE_BYTES,
+      dimensions.estimatedBytes,
+    )
+  }
+
+  @Test
+  fun animatedDecoderUsesAPowerOfTwoSampleWithinTheCap() {
+    val desired = OneKeyImageDecodeDimensions.forAnimatedDecoder(8000, 4000, 2048, 2048)
+
+    requireNotNull(desired)
+    assertEquals(2000, desired.width)
+    assertEquals(1000, desired.height)
+    assertTrue(desired.estimatedBytes <= OneKeyImageDecodeDimensions.MAX_DECODE_BYTES)
+  }
+
+  @Test
+  fun staticDownsampleStrategyCapsExtremeAspectRatioArea() {
+    val scale = OneKeyImageDecodeDimensions.safeStaticScaleFactor(8000, 1000, 2048, 2048)
+    val decodedBytes = 8000.0 * scale * 1000.0 * scale * 4.0
+
+    assertTrue(decodedBytes <= OneKeyImageDecodeDimensions.MAX_DECODE_BYTES)
+  }
+}

package/android/src/test/java/com/margelo/nitro/onekeyimage/OneKeyImageModelTest.kt

@@ -0,0 +1,65 @@
+package com.margelo.nitro.onekeyimage
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import com.bumptech.glide.load.Key
+import java.security.MessageDigest
+
+class OneKeyImageModelTest {
+  @Test
+  fun dataUriUsesDedicatedModelWithoutBuiltInStringFallback() {
+    val uri = "data:image/png;base64,AA=="
+    val model = OneKeyImageModel.build(uri, null)
+
+    assertTrue(model is OneKeyImageDataUriModel)
+    assertFalse(model is String)
+    assertEquals(uri, (model as OneKeyImageDataUriModel).dataUri)
+  }
+
+  @Test
+  fun headerDigestIsStableAndDoesNotContainPlaintext() {
+    val first = OneKeyImageModel.remoteHeadersDigest(
+      linkedMapOf("X-Mode" to "private-value", "Authorization" to "token"),
+    )
+    val same = OneKeyImageModel.remoteHeadersDigest(
+      linkedMapOf("authorization" to "token", "x-mode" to "private-value"),
+    )
+
+    assertEquals(first, same)
+    assertFalse(first!!.contains("token"))
+    assertFalse(first.contains("private-value"))
+    assertEquals(64, first.length)
+    assertNull(OneKeyImageModel.remoteHeadersDigest(emptyMap()))
+  }
+
+  @Test
+  fun remoteSourceKeyIncludesUrlAndHashedHeadersInMemoryAndDiskIdentity() {
+    val url = "https://example.com/image.png"
+    val otherUrl = "https://example.com/other.png"
+    val firstHeaders = OneKeyImageModel.remoteHeadersDigest(mapOf("Authorization" to "first"))
+    val secondHeaders = OneKeyImageModel.remoteHeadersDigest(mapOf("Authorization" to "second"))
+    val first = OneKeyImageRemoteSourceKey(url, firstHeaders)
+    val same = OneKeyImageRemoteSourceKey("https://example.com/image.png", firstHeaders)
+    val differentHeaders = OneKeyImageRemoteSourceKey(url, secondHeaders)
+    val differentUrl = OneKeyImageRemoteSourceKey(otherUrl, firstHeaders)
+    val withoutHeaders = OneKeyImageRemoteSourceKey(url, null)
+
+    assertEquals(first, same)
+    assertEquals(first.hashCode(), same.hashCode())
+    assertTrue(diskDigest(first).contentEquals(diskDigest(same)))
+    assertNotEquals(first, differentHeaders)
+    assertFalse(diskDigest(first).contentEquals(diskDigest(differentHeaders)))
+    assertNotEquals(first, differentUrl)
+    assertFalse(diskDigest(first).contentEquals(diskDigest(differentUrl)))
+    assertNotEquals(first, withoutHeaders)
+    assertFalse(diskDigest(first).contentEquals(diskDigest(withoutHeaders)))
+  }
+
+  private fun diskDigest(key: Key): ByteArray = MessageDigest.getInstance("SHA-256").apply {
+    key.updateDiskCacheKey(this)
+  }.digest()
+}

package/android/src/test/java/com/margelo/nitro/onekeyimage/OneKeyImageRequestSignatureTest.kt

@@ -0,0 +1,33 @@
+package com.margelo.nitro.onekeyimage
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Test
+
+class OneKeyImageRequestSignatureTest {
+  @Test
+  fun contentFitParticipatesInRequestIdentity() {
+    val cover = signature(OneKeyImageContentFit.COVER)
+    val contain = signature(OneKeyImageContentFit.CONTAIN)
+
+    assertNotEquals(cover, contain)
+  }
+
+  @Test
+  fun nullContentFitUsesCoverIdentity() {
+    assertEquals(signature(OneKeyImageContentFit.COVER), signature(null))
+  }
+
+  private fun signature(contentFit: OneKeyImageContentFit?): String = oneKeyImageRequestSignature(
+    rawUrl = "https://example.com/image.png",
+    sourceHeadersJson = null,
+    recyclingKey = null,
+    cachePolicy = OneKeyImageCachePolicy.MEMORY_DISK,
+    contentFit = contentFit,
+    optimizeTos = true,
+    overscan = 1.1,
+    width = 200,
+    height = 100,
+    density = 2f,
+  )
+}