@amazon-devices/expo-image 2.0.1758683737

package/android/src/main/java/expo/modules/image/GlideModel.kt

@@ -0,0 +1,73 @@
+package expo.modules.image
+
+import android.net.Uri
+import com.bumptech.glide.load.model.GlideUrl
+import expo.modules.image.okhttp.GlideUrlWrapper
+
+sealed class GlideModel {
+  abstract val glideData: Any
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) {
+      return true
+    }
+    return other is GlideModel && glideData == other.glideData
+  }
+
+  override fun hashCode(): Int = glideData.hashCode()
+}
+
+class GlideUrlModel(
+  glideUrl: GlideUrl
+) : GlideModel() {
+  override val glideData: GlideUrlWrapper = GlideUrlWrapper(glideUrl)
+}
+
+class GlideRawModel(
+  data: String
+) : GlideModel() {
+  override val glideData: String = data
+}
+
+class GlideUriModel(
+  uri: Uri
+) : GlideModel() {
+  override val glideData: Uri = uri
+}
+
+class GlideBlurhashModel(
+  val uri: Uri,
+  val width: Int,
+  val height: Int
+) : GlideModel() {
+  override val glideData: GlideBlurhashModel = this
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) {
+      return true
+    }
+
+    return other is GlideBlurhashModel && uri == other.uri && width == other.width && height == other.height
+  }
+
+  override fun hashCode(): Int {
+    var result = uri.hashCode()
+    result = 31 * result + width
+    result = 31 * result + height
+    return result
+  }
+}
+
+class GlideThumbhashModel(
+  var uri: Uri
+) : GlideModel() {
+  override val glideData: GlideThumbhashModel = this
+
+  override fun equals(other: Any?): Boolean {
+    return (this === other) || other is GlideThumbhashModel && uri == other.uri
+  }
+
+  override fun hashCode(): Int {
+    return uri.hashCode()
+  }
+}

package/android/src/main/java/expo/modules/image/ImageUtils.kt

@@ -0,0 +1,50 @@
+package expo.modules.image
+
+import android.graphics.RectF
+import com.bumptech.glide.request.FutureTarget
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runInterruptible
+
+/**
+ * Converts blocking [java.util.concurrent.Future] result into non-blocking suspend function.
+ */
+internal suspend fun <T> FutureTarget<T>.awaitGet(): T = runInterruptible(Dispatchers.IO) { get() }
+
+fun calcXTranslation(
+  value: Float,
+  imageRect: RectF,
+  viewRect: RectF,
+  isPercentage: Boolean = false,
+  isReverse: Boolean = false
+): Float = calcTranslation(value, imageRect.width(), viewRect.width(), isPercentage, isReverse)
+
+fun calcYTranslation(
+  value: Float,
+  imageRect: RectF,
+  viewRect: RectF,
+  isPercentage: Boolean = false,
+  isReverse: Boolean = false
+): Float = calcTranslation(value, imageRect.height(), viewRect.height(), isPercentage, isReverse)
+
+fun calcTranslation(
+  value: Float,
+  imageRefValue: Float,
+  viewRefValue: Float,
+  isPercentage: Boolean = false,
+  isReverse: Boolean = false
+): Float {
+  if (isPercentage) {
+    val finalPercentage = if (isReverse) {
+      100f - value
+    } else {
+      value
+    }
+    return (finalPercentage / 100f) * (viewRefValue - imageRefValue)
+  }
+
+  if (isReverse) {
+    return viewRefValue - imageRefValue - value
+  }
+
+  return value
+}

package/android/src/main/java/expo/modules/image/ImageViewWrapperTarget.kt

@@ -0,0 +1,313 @@
+package expo.modules.image
+
+import android.content.Context
+import android.graphics.Point
+import android.graphics.drawable.Drawable
+import android.util.Log
+import android.view.ViewGroup
+import android.view.ViewTreeObserver
+import android.view.WindowManager
+import androidx.annotation.VisibleForTesting
+import com.bumptech.glide.RequestManager
+import com.bumptech.glide.request.Request
+import com.bumptech.glide.request.ThumbnailRequestCoordinator
+import com.bumptech.glide.request.target.SizeReadyCallback
+import com.bumptech.glide.request.target.Target
+import com.bumptech.glide.request.transition.Transition
+import com.bumptech.glide.util.Preconditions
+import com.bumptech.glide.util.Synthetic
+import expo.modules.core.utilities.ifNull
+import expo.modules.image.enums.ContentFit
+import java.lang.ref.WeakReference
+import kotlin.math.max
+
+/**
+ * A custom target to provide a smooth transition between multiple drawables.
+ * It delegates images to the [ExpoImageViewWrapper], where we handle the loaded [Drawable].
+ * When the target is cleared, we don't do anything. The [ExpoImageViewWrapper] is responsible for
+ * clearing bitmaps before freeing targets. That may be error-prone, but that is the only way
+ * of implementing the transition between bitmaps.
+ */
+class ImageViewWrapperTarget(
+  private val imageViewHolder: WeakReference<ExpoImageViewWrapper>,
+) : Target<Drawable> {
+  /**
+   * Whether the target has a main, non-placeholder source
+   */
+  var hasSource = false
+
+  /**
+   * Whether the target is used - the asset loaded by it has been drawn in the image view
+   */
+  var isUsed = false
+
+  /**
+   * The main source height where -1 means unknown
+   */
+  var sourceHeight = -1
+
+  /**
+   * The main source width where -1 means unknown
+   */
+  var sourceWidth = -1
+
+  /**
+   * The content fit of the placeholder
+   */
+  var placeholderContentFit: ContentFit? = null
+
+  private var request: Request? = null
+  private var sizeDeterminer = SizeDeterminer(imageViewHolder)
+
+  override fun onResourceReady(resource: Drawable, transition: Transition<in Drawable>?) {
+    // The image view should always be valid. When the view is deallocated, all targets should be
+    // canceled. Therefore that code shouldn't be called in that case. Instead of crashing, we
+    // decided to ignore that.
+    val imageView = imageViewHolder.get().ifNull {
+      Log.w("ExpoImage", "The `ExpoImageViewWrapper` was deallocated, but the target wasn't canceled in time.")
+      return
+    }
+
+    // The thumbnail and full request are handled in the same way by Glide.
+    // Here we're checking if the provided resource is the final bitmap or a thumbnail.
+    val isPlaceholder = if (request is ThumbnailRequestCoordinator) {
+      (request as? ThumbnailRequestCoordinator)
+        ?.getPrivateFullRequest()
+        ?.isComplete == false
+    } else {
+      false
+    }
+
+    imageView.onResourceReady(this, resource, isPlaceholder)
+  }
+
+  override fun onStart() = Unit
+
+  override fun onStop() = Unit
+
+  override fun onDestroy() = Unit
+
+  override fun onLoadStarted(placeholder: Drawable?) = Unit
+
+  // When loading fails, it's handled by the global listener, therefore that method can be NOOP.
+  override fun onLoadFailed(errorDrawable: Drawable?) = Unit
+
+  override fun onLoadCleared(placeholder: Drawable?) = Unit
+
+  override fun getSize(cb: SizeReadyCallback) {
+    // If we can't resolve the image, we just return unknown size.
+    // It shouldn't happen in a production application, because it means that our view was deallocated.
+    if (imageViewHolder.get() == null) {
+      cb.onSizeReady(Target.SIZE_ORIGINAL, Target.SIZE_ORIGINAL)
+      return
+    }
+
+    sizeDeterminer.getSize(cb)
+  }
+
+  override fun removeCallback(cb: SizeReadyCallback) {
+    sizeDeterminer.removeCallback(cb)
+  }
+
+  override fun setRequest(request: Request?) {
+    this.request = request
+  }
+
+  override fun getRequest() = request
+
+  fun clear(requestManager: RequestManager) {
+    sizeDeterminer.clearCallbacksAndListener()
+    requestManager.clear(this)
+  }
+}
+
+// Copied from the Glide codebase.
+// We modified that to receive a weak ref to our view instead of strong one.
+internal class SizeDeterminer(private val imageViewHolder: WeakReference<ExpoImageViewWrapper>) {
+  private val cbs: MutableList<SizeReadyCallback> = ArrayList()
+
+  @Synthetic
+  var waitForLayout = false
+  private var layoutListener: SizeDeterminerLayoutListener? = null
+  private fun notifyCbs(width: Int, height: Int) {
+    // One or more callbacks may trigger the removal of one or more additional callbacks, so we
+    // need a copy of the list to avoid a concurrent modification exception. One place this
+    // happens is when a full request completes from the in memory cache while its thumbnail is
+    // still being loaded asynchronously. See #2237.
+    for (cb in ArrayList(cbs)) {
+      cb.onSizeReady(width, height)
+    }
+  }
+
+  @Synthetic
+  fun checkCurrentDimens() {
+    if (cbs.isEmpty()) {
+      return
+    }
+    val currentWidth = targetWidth
+    val currentHeight = targetHeight
+    if (!isViewStateAndSizeValid(currentWidth, currentHeight)) {
+      return
+    }
+    notifyCbs(currentWidth, currentHeight)
+    clearCallbacksAndListener()
+  }
+
+  fun getSize(cb: SizeReadyCallback) {
+    val view = imageViewHolder.get() ?: return
+
+    val currentWidth = targetWidth
+    val currentHeight = targetHeight
+    if (isViewStateAndSizeValid(currentWidth, currentHeight)) {
+      cb.onSizeReady(currentWidth, currentHeight)
+      return
+    }
+
+    // We want to notify callbacks in the order they were added and we only expect one or two
+    // callbacks to be added a time, so a List is a reasonable choice.
+    if (!cbs.contains(cb)) {
+      cbs.add(cb)
+    }
+    if (layoutListener == null) {
+      val observer = view.viewTreeObserver
+      layoutListener = SizeDeterminerLayoutListener(this)
+      observer.addOnPreDrawListener(layoutListener)
+    }
+  }
+
+  /**
+   * The callback may be called anyway if it is removed by another [SizeReadyCallback] or
+   * otherwise removed while we're notifying the list of callbacks.
+   *
+   *
+   * See #2237.
+   */
+  fun removeCallback(cb: SizeReadyCallback) {
+    cbs.remove(cb)
+  }
+
+  fun clearCallbacksAndListener() {
+    // Keep a reference to the layout attachStateListener and remove it here
+    // rather than having the observer remove itself because the observer
+    // we add the attachStateListener to will be almost immediately merged into
+    // another observer and will therefore never be alive. If we instead
+    // keep a reference to the attachStateListener and remove it here, we get the
+    // current view tree observer and should succeed.
+    val observer = imageViewHolder.get()?.viewTreeObserver
+    if (observer?.isAlive == true) {
+      observer.removeOnPreDrawListener(layoutListener)
+    }
+    layoutListener = null
+    cbs.clear()
+  }
+
+  private fun isViewStateAndSizeValid(width: Int, height: Int): Boolean {
+    return isDimensionValid(width) && isDimensionValid(height)
+  }
+
+  private val targetHeight: Int
+    get() {
+      val view = imageViewHolder.get() ?: return Target.SIZE_ORIGINAL
+      val verticalPadding = view.paddingTop + view.paddingBottom
+      val layoutParams = view.layoutParams
+      val layoutParamSize = layoutParams?.height ?: PENDING_SIZE
+      return getTargetDimen(view.height, layoutParamSize, verticalPadding)
+    }
+  private val targetWidth: Int
+    get() {
+      val view = imageViewHolder.get() ?: return Target.SIZE_ORIGINAL
+      val horizontalPadding = view.paddingLeft + view.paddingRight
+      val layoutParams = view.layoutParams
+      val layoutParamSize = layoutParams?.width ?: PENDING_SIZE
+      return getTargetDimen(view.width, layoutParamSize, horizontalPadding)
+    }
+
+  private fun getTargetDimen(viewSize: Int, paramSize: Int, paddingSize: Int): Int {
+    val view = imageViewHolder.get() ?: return Target.SIZE_ORIGINAL
+
+    // We consider the View state as valid if the View has non-null layout params and a non-zero
+    // layout params width and height. This is imperfect. We're making an assumption that View
+    // parents will obey their child's layout parameters, which isn't always the case.
+    val adjustedParamSize = paramSize - paddingSize
+    if (adjustedParamSize > 0) {
+      return adjustedParamSize
+    }
+
+    // Since we always prefer layout parameters with fixed sizes, even if waitForLayout is true,
+    // we might as well ignore it and just return the layout parameters above if we have them.
+    // Otherwise we should wait for a layout pass before checking the View's dimensions.
+    if (waitForLayout && view.isLayoutRequested) {
+      return PENDING_SIZE
+    }
+
+    // We also consider the View state valid if the View has a non-zero width and height. This
+    // means that the View has gone through at least one layout pass. It does not mean the Views
+    // width and height are from the current layout pass. For example, if a View is re-used in
+    // RecyclerView or ListView, this width/height may be from an old position. In some cases
+    // the dimensions of the View at the old position may be different than the dimensions of the
+    // View in the new position because the LayoutManager/ViewParent can arbitrarily decide to
+    // change them. Nevertheless, in most cases this should be a reasonable choice.
+    val adjustedViewSize = viewSize - paddingSize
+    if (adjustedViewSize > 0) {
+      return adjustedViewSize
+    }
+
+    // Finally we consider the view valid if the layout parameter size is set to wrap_content.
+    // It's difficult for Glide to figure out what to do here. Although Target.SIZE_ORIGINAL is a
+    // coherent choice, it's extremely dangerous because original images may be much too large to
+    // fit in memory or so large that only a couple can fit in memory, causing OOMs. If users want
+    // the original image, they can always use .override(Target.SIZE_ORIGINAL). Since wrap_content
+    // may never resolve to a real size unless we load something, we aim for a square whose length
+    // is the largest screen size. That way we're loading something and that something has some
+    // hope of being downsampled to a size that the device can support. We also log a warning that
+    // tries to explain what Glide is doing and why some alternatives are preferable.
+    // Since WRAP_CONTENT is sometimes used as a default layout parameter, we always wait for
+    // layout to complete before using this fallback parameter (ConstraintLayout among others).
+    if (!view.isLayoutRequested && paramSize == ViewGroup.LayoutParams.WRAP_CONTENT) {
+      return getMaxDisplayLength(view.context)
+    }
+
+    // If the layout parameters are < padding, the view size is < padding, or the layout
+    // parameters are set to match_parent or wrap_content and no layout has occurred, we should
+    // wait for layout and repeat.
+    return PENDING_SIZE
+  }
+
+  private fun isDimensionValid(size: Int): Boolean {
+    return size > 0 || size == Target.SIZE_ORIGINAL
+  }
+
+  private class SizeDeterminerLayoutListener(sizeDeterminer: SizeDeterminer) : ViewTreeObserver.OnPreDrawListener {
+    private val sizeDeterminerRef: WeakReference<SizeDeterminer>
+
+    init {
+      sizeDeterminerRef = WeakReference(sizeDeterminer)
+    }
+
+    override fun onPreDraw(): Boolean {
+      val sizeDeterminer = sizeDeterminerRef.get()
+      sizeDeterminer?.checkCurrentDimens()
+      return true
+    }
+  }
+
+  companion object {
+    // Some negative sizes (Target.SIZE_ORIGINAL) are valid, 0 is never valid.
+    private const val PENDING_SIZE = 0
+
+    @VisibleForTesting
+    var maxDisplayLength: Int? = null
+
+    // Use the maximum to avoid depending on the device's current orientation.
+    private fun getMaxDisplayLength(context: Context): Int {
+      if (maxDisplayLength == null) {
+        val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+        val display = Preconditions.checkNotNull(windowManager).defaultDisplay
+        val displayDimensions = Point()
+        display.getSize(displayDimensions)
+        maxDisplayLength = max(displayDimensions.x, displayDimensions.y)
+      }
+      return maxDisplayLength!!
+    }
+  }
+}

package/android/src/main/java/expo/modules/image/ResourceIdHelper.kt

@@ -0,0 +1,47 @@
+package expo.modules.image
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.net.Uri
+import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper
+import java.util.*
+
+object ResourceIdHelper {
+  private val idMap = mutableMapOf<String, Int>()
+
+  @SuppressLint("DiscouragedApi")
+  private fun getResourceRawId(context: Context, name: String): Int {
+    if (name.isEmpty()) {
+      return -1
+    }
+
+    val normalizedName = name.lowercase(Locale.ROOT).replace("-", "_")
+    synchronized(this) {
+      val id = idMap[normalizedName]
+      if (id != null) {
+        return id
+      }
+
+      return context
+        .resources
+        .getIdentifier(normalizedName, "raw", context.packageName)
+        .also {
+          idMap[normalizedName] = it
+        }
+    }
+  }
+
+  fun getResourceUri(context: Context, name: String): Uri? {
+    val drawableUri = ResourceDrawableIdHelper.getInstance().getResourceDrawableUri(context, name)
+    if (drawableUri != null && drawableUri != Uri.EMPTY) {
+      return drawableUri
+    }
+
+    val resId = getResourceRawId(context, name)
+    return if (resId > 0) {
+      Uri.Builder().scheme("res").path(resId.toString()).build()
+    } else {
+      null
+    }
+  }
+}

package/android/src/main/java/expo/modules/image/ThumbnailRequestCoordinatorExtension.kt

@@ -0,0 +1,21 @@
+package expo.modules.image
+
+import android.util.Log
+import com.bumptech.glide.request.Request
+import com.bumptech.glide.request.ThumbnailRequestCoordinator
+
+fun ThumbnailRequestCoordinator.getPrivateFullRequest(): Request? {
+  return getPrivateField("full")
+}
+
+private fun <T> ThumbnailRequestCoordinator.getPrivateField(name: String): T? {
+  return try {
+    val field = this.javaClass.getDeclaredField(name)
+    field.isAccessible = true
+    @Suppress("UNCHECKED_CAST")
+    field.get(this) as T
+  } catch (e: Throwable) {
+    Log.e("ExpoImage", "Couldn't receive the `$name` field", e)
+    null
+  }
+}

package/android/src/main/java/expo/modules/image/YogaUtils.kt

@@ -0,0 +1,20 @@
+package expo.modules.image
+
+import com.facebook.yoga.YogaConstants
+
+fun Float.ifYogaUndefinedUse(value: Float) =
+  if (YogaConstants.isUndefined(this)) {
+    value
+  } else {
+    this
+  }
+
+inline fun Float.ifYogaDefinedUse(transformFun: (current: Float) -> Float) =
+  if (YogaConstants.isUndefined(this)) {
+    this
+  } else {
+    transformFun(this)
+  }
+
+fun makeYogaUndefinedIfNegative(value: Float) =
+  if (!YogaConstants.isUndefined(value) && value < 0) YogaConstants.UNDEFINED else value

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

@@ -0,0 +1,32 @@
+package expo.modules.image.blurhash
+
+import android.graphics.Bitmap
+import com.bumptech.glide.Priority
+import com.bumptech.glide.load.DataSource
+import com.bumptech.glide.load.data.DataFetcher
+import expo.modules.kotlin.exception.CodedException
+
+class BlurhashDecodingFailure(blurHash: String?) : CodedException(
+  message = "Cannot decode provided blurhash '$blurHash'"
+)
+
+class BlurHashFetcher(
+  private val blurHash: String?,
+  private val width: Int,
+  private val height: Int,
+  private val punch: Float
+) : DataFetcher<Bitmap> {
+  override fun cleanup() = Unit
+  override fun cancel() = Unit
+  override fun getDataClass(): Class<Bitmap> = Bitmap::class.java
+  override fun getDataSource(): DataSource = DataSource.LOCAL
+
+  override fun loadData(priority: Priority, callback: DataFetcher.DataCallback<in Bitmap>) {
+    val bitmap = BlurhashDecoder.decode(blurHash, width, height, punch)
+    if (bitmap == null) {
+      callback.onLoadFailed(BlurhashDecodingFailure(blurHash))
+      return
+    }
+    callback.onDataReady(bitmap)
+  }
+}