Android strings xml formatted

String Resources

A string resource provides text strings for your application with optional text styling and formatting. There are three types of resources that can provide your application with strings:

String XML resource that provides a single string. String Array XML resource that provides an array of strings. Quantity Strings (Plurals) XML resource that carries different strings for pluralization.

All strings are capable of applying some styling markup and formatting arguments. For information about styling and formatting strings, see the section about Formatting and Styling.

String

A single string that can be referenced from the application or from other resource files (such as an XML layout).

Note: A string is a simple resource that is referenced using the value provided in the name attribute (not the name of the XML file). So, you can combine string resources with other simple resources in the one XML file, under one element.

file location: res/values/filename.xml
The filename is arbitrary. The element’s name will be used as the resource ID. compiled resource datatype: Resource pointer to a String . resource reference: In Java: R.string.string_name
In XML: @string/string_name syntax: elements: Required. This must be the root node.

A string, which can include styling tags. Beware that you must escape apostrophes and quotation marks. For more information about how to properly style and format your strings see Formatting and Styling, below.

name String. A name for the string. This name will be used as the resource ID. example: XML file saved at res/values/strings.xml :

This layout XML applies a string to a View:

This application code retrieves a string:

You can use either getString(int) or getText(int) to retrieve a string. getText(int) will retain any rich text styling applied to the string.

String Array

An array of strings that can be referenced from the application.

Note: A string array is a simple resource that is referenced using the value provided in the name attribute (not the name of the XML file). As such, you can combine string array resources with other simple resources in the one XML file, under one element.

file location: res/values/filename.xml
The filename is arbitrary. The element’s name will be used as the resource ID. compiled resource datatype: Resource pointer to an array of String s. resource reference: In Java: R.array.string_array_name syntax: elements: Required. This must be the root node.

Defines an array of strings. Contains one or more elements.

name String. A name for the array. This name will be used as the resource ID to reference the array. A string, which can include styling tags. The value can be a reference to another string resource. Must be a child of a element. Beware that you must escape apostrophes and quotation marks. See Formatting and Styling, below, for information about to properly style and format your strings.

example: XML file saved at res/values/strings.xml :

This application code retrieves a string array:

Quantity Strings (Plurals)

Different languages have different rules for grammatical agreement with quantity. In English, for example, the quantity 1 is a special case. We write «1 book», but for any other quantity we’d write «n books». This distinction between singular and plural is very common, but other languages make finer distinctions. The full set supported by Android is zero , one , two , few , many , and other .

The rules for deciding which case to use for a given language and quantity can be very complex, so Android provides you with methods such as getQuantityString() to select the appropriate resource for you.

Although historically called «quantity strings» (and still called that in API), quantity strings should only be used for plurals. It would be a mistake to use quantity strings to implement something like Gmail’s «Inbox» versus «Inbox (12)» when there are unread messages, for example. It might seem convenient to use quantity strings instead of an if statement, but it’s important to note that some languages (such as Chinese) don’t make these grammatical distinctions at all, so you’ll always get the other string.

The selection of which string to use is made solely based on grammatical necessity. In English, a string for zero will be ignored even if the quantity is 0, because 0 isn’t grammatically different from 2, or any other number except 1 («zero books», «one book», «two books», and so on). Conversely, in Korean only the other string will ever be used.

Don’t be misled either by the fact that, say, two sounds like it could only apply to the quantity 2: a language may require that 2, 12, 102 (and so on) are all treated like one another but differently to other quantities. Rely on your translator to know what distinctions their language actually insists upon.

It’s often possible to avoid quantity strings by using quantity-neutral formulations such as «Books: 1». This will make your life and your translators’ lives easier, if it’s a style that’s in keeping with your application.

Note: A plurals collection is a simple resource that is referenced using the value provided in the name attribute (not the name of the XML file). As such, you can combine plurals resources with other simple resources in the one XML file, under one element.

file location: res/values/filename.xml
The filename is arbitrary. The

element’s name will be used as the resource ID. resource reference: In Java: R.plurals.plural_name syntax: elements: Required. This must be the root node.

A collection of strings, of which, one string is provided depending on the amount of something. Contains one or more elements.

name String. A name for the pair of strings. This name will be used as the resource ID. A plural or singular string. The value can be a reference to another string resource. Must be a child of a

element. Beware that you must escape apostrophes and quotation marks. See Formatting and Styling, below, for information about to properly style and format your strings.

quantity Keyword. A value indicating when this string should be used. Valid values, with non-exhaustive examples in parentheses:

Value	Description
zero	When the language requires special treatment of the number 0 (as in Arabic).
one	When the language requires special treatment of numbers like one (as with the number 1 in English and most other languages; in Russian, any number ending in 1 but not ending in 11 is in this class).
two	When the language requires special treatment of numbers like two (as with 2 in Welsh, or 102 in Slovenian).
few	When the language requires special treatment of «small» numbers (as with 2, 3, and 4 in Czech; or numbers ending 2, 3, or 4 but not 12, 13, or 14 in Polish).
many	When the language requires special treatment of «large» numbers (as with numbers ending 11-99 in Maltese).
other	When the language does not require special treatment of the given quantity (as with all numbers in Chinese, or 42 in English).

example: XML file saved at res/values/strings.xml :

XML file saved at res/values-pl/strings.xml :

When using the getQuantityString() method, you need to pass the count twice if your string includes string formatting with a number. For example, for the string %d songs found , the first count parameter selects the appropriate plural string and the second count parameter is inserted into the %d placeholder. If your plural strings do not include string formatting, you don’t need to pass the third parameter to getQuantityString .

Formatting and Styling

Here are a few important things you should know about how to properly format and style your string resources.

Escaping apostrophes and quotes

If you have an apostrophe ( ‘ ) in your string, you must either escape it with a backslash ( \’ ) or enclose the string in double-quotes ( «» ). For example, here are some strings that do and don’t work:

If you have a double-quote in your string, you must escape it ( \» ). Surrounding the string with single-quotes does not work.

Formatting strings

If you need to format your strings using String.format(String, Object. ) , then you can do so by putting your format arguments in the string resource. For example, with the following resource:

In this example, the format string has two arguments: %1$s is a string and %2$d is a decimal number. You can format the string with arguments from your application like this:

Styling with HTML markup

You can add styling to your strings with HTML markup. For example:

Supported HTML elements include:

Sometimes you may want to create a styled text resource that is also used as a format string. Normally, this won’t work because the String.format(String, Object. ) method will 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:

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:

Because the fromHtml(String) method will format 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’ll be passing a string argument to String.format() that may contain characters such as » fromHtml(String) , the characters come out the way they were originally written. For example:

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:

The following bold , italic , and color methods show you how to call the helper methods to apply styles defined in the android.text.style package. You can create similar methods to do other types of text styling.

Here’s an example of how to chain these methods to create a character sequence with different types of styling applied to individual words:

Источник

Android Strings XML Tips & Tricks

Karol Wrótniak Android Developer

This article shows a few tricks which can help you when developing string resources for Android applications.

Post also published on Medium. Click and Follow us.

How can percents make code sick?

By default, string resources are so-called formatted. This means that they can be potentially used for formatting. Here is a simple example:

Lint performs checks on formatted strings and will complain if it encounters a string like this: %d of %d left . The error message in such case is Multiple substitutions specified in non-positional format; did you mean to add the formatted=”false” attribute?.

One may think that adding the formatted=»false» attribute is the proper solution (in fact, there is no other direct suggestions on how to repair this issue). If you add the suggested attribute, the lint error will disappear. However, the correct fix in such cases is to make the format positional. In this example, it would be %1$d of %2$d left .

On the other hand, formatted=»false» is intended for strings where percent signs are not parts of any format specifiers, e.g. Equation: a=50%b+20%c .

Drive Your Product to Success – Free Guide for Digital Product Owners

Even the best team can’t deliver a successful product without proper guidance. If you own a digital product, our Ebook will be a perfect resource for mastering the fundamentals of successful product delivery.

Читайте также:  Как сменить систему android

The secret ingredient

Assume that you are developing an app for local market only and there is no need for English texts. The default translation (located in values directory) will be in the most common language in the given area e.g. Polish in Poland or German in Switzerland. Since there is no locale qualifier in a directory name, English is assumed. This leads to several problems. Firstly, Android Studio spellchecker will complain about most of the words.

Moreover, lint may detect some words as common misspellings and produce warnings as a result. For example, word adres is correct in Polish but is a common misspelling for English address. Here are the quick fixes suggested by Android Studio:

Unfortunately, the best one is not on the list. Note that adding tools:ignore=»Typos» attribute to each tag works but it is quite cumbersome and, thus, not the best solution.

tools:locale attribute is what can really help. It tells the tools what language is used inside a file. You can add it to the resources tag like this:

Keep in mind that this is used only by Android Studio spellchecker and lint. It won’t affect any behaviour at runtime! This is especially true in some areas – it won’t change plural rules, for instance. What does this mean in practice?

Let’s consider the same plural resource with the number of songs from the linked official documentation, but with Polish used as a default translation (located in values directory) and without English at all. Note that the current version of lint will complain about missing many quantity, but we’ll come back to this in the next chapter. Here is the snippet:

For example, if the language of the device is set to Polish and the actual number of songs is 5, the resulting text is Znaleziono 5 piosenek. because 5 in Polish belongs to the many quantity. However, in other languages, the same number may be mapped to different quantities. Take a look at the table below:

CLDR cardinal integer chart fragment. Full version can be found on unicode.org

For example, if the language is set to Lithuanian, we’ll get Znaleziono 5 piosenki. , which is incorrect in Polish. However, if a device is running Android 7 or newer (API 24+) and you specify resConfigs ‘pl’ (see DSL documentation for more information). Then the other quantity will be used in case of locales unsupported by the app. Here is a modified sample plural including this quantity:

Why are inserts sexy?

Let’s say that you have to repeat some text in a few places, e.g. some screen name is used as a label on a list and as a title on that screen itself. Of course, you can just copy and paste them but this is quite inconvenient. In the case of text changes, you have to remember to update it in several places. However, there is a better solution. You can just reference already existing strings, like this:

Entities to the rescue

What about cases where only part of the text is repeated? For example, the application name is used inside several texts. Well, we can create a custom internal XML entity for that. Then, it can used just like standard character entities ( & etc.). Look at the following example:

To translate or not to translate?

Some texts are not meant to be translated. For example, the author’s or application name and other proper names. If you only provide default translations for some strings, omitting them in language-specific files, lint will complain about missing translations. Of course, you can suppress this error but, fortunately, there is a cleaner solution.

translatable=»false» attribute marks the given string as untranslatable. Such resources not only don’t require translations, but must not even have any. Translations of untranslatable text will cause the appropriate lint error. This feature is also supported by Android Studio’s Translation Editor. Here is an example of an untranslatable string:

Источник