#前言
我们在Android的日常开发中经常会用到TextView，而在TextView的使用中有可能需要像下面这样使用。
上面只用了一个TextView就可以实现，有人可能会想到使用Html.fromHtml("...")实现，但是Android原生的font标签是不支持size属性的。我们来看下源码，看下font标签到底支持哪些属性：
//摘抄自Android API源码(Html类)
private void startFont(Editable text, Attributes attributes) {
String color = attributes.getValue("", "color");
String face = attributes.getValue("", "face");
if (!TextUtils.isEmpty(color)) {
int c = getHtmlColor(color);
if (c != -1) {
start(text, new Foreground(c | 0xFF000000));
}
}
if (!TextUtils.isEmpty(face)) {
start(text, new Font(face));
}
}
可以看到原生只支持color和face两个属性。如果你需要它支持下划线、加粗、以及字体大小等属性是不可能。如果你需要font标签支持这些属性就只能通过自定标签的方式实现了。我们可以看到startFont方法是被private void handleStartTag(String tag, Attributes attributes)方法调用的，如下：
private void handleStartTag(String tag, Attributes attributes) {
//省略N行代码
if (tag.equalsIgnoreCase("font")) {
startFont(mSpannableStringBuilder, attributes);
} else if (mTagHandler != null) {
mTagHandler.handleTag(true, tag, mSpannableStringBuilder, mReader);
}
}
可以看到，如果我们的文本中有什么标签没有被Html类处理的话最终会调用mTagHandler.handleTag(true, tag, mSpannableStringBuilder, mReader);这段代码。而mTagHandler是可以在调用fromHtml方法是传入的，源码如下：
/**
* Returns displayable styled text from the provided HTML string with the legacy flags
* {@link #FROM_HTML_MODE_LEGACY}.
*
* @deprecated use {@link #fromHtml(String, int, ImageGetter, TagHandler)} instead.
*/
@Deprecated
public static Spanned fromHtml(String source, ImageGetter imageGetter, TagHandler tagHandler) {
return fromHtml(source, FROM_HTML_MODE_LEGACY, imageGetter, tagHandler);
}
/**
* Returns displayable styled text from the provided HTML string. Any <img> 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, int flags, ImageGetter imageGetter,
TagHandler tagHandler) {
Parser parser = new Parser();
try {
parser.setProperty(Parser.schemaProperty, HtmlParser.schema);
} catch (org.xml.sax.SAXNotRecognizedException e) {
// Should not happen.
throw new RuntimeException(e);
} catch (org.xml.sax.SAXNotSupportedException e) {
// Should not happen.
throw new RuntimeException(e);
}
HtmlToSpannedConverter converter =
new HtmlToSpannedConverter(source, imageGetter, tagHandler, parser, flags);
return converter.convert();
}
上面的方法在API24之后就淘汰了，所以API24之后要用下面的，API24之前要用上面的。每个参数的意义就不详细介绍了(不是本文重点)，主要来看下TagHandler这个接口。他只有一个抽象法方法handleTag，如下：
public static interface TagHandler {
public void handleTag(boolean opening, String tag,Editable output, XMLReader xmlReader);
}
#####参数说明：
opening：从Html的源码中可以看出，处理标签开始时该参数为true,处理结束时该参数为false。例如<font>Holle</font>当读取到<font>时为开始，当读取到</font>时为结束。
tag：标签名字，例如<font>Holle</font>中font就是tag参数的值。
output：已经被处理到的你的文本源。
xmlReader：封装了所有tag标签的参数，如<font color=#000000>Holle</font>中color的值就从这个参数中读取。但不幸的是我们并不能直接从xmlReader读取我们的自定义参数，这里需要用到反射。核心代码如下：
####Kotlin
/**
* 利用反射获取html标签的属性值。使用该方法获取自定义属性等号后面的值。
*
* @param xmlReader XMLReader对象。
* @param property 你的自定义属性，例如color。
*/
@Suppress("UNCHECKED_CAST")
private fun getProperty(xmlReader: XMLReader, property: String): String? {
try {
val elementField = xmlReader.javaClass.getDeclaredField("theNewElement")
elementField.isAccessible = true
val element: Any = elementField.get(xmlReader)
val attsField = element.javaClass.getDeclaredField("theAtts")
attsField.isAccessible = true
val atts: Any = attsField.get(element)
val dataField = atts.javaClass.getDeclaredField("data")
dataField.isAccessible = true
val data = dataField.get(atts) as Array<String>
val lengthField = atts.javaClass.getDeclaredField("length")
lengthField.isAccessible = true
val len = lengthField.getInt(atts)
for (i in 0 until len) {
// 判断属性名
if (property == data[i * 5 + 1]) {
return data[i * 5 + 4]
}
}
} catch (e: Exception) {
e.printStackTrace()
}
return null
}
好，既然参数都明白了那么就开始来实现吧。首先我们来定义一个CustomTagHandler并重写他的抽象方法handleTag,然后根据opening参数判断当前是处理tag标签的开始还是结束。代码如下：
override fun handleTag(opening: Boolean, tag: String, output: Editable, xmlReader: XMLReader) {
if (opening) {
handlerStartTAG(tag, output, xmlReader)
} else {
handlerEndTAG(tag, output)
}
}
在上面的代码中我们根据opening参数判断当前是处理tag标签的开始还是结束，如果是开始就调用handlerStartTAG否者则调用handlerEndTAG方法。
下面在来看下这个两个方法的实现：
private fun handlerStartTAG(tag: String, output: Editable, xmlReader: XMLReader) {
if (tag.equals("kFont", ignoreCase = true)) {
handlerKFontStart(output, xmlReader)
}
}
private fun handlerEndTAG(tag: String, output: Editable) {
if (tag.equals("kFont", ignoreCase = true)) {
handlerKFontEnd(output)
}
}
这两个方法的主要作用是区分我们的自定义标签，只要我们能识别的标签我们才去处理。这里在检测到是我们自定义的标签后分别调用了handlerKFontStart和handlerKFontEnd方法(其实这里你可以将你的自定义标签封装成类，然后所有的处理都在你自己的类中处理，这样的话方便以后的扩展。我们现在是demo，demo还是简单点儿好。)，handlerKFontStart主要是记录我们标签开始的位置，以及获取我们所有的参数的值，例如我们的标签只有一个size属性和一个clickable属性。代码如下：
private fun handlerKFontStart(output: Editable, xmlReader: XMLReader) {
val index = output.length
val tagInfo = TagInfo(index)
val clickable = getProperty(xmlReader, "clickable")
if (!clickable.isNullOrEmpty()) {
tagInfo.clickable = clickable
}
val size = getProperty(xmlReader, "size")
if (!size.isNullOrEmpty()) {
tagInfo.size = when {
size.endsWith("sp", true) -> Integer.parseInt(size.replace("sp", "", true))
size.endsWith("px", true) -> {
tagInfo.hasUnderline = false
Integer.parseInt(size.replace("px", "", true))
}
else -> try {
Integer.parseInt(size)
} catch (e: Exception) {
20
}
}
}
currentTagInfo = tagInfo
}
这里我们主要是定义一个实体类TagInfo用来记录我们自定义tag的各个属性以及所在位置。获取参数值的getProperty方法刚刚都已经贴出来了，直接使用即可。接下来就是处理标签结束的时候(handlerKFontEnd方法)，具体代码如下：
private fun handlerKFontEnd(output: Editable) {
val tagInfo = currentTagInfo
if (tagInfo != null) {
val size = tagInfo.size
val clickable = tagInfo.clickable
val end = output.length
if (!clickable.isNullOrEmpty()) {
output.setSpan(KFontClickableSpan(clickable), tagInfo.startIndex, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
}
if (size > 0) {
output.setSpan(
AbsoluteSizeSpan(size, tagInfo.sizeDip),
tagInfo.startIndex,
end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
)
}
}
}
这个方法中主要就是获取我们记录下来的TagInfo然后根据这个属性设置自己的Span,这里只列举了两个简单的Span，有关更详细的SpannableString的用法请参考这篇博客。
一切完成之后在调用Html.fromHtml()方法的时候传入我们的CustomTagHandler就可以了，代码如下：
val source = "<kFont color=#F0F000 size=34>我</kFont>是一个<kFont color=#00FF00 size=14>小小小</kFont>鸟"
tvText.text = Html.fromHtml(source, null, CustomTagHandler())
好了，到这里基本就算结束了，下面是我封装的一个工具类，上面的代码都是摘抄自这个工具类，你可以直接把这个类拿去用(请叫我雷锋，哈哈)。
class KFontHandler private constructor(private var onTextClickListener: ((flag: String) -> Unit)? = null) :
Html.TagHandler {
companion object {
private const val TAG_K_FONT = "kFont"
/**
* 格式化html文本。
* @param source 要格式化的html文本，除了支持Google原生支持的标签外，还支持kFont标签。
* @param textClickListener 如果你给kFont标签添加了clickable属性则可以通过该参数设置点击监听，监听中的flag参数为clickable等号后面的内容，例如
* 你kFont标签中clickable属性的为`clickable=A`，那么flag的值就为A。如果你没有使用clickable属性则该参数可以不传。
*
* @return 返回格式化后的文本(CharSequence类型)。
*/
fun format(source: String, textClickListener: ((flag: String) -> Unit)? = null): CharSequence {
return htmlFrom(source.replace("\n", "<br/>", true), textClickListener)
}
/**
* 格式化html文本。
* @param context 上下文参数，用来读取资源文件中的文本。
* @param resId 要格式化的html文本文件的ID，例如R.raw.html_text。除了支持Google原生支持的标签外，还支持kFont标签。
* @param textClickListener 如果你给kFont标签添加了clickable属性则可以通过该参数设置点击监听，监听中的flag参数为clickable等号后面的内容，例如
* 你kFont标签中clickable属性的为`clickable=A`，那么flag的值就为A。如果你没有使用clickable属性则该参数可以不传。
*
* @return 返回格式化后的文本(CharSequence类型)。
*/
fun loadResource(
context: Context, @RawRes resId: Int,
textClickListener: ((flag: String) -> Unit)? = null
): CharSequence {
return htmlFrom(getStringFromStream(context.resources.openRawResource(resId)), textClickListener)
}
private fun htmlFrom(source: String, textClickListener: ((flag: String) -> Unit)? = null): CharSequence {
return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
Html.fromHtml(
if (source.startsWith("<html>")) source else "<html>$source</html>",
Html.FROM_HTML_MODE_LEGACY,
null,
KFontHandler(textClickListener)
)
} else {
Html.fromHtml(
if (source.startsWith("<html>")) source else "<html>$source</html>",
null,
KFontHandler(textClickListener)
)
}
}
private fun getStringFromStream(inputStream: InputStream): String {
val inputStreamReader = InputStreamReader(inputStream, "UTF-8")
val reader = BufferedReader(inputStreamReader)
val sb = StringBuffer("")
var line = reader.readLine()
while (line != null) {
sb.append(line)
sb.append("<br/>")
line = reader.readLine()
}
return sb.toString()
}
}
private var currentTagInfo: TagInfo? = null
override fun handleTag(opening: Boolean, tag: String, output: Editable, xmlReader: XMLReader) {
if (opening) {
handlerStartTAG(tag, output, xmlReader)
} else {
handlerEndTAG(tag, output)
}
}
private fun handlerStartTAG(tag: String, output: Editable, xmlReader: XMLReader) {
if (tag.equals(TAG_K_FONT, ignoreCase = true)) {
handlerKFontStart(output, xmlReader)
}
}
private fun handlerEndTAG(tag: String, output: Editable) {
if (tag.equals(TAG_K_FONT, ignoreCase = true)) {
handlerKFontEnd(output)
}
}
private fun handlerKFontStart(output: Editable, xmlReader: XMLReader) {
val index = output.length
val tagInfo = TagInfo(index)
val style = getProperty(xmlReader, "style")
if (!style.isNullOrEmpty()) {
tagInfo.style = when (style) {
"b", "bold" -> Typeface.BOLD
"i", "italic" -> Typeface.ITALIC
"b_i", "i_b", "bold_italic", "italic_bold" -> Typeface.BOLD_ITALIC
"u", "underline" -> {
tagInfo.hasUnderline = true
Typeface.NORMAL
}
"i_u", "u_i", "italic_underline", "underline_italic" -> {
tagInfo.hasUnderline = true
Typeface.ITALIC
}
"b_u", "u_b", "bold_underline", "underline_bold" -> {
tagInfo.hasUnderline = true
Typeface.BOLD
}
"b_u_i",
"b_i_u",
"u_b_i",
"u_i_b",
"i_u_b",
"i_b_u",
"italic_bold_underline",
"italic_underline_bold",
"underline_italic_bold",
"underline_bold_italic",
"bold_underline_italic",
"bold_italic_underline" -> {
tagInfo.hasUnderline = true
Typeface.BOLD_ITALIC
}
else -> Typeface.NORMAL
}
}
val clickable = getProperty(xmlReader, "clickable")
if (!clickable.isNullOrEmpty()) {
tagInfo.clickable = clickable
}
val size = getProperty(xmlReader, "size")
if (!size.isNullOrEmpty()) {
tagInfo.size = when {
size.endsWith("sp", true) -> Integer.parseInt(size.replace("sp", "", true))
size.endsWith("px", true) -> {
tagInfo.hasUnderline = false
Integer.parseInt(size.replace("px", "", true))
}
else -> try {
Integer.parseInt(size)
} catch (e: Exception) {
20
}
}
}
val color = getProperty(xmlReader, "color")
if (!color.isNullOrEmpty()) {
tagInfo.color = color
}
currentTagInfo = tagInfo
}
private fun handlerKFontEnd(output: Editable) {
val tagInfo = currentTagInfo
if (tagInfo != null) {
val color = tagInfo.color
val size = tagInfo.size
val style = tagInfo.style
val clickable = tagInfo.clickable
val end = output.length
if (!clickable.isNullOrEmpty()) {
output.setSpan(KFontClickableSpan(clickable), tagInfo.startIndex, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
}
if (!color.isNullOrEmpty()) {
output.setSpan(
ForegroundColorSpan(Color.parseColor(color)),
tagInfo.startIndex,
end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
)
}
if (size > 0) {
output.setSpan(
AbsoluteSizeSpan(size, tagInfo.sizeDip),
tagInfo.startIndex,
end,
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
)
}
if (style != Typeface.NORMAL) {
output.setSpan(StyleSpan(style), tagInfo.startIndex, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
}
if (tagInfo.hasUnderline) {
output.setSpan(UnderlineSpan(), tagInfo.startIndex, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE)
}
}
}
/**
* 利用反射获取html标签的属性值
*/
@Suppress("UNCHECKED_CAST")
private fun getProperty(xmlReader: XMLReader, property: String): String? {
try {
val elementField = xmlReader.javaClass.getDeclaredField("theNewElement")
elementField.isAccessible = true
val element: Any = elementField.get(xmlReader)
val attsField = element.javaClass.getDeclaredField("theAtts")
attsField.isAccessible = true
val atts: Any = attsField.get(element)
val dataField = atts.javaClass.getDeclaredField("data")
dataField.isAccessible = true
val data = dataField.get(atts) as Array<String>
val lengthField = atts.javaClass.getDeclaredField("length")
lengthField.isAccessible = true
val len = lengthField.getInt(atts)
for (i in 0 until len) {
// 判断属性名
if (property == data[i * 5 + 1]) {
return data[i * 5 + 4]
}
}
} catch (e: Exception) {
e.printStackTrace()
}
return null
}
private inner class TagInfo internal constructor(val startIndex: Int) {
internal var style: Int = Typeface.NORMAL
internal var hasUnderline: Boolean = false
internal var clickable: String? = null
internal var color: String? = null
internal var size: Int = 0
set(value) {
if (value > 0) {
field = value
}
}
internal var sizeDip: Boolean = true
}
private inner class KFontClickableSpan(private val flag: String) : ClickableSpan() {
override fun onClick(widget: View) {
onTextClickListener?.invoke(flag)
}
override fun updateDrawState(ds: TextPaint) {
}
}
}
如果你觉的本文对你有用还请不要吝啬你的赞哦，你的鼓励将会转换成我继续创作下去的勇气。再次感谢。
最后还是奉上Demo地址吧
扫一扫
175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
