@amazon-devices/expo-image 2.0.1758683737

package/android/src/main/java/expo/modules/image/events/GlideRequestListener.kt

@@ -0,0 +1,64 @@
+package expo.modules.image.events
+
+import android.graphics.drawable.Drawable
+import android.util.Log
+import com.bumptech.glide.load.DataSource
+import com.bumptech.glide.load.engine.GlideException
+import com.bumptech.glide.request.RequestListener
+import com.bumptech.glide.request.target.Target
+import expo.modules.image.ExpoImageViewWrapper
+import expo.modules.image.enums.ImageCacheType
+import expo.modules.image.records.ImageErrorEvent
+import expo.modules.image.records.ImageLoadEvent
+import expo.modules.image.records.ImageSource
+import java.lang.ref.WeakReference
+import java.util.*
+
+class GlideRequestListener(
+  private val expoImageViewWrapper: WeakReference<ExpoImageViewWrapper>
+) : RequestListener<Drawable> {
+  override fun onLoadFailed(
+    e: GlideException?,
+    model: Any?,
+    target: Target<Drawable>,
+    isFirstResource: Boolean
+  ): Boolean {
+    val errorMessage = e
+      ?.message
+      // Glide always append that line to the end of the message.
+      // It's not possible to call `logRootCauses` from the JS, so we decided to remove it.
+      ?.removeSuffix("\n call GlideException#logRootCauses(String) for more detail")
+      ?: "Unknown error"
+
+    expoImageViewWrapper
+      .get()
+      ?.onError
+      ?.invoke(ImageErrorEvent(errorMessage))
+
+    Log.e("ExpoImage", errorMessage)
+    e?.logRootCauses("ExpoImage")
+    return false
+  }
+
+  override fun onResourceReady(
+    resource: Drawable,
+    model: Any,
+    target: Target<Drawable>,
+    dataSource: DataSource,
+    isFirstResource: Boolean
+  ): Boolean {
+    expoImageViewWrapper.get()?.onLoad?.invoke(
+      ImageLoadEvent(
+        cacheType = ImageCacheType.fromNativeValue(dataSource).name.lowercase(Locale.getDefault()),
+        source = ImageSource(
+          url = model.toString(),
+          width = resource.intrinsicWidth,
+          height = resource.intrinsicHeight,
+          mediaType = null // TODO(@lukmccall): add mediaType
+        )
+      )
+    )
+
+    return false
+  }
+}

package/android/src/main/java/expo/modules/image/events/OkHttpProgressListener.kt

@@ -0,0 +1,26 @@
+package expo.modules.image.events
+
+import com.facebook.react.modules.network.ProgressListener
+import expo.modules.image.ExpoImageViewWrapper
+import expo.modules.image.records.ImageProgressEvent
+import java.lang.ref.WeakReference
+
+class OkHttpProgressListener(
+  private val expoImageViewWrapper: WeakReference<ExpoImageViewWrapper>
+) : ProgressListener {
+  override fun onProgress(bytesWritten: Long, contentLength: Long, done: Boolean) {
+    // OkHttp calls that function twice at the end - when the last byte was downloaded with done set to false,
+    // and also shortly after, with done set to true. In both cases, the bytesWritten and the contentLength are equal.
+    // We want to avoid sending two same events to JS, that's why we return when done is set to true.
+    if (contentLength <= 0 || done) {
+      return
+    }
+
+    expoImageViewWrapper.get()?.onProgress?.invoke(
+      ImageProgressEvent(
+        loaded = bytesWritten.toInt(),
+        total = contentLength.toInt()
+      )
+    )
+  }
+}

package/android/src/main/java/expo/modules/image/okhttp/ExpoImageOkHttpClientGlideModule.kt

@@ -0,0 +1,80 @@
+package expo.modules.image.okhttp
+
+import android.content.Context
+import com.bumptech.glide.Glide
+import com.bumptech.glide.Registry
+import com.bumptech.glide.annotation.GlideModule
+import com.bumptech.glide.integration.okhttp3.OkHttpUrlLoader
+import com.bumptech.glide.load.model.GlideUrl
+import com.bumptech.glide.load.model.Headers
+import com.bumptech.glide.module.LibraryGlideModule
+import expo.modules.image.events.OkHttpProgressListener
+import okhttp3.OkHttpClient
+import java.io.InputStream
+
+/**
+ * GlideUrl with custom cache key.
+ * It wraps the base implementation and overrides logic behind cache key and when two
+ * objects are equal. Typically, Glide uses the only cache key to compare objects.
+ * It won't suit our use case. We want to make custom cache key transparent and
+ * not use it to compare objects.
+ */
+class GlideUrlWithCustomCacheKey(
+  uri: String?,
+  headers: Headers?,
+  private val cacheKey: String
+) : GlideUrl(uri, headers) {
+  /**
+   * Cached hash code value
+   */
+  private var hashCode = 0
+
+  /**
+   * @return a super cache key from [GlideUrl]
+   */
+  private fun getBaseCacheKey(): String = super.getCacheKey()
+
+  override fun getCacheKey(): String = cacheKey
+
+  // Mostly copied from GlideUrl::equal
+  override fun equals(other: Any?): Boolean {
+    if (other is GlideUrlWithCustomCacheKey) {
+      return getBaseCacheKey() == other.getBaseCacheKey() && headers.equals(other.headers)
+    } else if (other is GlideUrl) {
+      return getBaseCacheKey() == other.cacheKey && headers.equals(other.headers)
+    }
+    return false
+  }
+
+  // Mostly copied from GlideUrl::hashCode
+  override fun hashCode(): Int {
+    if (hashCode == 0) {
+      hashCode = getBaseCacheKey().hashCode()
+      hashCode = 31 * hashCode + headers.hashCode()
+    }
+    return hashCode
+  }
+}
+
+/**
+ * To connect listener with the request we have to create custom model.
+ * In that way, we're passing more information to the final data loader.
+ */
+data class GlideUrlWrapper(val glideUrl: GlideUrl) {
+  var progressListener: OkHttpProgressListener? = null
+
+  override fun toString(): String {
+    return glideUrl.toString()
+  }
+}
+
+@GlideModule
+class ExpoImageOkHttpClientGlideModule : LibraryGlideModule() {
+  override fun registerComponents(context: Context, glide: Glide, registry: Registry) {
+    val client = OkHttpClient()
+    // We don't use the `GlideUrl` directly but we want to replace the default okhttp loader anyway
+    // to make sure that the app will use only one client.
+    registry.replace(GlideUrl::class.java, InputStream::class.java, OkHttpUrlLoader.Factory(client))
+    registry.prepend(GlideUrlWrapper::class.java, InputStream::class.java, GlideUrlWrapperLoader.Factory(client))
+  }
+}

package/android/src/main/java/expo/modules/image/okhttp/GlideUrlWrapperLoader.kt

@@ -0,0 +1,55 @@
+package expo.modules.image.okhttp
+
+import com.bumptech.glide.integration.okhttp3.OkHttpUrlLoader
+import com.bumptech.glide.load.Options
+import com.bumptech.glide.load.model.ModelLoader
+import com.bumptech.glide.load.model.ModelLoaderFactory
+import com.bumptech.glide.load.model.MultiModelLoaderFactory
+import com.facebook.react.modules.network.ProgressResponseBody
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import java.io.InputStream
+
+class GlideUrlWrapperLoader(
+  private val commonClient: OkHttpClient
+) : ModelLoader<GlideUrlWrapper, InputStream> {
+  override fun buildLoadData(
+    model: GlideUrlWrapper,
+    width: Int,
+    height: Int,
+    options: Options
+  ): ModelLoader.LoadData<InputStream>? {
+    val loader = OkHttpUrlLoader(
+      commonClient
+        .newBuilder()
+        .addInterceptor(
+          Interceptor { chain ->
+            val originalResponse = chain.proceed(chain.request())
+            originalResponse
+              .newBuilder()
+              .body(
+                ProgressResponseBody(originalResponse.body) { bytesWritten, contentLength, done ->
+                  model.progressListener?.onProgress(bytesWritten, contentLength, done)
+                }
+              )
+              .build()
+          }
+        )
+        .build()
+    )
+
+    return loader.buildLoadData(model.glideUrl, width, height, options)
+  }
+
+  // The default http loader always returns true.
+  override fun handles(model: GlideUrlWrapper): Boolean = true
+
+  class Factory(
+    private val commonClient: OkHttpClient
+  ) : ModelLoaderFactory<GlideUrlWrapper, InputStream> {
+    override fun build(multiFactory: MultiModelLoaderFactory): ModelLoader<GlideUrlWrapper, InputStream> =
+      GlideUrlWrapperLoader(commonClient)
+
+    override fun teardown() = Unit
+  }
+}

package/android/src/main/java/expo/modules/image/records/CachePolicy.kt

@@ -0,0 +1,10 @@
+package expo.modules.image.records
+
+import expo.modules.kotlin.types.Enumerable
+
+enum class CachePolicy(val value: String) : Enumerable {
+  NONE("none"),
+  DISK("disk"),
+  MEMORY("memory"),
+  MEMORY_AND_DISK("memory-disk")
+}

package/android/src/main/java/expo/modules/image/records/ContentPosition.kt

@@ -0,0 +1,89 @@
+package expo.modules.image.records
+
+import android.graphics.Matrix
+import android.graphics.RectF
+import expo.modules.image.calcXTranslation
+import expo.modules.image.calcYTranslation
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+/**
+ * Represents a position value that might be either `Double` or `String`.
+ * TODO(@lukmccall): Use `Either` instead of `Any`
+ */
+typealias ContentPositionValue = Any
+
+private typealias CalcAxisOffset = (
+  value: Float,
+  imageRect: RectF,
+  viewRect: RectF,
+  isPercentage: Boolean,
+  isReverse: Boolean
+) -> Float
+
+class ContentPosition : Record {
+  @Field
+  val top: ContentPositionValue? = null
+
+  @Field
+  val bottom: ContentPositionValue? = null
+
+  @Field
+  val right: ContentPositionValue? = null
+
+  @Field
+  val left: ContentPositionValue? = null
+
+  private fun ContentPositionValue?.calcOffset(
+    isReverse: Boolean,
+    imageRect: RectF,
+    viewRect: RectF,
+    calcAxisOffset: CalcAxisOffset
+  ): Float? {
+    if (this == null) {
+      return null
+    }
+
+    return if (this is Double) {
+      val value = this.toFloat()
+      calcAxisOffset(value, imageRect, viewRect, false, isReverse)
+    } else {
+      val value = this as String
+
+      if (value == "center") {
+        calcAxisOffset(50f, imageRect, viewRect, true, isReverse)
+      } else {
+        calcAxisOffset(value.removeSuffix("%").toFloat(), imageRect, viewRect, true, isReverse)
+      }
+    }
+  }
+
+  private fun offsetX(
+    imageRect: RectF,
+    viewRect: RectF
+  ): Float {
+    return left.calcOffset(false, imageRect, viewRect, ::calcXTranslation)
+      ?: right.calcOffset(true, imageRect, viewRect, ::calcXTranslation)
+      ?: calcXTranslation(50f, imageRect, viewRect, isPercentage = true) // default value
+  }
+
+  private fun offsetY(
+    imageRect: RectF,
+    viewRect: RectF
+  ): Float {
+    return top.calcOffset(false, imageRect, viewRect, ::calcYTranslation)
+      ?: bottom.calcOffset(true, imageRect, viewRect, ::calcYTranslation)
+      ?: calcYTranslation(50f, imageRect, viewRect, isPercentage = true) // default value
+  }
+
+  internal fun apply(to: Matrix, imageRect: RectF, viewRect: RectF) {
+    val xOffset = offsetX(imageRect, viewRect)
+    val yOffset = offsetY(imageRect, viewRect)
+
+    to.postTranslate(xOffset, yOffset)
+  }
+
+  companion object {
+    val center = ContentPosition()
+  }
+}

package/android/src/main/java/expo/modules/image/records/ImageTransition.kt

@@ -0,0 +1,8 @@
+package expo.modules.image.records
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+data class ImageTransition(
+  @Field val duration: Int = 0
+) : Record

package/android/src/main/java/expo/modules/image/records/SourceMap.kt

@@ -0,0 +1,160 @@
+package expo.modules.image.records
+
+import android.content.Context
+import android.net.Uri
+import com.bumptech.glide.load.model.GlideUrl
+import com.bumptech.glide.load.model.Headers
+import com.bumptech.glide.load.model.LazyHeaders
+import com.bumptech.glide.request.RequestOptions
+import com.bumptech.glide.signature.ApplicationVersionSignature
+import expo.modules.image.GlideBlurhashModel
+import expo.modules.image.GlideModel
+import expo.modules.image.GlideRawModel
+import expo.modules.image.GlideThumbhashModel
+import expo.modules.image.GlideUriModel
+import expo.modules.image.GlideUrlModel
+import expo.modules.image.ResourceIdHelper
+import expo.modules.image.okhttp.GlideUrlWithCustomCacheKey
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+data class SourceMap(
+  @Field val uri: String? = null,
+  @Field val width: Int = 0,
+  @Field val height: Int = 0,
+  @Field val scale: Double = 1.0,
+  @Field val headers: Map<String, String>? = null,
+  @Field val cacheKey: String? = null
+) : Record {
+  private var parsedUri: Uri? = null
+
+  private fun isDataUrl() = parsedUri?.scheme?.startsWith("data") ?: false
+
+  private fun isContentUrl() = parsedUri?.scheme?.startsWith("content") ?: false
+
+  private fun isResourceUri() = parsedUri?.scheme?.startsWith("android.resource") ?: false
+
+  private fun isLocalResourceUri() = parsedUri?.scheme?.startsWith("res") ?: false
+
+  private fun isLocalFileUri() = parsedUri?.scheme?.startsWith("file") ?: false
+
+  private fun isSvg() = parsedUri?.toString()?.substring(parsedUri.toString().lastIndexOf('.'))?.startsWith(".svg") ?: false
+
+  fun isBlurhash() = parsedUri?.scheme?.startsWith("blurhash") ?: false
+
+  fun isThumbhash() = parsedUri?.scheme?.startsWith("thumbhash") ?: false
+
+  internal fun createGlideModel(context: Context): GlideModel? {
+    if (uri.isNullOrBlank()) {
+      return null
+    }
+
+    if (parsedUri == null) {
+      parsedUri = computeUri(context)
+    }
+
+    if (isContentUrl() || isDataUrl()) {
+      return GlideRawModel(uri)
+    }
+
+    if (isBlurhash()) {
+      return GlideBlurhashModel(
+        parsedUri!!,
+        width,
+        height
+      )
+    }
+
+    if (isThumbhash()) {
+      return GlideThumbhashModel(
+        parsedUri!!
+      )
+    }
+
+    if (isResourceUri()) {
+      return GlideUriModel(parsedUri!!)
+    }
+
+    if (isLocalResourceUri()) {
+      return GlideUriModel(
+        // Convert `res:/` scheme to `android.resource://`.
+        // Otherwise, glide can't understand the Uri.
+        Uri.parse(parsedUri!!.toString().replace("res:/", "android.resource://" + context.packageName + "/"))
+      )
+    }
+
+    if (isLocalFileUri()) {
+      return GlideRawModel(parsedUri!!.toString())
+    }
+
+    val glideUrl = if (cacheKey == null) {
+      GlideUrl(uri, getCustomHeaders())
+    } else {
+      GlideUrlWithCustomCacheKey(uri, getCustomHeaders(), cacheKey)
+    }
+    return GlideUrlModel(glideUrl)
+  }
+
+  internal fun createOptions(context: Context): RequestOptions {
+    return RequestOptions()
+      .apply {
+        if (parsedUri == null) {
+          parsedUri = computeUri(context)
+        }
+
+        // Override the size for local assets (apart from SVGs). This ensures that
+        // resizeMode "center" displays the image in the correct size.
+        if (width != 0 && height != 0 && !isSvg()) {
+          override((width * scale).toInt(), (height * scale).toInt())
+        }
+
+        if (isResourceUri()) {
+          // Every local resource (drawable) in Android has its own unique numeric id, which are
+          // generated at build time. Although these ids are unique, they are not guaranteed unique
+          // across builds. The underlying glide implementation caches these resources. To make
+          // sure the cache does not return the wrong image, we should clear the cache when the
+          // application version changes.
+          apply(
+            RequestOptions.signatureOf(ApplicationVersionSignature.obtain(context))
+          )
+        }
+      }
+  }
+
+  private fun getCustomHeaders(): Headers {
+    if (headers == null) {
+      return LazyHeaders.DEFAULT
+    }
+
+    return LazyHeaders
+      .Builder()
+      .apply {
+        headers.forEach { (key, value) ->
+          addHeader(key, value)
+        }
+      }
+      .build()
+  }
+
+  private fun computeUri(context: Context): Uri? {
+    val stringUri = uri ?: return null
+    return try {
+      val uri: Uri = Uri.parse(stringUri)
+      // Verify scheme is set, so that relative uri (used by static resources) are not handled.
+      if (uri.scheme == null) {
+        computeLocalUri(stringUri, context)
+      } else {
+        uri
+      }
+    } catch (e: Exception) {
+      computeLocalUri(stringUri, context)
+    }
+  }
+
+  private fun computeLocalUri(stringUri: String, context: Context): Uri? {
+    return ResourceIdHelper.getResourceUri(context, stringUri)
+  }
+
+  internal val pixelCount: Double
+    get() = width * height * scale * scale
+}

package/android/src/main/java/expo/modules/image/records/events.kt

@@ -0,0 +1,25 @@
+package expo.modules.image.records
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+data class ImageSource(
+  @Field val url: String,
+  @Field val width: Int,
+  @Field val height: Int,
+  @Field val mediaType: String?
+) : Record
+
+data class ImageLoadEvent(
+  @Field val cacheType: String,
+  @Field val source: ImageSource
+) : Record
+
+data class ImageProgressEvent(
+  @Field val loaded: Int,
+  @Field val total: Int
+) : Record
+
+data class ImageErrorEvent(
+  @Field val error: String
+) : Record

package/android/src/main/java/expo/modules/image/svg/SVGDecoder.kt

@@ -0,0 +1,33 @@
+package expo.modules.image.svg
+
+import com.bumptech.glide.load.Options
+import com.bumptech.glide.load.ResourceDecoder
+import com.bumptech.glide.load.engine.Resource
+import com.bumptech.glide.load.resource.SimpleResource
+import com.caverock.androidsvg.SVG
+import com.caverock.androidsvg.SVGParseException
+import java.io.IOException
+import java.io.InputStream
+
+/**
+ * Decodes an SVG internal representation from an [InputStream].
+ *
+ * Copied from https://github.com/bumptech/glide/blob/10acc31a16b4c1b5684f69e8de3117371dfa77a8/samples/svg/src/main/java/com/bumptech/glide/samples/svg/SvgDecoder.java
+ * and rewritten to Kotlin.
+ */
+class SVGDecoder : ResourceDecoder<InputStream, SVG> {
+  // TODO: Can we tell?
+  override fun handles(source: InputStream, options: Options) = true
+
+  @Throws(IOException::class)
+  override fun decode(source: InputStream, width: Int, height: Int, options: Options): Resource<SVG>? {
+    return try {
+      val svg: SVG = SVG.getFromInputStream(source)
+      svg.documentWidth = width.toFloat()
+      svg.documentHeight = height.toFloat()
+      SimpleResource(svg)
+    } catch (ex: SVGParseException) {
+      throw IOException("Cannot load SVG from stream", ex)
+    }
+  }
+}

package/android/src/main/java/expo/modules/image/svg/SVGDrawableTranscoder.kt

@@ -0,0 +1,37 @@
+package expo.modules.image.svg
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Picture
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.PictureDrawable
+import com.bumptech.glide.load.Options
+import com.bumptech.glide.load.engine.Resource
+import com.bumptech.glide.load.resource.SimpleResource
+import com.bumptech.glide.load.resource.transcode.ResourceTranscoder
+import com.caverock.androidsvg.SVG
+
+/**
+ * Convert the [SVG]'s internal representation to an Android-compatible one ([Picture]).
+ *
+ * Copied from https://github.com/bumptech/glide/blob/10acc31a16b4c1b5684f69e8de3117371dfa77a8/samples/svg/src/main/java/com/bumptech/glide/samples/svg/SvgDrawableTranscoder.java
+ * and rewritten to Kotlin.
+ */
+class SVGDrawableTranscoder(val context: Context) : ResourceTranscoder<SVG?, Drawable> {
+  override fun transcode(toTranscode: Resource<SVG?>, options: Options): Resource<Drawable> {
+    val picture = toTranscode.get().renderToPicture()
+    val drawable = PictureDrawable(picture)
+    val width = drawable.intrinsicWidth
+    val height = drawable.intrinsicHeight
+
+    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    val canvas = Canvas(bitmap)
+    drawable.setBounds(0, 0, canvas.width, canvas.height)
+    drawable.draw(canvas)
+
+    val newDrawable = BitmapDrawable(context.resources, bitmap)
+    return SimpleResource(newDrawable)
+  }
+}

package/android/src/main/java/expo/modules/image/svg/SVGModule.kt

@@ -0,0 +1,26 @@
+package expo.modules.image.svg
+
+import android.content.Context
+import android.graphics.drawable.Drawable
+import com.bumptech.glide.Glide
+import com.bumptech.glide.Registry
+import com.bumptech.glide.annotation.GlideModule
+import com.bumptech.glide.module.LibraryGlideModule
+import com.caverock.androidsvg.SVG
+import java.io.InputStream
+
+/**
+ * [LibraryGlideModule] registering support for SVG to Glide.
+ *
+ * Copied from https://github.com/bumptech/glide/blob/10acc31a16b4c1b5684f69e8de3117371dfa77a8/samples/svg/src/main/java/com/bumptech/glide/samples/svg/SvgModule.java
+ * and rewritten to Kotlin.
+ */
+@GlideModule
+class SVGModule : LibraryGlideModule() {
+  override fun registerComponents(context: Context, glide: Glide, registry: Registry) {
+    super.registerComponents(context, glide, registry)
+    registry
+      .append(InputStream::class.java, SVG::class.java, SVGDecoder())
+      .register(SVG::class.java, Drawable::class.java, SVGDrawableTranscoder(context))
+  }
+}