Recursos de strings

Un recurso de string ofrece strings de texto para tu aplicación con formato y estilo de texto opcionales. Existen tres tipos de recursos que pueden proporcionar strings para tu aplicación:

String: Recurso XML que ofrece una sola string.
Matriz de strings: Recurso XML que ofrece una matriz de strings.
Strings de cantidad (plurales): Recurso XML que conlleva diferentes strings para brindar pluralización.

Todas las strings pueden aplicar algunos argumentos de formato y lenguaje de marcado de estilo. Para obtener información sobre las strings de formato y estilo, consulta la sección sobre Formato y estilo.

String

Una sola string a la cual se puede hacer referencia desde la aplicación o desde otros archivos de recursos (por ejemplo, un diseño XML).

Nota: Una string es un recurso simple al cual se hace referencia mediante el valor proporcionado en el atributo name (no el nombre del archivo XML). De este modo, puedes combinar recursos de strings con otros recursos simples en el único archivo XML, debajo de un elemento <resources>.

ubicación del archivo:

res/values/filename.xml
El nombre del archivo es arbitrario. El name del elemento de <string> se usa como ID del recurso.

tipo de datos del recurso compilado:

Puntero de recurso para un elemento String.

referencia del recurso:

En Java: R.string.string_name
En XML:@string/string_name

sintaxis:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string
        name="string_name"
        >text_string</string>
</resources>

elementos:

ejemplo:

archivo XML guardado en res/values/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello">Hello!</string>
</resources>

Este XML de diseño aplica una string a un objeto View:

<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/hello" />

Este código de aplicación recupera una string:

Kotlin

val string: String = getString(R.string.hello)

Java

String string = getString(R.string.hello);

Puedes usar getString(int) o getText(int) para obtener una string. getText(int) retiene todo estilo de texto enriquecido aplicado a la string.

Matriz de strings

Matriz de strings a la cual se puede hacer referencia desde la aplicación.

Nota: Una matriz de strings es un recurso simple al cual se hace referencia mediante el valor proporcionado en el atributo name (no el nombre del archivo XML). De este modo, puedes combinar recursos de matriz de strings con otros recursos simples en el único archivo XML, debajo de un elemento <resources>.

ubicación del archivo:

res/values/filename.xml
El nombre del archivo es arbitrario. El name del elemento de <string-array> se usa como ID del recurso.

tipo de datos del recurso compilado:

Puntero de recurso para un elemento de matriz de String.

referencia del recurso:

En Java: R.array.string_array_name

sintaxis:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array
        name="string_array_name">
        <item
            >text_string</item>
    </string-array>
</resources>

elementos:

ejemplo:

archivo XML guardado en res/values/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="planets_array">
        <item>Mercury</item>
        <item>Venus</item>
        <item>Earth</item>
        <item>Mars</item>
    </string-array>
</resources>

Este código de aplicación obtiene una matriz de strings:

Kotlin

val array: Array = resources.getStringArray(R.array.planets_array)

Java

Resources res = getResources();
String[] planets = res.getStringArray(R.array.planets_array);

Strings de cantidad (plurales)

Los diferentes idiomas tienen distintas reglas de concordancia gramatical con la cantidad. En inglés, por ejemplo, la cantidad 1 es un caso especial. Se escribe "1 book" (1 libro), pero, para las demás cantidades, se debe escribir "n books" (n libros). Esta distinción entre singular y plural es muy común; sin embargo, en otros idiomas, se hacen distinciones más detalladas. El conjunto completo compatible con Android es zero, one, two, few, many y other.

Las reglas para decidir el caso que se usará para un idioma y una cantidad determinados pueden ser muy complejas, por lo cual Android te proporciona métodos como getQuantityString() para seleccionar el recurso adecuado para ti.

Si bien históricamente se llamaron "strings de cantidad" (y aún se llaman así en API), las strings de cantidad solo deben usarse para los plurales. Sería un error usar strings de cantidad para implementar algo como "Inbox" de Gmail en comparación con "Inbox (12)" cuando existen mensajes no leídos, por ejemplo. Podría parecer conveniente usar strings de cantidad en lugar de una instrucción if, pero es importante tener en cuenta que, en algunos idiomas (como el chino), no se hacen estas distinciones gramaticales en absoluto, por lo que siempre obtendrás la string other.

La selección de la string que se debe usar se realiza únicamente según la necesidad gramatical. En inglés, una string para zero se ignora incluso si la cantidad es 0, ya que 0 no es gramaticalmente diferente de 2 o cualquier otro número, excepto 1 ("zero books", "one book", "two books", y así sucesivamente). En cambio, en coreano, solo se usa la string other.

No te confundas por el hecho de que, por ejemplo, two suena como si solo pudiera aplicarse a la cantidad 2: un idioma puede requerir que 2, 12, 102 (y así sucesivamente) se traten de manera similar, pero de forma diferente de otras cantidades. Confía en tu traductor para conocer las distinciones en las que insiste su idioma.

En ocasiones, es posible evitar las strings de cantidad usando fórmulas de cantidad neutra, por ejemplo "Books: 1" (Libros: 1). Esto hará más fáciles las cosas para ti y tus traductores si se trata de un estilo aceptable para tu aplicación.

Nota: Una colección de plurales es un recurso simple al cual se hace referencia en el atributo name (no el nombre del archivo XML). Por eso, puedes combinar recursos de plurales con otros recursos simples en un archivo XML, en un elemento <resources>.

ubicación del archivo:

res/values/filename.xml
El nombre del archivo es arbitrario. El name del elemento de <plurals> se usa como ID del recurso.

referencia del recurso:

En Java: R.plurals.plural_name

sintaxis:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <plurals
        name="plural_name">
        <item
            quantity=["zero" | "one" | "two" | "few" | "many" | "other"]
            >text_string</item>
    </plurals>
</resources>

elementos:

<resources>

Obligatorio. Debe ser el nodo raíz.

Sin atributos.

<plurals>

Una colección de strings, de las cuales se proporciona una string según la cantidad de algún elemento. Contiene uno o más elementos <item>.

atributos:

name: String. Nombre para el par de strings. El nombre se usa como ID del recurso.

<item>

Una string singular o plural. El valor puede ser una referencia a otro recurso de strings. Debe ser un campo secundario de un elemento <plurals>. Ten en cuenta que se deben escapar apóstrofos y comillas. Consulta Formato y estilo a continuación para obtener información sobre cómo dar formato y estilo adecuadamente a tus strings.

atributos:

quantity

Palabra clave. Valor que indica cuándo debe usarse esta string. Valores válidos, con ejemplos no exhaustivos entre paréntesis:

Valor	Descripción
`zero`	Cuando el idioma requiere tratamiento especial del número 0 (como en árabe).
`one`	Cuando el idioma requiere tratamiento especial de números como el uno (como el número 1 en inglés y la mayoría de los demás idiomas; en ruso, se encuentran dentro de esta clase todos los números que finalizan en 1, pero no en 11).
`two`	Cuando el idioma requiere tratamiento especial de números como el dos (como el 2 en galés, o el 102 en esloveno).
`few`	Cuando el idioma requiere tratamiento especial de números "pequeños" (como el 2, el 3 y el 4 en checo, o los números que finalizan en 2, 3 o 4, excepto el 12, el 13 o el 14 en polaco).
`many`	Cuando el idioma requiere tratamiento especial de números "grandes" (como los números que finalizan en 11-99 en maltés).
`other`	Cuando el idioma no requiere tratamiento especial de la cantidad especificada (como todos los números en chino o el 42 en inglés).

ejemplo:

archivo XML guardado en res/values/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <plurals name="numberOfSongsAvailable">
        <!--
             As a developer, you should always supply "one" and "other"
             strings. Your translators will know which strings are actually
             needed for their language. Always include %d in "one" because
             translators will need to use %d for languages where "one"
             doesn't mean 1 (as explained above).
          -->
        <item quantity="one">%d song found.</item>
        <item quantity="other">%d songs found.</item>
    </plurals>
</resources>

Archivo XML guardado en res/values-pl/strings.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <plurals name="numberOfSongsAvailable">
        <item quantity="one">Znaleziono %d piosenkę.</item>
        <item quantity="few">Znaleziono %d piosenki.</item>
        <item quantity="other">Znaleziono %d piosenek.</item>
    </plurals>
</resources>

Uso:

Kotlin

val count = getNumberOfSongsAvailable()
val songsFound = resources.getQuantityString(R.plurals.numberOfSongsAvailable, count, count)

Java

int count = getNumberOfSongsAvailable();
Resources res = getResources();
String songsFound = res.getQuantityString(R.plurals.numberOfSongsAvailable, count, count);

Cuando se usa el método getQuantityString(), debes pasar count dos veces si tu string incluye formato de string con un número. Por ejemplo, para la string %d songs found, el primer parámetro de count selecciona el plural adecuado, y el segundo parámetro de count se inserta en el marcador de posición %d. Si tus strings de plural no incluyen formato de string, no es necesario que pases el tercer parámetro a getQuantityString.

Formato y estilo

A continuación, se mencionan algunos puntos importantes que debes conocer sobre cómo dar formato y estilo adecuadamente a tus recursos de strings.

Caracteres especiales

Cuando una string contiene caracteres que se usan de manera especial en XML o Android, se deben escapar esos caracteres. Es posible escapar algunos caracteres colocando antes una barra invertida, mientras que otros requieren el escape con XML. Los apóstrofos y las comillas simples también pueden manejarse si se encierra toda la string entre comillas dobles. Estos son algunos ejemplos:

Carácter	Formas de escape
@	\@
?	\?
<	<
&	&
Comilla simple (`'`)	Cualquiera de los siguientes: ' \' Encierra toda la string entre comillas dobles ("de este modo", por ejemplo)
Comilla doble (`"`)	Cualquiera de los siguientes: " \" Ten presente que se deben escapar las comillas dobles. Encerrar la string entre comillas simples no funciona.

Dar formato a las strings

Si necesitas dar formato a tus strings, puedes hacerlo disponiendo tus argumentos de formato en el recurso de strings, tal como se demuestra en el siguiente recurso de ejemplo:

<string name="welcome_messages">Hello, %1$s! You have %2$d new messages.</string>

En este ejemplo, la string de formato tiene dos argumentos: %1$s es una string y %2$d es un número decimal. Entonces, dale formato a la string llamando a getString(int, Object...). Por ejemplo:

Kotlin

var text = getString(R.string.welcome_messages, username, mailCount)

Java

String text = getString(R.string.welcome_messages, username, mailCount);

Dar estilo con el lenguaje de marcado HTML

Puedes agregar estilo a tus strings con el lenguaje de marcado HTML. Por ejemplo:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="welcome">Welcome to <b>Android</b>!</string>
</resources>

Se admiten los siguientes elementos HTML:

Negrita: ,
Cursiva: , <cite>, <dfn>
Texto 25 % más grande: <big>
Texto 20 % más pequeño:
Configurar propiedades de la fuente: . Algunas familias de fuentes posibles son monospace, serif y sans_serif.
Configurar una familia de fuentes monospace: <tt>
Tachado: <s>, <strike>, <del>
Subrayado:
Superíndice:
Subíndice:
Viñetas: <ul>, <li>
Saltos de línea:
División: <div>
Estilo CSS:
Párrafos:

Si decides no aplicar formato, puedes llamar a setText(java.lang.CharSequence) para establecer el texto de TextView directamente. Sin embargo, en algunos casos, es posible que desees crear un recurso de texto con estilo que también se use como string de formato. Generalmente, esto no funciona porque los métodos format(String, Object...) y getString(int, Object...) quitan toda la información de estilo de la string. La solución temporal para esto es escribir las etiquetas HTML con entidades escapadas, que se recuperan después con fromHtml(String) una vez que se lleva a cabo el formato. Por ejemplo:

Almacena tu recurso de texto con estilo como una string escapada con HTML:
```
<resources>
 <string name="welcome_messages">Hello, %1$s! You have &lt;b>%2$d new messages&lt;/b>.</string>
</resources>
```
En esta string con formato, se agrega un elemento . Ten en cuenta que el corchete de apertura está con escape HTML mediante la anotación <.

Luego, da formato a la string como siempre, pero también llama a fromHtml(String) para convertir el texto HTML en texto con estilo:

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);

Debido a que el método fromHtml(String) da formato a todas las entidades HTML, asegúrate de escapar todos los caracteres HTML posibles en las strings que usas con el texto con formato mediante htmlEncode(String). Por ejemplo, si das formato a una string que contiene caracteres como "<" o "&", se deben escapar antes de dar formato, de modo que, cuando se pase la string con formato por fromHtml(String), los caracteres aparezcan como se escribieron originalmente. Por ejemplo:

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);

Dar estilo con Spannable

Un Spannable es un objeto de texto al cual puedes dar estilo con propiedades de tipos de letras, como color y tamaño de las fuentes. Usas SpannableStringBuilder para crear tu texto y, luego, aplicar estilos definidos en el paquete de android.text.style para el texto.

Puedes usar los siguientes métodos auxiliares para configurar gran parte del trabajo de crear texto de Spannable:

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<out CharSequence>, 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<out Any>) {
    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<out Any>) {
    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);
        }
    }
}

Los siguientes métodos bold, italic y color contienen los métodos de ayuda anteriores y permiten ver ejemplos específicos de cómo dar estilos definidos en el paquete android.text.style. Puedes crear métodos similares para dar otros tipos de estilos al texto.

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));
}

Este es un ejemplo de cómo encadenar estos métodos a fin de aplicar diversos estilos a palabras específicas en una frase:

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)))
</pre>
</section><section><h3 id="java">Java</h3>
<pre class="prettyprint lang-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)));

El módulo core-ktx de Kotlin también contiene funciones de extensión que facilitan mucho más el trabajo con intervalos. Para obtener más información, puedes consultar la documentación sobre el paquete android.text en GitHub.

Para obtener más información sobre el trabajo con intervalos, consulta estos enlaces:

Dar estilo con anotaciones

Puedes aplicar estilos complejos o personalizados si usas la clase Annotation junto con la etiqueta <annotation> en tus archivos de recursos strings.xml. La etiqueta de anotación permite marcar partes de la string para darles un estilo personalizado. Para hacerlo, deben definirse pares clave-valor personalizados en el XML que el marco de trabajo convertirá en intervalos de Annotation. Después, puedes recuperar estas anotaciones y usar la clave y el valor para aplicar el estilo.

Al crear anotaciones, asegúrate de agregar la etiqueta <annotation> a todas las traducciones de la string en cada archivo strings.xml.

Aplicar un tipo de letra personalizado a la palabra "texto" en todos los idiomas

Ejemplo: Agregar un tipo de letra personalizado

Agrega la etiqueta <annotation> y define el par clave-valor. En este caso, la clave es font y el valor es el tipo de fuente que queremos usar: title_emphasis.

// values/strings.xml
<string name="title">Best practices for <annotation font="title_emphasis">text</annotation> on Android</string>

// values-es/strings.xml
<string name="title"><annotation font="title_emphasis">Texto</annotation> en Android: mejores prácticas</string>

Carga el recurso de strings y busca las anotaciones con la clave font. Después, crea un intervalo personalizado y reemplaza el existente.

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_about);

// 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;

Si usas el mismo texto varias veces, debes construir el objeto SpannableString una vez y volver a usarlo cuando lo necesites. Así evitarás posibles problemas de rendimiento y memoria.

Para conocer otros ejemplos del uso de anotaciones, consulta Dar estilo a texto internacional en Android.

Intervalos de anotación y parcelas de texto

Dado que los intervalos de Annotation también son ParcelableSpans, los pares clave-valor pueden dividirse y reunirse en parcelas. Siempre y cuando el receptor de la parcela sepa cómo interpretar las anotaciones, puedes usar intervalos de Annotation para aplicar estilos personalizados al texto en parcelas.

Para mantener el estilo personalizado cuando pasas el texto a un conjunto de la intent, primero debes agregar a tu texto intervalos de Annotation. Puedes hacerlo en los recursos XML usando la etiqueta <annotation> (como se muestra en el ejemplo anterior) o en el código, creando una nueva Annotation y definiéndola como intervalo, tal como se ejemplifica a continuación:

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);

Recupera el texto del Bundle como una SpannableString y, luego, divide las anotaciones adjuntas, tal como se ejemplificó anteriormente.

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);

Para obtener más información sobre cómo dar estilo al texto, consulta los siguientes enlaces:

Menú

Estilo