@mathers101/react-native-render-rich-text 0.1.10 → 0.1.14

package/android/src/main/java/com/renderrichtext/utils/text/ImageCache.kt

@@ -1,88 +1,88 @@
-package com.renderrichtext.utils.text
-
-import android.graphics.Bitmap
-import android.util.LruCache
-import java.security.MessageDigest
-
-object ImageCache {
-  private const val ORIGINAL_CACHE_SIZE = 20 * 1024 * 1024
-  private const val PROCESSED_CACHE_SIZE = 30 * 1024 * 1024
-
-  private val originalCache = bitmapLruCache(ORIGINAL_CACHE_SIZE)
-  private val processedCache = bitmapLruCache(PROCESSED_CACHE_SIZE)
-
-  /** Header names lower-cased; sorted first so case aliases collapse deterministically. */
-  fun normalizedHeaders(headers: Map<String, String>): Map<String, String> =
-    headers.entries
-      .sortedBy { it.key }
-      .associate { it.key.lowercase() to it.value }
-
-  /**
-   * Cache identity for a remote image request. Returns the URL itself when no
-   * headers are set; otherwise appends a SHA-256 digest of the sorted header
-   * pairs, so the same URL fetched with different headers is cached and
-   * deduplicated separately without embedding header values in the key.
-   * Header names are compared case-insensitively.
-   */
-  fun requestKey(
-    url: String,
-    headers: Map<String, String>,
-  ): String {
-    if (headers.isEmpty()) return url
-    val joined =
-      normalizedHeaders(headers)
-        .entries
-        .sortedBy { it.key }
-        .joinToString(separator = "\n") { "${it.key}:${it.value}" }
-    val digest = MessageDigest.getInstance("SHA-256").digest(joined.toByteArray())
-    return url + "|" + digest.joinToString(separator = "") { "%02x".format(it) }
-  }
-
-  fun getOriginal(url: String): Bitmap? = originalCache.get(url)
-
-  fun putOriginal(
-    url: String,
-    bitmap: Bitmap,
-  ) {
-    originalCache.put(url, bitmap)
-  }
-
-  fun getProcessed(
-    url: String,
-    width: Int,
-    height: Int,
-    borderRadius: Int,
-    resizeMode: String,
-  ): Bitmap? = processedCache.get(processedKey(url, width, height, borderRadius, resizeMode))
-
-  fun putProcessed(
-    url: String,
-    width: Int,
-    height: Int,
-    borderRadius: Int,
-    resizeMode: String,
-    bitmap: Bitmap,
-  ) {
-    processedCache.put(processedKey(url, width, height, borderRadius, resizeMode), bitmap)
-  }
-
-  private fun processedKey(
-    url: String,
-    width: Int,
-    height: Int,
-    borderRadius: Int,
-    resizeMode: String,
-  ): String = "${url}_w${width}_h${height}_r${borderRadius}_m$resizeMode"
-
-  // A minimum per-entry cost bounds entry count as well as decoded bytes.
-  internal fun bitmapLruCache(
-    maxSize: Int,
-    maxEntries: Int = Int.MAX_VALUE,
-  ): LruCache<String, Bitmap> =
-    object : LruCache<String, Bitmap>(maxSize) {
-      override fun sizeOf(
-        key: String,
-        value: Bitmap,
-      ): Int = value.allocationByteCount.coerceAtLeast(((maxSize.toLong() + maxEntries - 1) / maxEntries).toInt())
-    }
-}
+package com.renderrichtext.utils.text
+
+import android.graphics.Bitmap
+import android.util.LruCache
+import java.security.MessageDigest
+
+object ImageCache {
+  private const val ORIGINAL_CACHE_SIZE = 20 * 1024 * 1024
+  private const val PROCESSED_CACHE_SIZE = 30 * 1024 * 1024
+
+  private val originalCache = bitmapLruCache(ORIGINAL_CACHE_SIZE)
+  private val processedCache = bitmapLruCache(PROCESSED_CACHE_SIZE)
+
+  /** Header names lower-cased; sorted first so case aliases collapse deterministically. */
+  fun normalizedHeaders(headers: Map<String, String>): Map<String, String> =
+    headers.entries
+      .sortedBy { it.key }
+      .associate { it.key.lowercase() to it.value }
+
+  /**
+   * Cache identity for a remote image request. Returns the URL itself when no
+   * headers are set; otherwise appends a SHA-256 digest of the sorted header
+   * pairs, so the same URL fetched with different headers is cached and
+   * deduplicated separately without embedding header values in the key.
+   * Header names are compared case-insensitively.
+   */
+  fun requestKey(
+    url: String,
+    headers: Map<String, String>,
+  ): String {
+    if (headers.isEmpty()) return url
+    val joined =
+      normalizedHeaders(headers)
+        .entries
+        .sortedBy { it.key }
+        .joinToString(separator = "\n") { "${it.key}:${it.value}" }
+    val digest = MessageDigest.getInstance("SHA-256").digest(joined.toByteArray())
+    return url + "|" + digest.joinToString(separator = "") { "%02x".format(it) }
+  }
+
+  fun getOriginal(url: String): Bitmap? = originalCache.get(url)
+
+  fun putOriginal(
+    url: String,
+    bitmap: Bitmap,
+  ) {
+    originalCache.put(url, bitmap)
+  }
+
+  fun getProcessed(
+    url: String,
+    width: Int,
+    height: Int,
+    borderRadius: Int,
+    resizeMode: String,
+  ): Bitmap? = processedCache.get(processedKey(url, width, height, borderRadius, resizeMode))
+
+  fun putProcessed(
+    url: String,
+    width: Int,
+    height: Int,
+    borderRadius: Int,
+    resizeMode: String,
+    bitmap: Bitmap,
+  ) {
+    processedCache.put(processedKey(url, width, height, borderRadius, resizeMode), bitmap)
+  }
+
+  private fun processedKey(
+    url: String,
+    width: Int,
+    height: Int,
+    borderRadius: Int,
+    resizeMode: String,
+  ): String = "${url}_w${width}_h${height}_r${borderRadius}_m$resizeMode"
+
+  // A minimum per-entry cost bounds entry count as well as decoded bytes.
+  internal fun bitmapLruCache(
+    maxSize: Int,
+    maxEntries: Int = Int.MAX_VALUE,
+  ): LruCache<String, Bitmap> =
+    object : LruCache<String, Bitmap>(maxSize) {
+      override fun sizeOf(
+        key: String,
+        value: Bitmap,
+      ): Int = value.allocationByteCount.coerceAtLeast(((maxSize.toLong() + maxEntries - 1) / maxEntries).toInt())
+    }
+}

package/android/src/main/java/com/renderrichtext/utils/text/ImageDownloader.kt

@@ -1,203 +1,203 @@
-package com.renderrichtext.utils.text
-
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.os.Handler
-import android.os.Looper
-import android.util.Log
-import okhttp3.Cache
-import okhttp3.Call
-import okhttp3.Callback
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.Response
-import java.io.File
-import java.io.IOException
-import java.util.concurrent.TimeUnit
-
-object ImageDownloader {
-  private const val TAG = "ImageDownloader"
-  private const val DISK_CACHE_SIZE = 100L * 1024 * 1024
-  private const val TIMEOUT = 15L
-
-  private val mainHandler = Handler(Looper.getMainLooper())
-
-  @Volatile
-  private var client: OkHttpClient? = null
-
-  // No disk cache: it keys by URL alone and would mix header sets.
-  @Volatile
-  private var headerClient: OkHttpClient? = null
-  private var maxTargetWidth: Int = 0
-
-  private val inFlight = HashMap<String, MutableList<(Bitmap?) -> Unit>>()
-
-  private fun getClient(context: Context): OkHttpClient =
-    client ?: synchronized(this) {
-      client ?: buildClient(context).also {
-        client = it
-        maxTargetWidth = context.applicationContext.resources.displayMetrics.widthPixels
-      }
-    }
-
-  private fun getHeaderClient(context: Context): OkHttpClient =
-    headerClient ?: synchronized(this) {
-      headerClient ?: getClient(context)
-        .newBuilder()
-        .cache(null)
-        .build()
-        .also { headerClient = it }
-    }
-
-  private fun buildClient(context: Context): OkHttpClient {
-    val cacheDir = File(context.applicationContext.cacheDir, "enrm_image_cache")
-    return OkHttpClient
-      .Builder()
-      .cache(Cache(cacheDir, DISK_CACHE_SIZE))
-      .connectTimeout(TIMEOUT, TimeUnit.SECONDS)
-      .readTimeout(TIMEOUT, TimeUnit.SECONDS)
-      .build()
-  }
-
-  fun download(
-    context: Context,
-    url: String,
-    headers: Map<String, String> = emptyMap(),
-    callback: (Bitmap?) -> Unit,
-  ) {
-    val headers = ImageCache.normalizedHeaders(headers)
-    val requestKey = ImageCache.requestKey(url, headers)
-
-    ImageCache.getOriginal(requestKey)?.let {
-      callback(it)
-      return
-    }
-
-    synchronized(inFlight) {
-      val existing = inFlight[requestKey]
-      if (existing != null) {
-        existing.add(callback)
-        return
-      }
-      inFlight[requestKey] = mutableListOf(callback)
-    }
-
-    // OkHttp throws on a URL or header it cannot use; report that like any failed download.
-    val request =
-      try {
-        Request
-          .Builder()
-          .url(url)
-          .apply { headers.forEach { (name, value) -> addHeader(name, value) } }
-          .build()
-      } catch (e: IllegalArgumentException) {
-        Log.e(TAG, "Invalid image request: $url", e)
-        dispatchCallbacks(requestKey, null)
-        return
-      }
-    val client = if (headers.isEmpty()) getClient(context) else getHeaderClient(context)
-    client.newCall(request).enqueue(
-      object : Callback {
-        override fun onResponse(
-          call: Call,
-          response: Response,
-        ) {
-          val bitmap =
-            response.use {
-              try {
-                val bytes = it.body?.bytes() ?: return@use null
-                decodeDownsampled(bytes, maxTargetWidth)
-              } catch (_: OutOfMemoryError) {
-                Log.e(TAG, "OOM decoding image: $url")
-                null
-              } catch (e: Exception) {
-                Log.e(TAG, "Failed to decode image: $url", e)
-                null
-              }
-            }
-
-          bitmap?.let { ImageCache.putOriginal(requestKey, it) }
-          dispatchCallbacks(requestKey, bitmap)
-        }
-
-        override fun onFailure(
-          call: Call,
-          e: IOException,
-        ) {
-          Log.e(TAG, "Failed to download image: $url", e)
-          dispatchCallbacks(requestKey, null)
-        }
-      },
-    )
-  }
-
-  private fun decodeDownsampled(
-    bytes: ByteArray,
-    targetWidth: Int,
-    maxDimension: Int? = null,
-  ): Bitmap? {
-    val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
-    BitmapFactory.decodeByteArray(bytes, 0, bytes.size, opts)
-    return decodeWithSampleSize(opts, targetWidth, maxDimension) {
-      BitmapFactory.decodeByteArray(bytes, 0, bytes.size, it)
-    }
-  }
-
-  fun decodeBytesDownsampled(
-    context: Context,
-    bytes: ByteArray,
-    maxDimension: Int? = null,
-  ): Bitmap? = decodeDownsampled(bytes, context.resources.displayMetrics.widthPixels, maxDimension)
-
-  fun decodeFileDownsampled(
-    context: Context,
-    path: String,
-    maxDimension: Int? = null,
-  ): Bitmap? {
-    val targetWidth = context.resources.displayMetrics.widthPixels
-    val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
-    BitmapFactory.decodeFile(path, opts)
-    return decodeWithSampleSize(opts, targetWidth, maxDimension) {
-      BitmapFactory.decodeFile(path, it)
-    }
-  }
-
-  private inline fun decodeWithSampleSize(
-    opts: BitmapFactory.Options,
-    targetWidth: Int,
-    maxDimension: Int?,
-    decode: (BitmapFactory.Options) -> Bitmap?,
-  ): Bitmap? {
-    if (opts.outWidth <= 0 || opts.outHeight <= 0) return null
-    opts.inSampleSize =
-      if (maxDimension == null) {
-        calculateInSampleSize(opts.outWidth, targetWidth)
-      } else {
-        var sample = 1
-        val limit = maxDimension.coerceAtLeast(1).toLong()
-        while (maxOf(opts.outWidth, opts.outHeight).toLong() > limit * sample) sample *= 2
-        sample
-      }
-    opts.inJustDecodeBounds = false
-    return decode(opts)
-  }
-
-  private fun calculateInSampleSize(
-    srcWidth: Int,
-    reqWidth: Int,
-  ): Int {
-    if (srcWidth in 0..reqWidth) return 1
-    return Integer.highestOneBit(srcWidth / reqWidth)
-  }
-
-  private fun dispatchCallbacks(
-    requestKey: String,
-    bitmap: Bitmap?,
-  ) {
-    val callbacks = synchronized(inFlight) { inFlight.remove(requestKey) } ?: return
-    mainHandler.post {
-      callbacks.forEach { it(bitmap) }
-    }
-  }
-}
+package com.renderrichtext.utils.text
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import okhttp3.Cache
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import java.io.File
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+
+object ImageDownloader {
+  private const val TAG = "ImageDownloader"
+  private const val DISK_CACHE_SIZE = 100L * 1024 * 1024
+  private const val TIMEOUT = 15L
+
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  @Volatile
+  private var client: OkHttpClient? = null
+
+  // No disk cache: it keys by URL alone and would mix header sets.
+  @Volatile
+  private var headerClient: OkHttpClient? = null
+  private var maxTargetWidth: Int = 0
+
+  private val inFlight = HashMap<String, MutableList<(Bitmap?) -> Unit>>()
+
+  private fun getClient(context: Context): OkHttpClient =
+    client ?: synchronized(this) {
+      client ?: buildClient(context).also {
+        client = it
+        maxTargetWidth = context.applicationContext.resources.displayMetrics.widthPixels
+      }
+    }
+
+  private fun getHeaderClient(context: Context): OkHttpClient =
+    headerClient ?: synchronized(this) {
+      headerClient ?: getClient(context)
+        .newBuilder()
+        .cache(null)
+        .build()
+        .also { headerClient = it }
+    }
+
+  private fun buildClient(context: Context): OkHttpClient {
+    val cacheDir = File(context.applicationContext.cacheDir, "enrm_image_cache")
+    return OkHttpClient
+      .Builder()
+      .cache(Cache(cacheDir, DISK_CACHE_SIZE))
+      .connectTimeout(TIMEOUT, TimeUnit.SECONDS)
+      .readTimeout(TIMEOUT, TimeUnit.SECONDS)
+      .build()
+  }
+
+  fun download(
+    context: Context,
+    url: String,
+    headers: Map<String, String> = emptyMap(),
+    callback: (Bitmap?) -> Unit,
+  ) {
+    val headers = ImageCache.normalizedHeaders(headers)
+    val requestKey = ImageCache.requestKey(url, headers)
+
+    ImageCache.getOriginal(requestKey)?.let {
+      callback(it)
+      return
+    }
+
+    synchronized(inFlight) {
+      val existing = inFlight[requestKey]
+      if (existing != null) {
+        existing.add(callback)
+        return
+      }
+      inFlight[requestKey] = mutableListOf(callback)
+    }
+
+    // OkHttp throws on a URL or header it cannot use; report that like any failed download.
+    val request =
+      try {
+        Request
+          .Builder()
+          .url(url)
+          .apply { headers.forEach { (name, value) -> addHeader(name, value) } }
+          .build()
+      } catch (e: IllegalArgumentException) {
+        Log.e(TAG, "Invalid image request: $url", e)
+        dispatchCallbacks(requestKey, null)
+        return
+      }
+    val client = if (headers.isEmpty()) getClient(context) else getHeaderClient(context)
+    client.newCall(request).enqueue(
+      object : Callback {
+        override fun onResponse(
+          call: Call,
+          response: Response,
+        ) {
+          val bitmap =
+            response.use {
+              try {
+                val bytes = it.body?.bytes() ?: return@use null
+                decodeDownsampled(bytes, maxTargetWidth)
+              } catch (_: OutOfMemoryError) {
+                Log.e(TAG, "OOM decoding image: $url")
+                null
+              } catch (e: Exception) {
+                Log.e(TAG, "Failed to decode image: $url", e)
+                null
+              }
+            }
+
+          bitmap?.let { ImageCache.putOriginal(requestKey, it) }
+          dispatchCallbacks(requestKey, bitmap)
+        }
+
+        override fun onFailure(
+          call: Call,
+          e: IOException,
+        ) {
+          Log.e(TAG, "Failed to download image: $url", e)
+          dispatchCallbacks(requestKey, null)
+        }
+      },
+    )
+  }
+
+  private fun decodeDownsampled(
+    bytes: ByteArray,
+    targetWidth: Int,
+    maxDimension: Int? = null,
+  ): Bitmap? {
+    val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+    BitmapFactory.decodeByteArray(bytes, 0, bytes.size, opts)
+    return decodeWithSampleSize(opts, targetWidth, maxDimension) {
+      BitmapFactory.decodeByteArray(bytes, 0, bytes.size, it)
+    }
+  }
+
+  fun decodeBytesDownsampled(
+    context: Context,
+    bytes: ByteArray,
+    maxDimension: Int? = null,
+  ): Bitmap? = decodeDownsampled(bytes, context.resources.displayMetrics.widthPixels, maxDimension)
+
+  fun decodeFileDownsampled(
+    context: Context,
+    path: String,
+    maxDimension: Int? = null,
+  ): Bitmap? {
+    val targetWidth = context.resources.displayMetrics.widthPixels
+    val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+    BitmapFactory.decodeFile(path, opts)
+    return decodeWithSampleSize(opts, targetWidth, maxDimension) {
+      BitmapFactory.decodeFile(path, it)
+    }
+  }
+
+  private inline fun decodeWithSampleSize(
+    opts: BitmapFactory.Options,
+    targetWidth: Int,
+    maxDimension: Int?,
+    decode: (BitmapFactory.Options) -> Bitmap?,
+  ): Bitmap? {
+    if (opts.outWidth <= 0 || opts.outHeight <= 0) return null
+    opts.inSampleSize =
+      if (maxDimension == null) {
+        calculateInSampleSize(opts.outWidth, targetWidth)
+      } else {
+        var sample = 1
+        val limit = maxDimension.coerceAtLeast(1).toLong()
+        while (maxOf(opts.outWidth, opts.outHeight).toLong() > limit * sample) sample *= 2
+        sample
+      }
+    opts.inJustDecodeBounds = false
+    return decode(opts)
+  }
+
+  private fun calculateInSampleSize(
+    srcWidth: Int,
+    reqWidth: Int,
+  ): Int {
+    if (srcWidth in 0..reqWidth) return 1
+    return Integer.highestOneBit(srcWidth / reqWidth)
+  }
+
+  private fun dispatchCallbacks(
+    requestKey: String,
+    bitmap: Bitmap?,
+  ) {
+    val callbacks = synchronized(inFlight) { inFlight.remove(requestKey) } ?: return
+    mainHandler.post {
+      callbacks.forEach { it(bitmap) }
+    }
+  }
+}