@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.9

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

@@ -0,0 +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/android/src/main/java/com/renderrichtext/utils/text/ImageDownloader.kt

@@ -0,0 +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/android/src/main/java/com/renderrichtext/utils/text/LocalImageLoader.kt

@@ -0,0 +1,167 @@
+package com.renderrichtext.utils.text
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.net.Uri
+import android.util.Base64
+import android.util.Log
+import java.io.FileNotFoundException
+import java.io.InputStream
+
+/**
+ * Loads tiptap images from non-network sources (issue #377).
+ *
+ * React Native's asset system produces different URI shapes for the same
+ * `require('./img.png')` depending on environment, and none of them are plain
+ * file paths in a bundled app:
+ * - Metro dev server: `http://host:8081/assets/...` (handled by [ImageDownloader])
+ * - Release APK: a bare drawable resource name, e.g. `src_assets_logo`
+ *   (RN's `AssetSourceResolver.resourceIdentifierWithoutScale`)
+ * - Sideloaded JS bundle: `file:///.../drawable-xhdpi/src_assets_logo.png`
+ * - expo-updates embedded assets: `file:///android_res/drawable/<name>.png`
+ * - expo-asset downloads: percent-encoded `file://` paths in the cache dir
+ *
+ * Resolution mirrors RN core: `ImageSource.computeUri` treats a scheme-less
+ * source as a resource name, and `ResourceDrawableIdHelper` normalizes names
+ * by lowercasing, replacing `-` with `_`, and accepting numeric resource ids. The
+ * `android_res`/`android_asset` and drawable/raw lookups follow expo-asset's
+ * `ResourceAsset.kt`. `content://`, `asset://`, `res://` and `data:` URIs are
+ * supported for parity with RN's Fresco pipeline. All decodes are downsampled
+ * to screen width like the network path.
+ */
+object LocalImageLoader {
+  private const val TAG = "LocalImageLoader"
+  private const val ASSET_PATH_PREFIX = "/android_asset/"
+  private const val RES_PATH_PREFIX = "/android_res/"
+  private const val BASE64_MARKER = "base64,"
+
+  fun load(
+    context: Context,
+    source: String,
+    maxDimension: Int? = null,
+  ): Bitmap? =
+    try {
+      val uri = Uri.parse(source)
+      when (uri.scheme?.lowercase()) {
+        null -> {
+          if (source.startsWith('/')) {
+            ImageDownloader.decodeFileDownsampled(context, source, maxDimension)
+          } else {
+            decodeResourceByName(context, source, maxDimension)
+          }
+        }
+
+        "file" -> {
+          loadFileUri(context, uri, maxDimension)
+        }
+
+        "asset" -> {
+          decodeStream(context, maxDimension) { context.assets.open(schemelessPath(uri)) }
+        }
+
+        "content" -> {
+          decodeStream(context, maxDimension) {
+            context.contentResolver.openInputStream(uri) ?: throw FileNotFoundException(source)
+          }
+        }
+
+        "res" -> {
+          decodeResourceByName(context, schemelessPath(uri), maxDimension)
+        }
+
+        "data" -> {
+          decodeDataUri(context, source, maxDimension)
+        }
+
+        else -> {
+          Log.w(TAG, "Unsupported image URI scheme: $source")
+          null
+        }
+      }
+    } catch (_: OutOfMemoryError) {
+      Log.e(TAG, "OOM loading local image: $source")
+      null
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to load local image: $source", e)
+      null
+    }
+
+  private fun loadFileUri(
+    context: Context,
+    uri: Uri,
+    maxDimension: Int?,
+  ): Bitmap? {
+    val path = uri.path ?: return null
+    return when {
+      path.startsWith(ASSET_PATH_PREFIX) -> {
+        decodeStream(context, maxDimension) { context.assets.open(path.removePrefix(ASSET_PATH_PREFIX)) }
+      }
+
+      path.startsWith(RES_PATH_PREFIX) -> {
+        decodeAndroidRes(context, uri, maxDimension)
+      }
+
+      else -> {
+        ImageDownloader.decodeFileDownsampled(context, path, maxDimension)
+      }
+    }
+  }
+
+  /**
+   * Resolves `file:///android_res/<dir>[-qualifier]/<file>[.<ext>]` by stripping
+   * density qualifiers and the file extension, then looking the resource up by name.
+   */
+  private fun decodeAndroidRes(
+    context: Context,
+    uri: Uri,
+    maxDimension: Int?,
+  ): Bitmap? {
+    val segments = uri.pathSegments
+    if (segments.size < 3) return null
+    val directory = segments[1].substringBefore('-')
+    val name = segments[2].substringBeforeLast('.')
+    val resId = context.resources.getIdentifier(name, directory, context.packageName)
+    if (resId == 0) {
+      Log.w(TAG, "No $directory resource named: $name")
+      return null
+    }
+    return decodeStream(context, maxDimension) { context.resources.openRawResource(resId) }
+  }
+
+  private fun decodeResourceByName(
+    context: Context,
+    name: String,
+    maxDimension: Int?,
+  ): Bitmap? {
+    if (name.isEmpty()) return null
+    val normalized = name.lowercase().replace('-', '_')
+    val resId =
+      normalized.toIntOrNull()
+        ?: context.resources.getIdentifier(normalized, "drawable", context.packageName).takeIf { it != 0 }
+        ?: context.resources.getIdentifier(normalized, "raw", context.packageName)
+    if (resId == 0) {
+      Log.w(TAG, "No drawable or raw resource named: $normalized")
+      return null
+    }
+    return decodeStream(context, maxDimension) { context.resources.openRawResource(resId) }
+  }
+
+  private fun decodeDataUri(
+    context: Context,
+    source: String,
+    maxDimension: Int?,
+  ): Bitmap? {
+    val marker = source.indexOf(BASE64_MARKER)
+    if (marker == -1) return null
+    val bytes = Base64.decode(source.substring(marker + BASE64_MARKER.length), Base64.DEFAULT)
+    return ImageDownloader.decodeBytesDownsampled(context, bytes, maxDimension)
+  }
+
+  private inline fun decodeStream(
+    context: Context,
+    maxDimension: Int?,
+    open: () -> InputStream,
+  ): Bitmap? = open().use { ImageDownloader.decodeBytesDownsampled(context, it.readBytes(), maxDimension) }
+
+  private fun schemelessPath(uri: Uri): String = (uri.host.orEmpty() + uri.path.orEmpty()).trimStart('/')
+}

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

@@ -0,0 +1,84 @@
+package com.renderrichtext.utils.text
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.ValueAnimator
+import android.text.Spannable
+import android.view.animation.LinearInterpolator
+import android.widget.TextView
+import com.renderrichtext.spans.FadeInSpan
+import com.renderrichtext.utils.common.isReducedMotionEnabled
+import java.lang.ref.WeakReference
+
+class TailFadeInAnimator(
+  textView: TextView,
+) {
+  private val viewRef = WeakReference(textView)
+
+  private val activeAnimations = mutableMapOf<FadeInSpan, ValueAnimator>()
+
+  fun animate(
+    tailStart: Int,
+    tailEnd: Int,
+  ) {
+    if (tailEnd <= tailStart) return
+
+    val textView = viewRef.get() ?: return
+    val spannable = textView.text as? Spannable ?: return
+
+    if (isReducedMotionEnabled(textView.context)) return
+
+    val fadeSpan = FadeInSpan().apply { alpha = 0f }
+    spannable.setSpan(fadeSpan, tailStart, tailEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+
+    val animator =
+      ValueAnimator.ofFloat(0f, 1f).apply {
+        duration = FADE_DURATION_MS
+        interpolator = LinearInterpolator()
+
+        addUpdateListener { anim ->
+          fadeSpan.alpha = anim.animatedValue as Float
+          val tv = viewRef.get() ?: return@addUpdateListener
+          val currentSpannable = tv.text as? Spannable ?: return@addUpdateListener
+
+          val end = minOf(tailEnd, currentSpannable.length)
+          if (end > tailStart) {
+            currentSpannable.setSpan(fadeSpan, tailStart, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+          }
+          tv.invalidate()
+        }
+
+        addListener(
+          object : AnimatorListenerAdapter() {
+            override fun onAnimationEnd(animation: Animator) {
+              cleanup(fadeSpan)
+            }
+
+            override fun onAnimationCancel(animation: Animator) {
+              cleanup(fadeSpan)
+            }
+          },
+        )
+      }
+
+    activeAnimations[fadeSpan] = animator
+    animator.start()
+  }
+
+  private fun cleanup(span: FadeInSpan) {
+    activeAnimations.remove(span)
+    val spannable = viewRef.get()?.text as? Spannable ?: return
+    span.alpha = 1f
+    spannable.removeSpan(span)
+  }
+
+  fun cancelAll() {
+    val spans = activeAnimations.keys.toList()
+    spans.forEach { activeAnimations[it]?.cancel() }
+    activeAnimations.clear()
+  }
+
+  companion object {
+    private const val FADE_DURATION_MS = 150L
+  }
+}