Android ---- SpannableString, spannablestring

Android ---- SpannableString, spannablestring
1. Background

In the process of application development, it is often seen that some information with different font styles is like the time and charging information on the default LockScreen. In a similar situation, the first possible response is to use different textviews. Different font styles are set for each TextView to meet the requirements.

Android is recommended. text. *; and android. text. style. *; the following component implements RichText: that is, set different font styles in the same TextView. For some applications, such as text editing, notepad, MMS, and SMS, you must use these components to achieve the desired display effect.

The main basic tool classes are android. text. Spanned; android. text. SpannableString; android. text. SpannableStringBuilder; these classes are used to replace regular strings. SpannableString and SpannableStringBuilder can be used to set different spans. These spans are used to implement Rich Text, such as bold, italic, foreground color, background color, font size, and font style. android. text. style. * defines many Span types for use.

This is the related API Class General Hierarchy:

 

Because Spannable and so on finally implement the CharSequence interface, you can directly set SpannableString and SpannableStringBuilder to TextView through TextView. setText.

 

2. Usage

When you want to display Rich Text information, you can create a SpannableString or SpannableStringBuilder. The difference is that SpannableString is like a String, and a String is input when constructing an object, after that, you cannot change the String content or splice multiple spannablestrings. The SpannableStringBuilder is more like a StringBuilder. It can splice multiple strings through its append () method:

SpannableString word = new SpannableString("The quick fox jumps over the lazy dog");SpannableStringBuilder multiWord = new SpannableStringBuilder();multiWord.append("The Quick Fox");multiWord.append("jumps over");multiWord.append("the lazy dog");

After the Spannable object is created, you can set the Span for them to implement the expected Rich Text. Common spans include:

• AbsoluteSizeSpan (int size) ---- set the font size. The parameter is an absolute value, which is equivalent to the font size in Word.
• RelativeSizeSpan (float proportion) ---- set the font size. The parameter is a multiple of the default font size. For example, if the default font size is x, the configured font size is x * proportion, this is more flexible to use. proportion> 1 is zoom in, and proportion <1 is zoom out)
  
• ScaleXSpan (float proportion) ---- scale the font. Similar to the preceding one, the default value is 1. After setting it, It is multiplied by proportion. If it is greater than 1, it is zoon in ), zoom out)
• BackgroundColorSpan (int color) ---- background coloring. The parameter is a Color value. You can directly use the constant defined in android. graphics. Color, or use color. rgb (int, int, int)
• ForegroundColorSpan (int color) ---- foreground color, that is, the color of the word. The parameter is consistent with that of the background color.
• TypefaceSpan (String family) ---- font. The parameter is the font name, such as "sans" and "sans-serif ".
• StyleSpan (Typeface style) ----- font style, such as BOLD and ITALIC. The parameters are constants defined in android. graphics. Typeface, such as Typeface. BOLD and Typeface. ITALIC.
• StrikethroughSpan ---- if this style is set, there will be a line passing through all words from the middle, just like being crossed out.

When using these Sytle spans, you can only pass the preceding constructor parameters. You do not need to set other attributes. If you need them, you can also set other attributes for them, for more information, see the documentation.
Both SpannableString and SpannableStringBuilder have a method to set the preceding Span:

/** * Set the style span to Spannable, such as SpannableString or SpannableStringBuilder * @param what --- the style span, such as StyleSpan * @param start --- the starting index of characters to which the style span to apply * @param end --- the ending index of characters to which the style span to apply * @param flags --- the flag specified to control */setSpan(Object what, int start, int end, int flags);

Among them, what is the Style span to be set, start and end are the start position of Span in String, and flags are used to control behavior, it is usually set to 0 or a constant defined in Spanned. Commonly Used constants include:

• Spanned. SPAN_EXCLUSIVE_EXCLUSIVE --- does not contain the endpoints of start and end at both ends
  
• Spanned. SPAN_EXCLUSIVE_INCLUSIVE --- does not contain end start, but contains the end
• Spanned. SPAN_INCLUSIVE_EXCLUSIVE --- contains the start at both ends, but does not include the endpoint of the end.
• Spanned. SPAN_INCLUSIVE_INCLUSIVE --- contains the endpoints of start and end at both ends

It is like defining a range in mathematics, and opening or closing a range is the same. There are many other flags. For more information, see here. Here, we will focus on parameter 0. In many cases, if the preceding parameter is set, Span will be applied from start to end of Text, rather than between start and end, in this case, Flag 0 is required.

3. Linkify

In addition, you can also use TextView. setAutoLink (int) sets its Linkify attribute. In this case, TextView automatically checks its content and identifies the phone number, web address or email address as a hyperlink. You can click, click to jump to the corresponding application, such as Dialer, Browser, or Email. Linkify has several common options. For more information, see:

• Linkify. EMAIL_ADDRESS -- only identifies the Email address in the TextView as a hyperlink. After clicking it, it will jump to the Email and send an Email to this address.
  
• Linkify. PHONE_NUMBERS -- only identifies the phone number in TextView as a hyperlink. After clicking it, it will jump to Dialer and Call this number.
• Linkify. WEB_URLS -- only identifies the URL in TextView as a hyperlink. After clicking it, the URL is displayed in Browser.
• Linkify. ALL -- this option identifies the special Uris supported by ALL systems, and then performs the corresponding operations.

4. Weight Selection

I personally think that the most common problem in software development is not how to use a certain technique, but when to use it, because there may be N different ways to achieve the same goal, we need to weigh the pros and cons and select the most appropriate one. As the saying goes, there is no best, but the most suitable cloud. As discussed earlier, you can use multiple textviews in addition to Style Span to display different information in different fonts. We need to summarize when to use StyleSpan and when to use multiple textviews:

1. If multiple different categories of information are displayed, multiple textviews should be used to conveniently control and change their respective information. The example is the date and charging information on LockScreen by default, because they carry different information, multiple textviews should be used to present them separately.
2. If the display is the same class information or the same information, StyleSpan should be used. For example, in a short message, you need to Highlight the relevant information of the contact, or want some information such as Highlight.
3. If you want to implement Rich text, you can only use Style span.
4. If you want to implement some special effects, you can also consider using StyleSpan. Setting different font styles is only an elementary application of Style span. If you study it in depth, you can find many amazing effects.

Spannable and ImageSapn can be used in combination to achieve text-and-image mixing in EditText.

 

Below are some instance code

1. /**
2. * Hyperlink
3. */
4. Private void addUrlSpan (){
5. SpannableString spanString = new SpannableString ("HYPERLINK ");
6. URLSpan span = new URLSpan ("tel: 0123456789 ");
7. SpanString. setSpan (span, 0, 3, Spannable. SPAN_EXCLUSIVE_EXCLUSIVE );
8. TV. append (spanString );
9. }
12. /**
13. * Text background color
14. */
15. Private void addBackColorSpan (){
16. SpannableString spanString = new SpannableString ("color 2 ");
17. BackgroundColorSpan span = new BackgroundColorSpan (Color. YELLOW );
18. SpanString. setSpan (span, 0, 3, Spannable. SPAN_EXCLUSIVE_EXCLUSIVE );
19. TV. append (spanString );
20. }
23. /**
24. * Text color
25. */
26. Private void addForeColorSpan (){
27. SpannableString spanString = new SpannableString ("color 1 ");
28. ForegroundColorSpan span = new ForegroundColorSpan (Color. BLUE );
29. SpanString. setSpan (span, 0, 3, Spannable. SPAN_EXCLUSIVE_EXCLUSIVE );
30. TV. append (spanString );
31. }
34. /**
35. * Font size
36. */
37. Private void addFontSpan (){
38. SpannableString spanString = new SpannableString ("font 36 ");
39. AbsoluteSizeSpan span = new AbsoluteSizeSpan (36 );
40. SpanString. setSpan (span, 0, 5, Spannable. SPAN_EXCLUSIVE_EXCLUSIVE );
41. TV. append (spanString );
42. }
45. /**
46. * Bold and italic
47. */
48. Private void addStyleSpan (){
49. SpannableString spanString = new SpannableString ("BIBI ");
50. StyleSpan span = new StyleSpan (Typeface. BOLD_ITALIC );
51. SpanString. setSpan (span, 0, 2, Spannable. SPAN_EXCLUSIVE_EXCLUSIVE );
52. TV. append (spanString );
53. }
56. /**
57. * Strikethrough
58. */
59. Private void addStrikeSpan (){
60. SpannableString spanString = new SpannableString ("strikethrough ");
61. StrikethroughSpan span = new StrikethroughSpan ();
62. SpanString. setSpan (span, 0, 3, Spannable. SPAN_EXCLUSIVE_EXCLUSIVE );
63. TV. append (spanString );
64. }
66. /**
67. * Underline
68. */
69. Private void addUnderLineSpan (){
70. SpannableString spanString = new SpannableString ("underline ");
71. UnderlineSpan span = new UnderlineSpan ();
72. SpanString. setSpan (span, 0, 3, Spannable. SPAN_EXCLUSIVE_EXCLUSIVE );
73. TV. append (spanString );
74. }
78. /**
79. * Image
80. */
81. Private void addImageSpan (){
82. SpannableString spanString = new SpannableString ("");
83. Drawable d = getResources (). getDrawable (R. drawable. ic_launcher );
84. D. setBounds (0, 0, d. getIntrinsicWidth (), d. getIntrinsicHeight ());
85. ImageSpan span = new ImageSpan (d, ImageSpan. ALIGN_BASELINE );
86. SpanString. setSpan (span, 0, 1, Spannable. SPAN_EXCLUSIVE_EXCLUSIVE );
87. TV. append (spanString );
88. }
89. }

Copyright Disclaimer: This article is an original article by the blogger and cannot be reproduced without the permission of the blogger.