@amazon-devices/expo-image 2.0.1758683737

package/android/src/main/java/expo/modules/image/blurhash/BlurhashDecoder.kt

@@ -0,0 +1,189 @@
+package expo.modules.image.blurhash
+
+import android.graphics.Bitmap
+import android.graphics.Color
+import kotlin.math.cos
+import kotlin.math.pow
+import kotlin.math.withSign
+
+/**
+ * Copied from https://github.com/woltapp/blurhash.
+ */
+object BlurhashDecoder {
+
+  // cache Math.cos() calculations to improve performance.
+  // The number of calculations can be huge for many bitmaps: width * height * numCompX * numCompY * 2 * nBitmaps
+  // the cache is enabled by default, it is recommended to disable it only when just a few images are displayed
+  private val cacheCosinesX = HashMap<Int, DoubleArray>()
+  private val cacheCosinesY = HashMap<Int, DoubleArray>()
+
+  /**
+   * Clear calculations stored in memory cache.
+   * The cache is not big, but will increase when many image sizes are used,
+   * if the app needs memory it is recommended to clear it.
+   */
+  fun clearCache() {
+    cacheCosinesX.clear()
+    cacheCosinesY.clear()
+  }
+
+  /**
+   * Decode a blur hash into a new bitmap.
+   *
+   * @param useCache use in memory cache for the calculated math, reused by images with same size.
+   *                 if the cache does not exist yet it will be created and populated with new calculations.
+   *                 By default it is true.
+   */
+  fun decode(blurHash: String?, width: Int, height: Int, punch: Float = 1f, useCache: Boolean = true): Bitmap? {
+    if (blurHash == null || blurHash.length < 6) {
+      return null
+    }
+    val numCompEnc = decode83(blurHash, 0, 1)
+    val numCompX = (numCompEnc % 9) + 1
+    val numCompY = (numCompEnc / 9) + 1
+    if (blurHash.length != 4 + 2 * numCompX * numCompY) {
+      return null
+    }
+    val maxAcEnc = decode83(blurHash, 1, 2)
+    val maxAc = (maxAcEnc + 1) / 166f
+    val colors = Array(numCompX * numCompY) { i ->
+      if (i == 0) {
+        val colorEnc = decode83(blurHash, 2, 6)
+        decodeDc(colorEnc)
+      } else {
+        val from = 4 + i * 2
+        val colorEnc = decode83(blurHash, from, from + 2)
+        decodeAc(colorEnc, maxAc * punch)
+      }
+    }
+    return composeBitmap(width, height, numCompX, numCompY, colors, useCache)
+  }
+
+  private fun decode83(str: String, from: Int = 0, to: Int = str.length): Int {
+    var result = 0
+    for (i in from until to) {
+      val index = charMap[str[i]] ?: -1
+      if (index != -1) {
+        result = result * 83 + index
+      }
+    }
+    return result
+  }
+
+  private fun decodeDc(colorEnc: Int): FloatArray {
+    val r = colorEnc shr 16
+    val g = (colorEnc shr 8) and 255
+    val b = colorEnc and 255
+    return floatArrayOf(srgbToLinear(r), srgbToLinear(g), srgbToLinear(b))
+  }
+
+  private fun srgbToLinear(colorEnc: Int): Float {
+    val v = colorEnc / 255f
+    return if (v <= 0.04045f) {
+      (v / 12.92f)
+    } else {
+      ((v + 0.055f) / 1.055f).pow(2.4f)
+    }
+  }
+
+  private fun decodeAc(value: Int, maxAc: Float): FloatArray {
+    val r = value / (19 * 19)
+    val g = (value / 19) % 19
+    val b = value % 19
+    return floatArrayOf(
+      signedPow2((r - 9) / 9.0f) * maxAc,
+      signedPow2((g - 9) / 9.0f) * maxAc,
+      signedPow2((b - 9) / 9.0f) * maxAc
+    )
+  }
+
+  private fun signedPow2(value: Float) = value.pow(2f).withSign(value)
+
+  private fun composeBitmap(
+    width: Int,
+    height: Int,
+    numCompX: Int,
+    numCompY: Int,
+    colors: Array<FloatArray>,
+    useCache: Boolean
+  ): Bitmap {
+    // use an array for better performance when writing pixel colors
+    val imageArray = IntArray(width * height)
+    val calculateCosX = !useCache || !cacheCosinesX.containsKey(width * numCompX)
+    val cosinesX = getArrayForCosinesX(calculateCosX, width, numCompX)
+    val calculateCosY = !useCache || !cacheCosinesY.containsKey(height * numCompY)
+    val cosinesY = getArrayForCosinesY(calculateCosY, height, numCompY)
+    for (y in 0 until height) {
+      for (x in 0 until width) {
+        var r = 0f
+        var g = 0f
+        var b = 0f
+        for (j in 0 until numCompY) {
+          for (i in 0 until numCompX) {
+            val cosX = cosinesX.getCos(calculateCosX, i, numCompX, x, width)
+            val cosY = cosinesY.getCos(calculateCosY, j, numCompY, y, height)
+            val basis = (cosX * cosY).toFloat()
+            val color = colors[j * numCompX + i]
+            r += color[0] * basis
+            g += color[1] * basis
+            b += color[2] * basis
+          }
+        }
+        imageArray[x + width * y] = Color.rgb(linearToSrgb(r), linearToSrgb(g), linearToSrgb(b))
+      }
+    }
+    return Bitmap.createBitmap(imageArray, width, height, Bitmap.Config.ARGB_8888)
+  }
+
+  private fun getArrayForCosinesY(calculate: Boolean, height: Int, numCompY: Int) = when {
+    calculate -> {
+      DoubleArray(height * numCompY).also {
+        cacheCosinesY[height * numCompY] = it
+      }
+    }
+    else -> {
+      cacheCosinesY[height * numCompY]!!
+    }
+  }
+
+  private fun getArrayForCosinesX(calculate: Boolean, width: Int, numCompX: Int) = when {
+    calculate -> {
+      DoubleArray(width * numCompX).also {
+        cacheCosinesX[width * numCompX] = it
+      }
+    }
+    else -> cacheCosinesX[width * numCompX]!!
+  }
+
+  private fun DoubleArray.getCos(
+    calculate: Boolean,
+    x: Int,
+    numComp: Int,
+    y: Int,
+    size: Int
+  ): Double {
+    if (calculate) {
+      this[x + numComp * y] = cos(Math.PI * y * x / size)
+    }
+    return this[x + numComp * y]
+  }
+
+  private fun linearToSrgb(value: Float): Int {
+    val v = value.coerceIn(0f, 1f)
+    return if (v <= 0.0031308f) {
+      (v * 12.92f * 255f + 0.5f).toInt()
+    } else {
+      ((1.055f * v.pow(1 / 2.4f) - 0.055f) * 255 + 0.5f).toInt()
+    }
+  }
+
+  private val charMap = listOf(
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+    'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+    'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '#', '$', '%', '*', '+', ',',
+    '-', '.', ':', ';', '=', '?', '@', '[', ']', '^', '_', '{', '|', '}', '~'
+  )
+    .mapIndexed { i, c -> c to i }
+    .toMap()
+}

package/android/src/main/java/expo/modules/image/blurhash/BlurhashModelLoader.kt

@@ -0,0 +1,30 @@
+package expo.modules.image.blurhash
+
+import android.graphics.Bitmap
+import android.net.Uri
+import com.bumptech.glide.load.Options
+import com.bumptech.glide.load.model.ModelLoader
+import com.bumptech.glide.signature.ObjectKey
+import expo.modules.image.GlideBlurhashModel
+
+class BlurhashModelLoader : ModelLoader<GlideBlurhashModel, Bitmap> {
+  override fun handles(model: GlideBlurhashModel): Boolean = true
+
+  override fun buildLoadData(
+    model: GlideBlurhashModel,
+    width: Int,
+    height: Int,
+    options: Options
+  ): ModelLoader.LoadData<Bitmap> {
+    val blurhash = getPath(model.uri, 0, null) { it }
+    return ModelLoader.LoadData(
+      ObjectKey(model),
+      BlurHashFetcher(blurhash, model.width, model.height, 1f)
+    )
+  }
+
+  private fun <T> getPath(uri: Uri, index: Int, default: T, converter: (String) -> T): T {
+    val value = uri.pathSegments.getOrNull(index) ?: return default
+    return converter(value)
+  }
+}

package/android/src/main/java/expo/modules/image/blurhash/BlurhashModelLoaderFactory.kt

@@ -0,0 +1,14 @@
+package expo.modules.image.blurhash
+
+import android.graphics.Bitmap
+import com.bumptech.glide.load.model.ModelLoader
+import com.bumptech.glide.load.model.ModelLoaderFactory
+import com.bumptech.glide.load.model.MultiModelLoaderFactory
+import expo.modules.image.GlideBlurhashModel
+
+class BlurhashModelLoaderFactory : ModelLoaderFactory<GlideBlurhashModel, Bitmap> {
+  override fun build(multiFactory: MultiModelLoaderFactory): ModelLoader<GlideBlurhashModel, Bitmap> =
+    BlurhashModelLoader()
+
+  override fun teardown() = Unit
+}

package/android/src/main/java/expo/modules/image/blurhash/BlurhashModule.kt

@@ -0,0 +1,17 @@
+package expo.modules.image.blurhash
+
+import android.content.Context
+import android.graphics.Bitmap
+import com.bumptech.glide.Glide
+import com.bumptech.glide.Registry
+import com.bumptech.glide.annotation.GlideModule
+import com.bumptech.glide.module.LibraryGlideModule
+import expo.modules.image.GlideBlurhashModel
+
+@GlideModule
+class BlurhashModule : LibraryGlideModule() {
+  override fun registerComponents(context: Context, glide: Glide, registry: Registry) {
+    super.registerComponents(context, glide, registry)
+    registry.prepend(GlideBlurhashModel::class.java, Bitmap::class.java, BlurhashModelLoaderFactory())
+  }
+}

package/android/src/main/java/expo/modules/image/dataurls/Base64DataFetcher.kt

@@ -0,0 +1,27 @@
+package expo.modules.image.dataurls
+
+import android.util.Base64
+import com.bumptech.glide.Priority
+import com.bumptech.glide.load.DataSource
+import com.bumptech.glide.load.data.DataFetcher
+import java.nio.ByteBuffer
+
+class Base64DataFetcher(private val data: 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>) {
+    val base64Section = getBase64Section()
+    val data = Base64.decode(base64Section, Base64.DEFAULT)
+    val byteBuffer = ByteBuffer.wrap(data)
+    callback.onDataReady(byteBuffer)
+  }
+
+  private fun getBase64Section(): String {
+    // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs.
+    val startOfBase64Section = data.indexOf(',')
+    return data.substring(startOfBase64Section + 1)
+  }
+}

package/android/src/main/java/expo/modules/image/dataurls/Base64ModelLoader.kt

@@ -0,0 +1,24 @@
+package expo.modules.image.dataurls
+
+import com.bumptech.glide.load.Options
+import com.bumptech.glide.load.model.ModelLoader
+import com.bumptech.glide.signature.ObjectKey
+import java.nio.ByteBuffer
+
+/**
+ * Loads an [java.io.InputStream] from a Base 64 encoded String.
+ */
+class Base64ModelLoader : ModelLoader<String, ByteBuffer> {
+  override fun handles(model: String): Boolean {
+    return model.startsWith("data:")
+  }
+
+  override fun buildLoadData(
+    model: String,
+    width: Int,
+    height: Int,
+    options: Options
+  ): ModelLoader.LoadData<ByteBuffer> {
+    return ModelLoader.LoadData(ObjectKey(model), Base64DataFetcher(model))
+  }
+}

package/android/src/main/java/expo/modules/image/dataurls/Base64ModelLoaderFactory.kt

@@ -0,0 +1,12 @@
+package expo.modules.image.dataurls
+
+import com.bumptech.glide.load.model.ModelLoader
+import com.bumptech.glide.load.model.ModelLoaderFactory
+import com.bumptech.glide.load.model.MultiModelLoaderFactory
+import java.nio.ByteBuffer
+
+class Base64ModelLoaderFactory : ModelLoaderFactory<String, ByteBuffer> {
+  override fun build(multiFactory: MultiModelLoaderFactory): ModelLoader<String, ByteBuffer> =
+    Base64ModelLoader()
+  override fun teardown() = Unit
+}

package/android/src/main/java/expo/modules/image/dataurls/Base64Module.kt

@@ -0,0 +1,16 @@
+package expo.modules.image.dataurls
+
+import android.content.Context
+import com.bumptech.glide.Glide
+import com.bumptech.glide.Registry
+import com.bumptech.glide.annotation.GlideModule
+import com.bumptech.glide.module.LibraryGlideModule
+import java.nio.ByteBuffer
+
+@GlideModule
+class Base64Module : LibraryGlideModule() {
+  override fun registerComponents(context: Context, glide: Glide, registry: Registry) {
+    super.registerComponents(context, glide, registry)
+    registry.prepend(String::class.java, ByteBuffer::class.java, Base64ModelLoaderFactory())
+  }
+}

package/android/src/main/java/expo/modules/image/drawing/OutlineProvider.kt

@@ -0,0 +1,201 @@
+package expo.modules.image.drawing
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Outline
+import android.graphics.Path
+import android.graphics.RectF
+import android.view.View
+import android.view.ViewOutlineProvider
+import com.facebook.react.modules.i18nmanager.I18nUtil
+import com.facebook.react.uimanager.FloatUtil
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.yoga.YogaConstants
+import expo.modules.image.ifYogaUndefinedUse
+
+class OutlineProvider(private val mContext: Context) : ViewOutlineProvider() {
+  enum class BorderRadiusConfig {
+    ALL, TOP_LEFT, TOP_RIGHT, BOTTOM_RIGHT, BOTTOM_LEFT, TOP_START, TOP_END, BOTTOM_START, BOTTOM_END
+  }
+
+  enum class CornerRadius {
+    TOP_LEFT, TOP_RIGHT, BOTTOM_RIGHT, BOTTOM_LEFT
+  }
+
+  private var mLayoutDirection = View.LAYOUT_DIRECTION_LTR
+  private val mBounds = RectF()
+  val borderRadiiConfig = FloatArray(9) { YogaConstants.UNDEFINED }
+  private val mCornerRadii = FloatArray(4)
+  private var mCornerRadiiInvalidated = true
+  private val mConvexPath = Path()
+  private var mConvexPathInvalidated = true
+
+  init {
+    updateCornerRadiiIfNeeded()
+  }
+
+  private fun updateCornerRadiiIfNeeded() {
+    if (!mCornerRadiiInvalidated) {
+      return
+    }
+
+    val isRTL = mLayoutDirection == View.LAYOUT_DIRECTION_RTL
+    val isRTLSwap = I18nUtil.getInstance().doLeftAndRightSwapInRTL(mContext)
+    updateCornerRadius(
+      CornerRadius.TOP_LEFT,
+      BorderRadiusConfig.TOP_LEFT,
+      BorderRadiusConfig.TOP_RIGHT,
+      BorderRadiusConfig.TOP_START,
+      BorderRadiusConfig.TOP_END,
+      isRTL,
+      isRTLSwap
+    )
+    updateCornerRadius(
+      CornerRadius.TOP_RIGHT,
+      BorderRadiusConfig.TOP_RIGHT,
+      BorderRadiusConfig.TOP_LEFT,
+      BorderRadiusConfig.TOP_END,
+      BorderRadiusConfig.TOP_START,
+      isRTL,
+      isRTLSwap
+    )
+    updateCornerRadius(
+      CornerRadius.BOTTOM_LEFT,
+      BorderRadiusConfig.BOTTOM_LEFT,
+      BorderRadiusConfig.BOTTOM_RIGHT,
+      BorderRadiusConfig.BOTTOM_START,
+      BorderRadiusConfig.BOTTOM_END,
+      isRTL,
+      isRTLSwap
+    )
+    updateCornerRadius(
+      CornerRadius.BOTTOM_RIGHT,
+      BorderRadiusConfig.BOTTOM_RIGHT,
+      BorderRadiusConfig.BOTTOM_LEFT,
+      BorderRadiusConfig.BOTTOM_END,
+      BorderRadiusConfig.BOTTOM_START,
+      isRTL,
+      isRTLSwap
+    )
+    mCornerRadiiInvalidated = false
+    mConvexPathInvalidated = true
+  }
+
+  private fun updateCornerRadius(
+    outputPosition: CornerRadius,
+    inputPosition: BorderRadiusConfig,
+    oppositePosition: BorderRadiusConfig,
+    startPosition: BorderRadiusConfig,
+    endPosition: BorderRadiusConfig,
+    isRTL: Boolean,
+    isRTLSwap: Boolean
+  ) {
+    var radius = borderRadiiConfig[inputPosition.ordinal]
+    if (isRTL) {
+      if (isRTLSwap) {
+        radius = borderRadiiConfig[oppositePosition.ordinal]
+      }
+      if (YogaConstants.isUndefined(radius)) {
+        radius = borderRadiiConfig[endPosition.ordinal]
+      }
+    } else {
+      if (YogaConstants.isUndefined(radius)) {
+        radius = borderRadiiConfig[startPosition.ordinal]
+      }
+    }
+    radius = radius
+      .ifYogaUndefinedUse(borderRadiiConfig[BorderRadiusConfig.ALL.ordinal])
+      .ifYogaUndefinedUse(0f)
+    mCornerRadii[outputPosition.ordinal] = PixelUtil.toPixelFromDIP(radius)
+  }
+
+  private fun updateConvexPathIfNeeded() {
+    if (!mConvexPathInvalidated) {
+      return
+    }
+    mConvexPath.reset()
+    mConvexPath.addRoundRect(
+      mBounds,
+      floatArrayOf(
+        mCornerRadii[CornerRadius.TOP_LEFT.ordinal],
+        mCornerRadii[CornerRadius.TOP_LEFT.ordinal],
+        mCornerRadii[CornerRadius.TOP_RIGHT.ordinal],
+        mCornerRadii[CornerRadius.TOP_RIGHT.ordinal],
+        mCornerRadii[CornerRadius.BOTTOM_RIGHT.ordinal],
+        mCornerRadii[CornerRadius.BOTTOM_RIGHT.ordinal],
+        mCornerRadii[CornerRadius.BOTTOM_LEFT.ordinal],
+        mCornerRadii[CornerRadius.BOTTOM_LEFT.ordinal]
+      ),
+      Path.Direction.CW
+    )
+    mConvexPathInvalidated = false
+  }
+
+  fun hasEqualCorners(): Boolean {
+    updateCornerRadiiIfNeeded()
+    val initialCornerRadius = mCornerRadii[0]
+    return mCornerRadii.all { initialCornerRadius == it }
+  }
+
+  fun setBorderRadius(radius: Float, position: Int): Boolean {
+    if (!FloatUtil.floatsEqual(borderRadiiConfig[position], radius)) {
+      borderRadiiConfig[position] = radius
+      mCornerRadiiInvalidated = true
+      return true
+    }
+    return false
+  }
+
+  private fun updateBoundsAndLayoutDirection(view: View) {
+    // Update layout direction
+    val layoutDirection = view.layoutDirection
+    if (mLayoutDirection != layoutDirection) {
+      mLayoutDirection = layoutDirection
+      mCornerRadiiInvalidated = true
+    }
+
+    // Update size
+    val left = 0
+    val top = 0
+    val right = view.width
+    val bottom = view.height
+    if (mBounds.left != left.toFloat() ||
+      mBounds.top != top.toFloat() ||
+      mBounds.right != right.toFloat() ||
+      mBounds.bottom != bottom.toFloat()
+    ) {
+      mBounds[left.toFloat(), top.toFloat(), right.toFloat()] = bottom.toFloat()
+      mCornerRadiiInvalidated = true
+    }
+  }
+
+  override fun getOutline(view: View, outline: Outline) {
+    updateBoundsAndLayoutDirection(view)
+
+    // Calculate outline
+    updateCornerRadiiIfNeeded()
+    if (hasEqualCorners()) {
+      val cornerRadius = mCornerRadii[0]
+      if (cornerRadius > 0) {
+        outline.setRoundRect(0, 0, mBounds.width().toInt(), mBounds.height().toInt(), cornerRadius)
+      } else {
+        outline.setRect(0, 0, mBounds.width().toInt(), mBounds.height().toInt())
+      }
+    } else {
+      // Clipping is not supported when using a convex path, but drawing the elevation
+      // shadow is. For the particular case, we fallback to canvas clipping in the view
+      // which is supposed to call `clipCanvasIfNeeded` in its `draw` method.
+      updateConvexPathIfNeeded()
+      outline.setConvexPath(mConvexPath)
+    }
+  }
+
+  fun clipCanvasIfNeeded(canvas: Canvas, view: View) {
+    updateBoundsAndLayoutDirection(view)
+    updateCornerRadiiIfNeeded()
+    if (!hasEqualCorners()) {
+      updateConvexPathIfNeeded()
+      canvas.clipPath(mConvexPath)
+    }
+  }
+}

package/android/src/main/java/expo/modules/image/enums/ContentFit.kt

@@ -0,0 +1,89 @@
+package expo.modules.image.enums
+
+import android.graphics.Matrix
+import android.graphics.RectF
+import expo.modules.kotlin.types.Enumerable
+import kotlin.math.max
+
+/**
+ * Describes how the image should be resized to fit its container.
+ * - Note: It mirrors the CSS [`object-fit`](https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit) property.
+ */
+enum class ContentFit(val value: String) : Enumerable {
+  /**
+   * The image is scaled to maintain its aspect ratio while fitting within the container's box.
+   * The entire image is made to fill the box, while preserving its aspect ratio,
+   * so the image will be "letterboxed" if its aspect ratio does not match the aspect ratio of the box.
+   */
+  Contain("contain"),
+
+  /**
+   * The image is sized to maintain its aspect ratio while filling the element's entire content box.
+   * If the image's aspect ratio does not match the aspect ratio of its box, then the object will be clipped to fit.
+   */
+  Cover("cover"),
+
+  /**
+   * The image is sized to fill the element's content box. The entire object will completely fill the box.
+   * If the image's aspect ratio does not match the aspect ratio of its box, then the image will be stretched to fit.
+   */
+  Fill("fill"),
+
+  /**
+   * The image is not resized and is centered by default.
+   * When specified, the exact position can be controlled with `ContentPosition`.
+   */
+  None("none"),
+
+  /**
+   * The image is sized as if `none` or `contain` were specified,
+   * whichever would result in a smaller concrete image size.
+   */
+  ScaleDown("scale-down");
+
+  internal fun toMatrix(imageRect: RectF, viewRect: RectF, sourceWidth: Int, sourceHeight: Int) = Matrix().apply {
+    when (this@ContentFit) {
+      Contain -> setRectToRect(imageRect, viewRect, Matrix.ScaleToFit.START)
+      Cover -> {
+        val imageWidth = imageRect.width()
+        val imageHeight = imageRect.height()
+
+        val reactWidth = viewRect.width()
+        val reactHeight = viewRect.height()
+
+        val scale = max(reactWidth / imageWidth, reactHeight / imageHeight)
+
+        setScale(scale, scale)
+      }
+      Fill -> setRectToRect(imageRect, viewRect, Matrix.ScaleToFit.FILL)
+      None -> {
+        // we don't need to do anything
+      }
+      ScaleDown -> {
+        // If we have information about the original size of the source, we can resize the image more drastically.
+        // In certain situations, we may even permit upscaling when we anticipate the image to be reloaded without any reduction in size,
+        // which will create a seamless transition between various states.
+        if (sourceWidth != -1 && sourceHeight != -1) {
+          val sourceRect = RectF(0f, 0f, sourceWidth.toFloat(), sourceHeight.toFloat())
+          // Rather than checking if the image rectangle is within the bounds of the view rectangle, we verify the original source rectangle.
+          // We know that the newly loaded image has larger dimensions than the current one, and therefore,
+          // it will not be downscaled.
+          if (sourceRect.width() >= viewRect.width() || sourceRect.height() >= viewRect.height()) {
+            setRectToRect(imageRect, viewRect, Matrix.ScaleToFit.START)
+          }
+          // If the source rectangle is larger than the view rectangle and the image rectangle has not been upscaled to match the source rectangle,
+          // temporary upscaling is necessary to ensure a seamless transition.
+          // It should be noted that this upscaling is applied to the downscaled version of the image,
+          // not the original source image, and will be replaced by the original asset shortly thereafter.
+          else {
+            setRectToRect(imageRect, sourceRect, Matrix.ScaleToFit.START)
+          }
+        } else {
+          if (imageRect.width() >= viewRect.width() || imageRect.height() >= viewRect.height()) {
+            setRectToRect(imageRect, viewRect, Matrix.ScaleToFit.START)
+          }
+        }
+      }
+    }
+  }
+}

package/android/src/main/java/expo/modules/image/enums/ImageCacheType.kt

@@ -0,0 +1,14 @@
+package expo.modules.image.enums
+
+import com.bumptech.glide.load.DataSource
+
+enum class ImageCacheType(private vararg val dataSources: DataSource) {
+  NONE(DataSource.LOCAL, DataSource.REMOTE),
+  DISK(DataSource.DATA_DISK_CACHE, DataSource.RESOURCE_DISK_CACHE),
+  MEMORY(DataSource.MEMORY_CACHE);
+
+  companion object {
+    fun fromNativeValue(value: DataSource): ImageCacheType =
+      values().firstOrNull { it.dataSources.contains(value) } ?: NONE
+  }
+}

package/android/src/main/java/expo/modules/image/enums/Priority.kt

@@ -0,0 +1,15 @@
+package expo.modules.image.enums
+
+import expo.modules.kotlin.types.Enumerable
+
+enum class Priority(val value: String) : Enumerable {
+  LOW("low"),
+  NORMAL("normal"),
+  HIGH("high");
+
+  internal fun toGlidePriority(): com.bumptech.glide.Priority = when (this) {
+    LOW -> com.bumptech.glide.Priority.LOW
+    NORMAL -> com.bumptech.glide.Priority.NORMAL
+    HIGH -> com.bumptech.glide.Priority.IMMEDIATE
+  }
+}