react-native-enriched 0.2.1 → 0.4.0

package/android/src/main/java/com/swmansion/enriched/{utils → common/parser}/EnrichedParser.java

@@ -1,6 +1,5 @@
-package com.swmansion.enriched.utils;
+package com.swmansion.enriched.common.parser;
 
-import android.graphics.drawable.Drawable;
 import android.text.Editable;
 import android.text.Layout;
 import android.text.Spannable;
@@ -9,28 +8,33 @@ import android.text.Spanned;
 import android.text.TextUtils;
 import android.text.style.AlignmentSpan;
 import android.text.style.ParagraphStyle;
-
-import com.swmansion.enriched.spans.EnrichedBlockQuoteSpan;
-import com.swmansion.enriched.spans.EnrichedBoldSpan;
-import com.swmansion.enriched.spans.EnrichedCodeBlockSpan;
-import com.swmansion.enriched.spans.EnrichedH1Span;
-import com.swmansion.enriched.spans.EnrichedH2Span;
-import com.swmansion.enriched.spans.EnrichedH3Span;
-import com.swmansion.enriched.spans.EnrichedImageSpan;
-import com.swmansion.enriched.spans.EnrichedInlineCodeSpan;
-import com.swmansion.enriched.spans.EnrichedItalicSpan;
-import com.swmansion.enriched.spans.EnrichedLinkSpan;
-import com.swmansion.enriched.spans.EnrichedMentionSpan;
-import com.swmansion.enriched.spans.EnrichedOrderedListSpan;
-import com.swmansion.enriched.spans.EnrichedStrikeThroughSpan;
-import com.swmansion.enriched.spans.EnrichedUnderlineSpan;
-import com.swmansion.enriched.spans.EnrichedUnorderedListSpan;
-import com.swmansion.enriched.spans.interfaces.EnrichedBlockSpan;
-import com.swmansion.enriched.spans.interfaces.EnrichedParagraphSpan;
-import com.swmansion.enriched.spans.interfaces.EnrichedInlineSpan;
-import com.swmansion.enriched.spans.interfaces.EnrichedZeroWidthSpaceSpan;
-import com.swmansion.enriched.styles.HtmlStyle;
-
+import com.swmansion.enriched.common.EnrichedConstants;
+import com.swmansion.enriched.common.spans.EnrichedBoldSpan;
+import com.swmansion.enriched.common.spans.EnrichedCheckboxListSpan;
+import com.swmansion.enriched.common.spans.EnrichedCodeBlockSpan;
+import com.swmansion.enriched.common.spans.EnrichedH1Span;
+import com.swmansion.enriched.common.spans.EnrichedH2Span;
+import com.swmansion.enriched.common.spans.EnrichedH3Span;
+import com.swmansion.enriched.common.spans.EnrichedH4Span;
+import com.swmansion.enriched.common.spans.EnrichedH5Span;
+import com.swmansion.enriched.common.spans.EnrichedH6Span;
+import com.swmansion.enriched.common.spans.EnrichedImageSpan;
+import com.swmansion.enriched.common.spans.EnrichedInlineCodeSpan;
+import com.swmansion.enriched.common.spans.EnrichedItalicSpan;
+import com.swmansion.enriched.common.spans.EnrichedLinkSpan;
+import com.swmansion.enriched.common.spans.EnrichedMentionSpan;
+import com.swmansion.enriched.common.spans.EnrichedOrderedListSpan;
+import com.swmansion.enriched.common.spans.EnrichedStrikeThroughSpan;
+import com.swmansion.enriched.common.spans.EnrichedUnderlineSpan;
+import com.swmansion.enriched.common.spans.EnrichedUnorderedListSpan;
+import com.swmansion.enriched.common.spans.interfaces.EnrichedBlockSpan;
+import com.swmansion.enriched.common.spans.interfaces.EnrichedInlineSpan;
+import com.swmansion.enriched.common.spans.interfaces.EnrichedParagraphSpan;
+import com.swmansion.enriched.common.spans.interfaces.EnrichedZeroWidthSpaceSpan;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.HashMap;
+import java.util.Map;
 import org.ccil.cowan.tagsoup.HTMLSchema;
 import org.ccil.cowan.tagsoup.Parser;
 import org.xml.sax.Attributes;
@@ -42,50 +46,24 @@ import org.xml.sax.SAXNotRecognizedException;
 import org.xml.sax.SAXNotSupportedException;
 import org.xml.sax.XMLReader;
 
-import java.io.IOException;
-import java.io.StringReader;
-import java.util.HashMap;
-import java.util.Map;
-
 /**
  * Most of the code in this file is copied from the Android source code and adjusted to our needs.
- * For the reference see <a href="https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/java/android/text/Html.java">docs</a>
+ * For the reference see <a
+ * href="https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/java/android/text/Html.java">docs</a>
  */
 public class EnrichedParser {
-  /**
-   * Retrieves images for HTML &lt;img&gt; tags.
-   */
-  public interface ImageGetter {
-    /**
-     * This method is called when the HTML parser encounters an
-     * &lt;img&gt; tag.  The <code>source</code> argument is the
-     * string from the "src" attribute; the return value should be
-     * a Drawable representation of the image or <code>null</code>
-     * for a generic replacement image.  Make sure you call
-     * setBounds() on your Drawable if it doesn't already have
-     * its bounds set.
-     */
-    Drawable getDrawable(String source);
-  }
+  /** Retrieves images for HTML &lt;img&gt; tags. */
+  private EnrichedParser() {}
 
-  private EnrichedParser() { }
   /**
-   * Lazy initialization holder for HTML parser. This class will
-   * a) be preloaded by the zygote, or b) not loaded until absolutely
-   * necessary.
+   * Lazy initialization holder for HTML parser. This class will a) be preloaded by the zygote, or
+   * b) not loaded until absolutely necessary.
    */
   private static class HtmlParser {
     private static final HTMLSchema schema = new HTMLSchema();
   }
-  /**
-   * Returns displayable styled text from the provided HTML string. Any &lt;img&gt; tags in the
-   * HTML will use the specified ImageGetter to request a representation of the image (use null
-   * if you don't want this) and the specified TagHandler to handle unknown tags (specify null if
-   * you don't want this).
-   *
-   * <p>This uses TagSoup to handle real HTML, including all of the brokenness found in the wild.
-   */
-  public static Spanned fromHtml(String source, HtmlStyle style, ImageGetter imageGetter) {
+
+  public static <T> Spanned fromHtml(String source, T style, EnrichedSpanFactory<T> spanFactory) {
     Parser parser = new Parser();
     try {
       parser.setProperty(Parser.schemaProperty, HtmlParser.schema);
@@ -93,16 +71,19 @@ public class EnrichedParser {
       // Should not happen.
       throw new RuntimeException(e);
     }
-    HtmlToSpannedConverter converter = new HtmlToSpannedConverter(source, style, imageGetter, parser);
+    HtmlToSpannedConverter converter =
+        new HtmlToSpannedConverter(source, style, parser, spanFactory);
     return converter.convert();
   }
+
   public static String toHtml(Spanned text) {
     StringBuilder out = new StringBuilder();
     withinHtml(out, text);
     String outString = out.toString();
     // Codeblocks and blockquotes appends a newline character by default, so we have to remove it
     String normalizedCodeBlock = outString.replaceAll("</codeblock>\\n<br>", "</codeblock>");
-    String normalizedBlockQuote = normalizedCodeBlock.replaceAll("</blockquote>\\n<br>", "</blockquote>");
+    String normalizedBlockQuote =
+        normalizedCodeBlock.replaceAll("</blockquote>\\n<br>", "</blockquote>");
     return "<html>\n" + normalizedBlockQuote + "</html>";
   }
 
@@ -113,24 +94,24 @@ public class EnrichedParser {
     return "<html>\n<p></p>\n</html>";
   }
 
-  /**
-   * Returns an HTML escaped representation of the given plain text.
-   */
+  /** Returns an HTML escaped representation of the given plain text. */
   public static String escapeHtml(CharSequence text) {
     StringBuilder out = new StringBuilder();
     withinStyle(out, text, 0, text.length());
     return out.toString();
   }
+
   private static void withinHtml(StringBuilder out, Spanned text) {
     withinDiv(out, text, 0, text.length());
   }
+
   private static void withinDiv(StringBuilder out, Spanned text, int start, int end) {
     int next;
     for (int i = start; i < end; i = next) {
       next = text.nextSpanTransition(i, end, EnrichedBlockSpan.class);
       EnrichedBlockSpan[] blocks = text.getSpans(i, next, EnrichedBlockSpan.class);
       String tag = "unknown";
-      if (blocks.length > 0){
+      if (blocks.length > 0) {
         tag = blocks[0] instanceof EnrichedCodeBlockSpan ? "codeblock" : "blockquote";
       }
 
@@ -149,26 +130,38 @@ public class EnrichedParser {
       }
     }
   }
+
   private static String getBlockTag(EnrichedParagraphSpan[] spans) {
     for (EnrichedParagraphSpan span : spans) {
       if (span instanceof EnrichedUnorderedListSpan) {
         return "ul";
       } else if (span instanceof EnrichedOrderedListSpan) {
         return "ol";
+      } else if (span instanceof EnrichedCheckboxListSpan) {
+        return "ul data-type=\"checkbox\"";
       } else if (span instanceof EnrichedH1Span) {
         return "h1";
       } else if (span instanceof EnrichedH2Span) {
         return "h2";
       } else if (span instanceof EnrichedH3Span) {
         return "h3";
+      } else if (span instanceof EnrichedH4Span) {
+        return "h4";
+      } else if (span instanceof EnrichedH5Span) {
+        return "h5";
+      } else if (span instanceof EnrichedH6Span) {
+        return "h6";
       }
     }
 
     return "p";
   }
+
   private static void withinBlock(StringBuilder out, Spanned text, int start, int end) {
     boolean isInUlList = false;
     boolean isInOlList = false;
+    boolean isInCheckboxList = false;
+
     int next;
     for (int i = start; i <= end; i = next) {
       next = TextUtils.indexOf(text, '\n', i, end);
@@ -184,13 +177,19 @@ public class EnrichedParser {
           // Current paragraph is no longer a list item; close the previously opened list
           isInOlList = false;
           out.append("</ol>\n");
+        } else if (isInCheckboxList) {
+          // Current paragraph is no longer a list item; close the previously opened list
+          isInCheckboxList = false;
+          out.append("</ul>\n");
         }
         out.append("<br>\n");
       } else {
-        EnrichedParagraphSpan[] paragraphStyles = text.getSpans(i, next, EnrichedParagraphSpan.class);
+        EnrichedParagraphSpan[] paragraphStyles =
+            text.getSpans(i, next, EnrichedParagraphSpan.class);
         String tag = getBlockTag(paragraphStyles);
         boolean isUlListItem = tag.equals("ul");
         boolean isOlListItem = tag.equals("ol");
+        boolean isCheckboxListItem = tag.equals("ul data-type=\"checkbox\"");
 
         if (isInUlList && !isUlListItem) {
           // Current paragraph is no longer a list item; close the previously opened list
@@ -200,6 +199,10 @@ public class EnrichedParser {
           // Current paragraph is no longer a list item; close the previously opened list
           isInOlList = false;
           out.append("</ol>\n");
+        } else if (isInCheckboxList && !isCheckboxListItem) {
+          // Current paragraph is no longer a list item; close the previously opened list
+          isInCheckboxList = false;
+          out.append("</ul>\n");
         }
 
         if (isUlListItem && !isInUlList) {
@@ -210,14 +213,27 @@ public class EnrichedParser {
           // Current paragraph is the first item in a list
           isInOlList = true;
           out.append("<ol").append(">\n");
+        } else if (isCheckboxListItem && !isInCheckboxList) {
+          // Current paragraph is the first item in a list
+          isInCheckboxList = true;
+          out.append("<ul data-type=\"checkbox\">\n");
         }
 
-        boolean isList = isUlListItem || isOlListItem;
+        boolean isList = isUlListItem || isOlListItem || isCheckboxListItem;
         String tagType = isList ? "li" : tag;
-        out.append("<");
 
+        out.append("<");
         out.append(tagType);
 
+        if (isCheckboxListItem) {
+          EnrichedCheckboxListSpan[] checkboxSpans =
+              text.getSpans(i, next, EnrichedCheckboxListSpan.class);
+          if (checkboxSpans.length > 0) {
+            boolean isChecked = checkboxSpans[0].isChecked();
+            if (isChecked) out.append(" checked");
+          }
+        }
+
         out.append(">");
         withinParagraph(out, text, i, next);
         out.append("</");
@@ -229,11 +245,15 @@ public class EnrichedParser {
         } else if (next == end && isInOlList) {
           isInOlList = false;
           out.append("</ol>\n");
+        } else if (next == end && isInCheckboxList) {
+          isInCheckboxList = false;
+          out.append("</ul>\n");
         }
       }
       next++;
     }
   }
+
   private static void withinParagraph(StringBuilder out, Spanned text, int start, int end) {
     int next;
     for (int i = start; i < end; i = next) {
@@ -323,11 +343,11 @@ public class EnrichedParser {
       }
     }
   }
-  private static void withinStyle(StringBuilder out, CharSequence text,
-                                  int start, int end) {
+
+  private static void withinStyle(StringBuilder out, CharSequence text, int start, int end) {
     for (int i = start; i < end; i++) {
       char c = text.charAt(i);
-      if (c == '\u200B') {
+      if (c == EnrichedConstants.ZWS) {
         // Do not output zero-width space characters.
         continue;
       } else if (c == '<') {
@@ -359,22 +379,25 @@ public class EnrichedParser {
     }
   }
 }
-class HtmlToSpannedConverter implements ContentHandler {
-  private final HtmlStyle mStyle;
+
+class HtmlToSpannedConverter<T> implements ContentHandler {
+  private final EnrichedSpanFactory<T> mSpanFactory;
+  private final T mStyle;
   private final String mSource;
   private final XMLReader mReader;
   private final SpannableStringBuilder mSpannableStringBuilder;
-  private final EnrichedParser.ImageGetter mImageGetter;
   private static Integer currentOrderedListItemIndex = 0;
   private static Boolean isInOrderedList = false;
+  private static Boolean isInCheckboxList = false;
   private static Boolean isEmptyTag = false;
 
-  public HtmlToSpannedConverter(String source, HtmlStyle style, EnrichedParser.ImageGetter imageGetter, Parser parser) {
+  public HtmlToSpannedConverter(
+      String source, T style, Parser parser, EnrichedSpanFactory<T> spanFactory) {
     mStyle = style;
     mSource = source;
     mSpannableStringBuilder = new SpannableStringBuilder();
-    mImageGetter = imageGetter;
     mReader = parser;
+    mSpanFactory = spanFactory;
   }
 
   public Spanned convert() {
@@ -389,14 +412,15 @@ class HtmlToSpannedConverter implements ContentHandler {
       throw new RuntimeException(e);
     }
     // Fix flags and range for paragraph-type markup.
-    Object[] obj = mSpannableStringBuilder.getSpans(0, mSpannableStringBuilder.length(), ParagraphStyle.class);
+    Object[] obj =
+        mSpannableStringBuilder.getSpans(0, mSpannableStringBuilder.length(), ParagraphStyle.class);
     for (int i = 0; i < obj.length; i++) {
       int start = mSpannableStringBuilder.getSpanStart(obj[i]);
       int end = mSpannableStringBuilder.getSpanEnd(obj[i]);
       // If the last line of the range is blank, back off by one.
       if (end - 2 >= 0) {
-        if (mSpannableStringBuilder.charAt(end - 1) == '\n' &&
-          mSpannableStringBuilder.charAt(end - 2) == '\n') {
+        if (mSpannableStringBuilder.charAt(end - 1) == '\n'
+            && mSpannableStringBuilder.charAt(end - 2) == '\n') {
           end--;
         }
       }
@@ -404,25 +428,29 @@ class HtmlToSpannedConverter implements ContentHandler {
         mSpannableStringBuilder.removeSpan(obj[i]);
       } else {
         // TODO: verify if Spannable.SPAN_EXCLUSIVE_EXCLUSIVE does not break anything.
-        // Previously it was SPAN_PARAGRAPH. I've changed that in order to fix ranges for list items.
+        // Previously it was SPAN_PARAGRAPH. I've changed that in order to fix ranges for list
+        // items.
         mSpannableStringBuilder.setSpan(obj[i], start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
       }
     }
 
     // Assign zero-width space character to the proper spans.
-    EnrichedZeroWidthSpaceSpan[] zeroWidthSpaceSpans = mSpannableStringBuilder.getSpans(0, mSpannableStringBuilder.length(), EnrichedZeroWidthSpaceSpan.class);
+    EnrichedZeroWidthSpaceSpan[] zeroWidthSpaceSpans =
+        mSpannableStringBuilder.getSpans(
+            0, mSpannableStringBuilder.length(), EnrichedZeroWidthSpaceSpan.class);
     for (EnrichedZeroWidthSpaceSpan zeroWidthSpaceSpan : zeroWidthSpaceSpans) {
       int start = mSpannableStringBuilder.getSpanStart(zeroWidthSpaceSpan);
       int end = mSpannableStringBuilder.getSpanEnd(zeroWidthSpaceSpan);
 
-      if (mSpannableStringBuilder.charAt(start) != '\u200B') {
+      if (mSpannableStringBuilder.charAt(start) != EnrichedConstants.ZWS) {
         // Insert zero-width space character at the start if it's not already present.
-        mSpannableStringBuilder.insert(start, "\u200B");
+        mSpannableStringBuilder.insert(start, EnrichedConstants.ZWS_STRING);
         end++; // Adjust end position due to insertion.
       }
 
       mSpannableStringBuilder.removeSpan(zeroWidthSpaceSpan);
-      mSpannableStringBuilder.setSpan(zeroWidthSpaceSpan, start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+      mSpannableStringBuilder.setSpan(
+          zeroWidthSpaceSpan, start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
     }
 
     return mSpannableStringBuilder;
@@ -437,6 +465,8 @@ class HtmlToSpannedConverter implements ContentHandler {
       startBlockElement(mSpannableStringBuilder);
     } else if (tag.equalsIgnoreCase("ul")) {
       isInOrderedList = false;
+      String dataType = attributes.getValue("", "data-type");
+      isInCheckboxList = "checkbox".equals(dataType);
       startBlockElement(mSpannableStringBuilder);
     } else if (tag.equalsIgnoreCase("ol")) {
       isInOrderedList = true;
@@ -444,7 +474,7 @@ class HtmlToSpannedConverter implements ContentHandler {
       startBlockElement(mSpannableStringBuilder);
     } else if (tag.equalsIgnoreCase("li")) {
       isEmptyTag = true;
-      startLi(mSpannableStringBuilder);
+      startLi(mSpannableStringBuilder, attributes);
     } else if (tag.equalsIgnoreCase("b")) {
       start(mSpannableStringBuilder, new Bold());
     } else if (tag.equalsIgnoreCase("i")) {
@@ -469,8 +499,14 @@ class HtmlToSpannedConverter implements ContentHandler {
       startHeading(mSpannableStringBuilder, 2);
     } else if (tag.equalsIgnoreCase("h3")) {
       startHeading(mSpannableStringBuilder, 3);
+    } else if (tag.equalsIgnoreCase("h4")) {
+      startHeading(mSpannableStringBuilder, 4);
+    } else if (tag.equalsIgnoreCase("h5")) {
+      startHeading(mSpannableStringBuilder, 5);
+    } else if (tag.equalsIgnoreCase("h6")) {
+      startHeading(mSpannableStringBuilder, 6);
     } else if (tag.equalsIgnoreCase("img")) {
-      startImg(mSpannableStringBuilder, attributes, mImageGetter);
+      startImg(mSpannableStringBuilder, attributes, mSpanFactory);
     } else if (tag.equalsIgnoreCase("code")) {
       start(mSpannableStringBuilder, new Code());
     } else if (tag.equalsIgnoreCase("mention")) {
@@ -486,31 +522,40 @@ class HtmlToSpannedConverter implements ContentHandler {
     } else if (tag.equalsIgnoreCase("ul")) {
       endBlockElement(mSpannableStringBuilder);
     } else if (tag.equalsIgnoreCase("li")) {
-      endLi(mSpannableStringBuilder, mStyle);
+      endLi(mSpannableStringBuilder, mStyle, mSpanFactory);
     } else if (tag.equalsIgnoreCase("b")) {
-      end(mSpannableStringBuilder, Bold.class, new EnrichedBoldSpan(mStyle));
+      end(mSpannableStringBuilder, Bold.class, mSpanFactory.createBoldSpan(mStyle));
     } else if (tag.equalsIgnoreCase("i")) {
-      end(mSpannableStringBuilder, Italic.class, new EnrichedItalicSpan(mStyle));
+      end(mSpannableStringBuilder, Italic.class, mSpanFactory.createItalicSpan(mStyle));
     } else if (tag.equalsIgnoreCase("blockquote")) {
-      endBlockquote(mSpannableStringBuilder, mStyle);
+      endBlockquote(mSpannableStringBuilder, mStyle, mSpanFactory);
     } else if (tag.equalsIgnoreCase("codeblock")) {
-      endCodeBlock(mSpannableStringBuilder, mStyle);
+      endCodeBlock(mSpannableStringBuilder, mStyle, mSpanFactory);
     } else if (tag.equalsIgnoreCase("a")) {
-      endA(mSpannableStringBuilder, mStyle);
+      endA(mSpannableStringBuilder, mStyle, mSpanFactory);
     } else if (tag.equalsIgnoreCase("u")) {
-      end(mSpannableStringBuilder, Underline.class, new EnrichedUnderlineSpan(mStyle));
+      end(mSpannableStringBuilder, Underline.class, mSpanFactory.createUnderlineSpan(mStyle));
     } else if (tag.equalsIgnoreCase("s")) {
-      end(mSpannableStringBuilder, Strikethrough.class, new EnrichedStrikeThroughSpan(mStyle));
+      end(
+          mSpannableStringBuilder,
+          Strikethrough.class,
+          mSpanFactory.createStrikeThroughSpan(mStyle));
     } else if (tag.equalsIgnoreCase("h1")) {
-      endHeading(mSpannableStringBuilder, mStyle, 1);
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 1);
     } else if (tag.equalsIgnoreCase("h2")) {
-      endHeading(mSpannableStringBuilder, mStyle, 2);
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 2);
     } else if (tag.equalsIgnoreCase("h3")) {
-      endHeading(mSpannableStringBuilder, mStyle, 3);
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 3);
+    } else if (tag.equalsIgnoreCase("h4")) {
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 4);
+    } else if (tag.equalsIgnoreCase("h5")) {
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 5);
+    } else if (tag.equalsIgnoreCase("h6")) {
+      endHeading(mSpannableStringBuilder, mStyle, mSpanFactory, 6);
     } else if (tag.equalsIgnoreCase("code")) {
-      end(mSpannableStringBuilder, Code.class, new EnrichedInlineCodeSpan(mStyle));
+      end(mSpannableStringBuilder, Code.class, mSpanFactory.createInlineCodeSpan(mStyle));
     } else if (tag.equalsIgnoreCase("mention")) {
-      endMention(mSpannableStringBuilder, mStyle);
+      endMention(mSpannableStringBuilder, mStyle, mSpanFactory);
     }
   }
 
@@ -529,8 +574,8 @@ class HtmlToSpannedConverter implements ContentHandler {
   }
 
   private static void startBlockElement(Editable text) {
-      appendNewlines(text, 1);
-      start(text, new Newline(1));
+    appendNewlines(text, 1);
+    start(text, new Newline(1));
   }
 
   private static void endBlockElement(Editable text) {
@@ -549,26 +594,31 @@ class HtmlToSpannedConverter implements ContentHandler {
     text.append('\n');
   }
 
-  private void startLi(Editable text) {
+  private void startLi(Editable text, Attributes attributes) {
     startBlockElement(text);
 
     if (isInOrderedList) {
       currentOrderedListItemIndex++;
-      start(text, new List("ol", currentOrderedListItemIndex));
+      start(text, new List("ordered", currentOrderedListItemIndex, false));
+    } else if (isInCheckboxList) {
+      String isChecked = attributes.getValue("", "checked");
+      start(text, new List("checked", 0, "checked".equals(isChecked)));
     } else {
-      start(text, new List("ul", 0));
+      start(text, new List("unordered", 0, false));
     }
   }
 
-  private static void endLi(Editable text, HtmlStyle style) {
+  private static <T> void endLi(Editable text, T style, EnrichedSpanFactory<T> spanFactory) {
     endBlockElement(text);
 
     List l = getLast(text, List.class);
     if (l != null) {
-      if (l.mType.equals("ol")) {
-        setParagraphSpanFromMark(text, l, new EnrichedOrderedListSpan(l.mIndex, style));
+      if (l.mType.equals("ordered")) {
+        setParagraphSpanFromMark(text, l, spanFactory.createOrderedListSpan(l.mIndex, style));
+      } else if (l.mType.equals("checked")) {
+        setParagraphSpanFromMark(text, l, spanFactory.createCheckboxListSpan(l.mChecked, style));
       } else {
-        setParagraphSpanFromMark(text, l, new EnrichedUnorderedListSpan(style));
+        setParagraphSpanFromMark(text, l, spanFactory.createUnorderedListSpan(style));
       }
     }
 
@@ -580,10 +630,11 @@ class HtmlToSpannedConverter implements ContentHandler {
     start(text, new Blockquote());
   }
 
-  private static void endBlockquote(Editable text, HtmlStyle style) {
+  private static <T> void endBlockquote(
+      Editable text, T style, EnrichedSpanFactory<T> spanFactory) {
     endBlockElement(text);
     Blockquote last = getLast(text, Blockquote.class);
-    setParagraphSpanFromMark(text, last, new EnrichedBlockQuoteSpan(style));
+    setParagraphSpanFromMark(text, last, spanFactory.createBlockQuoteSpan(style));
   }
 
   private void startCodeBlock(Editable text) {
@@ -591,10 +642,10 @@ class HtmlToSpannedConverter implements ContentHandler {
     start(text, new CodeBlock());
   }
 
-  private static void endCodeBlock(Editable text, HtmlStyle style) {
+  private static <T> void endCodeBlock(Editable text, T style, EnrichedSpanFactory<T> spanFactory) {
     endBlockElement(text);
     CodeBlock last = getLast(text, CodeBlock.class);
-    setParagraphSpanFromMark(text, last, new EnrichedCodeBlockSpan(style));
+    setParagraphSpanFromMark(text, last, spanFactory.createCodeBlockSpan(style));
   }
 
   private void startHeading(Editable text, int level) {
@@ -610,26 +661,48 @@ class HtmlToSpannedConverter implements ContentHandler {
       case 3:
         start(text, new H3());
         break;
+      case 4:
+        start(text, new H4());
+        break;
+      case 5:
+        start(text, new H5());
+        break;
+      case 6:
+        start(text, new H6());
+        break;
       default:
         throw new IllegalArgumentException("Unsupported heading level: " + level);
     }
   }
 
-  private static void endHeading(Editable text, HtmlStyle style, int level) {
+  private static <T> void endHeading(
+      Editable text, T style, EnrichedSpanFactory<T> spanFactory, int level) {
     endBlockElement(text);
 
     switch (level) {
       case 1:
         H1 lastH1 = getLast(text, H1.class);
-        setParagraphSpanFromMark(text, lastH1, new EnrichedH1Span(style));
+        setParagraphSpanFromMark(text, lastH1, spanFactory.createH1Span(style));
         break;
       case 2:
         H2 lastH2 = getLast(text, H2.class);
-        setParagraphSpanFromMark(text, lastH2, new EnrichedH2Span(style));
+        setParagraphSpanFromMark(text, lastH2, spanFactory.createH2Span(style));
         break;
       case 3:
         H3 lastH3 = getLast(text, H3.class);
-        setParagraphSpanFromMark(text, lastH3, new EnrichedH3Span(style));
+        setParagraphSpanFromMark(text, lastH3, spanFactory.createH3Span(style));
+        break;
+      case 4:
+        H4 lastH4 = getLast(text, H4.class);
+        setParagraphSpanFromMark(text, lastH4, spanFactory.createH4Span(style));
+        break;
+      case 5:
+        H5 lastH5 = getLast(text, H5.class);
+        setParagraphSpanFromMark(text, lastH5, spanFactory.createH5Span(style));
+        break;
+      case 6:
+        H6 lastH6 = getLast(text, H6.class);
+        setParagraphSpanFromMark(text, lastH6, spanFactory.createH6Span(style));
         break;
       default:
         throw new IllegalArgumentException("Unsupported heading level: " + level);
@@ -667,7 +740,7 @@ class HtmlToSpannedConverter implements ContentHandler {
 
     // Block spans require at least one character to be applied.
     if (isEmptyTag) {
-      text.append("\u200B");
+      text.append(EnrichedConstants.ZWS);
       len++;
     }
 
@@ -695,15 +768,19 @@ class HtmlToSpannedConverter implements ContentHandler {
     }
   }
 
-  private static void startImg(Editable text, Attributes attributes, EnrichedParser.ImageGetter img) {
+  private static <T> void startImg(
+      Editable text, Attributes attributes, EnrichedSpanFactory<T> spanFactory) {
     String src = attributes.getValue("", "src");
     String width = attributes.getValue("", "width");
     String height = attributes.getValue("", "height");
 
     int len = text.length();
-    EnrichedImageSpan span = EnrichedImageSpan.Companion.createEnrichedImageSpan(src, Integer.parseInt(width), Integer.parseInt(height));
     text.append("");
-    text.setSpan(span, len, text.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+    text.setSpan(
+        spanFactory.createImageSpan(src, Integer.parseInt(width), Integer.parseInt(height)),
+        len,
+        text.length(),
+        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
   }
 
   private static void startA(Editable text, Attributes attributes) {
@@ -711,11 +788,11 @@ class HtmlToSpannedConverter implements ContentHandler {
     start(text, new Href(href));
   }
 
-  private void endA(Editable text, HtmlStyle style) {
+  private static <T> void endA(Editable text, T style, EnrichedSpanFactory<T> spanFactory) {
     Href h = getLast(text, Href.class);
     if (h != null) {
       if (h.mHref != null) {
-        setSpanFromMark(text, h, new EnrichedLinkSpan(h.mHref, style));
+        setSpanFromMark(text, h, spanFactory.createLinkSpan(h.mHref, style));
       }
     }
   }
@@ -736,29 +813,25 @@ class HtmlToSpannedConverter implements ContentHandler {
     start(mention, new Mention(indicator, text, attributesMap));
   }
 
-  private void endMention(Editable text, HtmlStyle style) {
+  private static <T> void endMention(Editable text, T style, EnrichedSpanFactory<T> spanFactory) {
     Mention m = getLast(text, Mention.class);
 
     if (m == null) return;
     if (m.mText == null) return;
 
-    setSpanFromMark(text, m, new EnrichedMentionSpan(m.mText, m.mIndicator, m.mAttributes, style));
+    setSpanFromMark(
+        text, m, spanFactory.createMentionSpan(m.mText, m.mIndicator, m.mAttributes, style));
   }
 
-  public void setDocumentLocator(Locator locator) {
-  }
+  public void setDocumentLocator(Locator locator) {}
 
-  public void startDocument() {
-  }
+  public void startDocument() {}
 
-  public void endDocument() {
-  }
+  public void endDocument() {}
 
-  public void startPrefixMapping(String prefix, String uri) {
-  }
+  public void startPrefixMapping(String prefix, String uri) {}
 
-  public void endPrefixMapping(String prefix) {
-  }
+  public void endPrefixMapping(String prefix) {}
 
   public void startElement(String uri, String localName, String qName, Attributes attributes) {
     handleStartTag(localName, attributes);
@@ -801,52 +874,47 @@ class HtmlToSpannedConverter implements ContentHandler {
     mSpannableStringBuilder.append(sb);
   }
 
-  public void ignorableWhitespace(char[] ch, int start, int length) {
-  }
+  public void ignorableWhitespace(char[] ch, int start, int length) {}
 
-  public void processingInstruction(String target, String data) {
-  }
+  public void processingInstruction(String target, String data) {}
 
-  public void skippedEntity(String name) {
-  }
+  public void skippedEntity(String name) {}
 
-  private static class H1 {
-  }
+  private static class H1 {}
 
-  private static class H2 {
-  }
+  private static class H2 {}
 
-  private static class H3 {
-  }
+  private static class H3 {}
 
-  private static class Bold {
-  }
+  private static class H4 {}
 
-  private static class Italic {
-  }
+  private static class H5 {}
 
-  private static class Underline {
-  }
+  private static class H6 {}
 
-  private static class Code {
-  }
+  private static class Bold {}
 
-  private static class CodeBlock {
-  }
+  private static class Italic {}
 
-  private static class Strikethrough {
-  }
+  private static class Underline {}
 
-  private static class Blockquote {
-  }
+  private static class Code {}
+
+  private static class CodeBlock {}
+
+  private static class Strikethrough {}
+
+  private static class Blockquote {}
 
   private static class List {
     public int mIndex;
     public String mType;
+    public boolean mChecked;
 
-    public List(String type, int index) {
+    public List(String type, int index, boolean checked) {
       mType = type;
       mIndex = index;
+      mChecked = checked;
     }
   }