En este artículo veremos el uso de strings en Android para el manejo de recursos de texto en nuestras aplicaciones. Esto implica conocer muy bien el archivo strings.xml y las etiquetas XML que podemos usar dentro de él.
Nos apoyaremos en la potencia de Android Studio al momento de generar automáticamente strings dentro de los recursos.
También veremos el formateo y la aplicación de estilos a las cadenas.
Casos para el uso de caracteres especiales como apostrofes, comillas dobles, signos mayor qué y menor qué, etc.
Incluso la aplicación de marcado HTML para representar mejor el contenido.
Finalmente terminaremos con la explicación de la clase Spannable, la cual facilita el estilizado de strings de forma programática. Y creación de apps con múltiples idiomas.
El Archivo strings.xml En Android
Antes de comenzar con la explicación, necesitas crear un proyecto nuevo en Android Studio para ir comprobando a la par los casos de estudio.
Para ello…
1. Abre Android Studio, ve a File > New > New Project… para crea un nuevo proyecto.
2. Una vez que el asistente de creación se abra, cambia el nombre del proyecto por «Uso De Strings En Android» y confirma.
3. Ahora solo presiona Next y deja el soporte de versiones por defecto.
4. Debido a que este proyecto solo es para probar strings, elegiremos una actividad en blanco como pantalla principal.
5. Ahora cambia el nombre de la clase a ActividadPrincipal al igual que su layout y menú. Al título asígnale «Recursos Strings En Android».
Como viste en el artículo Uso De Recursos En Android los recursos de texto son guardados en el archivo res/values/strings.xml.
La etiqueta básica de contenido es <string>, cuyo contenido es una cadena de caracteres. Al abrir este archivo en nuestro proyecto actual tendríamos el siguiente contenido:
<resources>
<string name="app_name">Uso De Strings En Android</string>
<string name="hello_world">Hello world!</string>
<string name="action_settings">Settings</string>
</resources>
La primera cadena representa el nombre de la aplicación y de la actividad principal que acabamos de crear. El string "hello_world" contiene el texto que va en un TextView generado automáticamente dentro del layout de la actividad. Y el tercer string es el texto para el action button que se encuentra en la action bar.
Cada uno de los elementos que representan texto dentro de strings.xml tiene un identificador asociado en el archivo R.java representado por el atributo name. Si observas el su contenido verás una clase estática interna llamada string, donde los campos son constantes con los identificadores:
Como ves, cada una de las cadenas usadas en el atributo name es convertida en una constante entera que representa al string en el código Java. Esta conexión permite que accedamos a los recursos con facilidad.
No te preocupes por la gran cantidad de identificadores agregados automáticamente por Android. Simplemente son elementos que se necesitan para mantener la compatibilidad de versiones, es inevitable que estén allí.
La Etiqueta <string>
Representa un string simple que al momento de ser compilado produce un tipo String para el código Java.
Para declarar este elemento dentro de strings.xml es necesario que exista un padre del tipo <resources> o de lo contrario no se reconocerá. Esto se muestra en la siguiente sintaxis:
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="nombre_string">contenido_string</string>
</resources>
Para acceder al contenido de un string a través del código, se usa la clase R de la siguiente forma:
R.string.nombre_string
Por otro lado, en una definición XML se accede así:
@string/nombre_string
Como ya vimos, el valor del atributo name representa el identificador de cada etiqueta <string>.
Si revisas el archivo res/layout/actividad_principal.xml verás que el TextView existente referencia el string hello_world en su atributo android:text.
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/hello_world"
android:text="@string/hello_world" />
En la vista de diseño de Android Studio podemos percibir el valor del texto gracias al árbol de componentes, el panel de propiedades y obviamente reflejado en la previsualización.
¿Cómo hacer para obtener el valor de un string en código?
Uno de los métodos es usar la clase Resources, la cual representa la carpeta res dentro del código. Esta provee métodos get*() para conseguir varios tipos de valor almacenados en recursos.
En este caso particular sería el método getString(). Solo pasas como parámetro el indicador y así obtendrás su contenido.
Por ejemplo… obtengamos el valor del string app_name y asignémoslo al text view de la actividad. Esto lo haremos dentro del controlador onCreate() de ActividadPrincipal.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.actividad_principal);
TextView helloWorld = (TextView)findViewById(R.id.hello_world);
String nombreAplicacion = getResources().getString(R.string.app_name);
helloWorld.setText(nombreAplicacion);
}
Ejecuta la app y tendrás el cambio:
También puedes usar el método getString() desde la actividad sin llamar a la clase Resources.
String nombreAplicacion = getString(R.string.app_name);
Otra alternativa es el método getText(), el cual retorna en un tipo CharSequence. Este método difiere a getString() en la capacidad de obtener el string con estilos (ej. cambio de color de fuente).
helloWorld.setText(getText(R.string.hello_world));
Arreglo De Strings Con La Etiqueta <string-array>
Otra forma de contener elementos de texto en los recursos es a través de arreglos. La etiqueta que nos permitirá este funcionalidad es <string-array>.
El identificador de este componente se define con el atributo name y cada elemento del arreglo se representa con elementos hijos del tipo <item>. El contenido de cada item sería un string.
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string-array name="nombre_arreglo">
<item>contenido_string</item>
<item>contenido_string</item>
<item>contenido_string</item>
...
</string-array>
</resources>
El acceso a un array de strings en java se realiza con la clase anidada estática R.array.
R.array.nombre_array
En XML se antepone la sentencia @array.
@array/nombre_array
Por ejemplo…
Uno de los usos comunes de un array de strings se da en el view Spinner. Recuerda que este control despliega una lista opciones para selección del usuario.
Comprobémoslo cambiando el text view de la actividad por un spinner de la siguiente forma.
<Spinner
android:id="@+id/spinner"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true" />
Ahora dentro de strings.xml añade el siguiente array de strings.
<string-array name="posiciones">
<item>Top</item>
<item>Mid</item>
<item>Bot</item>
<item>Jungla</item>
</string-array>
Este contiene las posiciones de los jugadores en el juego League Of Legends.
Para asignar los ítems al spinner sin usar un adaptador usamos el atributo android:entries. Este recibe la referencia de un array que contenga las opciones. Solo basta acceder a posiciones con definición XML.
<Spinner
android:id="@+id/spinner"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:entries="@array/posiciones"/>
También puedes hacerlo a través del panel de propiedades en Android Studio.
Limpia el código de onCreate() que ya no usarás y ejecuta la aplicación.
Ahora, si deseas obtener el valor de un array de strings en el código, entonces usa la el método Resources.getStringArray().
String[] posiciones = getResources().getStringArray(R.array.posiciones);
Creación De Plurales Con La Etiqueta <plurals>
Los plurales son strings que representan diferentes cantidades de un texto según la situación.
Por ejemplo…
Al realizar una búsqueda de elementos en tu aplicación tal vez quieras informarle al usuario cuantos fueron encontrados. Puede que no se haya encontrado ninguno, o tal vez uno o quizás varios.
Si deseas presentar la información en una frase sería algo como:
«n elementos encontrados»
Donde se reemplazaría n por la cantidad. Por lo tanto al tener la expresión n=1, el resultado sería:
«1 elementos encontrados»
Esta sería una solución para abarcar todas las opciones, pero produce resultados anómalos. Necesitaríamos tres tipos de frases para poder mantener la integridad de nuestra gramática.
- «No se encontraron elementos»
- «Se encontró un elemento»
- «Se encontraron n elementos»
Con el fin de solucionar este lio existen los plurales. Recursos que contienen una serie de elementos que representan la variación de una oración dependiendo del número de elementos mencionados.
Su implementación se basa en la etiqueta <plurals>. Su ID se genera a partir del atributo name y cada variación se define como un elemento hijo del tipo <item>.
La cantidad de elementos del ítem se asigna con el atributo quantity y su contenido es el string a guardar.
<?xml version="1.0" encoding="utf-8"?>
<resources>
<plurals name="nombre_plural">
<item quantity=["zero" | "one" | "two" | "few" | "many" | "other"]>contenido_string
</item>
</plurals>
</resources>
Las constantes que se ven para quantity definen cantidades estándar. Veamos una tabla con las definiciones:
| Valor | Descripción |
|---|---|
zero |
Se refiere a el número 0 si el lenguaje necesita este tipo de interpretación |
one |
Se refiere a la unidad (1) |
two |
Constante para la representación especial de 2 unidades. |
few |
Se refiere a una cantidad pequeña de unidades dependiendo del lenguaje |
many |
Se refiere a una gran cantidad de elementos. |
other |
Constante para cuando no se necesita un tratamiento específico. |
Cabe aclarar que la interpretación de cada constante varía de un lenguaje a otro, por lo que habría que asesorarse ante la traducción de plurales.
La única forma para acceder a un plural es a través de código.
R.plurals.nombre_plural
Ejemplo de plurales— Vamos a crear un plural que se refiera a una cantidad hipotética de productos encontrada en una búsqueda.
Para ello limpiamos el método onCreate() de la actividad y reemplazamos el spinner anterior por un text view.
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="New Text"
android:id="@+id/textView"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true" />
El plural que añadiremos a strings.xml tendrá tres casos disponibles. El no encontrar un valor, encontrar uno solo y encontrar varios.
<string name="zero">No se encontraron productos</string> <plurals name="noProductosEncontrados"> <item quantity="one">Se encontró %d producto</item> <item quantity="other">Se encontraron %d productos</item> </plurals>
Ahora obtendremos el valor de un plural en onCreate() con el método Resources.getQuantityString(). Este recibe el ID del plural como primer parámetro, el segundo parámetro es la cantidad de elementos encontrados y el tercero será el número que reemplace los placeholders %d.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.actividad_principal);
TextView textView = (TextView) findViewById(R.id.textView);
Random random = new Random();
int cantidad = random.nextInt(9);
if (cantidad == 0) {
textView.setText(R.string.zero);
} else {
Resources res = getResources();
String string = res.getQuantityString(
R.plurals.noProductosEncontrados,
cantidad,
cantidad);
textView.setText(string);
}
}
Si te fijas, el caso "zero" no se incluye en el plural. Esto sucede porque al parecer el framework de Android no interpreta el 0 como la ausencia de elementos, lo que hace que se incluya en el caso "other". Con eso tendríamos el resultado:
"Se encontraron 0 productos"
Para evitarlo, creamos un nuevo string simple con el valor correcto y luego usamos un if para diferenciar entre ambos resultados producidos por la cantidad aleatoria producida con la clase Random.
Cuando creas un plural Google recomienda añadirle como mínimo los casos "one" y "other" para el soporte de la mayoría de lenguajes. Además indica que el caso "one" debe tener el placeholder %d para darle el tratamiento en otros lenguajes donde «1» no se interpreta como en el español. Esto facilita la comprensión y trabajo a los traductores.
Si ejecutas la aplicación tendrías resultados similares a la siguiente ilustración.
Uso De Caracteres Especiales En Strings
Existen casos donde deseamos poner caracteres especiales dentro de nuestros recursos strings como lo son acentos, símbolos o caracteres que hacen parte de XML. Sin embargo hacerlo de forma estática no produce resultados deseados.
Para comprobarlo volvamos a nuestra aplicación. Limpia el método onCreate() y crea un nuevo string con el siguiente valor.
<string name="frase">"Su activo más valioso puede ser su voluntad de persistir más que cualquier otra persona"</string>
Asigna el recurso al text view y corre la aplicación.
¿Cuál es el resultado?
Las comillas no aparecerán.
Las comillas dobles y los apóstrofos no serán interpretados por el framework de Android a no ser que antepongas una barra vertical (' y "). Esto se debe a que las secuencias de caracteres en Java usan estos símbolos como escape para representar dichos elementos.
El ejemplo anterior quedaría de la siguiente forma.
<string name="frase">"Su activo más valioso puede ser su voluntad de persistir más que cualquier otra persona"</string>
Para el apostrofo es igual. Agregamos el backslash para subsanar el escape.
<string name="apostrofos">Donde procrastinar significa 'Diferir, aplazar'</string>
Otra opción es encerrar todo el string con comillas dobles y usar los apóstrofos de forma normal.
<string name="apostrofos">"Donde procrastinar significa 'Diferir, aplazar'"</string>
Sin embargo este mecanismo no funciona a la inversa.
<string name="frase">'"Ser discutido, es ser percibido"'</string>
Se produciría un error como este:
De forma similar podemos usar las otras secuencias de escape que existen para los strings en Java.
| Secuencia de escape | Descripción |
|---|---|
t |
Inserta una tabulación |
b |
Inserta un retroceso |
n |
Inserta nueva línea |
r |
Inserta retorno de carro |
f |
Comienzo de página |
' |
Comilla simple o apóstrofo |
" |
Comillas dobles |
\ |
Backslash |
Por ejemplo, si quisiéramos introducir una nueva en un string usaríamos la secuencia n.
<string name="nueva_linea">-Hola!n-Hablámen-Como va todo?n-Bien bien :D</string>
Caracteres especiales de acceso a recursos— Recuerda que el arroba '@' y el signo de interrogación '?' permiten acceder al valor de un recurso en XML. Lo que significa que son caracteres restringidos.
Si intentas usarlos en la primera posición de un string, se producirá un error de interpretación. La solución consiste en usar comillas dobles para evitar el inconveniente.
<string name="interrogacion">"?"</string> <string name="arroba">"@"</string>
Si estos símbolos son usados en otra posición no es necesario usar las comillas.
<string name="info_correo">Tu correo es: correo@gmail.com</string>
Caracteres de escape en XML— En el artículo Tutorial Básico Del Lengueje Xml vimos que hay 5 caracteres que no pueden ser usados normalmente dentro de los contenidos de una etiqueta, ya que hacen parte de la notación XML.
| Carácter | Representación |
|---|---|
& |
& |
< |
< |
> |
> |
“ |
" |
‘ |
' |
Algunos ejemplos serían…
Ampersand :
<string name="ampersand_mal">Johnson & Johnson</string> <string name="ampersand_correcto">Johnson & Johnson</string>
Menor qué:
<string name="menor_que_mal">3<2</string> <string name="menor_que_correcto">3<2</string>
Mayor qué:
<string name="etiqueta"><string></string>
Comillas dobles:
<string name="comillas_dobles_mal">"Coldplay"</string> <string name="comillas_dobles_correcto">"Coldplay"</string>
Sorprende un poco que el primer ejemplo no funcione. Esto se debe a que el parser cambia primero a texto plano los caracteres de escape XML y luego convierte el contenido resultante en un tipo String de java. Por eso es necesario usar los escapes de java también.
Apóstrofos:
<string name="apostrofos_mal">Signo de escritura (') que se emplea para indicar la elisión de una vocal.</string> <string name="apostrofos_correcto">Signo de escritura (') que se emplea para indicar la elisión de una vocal.</string>
Uso de caracteres Unicode— También es posible usar las representaciones de caracteres especiales a través del estándar Unicode. Simplemente haces referencia al código de cada elemento anteponiendo u. La siguiente tabla muestra algunos caracteres:
Si deseáramos usar las comillas, escribimos el código u0022:
<string name="comillas_unicode">u0022Capitan Teemo de serviciou0022</string>
Otro ejemplo podría ser el uso del carácter que representa una octava en música con el código u266A.
<string name="octava_unicode">Te quiero yo… y tú a mi u266A</string>
Formateo De Strings En Android
Los recursos de strings también pueden ser formateados a través de parámetros especificados por placeholders. Si tienes experiencia con la clase String de java, sabrás que el método estático String.format() nos permite añadir formato.
Para conectar este método con un recurso string simplemente debes añadir placeholders que indiquen el tipo de parámetro a reemplazar dentro de la cadena más la posición que se desea ocupar.
Veamos un ejemplo:
<string name="string_formateada">¡Qué bien %1$s! Has alcanzado %2$d puntos</string>
El anterior ejemplo tiene dos parámetros: %1$s y %2$s. El primero representa un string en java (%s) y su posición es determinada en el parser con 1$. El segundo es de tipo entero (%d) y está en segunda posición 2$.
Ve al método onCreate() de la actividad y obtén el recurso string que acabos de ver. Luego usa el método format() asignando dos valores correspondientes y por último setea el resultado en el text view.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.actividad_principal);
Resources res = getResources();
String recurso = res.getString(R.string.string_formateada);
String stringFormateada = String.format(recurso, "James", 120);
TextView texto = (TextView)findViewById(R.id.textView);
texto.setText(stringFormateada);
}
Al ejecutar la aplicación tendremos el siguiente resultado:
Aplicar Marcado Html En Un Recurso String
Como era de suponer, el contenido XML de un string puede ser estilizado usando marcado Html. Podemos usar las siguientes etiquetas:
<b>: Imprime el texto en negrilla.<i>: Transforma el texto a inclinación itálica.<u>: Subraya el texto.
Por ejemplo…
<string name="string_html"><i>Recursos</i> <u>String</u> Con Marcado <b>Html</b></string>
Si asignas el anterior string al text view en su definición XML, el parser automáticamente interpretará las etiquetas Html y producirá el resultado anterior.
Por otro lado, para asignar el recurso programáticamente debemos usar el método estático Html.fromHtml() para traducir las etiquetas Html. De lo contrario, en tu string saldrán las etiquetas textualmente.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.actividad_principal);
Resources res = getResources();
String texto = res.getString(R.string.string_html);
CharSequence textoInterpretado = Html.fromHtml(texto);
TextView textView = (TextView)findViewById(R.id.textView);
textView.setText(textoInterpretado);
}
Si pruebas el código anterior verás que no se aplican los estilos. La solución está en usar secuencias de escape, debido a que el parser al transformar el texto ha ignorado todo el html.
<string name="string_html"><i>Recursos</i> <u>String</u> Con Marcado <b>Html</b></string>
¿Es posible usar etiquetas html como <br>, <p> o <strong>?
De la forma en que lo estamos haciendo hasta ahora no.
Sin embargo puedes ignorar completamente el contenido de una etiqueta <string> con la cláusula CDATA. Con ello pasarías un código completo Html al método fromHtml() para que este interprete la cantidad de etiquetas que pueda (no todas son aceptadas).
Probemos usando el código html que tiene la descripción del método fromtHtml() en la documentación oficial.
<string name="string_html_cdata">
<![CDATA[
<div>
<h4>
<span>
public static
<a href="/reference/android/text/Spanned.html">Spanned</a>
</span>
<span>fromHtml</span>
<span>(<a href="/reference/java/lang/String.html">String</a> source)</span>
</h4>
<div>
<div> Added in <a href="/guide/topics/manifest/uses-sdk-element.html#ApiLevels">API level 1</a></div>
</div>
<div>
<div>
<p>Returns displayable styled text from the provided HTML string.
Any <img> tags in the HTML will display as a generic
replacement image which your program can then go through and
replace with real images.
</p>
<p>This uses TagSoup to handle real HTML, including all of the brokenness found in the wild.</p>
</div>
</div>
</div>
]]>
</string>
Al ejecutar la aplicación (obviamente después de haber cambiado la referencia del string en onCreate()) tendremos los siguiente.
Añadir Estilo Al Texto Con Spannable
Existe otra forma para aumentar las capacidades de estilo de nuestros strings y es a través de la interfaz Spannable.
Cuando un texto adquiere las características de la interfaz Spannable, este es capaz de modificar su aspecto en varios sentidos, como el tamaño de la fuente, color, el formato de sus caracteres, etc.
Para aprovechar esa capacidad se usa la clase auxiliar SpannableStringBuilder, la cual permite construir un texto con marcas de estilo. Luego se aplica sobre esas marcas algunos de los estilos contenidos en el paquete android.text.style.
Veamos un ejemplo donde ponemos la primera letra en negrilla de un string.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.actividad_principal);
SpannableStringBuilder stringBuilder =
new SpannableStringBuilder(getString(R.string.hello_world));
stringBuilder.setSpan(new StyleSpan(Typeface.BOLD),0,1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
TextView textView = (TextView)findViewById(R.id.textView);
textView.setText(stringBuilder);
}
En primera instancia creamos una instancia de SpannableStringBuilder con una copia del string hello_world.
Luego a través del método setSpan() aplicamos el estilo con los siguientes parámetros.
public void setSpan(Object what, int start, int end, int flags)
what: Un nuevo objeto del estilo de texto.start: Índice inicial del carácter donde se insertará el estilo.end: Índice del carácter final hasta donde se aplicará el estilo.flags: Banderas que determinan el comportamiento del texto cuando se aplica el estilo
La clase que proporciona el estilo de escritura es StyleSpan, por eso la usamos en el primer parámetro. Su constructor recibe una constante del tipo Typeface para determinar si es negrilla, itálica o cursiva. En este caso BOLD representa negrilla. Las otras constantes las encuentras en la definición de la clase.
Debido a que solo necesitamos colocar en negrilla la primer letra, entonces el índice inicial del string es 0 y el final será 1.
La bandera Spanned.SPAN_EXCLUSIVE_EXCLUSIVE evita que el tamaño del string cambie o tenga tamaño 0.
Si ejecutas la aplicación tendrás el siguiente resultado.
Para cambiar el color puedes usar la clase ForegroundColorSpan de la siguiente forma.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.actividad_principal);
SpannableStringBuilder stringBuilder =
new SpannableStringBuilder(getString(R.string.hello_world));
stringBuilder.setSpan(new ForegroundColorSpan(Color.RED),
0, 6, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
TextView textView = (TextView) findViewById(R.id.textView);
textView.setText(stringBuilder);
}
Esta vez solo pasamos un nuevo objeto ForegroundColorSpan con la constante que representa el color rojo Color.RED. El estilo es aplicado en la primera palabra.
Si ya revisaste el paquete android.text.style verás que existe una gran variedad de posibilidades de personalización.
Si quieres ver más ejemplos puedes visitar este artículo introductorio a spannables en Android.
Soportar Múltiples Lenguajes En Android
Es posible crear recursos alternativos para el archivo strings.xml y así mantener la compatibildiad con varias ubicaciones y regiones.
Recuerda que para ello es necesario añadir los calificadores de idioma y región. Todo depende del público al que va dirigido tu aplicación Android.
Veamos cómo hacer una pequeña traducción del español al inglés e italiano.
1. Modifica el contenido del archivo strings.xml con las siguientes cadenas.
<resources xmlns:tools="http://schemas.android.com/tools" tools:locale="es">
<string name="app_name">Uso De Strings En Android</string>
<string name="action_settings">Configuración</string>
<string name="etiqueta_estado_civil">Estado Civil</string>
<string name="boton_busqueda">Buscar</string>
<string-array name="estado_civil">
<item>Soltero</item>
<item>Casado</item>
<item>Viudo</item>
</string-array>
</resources>
El atributo tools:locale nos permite establecer el idioma por defecto del archivos strings.xml. En este caso español es.
2. Cambia el layout de la actividad principal con el siguiente diseño. La idea es tener un encabezado gigante con la etiqueta "Estado Civil". En el centro irá un Spinner que se alimenta del array estado_civil y al final un botón que contiene el texto de boton_busqueda.
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".ActividadPrincipal">
<Button
android:id="@+id/button"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_alignParentBottom="true"
android:layout_centerHorizontal="true"
android:layout_marginEnd="43dp"
android:layout_marginRight="43dp"
android:text="@string/boton_busqueda" />
<Spinner
android:id="@+id/spinner"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
android:entries="@array/estado_civil" />
<TextView
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:text="@string/etiqueta_estado_civil"
android:textSize="50sp" />
</RelativeLayout>
Si ejecutas hasta aquí, tendrás lo siguiente:
3. A continuación crearemos las traducciones para cada uno de los strings que tenemos. Abre el archivo strings.xml y selecciona la opción emergente Open Editor en la parte superior del espacio de trabajo.
Otra forma de acceder al editor de traducciones es presionar click derecho sobre el archivo strings.xml y seleccionar Open Translations Editor.
El editor de traducciones o Translations Editor es donde se gestionan los valores de idioma para cada elemento.
Dentro de él encontrarás tres columnas. Key para representar el identificador de cada string. Default Value que determina el valor por defecto del string. Untranslatable para marcar un elemento como no traducible (una señal que informa a los traductores que contrates).
4. El archivo res/values/strings.xml sin calificador se asigna al idioma por defecto que es el inglés. Sin embargo nosotros tenemos cadenas en español en esa ubicación.
Presiona el icono del globo terraqueo en la parte superior izquierda y luego selecciona la opción English (en).
Esto mostrará una nueva pantalla donde podremos ingresar la traducción directa al inglés de cada string.
5. Lo siguiente es editar las casillas correspondientes y añadir las traducciones:
6. Ahora realiza el mismo procedimiento con la traducción italiana (Usé Google Translator, quien sepa italiano podría colaborarme con mejores traducciones).
7. Abordemos la traducción del array de strings. Esto requiere la creación de strings simples que se referencien dentro de cada ítem. De lo contrario, no tendremos la traducción para estos elementos.
Crea tres nuevos recursos dentro de strings.xml. Luego asígnalos a las etiquetas <item> en el orden establecido.
<string name="estado_soltero">Soltero</string>
<string name="estado_casado">Casado</string>
<string name="estado_viudo">Viudo</string>
<string-array name="estado_civil">
<item>@string/estado_soltero</item>
<item>@string/estado_casado</item>
<item>@string/estado_viudo</item>
</string-array>
Ahora asignemos los valores correspondientes en ambas traducciones.
Con esto tendríamos los siguientes archivos.
values-en/strings.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="app_name">Uso De Strings En Android</string>
<string name="action_settings">Settings</string>
<string name="boton_busqueda">Search</string>
<string name="etiqueta_estado_civil">Marital Status</string>
<string name="estado_casado">Married</string>
<string name="estado_soltero">Single</string>
<string name="estado_viudo">Widower</string>
</resources>
values-it/strings.xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
<string name="app_name">Uso De Strings En Android</string>
<string name="action_settings">Configurazione</string>
<string name="boton_busqueda">Ricerca</string>
<string name="etiqueta_estado_civil">Stato Civile</string>
<string name="estado_casado">Sposato</string>
<string name="estado_soltero">Singolo</string>
<string name="estado_viudo">Vedovo</string>
</resources>
Si revisas la jerarquía de la carpeta res verás que tienes el subdirectorio values por defecto más otros dos, values-en y values-it.
8. Prueba los recursos strings.xml cambiando el idioma en Ajustes > Idioma e introducción de texto > Idioma.
Prueba usando inglés.
Con ello verás el siguiente resultado.
Ordenar Una Traducción En Android Studio
Finalmente te cuento que existe la posibilidad de contratar un servicio especial de Google para ordenar la traducción de tu archivo strings.xml a cualquier idioma.
Este tiene un costo, sin embargo es un servicio profesional de buena calidad.
Puedes contratarlo seleccionando la opción Order a translation… que se encuentra en el editor de traducciones.
Para ello es necesario que tengas una cuenta con Google. Subes tus recursos, seleccionas el lenguaje para la traducción y finalmente pagas.
Un servicio simple que puedes considerar usar para tus proyectos.
Conclusión
En este artículo has visto gran variedad de características de los recursos strings en Android.
Ahora ya sabes que es posible crear recursos de texto con gran variedad de utilidades. Esto representa una ventaja a la hora de generar interfaces basadas en texto con formatos y estilos especiales.
La idea es que practiques los diferentes formatos y estilos para que no te pierdas en la comprensión de temas más complejos al momento del desarrollo.
Recuerda que puedes seguir tu aprendizaje acudiendo al índice de contenidos sobre Desarollo Android.
Únete Al Discord De Develou
Si tienes problemas con el código de este tutorial, preguntas, recomendaciones o solo deseas discutir sobre desarrollo Android conmigo y otros desarrolladores, únete a la comunidad de Discord de Develou y siéntete libre de participar como gustes. ¡Te espero!
