CSS style:
Paragraphs:
If you aren't applying formatting, you can set TextView text directly by calling setText(java.lang.CharSequence) . In some cases, however, you may want to create a styled text resource that is also used as a format string. Normally, this doesn't work because the format(String, Object...) and getString(int, Object...) methods strip all the style information from the string. The work-around to this is to write the HTML tags with escaped entities, which are then recovered with fromHtml(String) , after the formatting takes place. For example:
Store your styled text resource as an HTML-escaped string: Hello, %1$s! You have %2$d new messages. In this formatted string, a element is added. Notice that the opening bracket is HTML-escaped, using the < notation. Then format the string as usual, but also call fromHtml(String) to convert the HTML text into styled text: Kotlin val text: String = getString(R.string.welcome_messages, username, mailCount) val styledText: Spanned = Html.fromHtml(text, FROM_HTML_MODE_LEGACY) Java String text = getString(R.string.welcome_messages, username, mailCount); Spanned styledText = Html.fromHtml(text, FROM_HTML_MODE_LEGACY);
Because the fromHtml(String) method formats all HTML entities, be sure to escape any possible HTML characters in the strings you use with the formatted text, using htmlEncode(String) . For instance, if you are formatting a string that contains characters such as "<" or "&", then they must be escaped before formatting, so that when the formatted string is passed through fromHtml(String) , the characters come out the way they were originally written. For example:
Kotlin val escapedUsername: String = TextUtils. htmlEncode (username) val text: String = getString(R.string.welcome_messages, escapedUsername, mailCount) val styledText: Spanned = Html.fromHtml(text, FROM_HTML_MODE_LEGACY) Java String escapedUsername = TextUtils. htmlEncode (username); String text = getString(R.string.welcome_messages, escapedUsername, mailCount); Spanned styledText = Html.fromHtml(text);
Styling with spannables
A Spannable is a text object that you can style with typeface properties such as color and font weight. You use SpannableStringBuilder to build your text and then apply styles defined in the android.text.style package to the text.
You can use the following helper methods to set up much of the work of creating spannable text:
Kotlin /** * Returns a CharSequence that concatenates the specified array of CharSequence * objects and then applies a list of zero or more tags to the entire range. * * @param content an array of character sequences to apply a style to * @param tags the styled span objects to apply to the content * such as android.text.style.StyleSpan */ private fun apply(content: Array, vararg tags: Any): CharSequence { return SpannableStringBuilder().apply { openTags(tags) content.forEach { charSequence -> append(charSequence) } closeTags(tags) } } /** * Iterates over an array of tags and applies them to the beginning of the specified * Spannable object so that future text appended to the text will have the styling * applied to it. Do not call this method directly. */ private fun Spannable.openTags(tags: Array) { tags.forEach { tag -> setSpan(tag, 0, 0, Spannable.SPAN_MARK_MARK) } } /** * "Closes" the specified tags on a Spannable by updating the spans to be * endpoint-exclusive so that future text appended to the end will not take * on the same styling. Do not call this method directly. */ private fun Spannable.closeTags(tags: Array) { tags.forEach { tag -> if (length > 0) { setSpan(tag, 0, length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE) } else { removeSpan(tag) } } } Java /** * Returns a CharSequence that concatenates the specified array of CharSequence * objects and then applies a list of zero or more tags to the entire range. * * @param content an array of character sequences to apply a style to * @param tags the styled span objects to apply to the content * such as android.text.style.StyleSpan * */ private static CharSequence applyStyles(CharSequence[] content, Object[] tags) { SpannableStringBuilder text = new SpannableStringBuilder(); openTags(text, tags); for (CharSequence item : content) { text.append(item); } closeTags(text, tags); return text; } /** * Iterates over an array of tags and applies them to the beginning of the specified * Spannable object so that future text appended to the text will have the styling * applied to it. Do not call this method directly. */ private static void openTags(Spannable text, Object[] tags) { for (Object tag : tags) { text.setSpan(tag, 0, 0, Spannable.SPAN_MARK_MARK); } } /** * "Closes" the specified tags on a Spannable by updating the spans to be * endpoint-exclusive so that future text appended to the end will not take * on the same styling. Do not call this method directly. */ private static void closeTags(Spannable text, Object[] tags) { int len = text.length(); for (Object tag : tags) { if (len > 0) { text.setSpan(tag, 0, len, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE); } else { text.removeSpan(tag); } } }
The following bold , italic , and color methods wrap the helper methods above and demonstrate specific examples of applying styles defined in the android.text.style package. You can create similar methods to do other types of text styling.
Kotlin /** * Returns a CharSequence that applies boldface to the concatenation * of the specified CharSequence objects. */ fun bold(vararg content: CharSequence): CharSequence = apply(content, StyleSpan(Typeface.BOLD)) /** * Returns a CharSequence that applies italics to the concatenation * of the specified CharSequence objects. */ fun italic(vararg content: CharSequence): CharSequence = apply(content, StyleSpan(Typeface.ITALIC)) /** * Returns a CharSequence that applies a foreground color to the * concatenation of the specified CharSequence objects. */ fun color(color: Int, vararg content: CharSequence): CharSequence = apply(content, ForegroundColorSpan(color)) Java /** * Returns a CharSequence that applies boldface to the concatenation * of the specified CharSequence objects. */ public static CharSequence bold(CharSequence... content) { return apply(content, new StyleSpan(Typeface.BOLD)); } /** * Returns a CharSequence that applies italics to the concatenation * of the specified CharSequence objects. */ public static CharSequence italic(CharSequence... content) { return apply(content, new StyleSpan(Typeface.ITALIC)); } /** * Returns a CharSequence that applies a foreground color to the * concatenation of the specified CharSequence objects. */ public static CharSequence color(int color, CharSequence... content) { return apply(content, new ForegroundColorSpan(color)); }
Here's an example of how to chain these methods together to apply various styles to individual words within a phrase:
Kotlin // Create an italic "hello, " a red "world", // and bold the entire sequence. val text: CharSequence = bold(italic(getString(R.string.hello)), color(Color.RED, getString(R.string.world))) Java // Create an italic "hello, " a red "world", // and bold the entire sequence. var text = bold(italic(getString(R.string.hello)), color(Color.RED, getString(R.string.world)))
Java
// Create an italic "hello, " a red "world", // and bold the entire sequence. CharSequence text = bold(italic(getString(R.string.hello)), color(Color.RED, getString(R.string.world)));
The core-ktx Kotlin module also contains extension functions that make working with spans even easier. You can check out the android.text package documentation on GitHub to learn more.
For more information on working with spans, see the following links:
Styling with annotations
You can apply complex or custom styling by using the Annotation class along with the tag in your strings.xml resource files. The annotation tag allows you to mark parts of the string for custom styling by defining custom key-value pairs in the XML that the framework then converts into Annotation spans. You can then retrieve these annotations and use the key and value to apply the styling.
When creating annotations, make sure you add the tag to all translations of the string in every strings.xml file.
Applying a custom typeface to the word “text” in all languages
Example - adding a custom typeface
Add the tag, and define the key-value pair. In this case, the key is font, and the value is the type of font we want to use: title_emphasis // values/strings.xml Best practices for text on Android // values-es/strings.xml Texto en Android: mejores prácticas Load the string resource and find the annotations with the font key. Then create a custom span and replace the existing span. Kotlin // get the text as SpannedString so we can get the spans attached to the text val titleText = getText(R.string.title) as SpannedString // get all the annotation spans from the text val annotations = titleText.getSpans(0, titleText.length, Annotation::class.java) // create a copy of the title text as a SpannableString. // the constructor copies both the text and the spans. so we can add and remove spans val spannableString = SpannableString(titleText) // iterate through all the annotation spans for (annotation in annotations) { // look for the span with the key font if (annotation.key == "font") { val fontName = annotation.value // check the value associated to the annotation key if (fontName == "title_emphasis") { // create the typeface val typeface = getFontCompat(R.font.permanent_marker) // set the span at the same indices as the annotation spannableString.setSpan(CustomTypefaceSpan(typeface), titleText.getSpanStart(annotation), titleText.getSpanEnd(annotation), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE) } } } // now, the spannableString contains both the annotation spans and the CustomTypefaceSpan styledText.text = spannableString Java // get the text as SpannedString so we can get the spans attached to the text SpannedString titleText = (SpannedString) getText(R.string.title); // get all the annotation spans from the text Annotation[] annotations = titleText.getSpans(0, titleText.length(), Annotation.class); // create a copy of the title text as a SpannableString. // the constructor copies both the text and the spans. so we can add and remove spans SpannableString spannableString = new SpannableString(titleText); // iterate through all the annotation spans for (Annotation annotation: annotations) { // look for the span with the key font if (annotation.getKey().equals("font")) { String fontName = annotation.getValue(); // check the value associated to the annotation key if (fontName.equals("title_emphasis")) { // create the typeface Typeface typeface = ResourcesCompat.getFont(this, R.font.roboto_mono); // set the span at the same indices as the annotation spannableString.setSpan(new CustomTypefaceSpan(typeface), titleText.getSpanStart(annotation), titleText.getSpanEnd(annotation), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); } } } // now, the spannableString contains both the annotation spans and the CustomTypefaceSpan styledText.text = spannableString;
If you’re using the same text multiple times, you should construct the SpannableString object once and reuse it as needed to avoid potential performance and memory issues.
For more examples of annotation usage, see Styling internationalized text in Android
Annotation spans and text parceling
Because Annotation spans are also ParcelableSpans , the key-value pairs are parceled and unparceled. As long as the receiver of the parcel knows how to interpret the annotations, you can use Annotation spans to apply custom styling to the parceled text.
To keep your custom styling when you pass the text to an Intent Bundle, you first need to add Annotation spans to your text. You can do this in the XML resources via the tag, as shown in the example above, or in code by creating a new Annotation and setting it as a span, as shown below:
Kotlin val spannableString = SpannableString("My spantastic text") val annotation = Annotation("font", "title_emphasis") spannableString.setSpan(annotation, 3, 7, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE) // start Activity with text with spans val intent = Intent(this, MainActivity::class.java) intent.putExtra(TEXT_EXTRA, spannableString) startActivity(intent) Java SpannableString spannableString = new SpannableString("My spantastic text"); Annotation annotation = new Annotation("font", "title_emphasis"); spannableString.setSpan(annotation, 3, 7, 33); // start Activity with text with spans Intent intent = new Intent(this, MainActivity.class); intent.putExtra(TEXT_EXTRA, spannableString); this.startActivity(intent);
Retrieve the text from the Bundle as a SpannableString and then parse the annotations attached, as shown in the example above.
Kotlin // read text with Spans val intentCharSequence = intent.getCharSequenceExtra(TEXT_EXTRA) as SpannableString Java // read text with Spans SpannableString intentCharSequence = (SpannableString)intent.getCharSequenceExtra(TEXT_EXTRA);
For more information on text styling, see the following links:
Convert string or numeric time values into date format—ArcGIS Pro
It is recommended that you store the time values of your temporal data in a date field. A date field is a database field type specifically for storing time and date information. It is more efficient for query performance and supports more sophisticated database queries than storing time in a numeric or string field.
If you have time values stored in a string or numeric (short, long, float, or double) field, you can convert them into a date field using the Convert Time Field geoprocessing tool. Use this tool to specify a standard or custom time format for interpreting date and time values and converting those into a date format.
Standard formats are supported with the Convert Time Field tool. However, if you have time values stored in a string field using a custom date and time format, you can create a custom date and time format to interpret your data. For example, when using the Convert Time Field tool to convert a time value of Tuesday, August 20, 2002, stored as a string into a date format, specify the input time format as dddd, MMMM dd, yyyy.
When using the Convert Time Field tool, the list of standard supported input time formats varies depending on whether the input time values are stored in a string or numeric (short, long, float, or double) field.
tool, the list of standard supported input time formats varies depending on whether the input time values are stored in a string or numeric (short, long, float, or double) field. The Convert Time Field tool allows you to specify custom date and time formats only when the time values are stored in a string field. Custom date and time formats are not supported when time values are stored in numeric fields.
Date and time format strings A date and time format string is a string of text used to interpret data values containing date and time information. Each format string consists of a combination of formats from an available format type. Some examples of format types are day of week, month, hour, and second. In a single date and time format string, only one format from each format type should be used. However, not every format type needs to be included in a format string. For example, it is common to define a date format string that contains only year, month, and day of month information, without including any information about the time of day. A format string can contain time information only, date information only, or a combination of date and time information. Format strings may also include separators, such as commas, that separate the formats used in the format string. You need to analyze your data to determine the appropriate date and time format string to interpret your data. The following examples show a variety of format strings for interpreting dates and times: Examples of Date and Time Format Strings Example data value Format string 30/05/1978 02:34:56 dd/MM/yyyy HH:mm:ss 2/4/2010 2:39:28 PM M/d/yyyy h:mm:ss tt 6:05:12 a.m. h:mm:ss tt 23:31:18.345 HH:mm:ss.s Tuesday, August 20, 2002 dddd, MMMM dd, yyyy Wed, Aug 31 1994 ddd, MMM dd yyyy 03281999030456 MMddyyyyHHmmss
Customize date and time formats A custom format string consists of one or more date and time format specifiers. The following table summarizes the format specifiers that can be used to create a custom date and time format for interpreting data: Date and Time Format Specifiers Format specifier Format type Description d Day of Month Day of month as digits with no leading zero for single-digit days. dd Day of Month Day of month as digits with leading zero for single-digit days. ddd Day of Week Day of week as a three-letter abbreviation. The function uses the abbreviations associated with the specified locale, for example, Mon in English (United States). Tip: Days of the week are not verified when interpreting a date value; therefore, it doesn't matter whether a day of the week appearing in your data correctly corresponds to the date represented in the data value. dddd Day of Week Day of week as its full name. The function uses the full day names associated with the specified locale, for example, Monday in English (United States). Tip: Days of the week are not verified when interpreting a date value; therefore, it doesn't matter whether a day of the week appearing in your data correctly corresponds to the date represented in the data value. M Month Month as digits with no leading zero for single-digit months. MM Month Month as digits with leading zero for single-digit months. MMM Month Month as a three-letter abbreviation. The function uses the month abbreviations associated with the specified locale, for example, Nov in English (United States). MMMM Month Month as its full name. The function uses the full month names associated with the specified locale, for example, November for English (United States), and noviembre for Spanish (Spain). y Year Year as last two digits but with no leading zero for years whose last two digits are less than 10. Tip: Years represented in this way can range from 1950 to 2049. A value of 49 or less is interpreted as occurring in the 21st century, for example, 7 is interpreted as 2007. A value of 50 or greater is interpreted as occurring in the 20th century, for example, 67 is interpreted as 1967. yy Year Year represented by the last two digits but with a leading zero for years whose last two digits are less than 10. Tip: Years represented in this way can range from 1950 to 2049. A value of 49 or less is interpreted as occurring in the 21st century. For example, 07 is interpreted as 2007. A value of 50 or greater is interpreted as occurring in the 20th century, for example, 67 is interpreted as1967. yyy Year Year represented by only three digits. Years represented in this way can range from 1 to 999. yyyy Year Year represented by four digits. gg Era Period/era string. The function uses the era values associated with the specified locale. h Hour Hour with no leading zero for single-digit hours; 12-hour clock. H Hour Hour with no leading zero for single-digit hours; 24-hour clock. hh Hour Hours with leading zero for single-digit hours; 12-hour clock. HH Hour Hours with leading zero for single-digit hours; 24-hour clock. m Minute Minutes with no leading zero for single-digit minutes. mm Minute Minutes with leading zero for single-digit minutes. s Second Seconds with no leading zero for single-digit seconds. ss Second Seconds with leading zero for single-digit seconds. s.s Second Seconds, including subseconds, with no leading zero for single-digit seconds. Although the format only shows one decimal place, any number of decimal places can be used. Caution: The precision of subsecond values is limited to what is supported for the time field data type. For example, if using a time field of field data type float or double, rounding errors should be expected. ss.s Second Seconds, including subseconds, with leading zero for single-digit seconds. Although the format only shows one decimal place, any number of decimal places can be used. Caution: The precision of subsecond values is limited to what is supported for the time field data type, for example, if using a time field of field data type float or double, rounding errors should be expected. t Time Marker One character time marker string, such as A or P. tt Time Marker Multicharacter time marker string, such as AM or PM.
Separators Separators are characters that separate information in text data values. Examples of commonly used separators are commas (,), colons (:), and spaces ( ), but there are no restrictions on the separators that can be used to create format strings. You can create format strings without any separators at all, especially when interpreting dates and times stored in numeric fields because numeric fields cannot store most of the commonly used separator characters. In rare cases, data may contain separators that conflict with the formats in the table above. In these cases, single quotation marks must be used to isolate separators within your format string. In general, single quotation marks can be used to isolate any separators within a format string, but it is not recommended that you use them unless there is a potential conflict. The following examples show these concepts: Example data value Format Date or time interpreted (displayed as MM/dd/yyyy or HH:mm:ss) month12day30year2010 'month'MM'day'dd'year'yyyy 12/30/2010 30/12/2010 ddMMyyyy 12/30/2010 Time:18hr6min3sec 'Time:'h'hr'm'min's'sec' 18:06:03 18:6:3 HH:m:s 18:06:03
Locales Locales are important because they determine the valid data values for the long representations of some of the date formats in the table above. For example, the value November is only interpreted correctly for MMMM if the locale is an English-language locale. In some cases, if the format string doesn't use any long representations, the locale is irrelevant for interpreting the date, but the locale may affect the interpretation of AM and PM designators. If no AM or PM designators are specified, the default AM and PM designators for the locale are used. Locales do not affect the formats used to create format strings. For example, the character M (or MM, MMM, MMMM) represents months regardless of the locale. The following examples illustrate how the locale is used to interpret dates: Data value Format string Locale Date interpreted (MM/dd/yyyy) November 30, 2010 MMMM dd, yyyy English (United States) 11/30/2010 Noviembre 30, 2010 MMMM dd, yyyy Spanish (Spain) 11/30/2010 Mon, Feb 22, 2010 ddd, MMM dd, yyyy English (United States) 2/22/2010 30/12/2010 dd/M/yyyy All locales 12/30/2010
AM and PM designators Standard time markers, or AM and PM designators, exist for each locale. However, you can define your own time markers. If time markers exist in your format string (t or tt), the characters used to represent the time markers must be defined. Time markers are only appropriate for use with format strings using a 12-hour clock (h or hh). They are not appropriate for format strings using a 24-hour clock (H or HH). If you don't define your own time markers, the standard time markers for the selected locale are used. To define your own AM and PM designators, the time field must have a field data type of text. The following examples show these concepts using only a PM designator for simplicity. The same concepts apply to the AM designator: Data value Format string PM designator Interpreted time (HH:mm:ss) 6:12:34 P h:mm:ss t P 18:12:34 6:12:34 p.m. h:mm:ss tt p.m. 18:12:34 6:12:34 H:mm:ss PM 6:12:34 6:12:34 PM h:mm:ss tt PM 18:12:34
So you have finished reading the android string format topic article, if you find this article useful, please share it. Thank you very much. See more: String format, String format Java, String format Android, String Android, String XML Android, string format(locale android), String format XML Android, android string format double