react-native-enriched 0.1.6 → 0.2.1

package/android/src/main/java/com/swmansion/enriched/spans/EnrichedImageSpan.kt

@@ -1,24 +1,35 @@
 package com.swmansion.enriched.spans
 
-import android.content.Context
+import android.annotation.SuppressLint
+import android.content.res.Resources
+import android.graphics.BitmapFactory
 import android.graphics.Canvas
 import android.graphics.Paint
+import android.graphics.drawable.BitmapDrawable
 import android.graphics.drawable.Drawable
-import android.net.Uri
+import android.text.Editable
+import android.text.Spannable
 import android.text.style.ImageSpan
+import android.util.Log
+import androidx.core.graphics.drawable.DrawableCompat
 import androidx.core.graphics.withSave
 import com.swmansion.enriched.spans.interfaces.EnrichedInlineSpan
+import com.swmansion.enriched.utils.AsyncDrawable
+import androidx.core.graphics.drawable.toDrawable
+import com.swmansion.enriched.R
+import com.swmansion.enriched.spans.utils.ForceRedrawSpan
 import com.swmansion.enriched.styles.HtmlStyle
+import com.swmansion.enriched.utils.ResourceManager
 
 class EnrichedImageSpan : ImageSpan, EnrichedInlineSpan {
-  private var htmlStyle: HtmlStyle? = null
+  override val dependsOnHtmlStyle: Boolean = false
 
-  constructor(context: Context, uri: Uri, htmlStyle: HtmlStyle, ) : super(context, uri, ALIGN_BASELINE) {
-    this.htmlStyle = htmlStyle
-  }
+  private var width: Int = 0
+  private var height: Int = 0
 
-  constructor(drawable: Drawable, source: String, htmlStyle: HtmlStyle) : super(drawable, source, ALIGN_BASELINE) {
-    this.htmlStyle = htmlStyle
+  constructor(drawable: Drawable, source: String, width: Int, height: Int) : super(drawable, source, ALIGN_BASELINE) {
+    this.width = width
+    this.height = height
   }
 
   override fun draw(
@@ -35,7 +46,122 @@ class EnrichedImageSpan : ImageSpan, EnrichedInlineSpan {
 
   override fun getDrawable(): Drawable {
     val drawable = super.getDrawable()
-    drawable.setBounds(0, 0, htmlStyle!!.imgWidth, htmlStyle!!.imgHeight)
+    val scale = Resources.getSystem().displayMetrics.density
+
+    drawable.setBounds(0, 0, (width * scale).toInt() , (height * scale).toInt())
     return drawable
   }
+
+  override fun getSize(
+    paint: Paint,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    fm: Paint.FontMetricsInt?
+  ): Int {
+    val d = drawable
+    val rect = d.bounds
+
+    if (fm != null) {
+      val imageHeight = rect.bottom - rect.top
+
+      // We want the image bottom to sit on the baseline (0).
+      // Therefore, the image top will be at: -imageHeight.
+      val targetTop = -imageHeight
+
+      // Expand the line UPWARDS if the image is taller than the current font
+      if (targetTop < fm.ascent) {
+        fm.ascent = targetTop
+        fm.top = targetTop
+      }
+    }
+
+    return rect.right
+  }
+
+  private fun registerDrawableLoadCallback (d: AsyncDrawable, text: Editable?) {
+    d.onLoaded = onLoaded@{
+      val spannable = text as? Spannable
+
+      if (spannable == null) {
+        return@onLoaded
+      }
+
+      val start = spannable.getSpanStart(this@EnrichedImageSpan)
+      val end = spannable.getSpanEnd(this@EnrichedImageSpan)
+
+      if (start != -1 && end != -1) {
+        // trick for adding empty span to force redraw when image is loaded
+        val redrawSpan = ForceRedrawSpan()
+        spannable.setSpan(redrawSpan, start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+        spannable.removeSpan(redrawSpan)
+      }
+    }
+  }
+
+  fun observeAsyncDrawableLoaded(text: Editable?) {
+    val d = drawable
+
+    if (d !is AsyncDrawable) {
+      return
+    }
+
+    registerDrawableLoadCallback(d, text)
+
+    // If it's already loaded (race condition), run logic immediately
+    if (d.isLoaded) {
+      d.onLoaded?.invoke()
+    }
+  }
+
+  fun getWidth(): Int {
+    return width
+  }
+
+  fun getHeight(): Int {
+    return height
+  }
+
+  override fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedImageSpan = this
+
+  companion object {
+    fun createEnrichedImageSpan(src: String, width: Int, height: Int): EnrichedImageSpan {
+      var imgDrawable = prepareDrawableForImage(src)
+
+      if (imgDrawable == null) {
+        imgDrawable = ResourceManager.getDrawableResource(R.drawable.broken_image)
+      }
+
+      return EnrichedImageSpan(imgDrawable, src, width, height)
+    }
+
+    private fun prepareDrawableForImage(src: String): Drawable? {
+      var cleanPath = src
+
+      if (cleanPath.startsWith("http://") || cleanPath.startsWith("https://")) {
+        return AsyncDrawable(cleanPath)
+      }
+
+      if (cleanPath.startsWith("file://")) {
+        cleanPath = cleanPath.substring(7)
+      }
+
+      var drawable: BitmapDrawable? = null
+
+      try {
+        val bitmap = BitmapFactory.decodeFile(cleanPath)
+        if (bitmap != null) {
+          drawable = bitmap.toDrawable(Resources.getSystem())
+          // set bounds so it knows how big it is naturally,
+          // though EnrichedImageSpan will override this with the HTML width/height later.
+          drawable.setBounds(0, 0, bitmap.getWidth(), bitmap.getHeight())
+        }
+      } catch (e: Exception) {
+        // Failed to load file
+        Log.e("EnrichedImageSpan", "Failed to load image from path: $cleanPath", e)
+      }
+
+      return drawable
+    }
+  }
 }

package/android/src/main/java/com/swmansion/enriched/spans/EnrichedInlineCodeSpan.kt

@@ -7,6 +7,8 @@ import com.swmansion.enriched.spans.interfaces.EnrichedInlineSpan
 import com.swmansion.enriched.styles.HtmlStyle
 
 class EnrichedInlineCodeSpan(private val htmlStyle: HtmlStyle) : MetricAffectingSpan(), EnrichedInlineSpan {
+  override val dependsOnHtmlStyle: Boolean = true
+
   override fun updateDrawState(textPaint: TextPaint) {
     val typeface = Typeface.create(Typeface.MONOSPACE, Typeface.NORMAL)
     textPaint.typeface = typeface
@@ -18,4 +20,8 @@ class EnrichedInlineCodeSpan(private val htmlStyle: HtmlStyle) : MetricAffecting
     val typeface = Typeface.create(Typeface.MONOSPACE, Typeface.NORMAL)
     textPaint.typeface = typeface
   }
+
+  override fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedInlineCodeSpan {
+    return EnrichedInlineCodeSpan(htmlStyle)
+  }
 }

package/android/src/main/java/com/swmansion/enriched/spans/EnrichedItalicSpan.kt

@@ -7,4 +7,9 @@ import com.swmansion.enriched.styles.HtmlStyle
 
 @Suppress("UNUSED_PARAMETER")
 class EnrichedItalicSpan(private val htmlStyle: HtmlStyle) : StyleSpan(Typeface.ITALIC), EnrichedInlineSpan {
+  override val dependsOnHtmlStyle: Boolean = false
+
+  override fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedItalicSpan {
+    return EnrichedItalicSpan(htmlStyle)
+  }
 }

package/android/src/main/java/com/swmansion/enriched/spans/EnrichedLinkSpan.kt

@@ -7,6 +7,8 @@ import com.swmansion.enriched.spans.interfaces.EnrichedInlineSpan
 import com.swmansion.enriched.styles.HtmlStyle
 
 class EnrichedLinkSpan(private val url: String, private val htmlStyle: HtmlStyle) : ClickableSpan(), EnrichedInlineSpan {
+  override val dependsOnHtmlStyle: Boolean = true
+
   override fun onClick(view: View) {
     // Do nothing, links inside the input are not clickable.
     // We are using `ClickableSpan` to allow the text to be styled as a link.
@@ -21,4 +23,8 @@ class EnrichedLinkSpan(private val url: String, private val htmlStyle: HtmlStyle
   fun getUrl(): String {
     return url
   }
+
+  override fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedLinkSpan {
+    return EnrichedLinkSpan(url, htmlStyle)
+  }
 }

package/android/src/main/java/com/swmansion/enriched/spans/EnrichedMentionSpan.kt

@@ -8,6 +8,8 @@ import com.swmansion.enriched.styles.HtmlStyle
 
 class EnrichedMentionSpan(private val text: String, private val indicator: String, private val attributes: Map<String, String>, private val htmlStyle: HtmlStyle) :
   ClickableSpan(), EnrichedInlineSpan {
+  override val dependsOnHtmlStyle: Boolean = true
+
   override fun onClick(view: View) {
     // Do nothing. Mentions inside the input are not clickable.
     // We are using `ClickableSpan` to allow the text to be styled as a clickable element.
@@ -33,4 +35,8 @@ class EnrichedMentionSpan(private val text: String, private val indicator: Strin
   fun getIndicator(): String {
     return indicator
   }
+
+  override fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedMentionSpan {
+    return EnrichedMentionSpan(text, indicator, attributes, htmlStyle)
+  }
 }

package/android/src/main/java/com/swmansion/enriched/spans/EnrichedOrderedListSpan.kt

@@ -11,6 +11,8 @@ import com.swmansion.enriched.spans.interfaces.EnrichedParagraphSpan
 import com.swmansion.enriched.styles.HtmlStyle
 
 class EnrichedOrderedListSpan(private var index: Int, private val htmlStyle: HtmlStyle) : MetricAffectingSpan(), LeadingMarginSpan, EnrichedParagraphSpan {
+  override val dependsOnHtmlStyle: Boolean = true
+
   override fun updateMeasureState(p0: TextPaint) {
     // Do nothing, but inform layout that this span affects text metrics
   }
@@ -78,4 +80,8 @@ class EnrichedOrderedListSpan(private var index: Int, private val htmlStyle: Htm
   fun setIndex(i: Int) {
     index = i
   }
+
+  override fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedOrderedListSpan {
+    return EnrichedOrderedListSpan(index, htmlStyle)
+  }
 }

package/android/src/main/java/com/swmansion/enriched/spans/EnrichedSpans.kt

@@ -2,9 +2,13 @@ package com.swmansion.enriched.spans
 
 import com.swmansion.enriched.styles.HtmlStyle
 
-data class BaseSpanConfig(val clazz: Class<*>)
-data class ParagraphSpanConfig(val clazz: Class<*>, val isContinuous: Boolean)
-data class ListSpanConfig(val clazz: Class<*>, val shortcut: String)
+interface ISpanConfig {
+  val clazz: Class<*>
+}
+
+data class BaseSpanConfig(override  val clazz: Class<*>): ISpanConfig
+data class ParagraphSpanConfig(override  val clazz: Class<*>, val isContinuous: Boolean): ISpanConfig
+data class ListSpanConfig(override val clazz: Class<*>, val shortcut: String) : ISpanConfig
 
 data class StylesMergingConfig(
   // styles that should be removed when we apply specific style
@@ -64,6 +68,8 @@ object EnrichedSpans {
     MENTION to BaseSpanConfig(EnrichedMentionSpan::class.java),
   )
 
+  val allSpans: Map<String, ISpanConfig> = inlineSpans + paragraphSpans + listSpans + parametrizedStyles
+
   fun getMergingConfigForStyle(style: String, htmlStyle: HtmlStyle): StylesMergingConfig? {
     return when (style) {
       BOLD -> {
@@ -123,4 +129,8 @@ object EnrichedSpans {
       else -> null
     }
   }
+
+  fun isTypeContinuous(type: Class<*>): Boolean {
+    return paragraphSpans.values.find { it.clazz == type }?.isContinuous == true
+  }
 }

package/android/src/main/java/com/swmansion/enriched/spans/EnrichedStrikeThroughSpan.kt

@@ -6,4 +6,9 @@ import com.swmansion.enriched.styles.HtmlStyle
 
 @Suppress("UNUSED_PARAMETER")
 class EnrichedStrikeThroughSpan(private val htmlStyle: HtmlStyle) : StrikethroughSpan(), EnrichedInlineSpan {
+  override val dependsOnHtmlStyle: Boolean = false
+
+  override fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedStrikeThroughSpan {
+    return EnrichedStrikeThroughSpan(htmlStyle)
+  }
 }

package/android/src/main/java/com/swmansion/enriched/spans/EnrichedUnderlineSpan.kt

@@ -6,4 +6,9 @@ import com.swmansion.enriched.styles.HtmlStyle
 
 @Suppress("UNUSED_PARAMETER")
 class EnrichedUnderlineSpan(private val htmlStyle: HtmlStyle) : UnderlineSpan(), EnrichedInlineSpan {
+  override val dependsOnHtmlStyle: Boolean = false
+
+  override fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedUnderlineSpan {
+    return EnrichedUnderlineSpan(htmlStyle)
+  }
 }

package/android/src/main/java/com/swmansion/enriched/spans/EnrichedUnorderedListSpan.kt

@@ -12,6 +12,8 @@ import com.swmansion.enriched.styles.HtmlStyle
 
 // https://android.googlesource.com/platform/frameworks/base/+/refs/heads/main/core/java/android/text/style/BulletSpan.java
 class EnrichedUnorderedListSpan(private val htmlStyle: HtmlStyle) : MetricAffectingSpan(), LeadingMarginSpan, EnrichedParagraphSpan {
+  override val dependsOnHtmlStyle: Boolean = true
+
   override fun updateMeasureState(p0: TextPaint) {
     // Do nothing, but inform layout that this span affects text metrics
   }
@@ -56,4 +58,8 @@ class EnrichedUnorderedListSpan(private val htmlStyle: HtmlStyle) : MetricAffect
       paint.style = style
     }
   }
+
+  override fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedUnorderedListSpan {
+    return EnrichedUnorderedListSpan(htmlStyle)
+  }
 }

package/android/src/main/java/com/swmansion/enriched/spans/interfaces/EnrichedSpan.kt

@@ -1,4 +1,8 @@
 package com.swmansion.enriched.spans.interfaces
 
+import com.swmansion.enriched.styles.HtmlStyle
+
 interface EnrichedSpan {
+  val dependsOnHtmlStyle: Boolean
+  fun rebuildWithStyle(htmlStyle: HtmlStyle): EnrichedSpan
 }

package/android/src/main/java/com/swmansion/enriched/spans/utils/ForceRedrawSpan.kt

@@ -0,0 +1,13 @@
+package com.swmansion.enriched.spans.utils
+
+import android.text.TextPaint
+import android.text.style.MetricAffectingSpan
+
+class ForceRedrawSpan:  MetricAffectingSpan() {
+  override fun updateMeasureState(tp: TextPaint) {
+    // Do nothing, we don't actually want to change how it looks
+  }
+  override fun updateDrawState(tp: TextPaint?) {
+    // Do nothing
+  }
+}

package/android/src/main/java/com/swmansion/enriched/styles/HtmlStyle.kt

@@ -43,9 +43,6 @@ class HtmlStyle {
   var ulBulletSize: Int = 8
   var ulBulletColor: Int = Color.BLACK
 
-  var imgWidth: Int = 200
-  var imgHeight: Int = 200
-
   var aColor: Int = Color.BLACK
   var aUnderline: Boolean = true
 
@@ -100,10 +97,6 @@ class HtmlStyle {
     ulMarginLeft = parseFloat(ulStyle, "marginLeft").toInt()
     ulBulletSize = parseFloat(ulStyle, "bulletSize").toInt()
 
-    val imgStyle = style.getMap("img")
-    imgWidth = parseFloat(imgStyle, "width").toInt()
-    imgHeight = parseFloat(imgStyle, "height").toInt()
-
     val aStyle = style.getMap("a")
     aColor = parseColor(aStyle, "color")
     aUnderline = parseIsUnderline(aStyle)
@@ -124,8 +117,8 @@ class HtmlStyle {
   private fun parseFloat(map: ReadableMap?, key: String): Float {
     val safeMap = ensureValueIsSet(map, key)
 
-    val fontSize = safeMap.getDouble(key)
-    return ceil(PixelUtil.toPixelFromSP(fontSize))
+    val value = safeMap.getDouble(key)
+    return ceil(PixelUtil.toPixelFromSP(value))
   }
 
   private fun parseColorWithOpacity(map: ReadableMap?, key: String, opacity: Int): Int {
@@ -219,6 +212,84 @@ class HtmlStyle {
     return parseFontWeight(fontWeight)
   }
 
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is HtmlStyle) return false
+
+    return h1FontSize == other.h1FontSize &&
+      h1Bold == other.h1Bold &&
+      h2FontSize == other.h2FontSize &&
+      h2Bold == other.h2Bold &&
+      h3FontSize == other.h3FontSize &&
+      h3Bold == other.h3Bold &&
+
+      blockquoteColor == other.blockquoteColor &&
+      blockquoteBorderColor == other.blockquoteBorderColor &&
+      blockquoteStripeWidth == other.blockquoteStripeWidth &&
+      blockquoteGapWidth == other.blockquoteGapWidth &&
+
+      olGapWidth == other.olGapWidth &&
+      olMarginLeft == other.olMarginLeft &&
+      olMarkerFontWeight == other.olMarkerFontWeight &&
+      olMarkerColor == other.olMarkerColor &&
+
+      ulGapWidth == other.ulGapWidth &&
+      ulMarginLeft == other.ulMarginLeft &&
+      ulBulletSize == other.ulBulletSize &&
+      ulBulletColor == other.ulBulletColor &&
+
+      aColor == other.aColor &&
+      aUnderline == other.aUnderline &&
+
+      codeBlockColor == other.codeBlockColor &&
+      codeBlockBackgroundColor == other.codeBlockBackgroundColor &&
+      codeBlockRadius == other.codeBlockRadius &&
+
+      inlineCodeColor == other.inlineCodeColor &&
+      inlineCodeBackgroundColor == other.inlineCodeBackgroundColor &&
+
+      mentionsStyle == other.mentionsStyle
+  }
+
+
+  override fun hashCode(): Int {
+    var result = h1FontSize.hashCode()
+    result = 31 * result + h1Bold.hashCode()
+    result = 31 * result + h2FontSize.hashCode()
+    result = 31 * result + h2Bold.hashCode()
+    result = 31 * result + h3FontSize.hashCode()
+    result = 31 * result + h3Bold.hashCode()
+
+    result = 31 * result + (blockquoteColor ?: 0)
+    result = 31 * result + blockquoteBorderColor.hashCode()
+    result = 31 * result + blockquoteStripeWidth.hashCode()
+    result = 31 * result + blockquoteGapWidth.hashCode()
+
+    result = 31 * result + olGapWidth.hashCode()
+    result = 31 * result + olMarginLeft.hashCode()
+    result = 31 * result + (olMarkerFontWeight?.hashCode() ?: 0)
+    result = 31 * result + (olMarkerColor ?: 0)
+
+    result = 31 * result + ulGapWidth.hashCode()
+    result = 31 * result + ulMarginLeft.hashCode()
+    result = 31 * result + ulBulletSize.hashCode()
+    result = 31 * result + ulBulletColor.hashCode()
+
+    result = 31 * result + aColor.hashCode()
+    result = 31 * result + aUnderline.hashCode()
+
+    result = 31 * result + codeBlockColor.hashCode()
+    result = 31 * result + codeBlockBackgroundColor.hashCode()
+    result = 31 * result + codeBlockRadius.hashCode()
+
+    result = 31 * result + inlineCodeColor.hashCode()
+    result = 31 * result + inlineCodeBackgroundColor.hashCode()
+
+    result = 31 * result + mentionsStyle.hashCode()
+
+    return result
+  }
+
   companion object {
     data class MentionStyle(
       val color: Int,

package/android/src/main/java/com/swmansion/enriched/styles/InlineStyles.kt

@@ -54,6 +54,7 @@ class InlineStyles(private val view: EnrichedTextInputView) {
       val spanEnd = spannable.getSpanEnd(span)
       var finalStart: Int? = null
       var finalEnd: Int? = null
+      if (spanStart == -1 || spanEnd == -1) continue
 
       spannable.removeSpan(span)