Android
Recursos

Traducir una cadena

Las cadenas se pueden internacionalizar definiendo un archivo strings.xml diferente para cada idioma que admita.

Usted agrega un nuevo idioma al crear un nuevo directorio de valores con el código de idioma ISO como un sufijo. Por ejemplo, cuando se agrega un conjunto alemán, su estructura puede tener el siguiente aspecto:

Cuando el sistema busca la cadena solicitada, primero verifica el xml específico del idioma, si no se encuentra, se devuelve el valor del archivo strings.xml predeterminado. La clave sigue siendo la misma para cada idioma y solo cambia el valor.

Contenidos de ejemplo:

/res/valores/strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">HelloWorld</string>
    <string name="hello_world">Hello World!</string>
</resources>

/res/valores-fr/strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="hello_world">Bonjour tout le monde !!!</string>
</resources>

Definir cuerdas

Normalmente, las cadenas se almacenan en el archivo de recursos strings.xml . Se definen utilizando un elemento XML <string> .

El propósito de strings.xml es permitir la internacionalización. Puede definir un strings.xml para cada código iso de idioma. Por lo tanto, cuando el sistema busca la cadena 'app_name', primero verifica el archivo xml correspondiente al idioma actual y, si no se encuentra, busca la entrada en el archivo strings.xml predeterminado. Esto significa que puede elegir solo localizar algunas de sus cadenas mientras que otras no.

/res/valores/strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">Hello World App</string>
    <string name="hello_world">Hello World!</string>
</resources>

Una vez que se define una cadena en un archivo de recursos XML, puede ser utilizada por otras partes de la aplicación.

Los archivos de proyecto XML de una aplicación pueden usar un elemento <string> refiriéndose a @string/string_name . Por ejemplo, el archivo de manifiesto de una aplicación (/manifests/AndroidManifest.xml) incluye la siguiente línea de forma predeterminada en Android Studio:

android:label="@string/app_name"

Esto le dice a Android que busque un recurso <string> llamado "app_name" para usarlo como el nombre de la aplicación cuando se instala o se muestra en un iniciador.

Otra vez que usaría un recurso <string> de un archivo XML en Android estaría en un archivo de diseño. Por ejemplo, lo siguiente representa un TextView que muestra la cadena hello_world que definimos anteriormente:

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

También puede acceder a <string> recursos <string> desde la parte java de su aplicación. Para recuperar nuestra misma cadena hello_world desde arriba dentro de una clase de actividad, use:

String helloWorld = getString(R.string.hello_world);

Definir matriz de cadena

Para definir una matriz de cadenas, escriba en un archivo de recursos.

res / values ​​/ filename.xml

<string-array name="string_array_name">
    <item>text_string</item>
    <item>@string/string_id</item>
</string-array>

por ejemplo

res / values ​​/ arrays.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="string_array_example">
        <item>@string/app_name</item>
        <item>@string/hello_world</item>
    </string-array>
</resources>

y usarlo desde java como

String[] strings = getResources().getStringArray(R.array.string_array_example;
Log.i("TAG",Arrays.toString(strings)));

Salida

I/TAG: [HelloWorld, Hello World!]

Definir dimensiones

Las dimensiones normalmente se almacenan en un archivo de recursos con el nombre dimens.xml . Se definen utilizando un elemento <dimen> .

res / values ​​/ dimens.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <dimen name="small_padding">5dp</dimen>
    <dimen name="medium_padding">10dp</dimen>
    <dimen name="large_padding">20dp</dimen>

    <dimen name="small_font">14sp</dimen>
    <dimen name="medium_font">16sp</dimen>
    <dimen name="large_font">20sp</dimen>
</resources> 

Puedes usar diferentes unidades:

• sp: Píxeles independientes de la escala. Para fuentes.
• dp: Pixeles independientes de densidad. Para todo lo demás.
• pt: puntos
• px: píxeles
• mm: milimetros
• im: pulgadas

Ahora se puede hacer referencia a las dimensiones en XML con la sintaxis @dimen/name_of_the_dimension .

Por ejemplo:

<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="@dimen/large_padding">
</RelativeLayout>

Definir enteros

Los enteros normalmente se almacenan en un archivo de recursos llamado integers.xml , pero el nombre del archivo puede elegirse arbitrariamente. Cada entero se define utilizando un elemento <integer> , como se muestra en el siguiente archivo:

res / values ​​/ integers.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <integer name="max">100</integer>
</resources> 

Ahora se puede hacer referencia a @integer/name_of_the_integer en XML con la sintaxis @integer/name_of_the_integer , como se muestra en el siguiente ejemplo:

<ProgressBar
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:max="@integer/max"/>

Definir matriz de enteros

Para definir una matriz de enteros, escriba en un archivo de recursos.

res / values ​​/ filename.xml

<integer-array name="integer_array_name">
    <item>integer_value</item>
    <item>@integer/integer_id</item>
</integer-array>

por ejemplo

res / values ​​/ arrays.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <integer-array name="fibo">
        <item>@integer/zero</item>
        <item>@integer/one</item>
        <item>@integer/one</item>
        <item>@integer/two</item>
        <item>@integer/three</item>
        <item>@integer/five</item>
    </integer-array>
</resources>

y usarlo desde java como

int[] values = getResources().getIntArray(R.array.fibo);
Log.i("TAG",Arrays.toString(values)));

Salida

I/TAG: [0, 1, 1, 2, 3, 5]

Definir colores

Los colores generalmente se almacenan en un archivo de recursos llamado colors.xml en la carpeta /res/values/ .

Están definidos por elementos <color> :

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <color name="colorPrimary">#3F51B5</color>
    <color name="colorPrimaryDark">#303F9F</color>
    <color name="colorAccent">#FF4081</color>

    <color name="blackOverlay">#66000000</color>
</resources>

Los colores se representan mediante valores de color hexadecimales para cada canal de color (0 - FF) en uno de los formatos:

• #RGB
• #ARGB
• #RRGGBB
• #AARRGGBB

Leyenda

• A - canal alfa - el valor 0 es completamente transparente, el valor FF es opaco
• R - canal rojo
• G - canal verde
• B - canal azul

Los colores definidos se pueden usar en XML con la siguiente sintaxis @color/name_of_the_color

Por ejemplo:

<RelativeLayout
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@color/blackOverlay">

Usando colores en codigo

Estos ejemplos asumen que this es una referencia de actividad. También se puede utilizar una referencia de contexto en su lugar.

int color = ContextCompat.getColor(this, R.color.black_overlay);
view.setBackgroundColor(color);

int color = this.getResources().getColor(this, R.color.black_overlay);
view.setBackgroundColor(color);

En la declaración colorPrimary , colorPrimary , colorPrimaryDark y colorAccent se utilizan para definir los colores de diseño del material que se utilizarán para definir el tema personalizado de Android en styles.xml . Se agregan automáticamente cuando se crea un nuevo proyecto con Android Studio.

Obteniendo recursos sin advertencias "obsoletas"

Usando la API de Android 23 o superior, muy a menudo tal situación se puede ver:

Esta situación es causada por el cambio estructural de la API de Android con respecto a obtener los recursos.
Ahora la función:

public int getColor(@ColorRes int id, @Nullable Theme theme) throws NotFoundException    

debería ser usado. Pero la biblioteca android.support.v4 tiene otra solución.

Agregue la siguiente dependencia al archivo build.gradle :

com.android.support:support-v4:24.0.0

Entonces todos los métodos de la biblioteca de soporte están disponibles:

ContextCompat.getColor(context, R.color.colorPrimaryDark);
ContextCompat.getDrawable(context, R.drawable.btn_check);
ContextCompat.getColorStateList(context, R.color.colorPrimary);
DrawableCompat.setTint(drawable);
ContextCompat.getColor(context,R.color.colorPrimaryDark));

Además, se pueden utilizar más métodos de la biblioteca de soporte:

ViewCompat.setElevation(textView, 1F);
ViewCompat.animate(textView);
TextViewCompat.setTextAppearance(textView, R.style.AppThemeTextStyle);
...

Defina un recurso de menú y utilícelo dentro de Actividad / Fragmento

Definir un menú en res / menu.

<?xml version="1.0" encoding="utf-8"?>
<menu
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <item
        android:id="@+id/first_item_id"
        android:orderInCategory="100"
        android:title="@string/first_item_string"
        android:icon="@drawable/first_item_icon"
        app:showAsAction="ifRoom"/>

    <item
        android:id="@+id/second_item_id"
        android:orderInCategory="110"
        android:title="@string/second_item_string"
        android:icon="@drawable/second_item_icon"
        app:showAsAction="ifRoom"/>

</menu>

Para más opciones de configuración consulte: Recurso de menú.

Activity interior:

@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
    ///Override defining menu resource
    inflater.inflate(R.menu.menu_resource_id, menu);
    super.onCreateOptionsMenu(menu, inflater);
}

@Override
public void onPrepareOptionsMenu(Menu menu) {
    //Override for preparing items (setting visibility, change text, change icon...)
    super.onPrepareOptionsMenu(menu);
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    //Override it for handling items
    int menuItemId = item.getItemId();
    switch (menuItemId) {
        case: R.id.first_item_id
             return true; //return true, if is handled
    }
    return super.onOptionsItemSelected(item);
}

Para invocar los métodos anteriores durante la visualización de la vista, llame a getActivity().invalidateOptionsMenu();

Dentro del Fragment se necesita una llamada adicional:

@Nullable
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    setHasOptionsMenu(true);
    super.onCreateView(inflater, container, savedInstanceState);
}

Formato de cadena en cadenas.xml

La definición de cadenas en el archivo strings.xml también permite el formato de cadenas. La única advertencia es que la Cadena deberá tratarse en un código como el que se muestra a continuación, en lugar de simplemente adjuntarlo a un diseño.

<string name="welcome_trainer">Hello Pokémon Trainer, %1$s! You have caught %2$d Pokémon.</string>

String welcomePokemonTrainerText = getString(R.string.welcome_trainer, tranerName, pokemonCount);

En el ejemplo anterior,
% 1 $ s
'%' se separa de los caracteres normales,
'1' denota el primer parámetro,
'$' se usa como separador entre el número de parámetro y el tipo,
's' indica el tipo de cadena ('d' se usa para un entero)

Tenga en cuenta que getString() es un método de Context o Resources , es decir, puede usarlo directamente dentro de una instancia de Activity , o bien puede usar getActivity().getString() o getContext().getString() respectivamente.

Definir una lista de estados de color.

Las listas de estados de color se pueden usar como colores, pero cambiarán dependiendo del estado de la vista para la que se usan.

Para definir uno, cree un archivo de recursos en res/color/foo.xml

<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:color="#888888" android:state_enabled="false"/>
    <item android:color="@color/lightGray" android:state_selected="false"/>
    <item android:color="@android:color/white" />
</selector>

Los elementos se evalúan en el orden en que se definen y se utiliza el primer elemento cuyos estados especificados coinciden con el estado actual de la vista. Por lo tanto, es una buena práctica especificar un catch-all al final, sin ningún selector de estado especificado.

Cada elemento puede usar un literal de color o hacer referencia a un color definido en otro lugar.

Definir plurales de cadena

Para diferenciar entre cadenas en plural y en singular, puede definir un plural en su archivo strings.xml y enumerar las diferentes cantidades, como se muestra en el siguiente ejemplo:

<?xml version="1.0" encoding="utf-8"?>
<resources>  
    <plurals name="hello_people">
        <item quantity="one">Hello to %d person</item>
        <item quantity="other">Hello to %d people</item>
    </plurals>
</resources>

Se puede acceder a esta definición desde el código Java utilizando el método getQuantityString() de la clase de Resources , como se muestra en el siguiente ejemplo:

getResources().getQuantityString(R.plurals.hello_people, 3, 3);

Aquí, el primer parámetro R.plurals.hello_people es el nombre del recurso. El segundo parámetro ( 3 en este ejemplo) se usa para elegir la cadena de quantity correcta. El tercer parámetro (también 3 en este ejemplo) es el argumento de formato que se usará para sustituir el especificador de formato %d .

Los valores de cantidad posibles (listados en orden alfabético) son:

few
many
one
other
two
zero

Es importante tener en cuenta que no todas las configuraciones regionales admiten cada denominación de quantity . Por ejemplo, el idioma chino no tiene un concepto de one elemento. El inglés no tiene un elemento zero , ya que es gramaticalmente el mismo que other . Las instancias de quantity no admitidas serán marcadas por el IDE como advertencias de pelusa, pero no causarán errores de complicación si se usan.

Importar matriz de objetos definidos en recursos.

Hay casos en los que es necesario crear y definir objetos personalizados en los recursos de la aplicación. Dichos objetos pueden estar compuestos de tipos simples de Java , por ejemplo, Integer , Float , String .

Este es el ejemplo de cómo importar un objeto definido en los recursos de la aplicación. La Category objeto consta de 3 propiedades de categoría:

• CARNÉ DE IDENTIDAD
• Color
• Nombre

Este POJO tiene su equivalente en el archivo categories.xml , donde cada matriz tiene las mismas propiedades definidas para cada categoría.

1. Crea un modelo para tu objeto:

public class Category {
    private Type id;
    private @ColorRes int color;
    private @StringRes String name;

    public Category getId() {
        return id;
    }

    public void setId(Category id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color = color;
    }

    public enum Type{
        REGISTRATION,
        TO_ACCEPT,
        TO_COMPLETE,
        TO_VERIFY,
        CLOSED
    }
}

2. Crea el archivo en la carpeta res/values :

categories.xml

3. Componga cada modelo que consta de recursos:

<array name="no_action">
    <item>0</item>
    <item>@android:color/transparent</item>
    <item>@string/statusRegistration</item>
</array>
<array name="to_accept">
    <item>1</item>
    <item>@color/light_gray</item>
    <item>@string/acceptance</item>
</array>
<array name="opened">
    <item>2</item>
    <item>@color/material_green_500</item>
    <item>@string/open</item>
</array>
<array name="to_verify">
    <item>3</item>
    <item>@color/material_gray_800</item>
    <item>@string/verification</item>
</array>
<array name="to_close">
    <item>4</item>
    <item>@android:color/black</item>
    <item>@string/closed</item>
</array>

4. Defina una matriz en el archivo de recursos:

   <array name="categories">
       <item>@array/no_action</item>
       <item>@array/to_accept</item>
       <item>@array/opened</item>
       <item>@array/to_verify</item>
       <item>@array/to_close</item>
   </array>
   

5. Crea una función para importarlos:

   @NonNull
   public List<Category> getCategories(@NonNull Context context) {
   final int DEFAULT_VALUE = 0;
   final int ID_INDEX = 0;
   final int COLOR_INDEX = 1;
   final int LABEL_INDEX = 2;
   
   if (context == null) {
       return Collections.emptyList();
   }
   // Get the array of objects from the `tasks_categories` array
   TypedArray statuses = context.getResources().obtainTypedArray(R.array.categories);
   if (statuses == null) {
       return Collections.emptyList();
   }
   List<Category> categoryList = new ArrayList<>();
   for (int i = 0; i < statuses.length(); i++) {
       int statusId = statuses.getResourceId(i, DEFAULT_VALUE);
       // Get the properties of one object
       TypedArray rawStatus = context.getResources().obtainTypedArray(statusId);
   
       Category category = new Category();
   
       int id = rawStatus.getInteger(ID_INDEX, DEFAULT_VALUE);
       Category.Type categoryId;
       //The ID's should maintain the order with `Category.Type`
       switch (id) { 
           case 0:
               categoryId = Category.Type.REGISTRATION;
               break;
           case 1:
               categoryId = Category.Type.TO_ACCEPT;
               break;
           case 2:
               categoryId = Category.Type.TO_COMPLETE;
               break;
           case 3:
               categoryId = Category.Type.TO_VERIFY;
               break;
           case 4:
               categoryId  = Category.Type.CLOSED;
               break;
           default:
               categoryId = Category.Type.REGISTRATION;
               break;
       }
       category.setId(categoryId);
   
       category.setColor(rawStatus.getResourceId(COLOR_INDEX, DEFAULT_VALUE));
   
       int labelId = rawStatus.getResourceId(LABEL_INDEX, DEFAULT_VALUE);
       category.setName(getString(context.getResources(), labelId));
   
       categoryList.add(taskCategory);
   }
   return taskCategoryList;
   }
   

9 parches

9 Los parches son imágenes estirables en las que las áreas que se pueden estirar están definidas por marcadores negros en un borde transparente.

Hay un gran tutorial aquí .
A pesar de ser tan viejo, sigue siendo tan valioso y nos ayudó a muchos a comprender el engranaje de 9 parches.

Desafortunadamente, recientemente esa página ha sido colocada por un tiempo (actualmente está arriba nuevamente).

Por lo tanto, la necesidad de tener una copia física de esa página para desarrolladores de Android en nuestros servidores confiables.

Aquí está.

GUÍA SENCILLA DE 9-PATCH PARA LA IU DE ANDROID 18 de mayo de 2011

Mientras trabajaba en mi primera aplicación de Android, encontré que 9 parches (también conocido como 9.png) son confusos y están mal documentados. Después de un rato, finalmente entendí cómo funciona y decidí juntar algo para ayudar a otros a resolverlo.

Básicamente, el parche 9 utiliza la transparencia png para hacer una forma avanzada de 9 cortes o escala9. Las guías son líneas negras rectas de 1 píxel dibujadas en el borde de la imagen que definen la escala y el relleno de la imagen. Al nombrar el nombre de su archivo de imagen.9.png, Android reconocerá el formato 9.png y utilizará las guías negras para escalar y completar sus mapas de bits.

Aquí hay un mapa guía básico:

Como puedes ver, tienes guías a cada lado de tu imagen. Las guías SUPERIOR e IZQUIERDA son para escalar su imagen (es decir, 9 cortes), mientras que las guías DERECHA y ABAJO definen el área de relleno.

Las líneas de guía negras se cortan / eliminan de su imagen, no se mostrarán en la aplicación. Las guías solo deben tener un píxel de ancho, por lo que si desea un botón 48 × 48, su png será en realidad 50 × 50. Cualquier cosa más gruesa que un píxel seguirá siendo parte de su imagen. (Mis ejemplos tienen guías de 4 píxeles de ancho para una mejor visibilidad. En realidad, deberían ser solo de 1 píxel).

Sus guías deben ser de color negro sólido (# 000000). Incluso una ligera diferencia en el color (# 000001) o alfa causará que falle y se estire normalmente. Este fallo tampoco será obvio *, ¡falla silenciosamente! Sí. De Verdad. Ahora tu sabes

También debe tener en cuenta que el área restante del contorno de un píxel debe ser completamente transparente. Esto incluye las cuatro esquinas de la imagen, que siempre deben ser claras. Esto puede ser un problema más grande de lo que te das cuenta. Por ejemplo, si escala una imagen en Photoshop, agregará píxeles con antialias que pueden incluir píxeles casi invisibles que también harán que falle *. Si debe escalar en Photoshop, use la configuración de Vecino más cercano en el menú desplegable Remuestrear imagen (en la parte inferior del menú emergente Tamaño de imagen) para mantener los bordes afilados en sus guías.

* (actualizado el 1/2012) Esto es en realidad un "arreglo" en el último kit de desarrollo. Anteriormente, se manifestaría como si todas tus otras imágenes y recursos se rompieran repentinamente, no la imagen de 9 parches realmente rota.

Las guías SUPERIOR e IZQUIERDA se utilizan para definir la parte escalable de su imagen: IZQUIERDA para la altura de escalado, TOP para el ancho de escala. Usando una imagen de botón como ejemplo, esto significa que el botón puede estirarse horizontal y verticalmente dentro de la parte negra y todo lo demás, como las esquinas, seguirá siendo del mismo tamaño. Le permite tener botones que pueden escalarse a cualquier tamaño y mantener una apariencia uniforme.

Es importante tener en cuenta que las imágenes de 9 parches no se reducen, solo aumentan. Así que es mejor empezar lo más pequeño posible.

Además, puede omitir partes en el centro de la línea de escala. Así, por ejemplo, si tiene un botón con un borde brillante y afilado en el medio, puede dejar algunos píxeles en el centro de la guía IZQUIERDA. El eje horizontal central de su imagen no se escalará, solo las partes arriba y abajo, por lo que su brillo nítido no se suavizará.

Las guías de área de relleno son opcionales y proporcionan una manera de definir el área para cosas como su etiqueta de texto. El relleno determina la cantidad de espacio que hay dentro de la imagen para colocar texto, un icono u otras cosas. El parche 9 no es solo para botones, también funciona para imágenes de fondo.

El ejemplo anterior de botón y etiqueta es exagerado simplemente para explicar la idea de relleno: la etiqueta no es completamente precisa. Para ser honesto, no he experimentado cómo Android hace etiquetas multilínea ya que una etiqueta de botón suele ser una sola fila de texto.

Finalmente, aquí hay una buena demostración de cómo pueden variar las guías de escala y relleno, como un LinearLayout con una imagen de fondo y lados completamente redondeados:

Con este ejemplo, la guía IZQUIERDA no se usa, pero aún se requiere que tengamos una guía. La imagen de fondo no se escala verticalmente; solo escala horizontalmente (basado en la guía TOP). Al mirar las guías de relleno, las guías DERECHA e INFERIOR se extienden más allá de donde se encuentran los bordes curvos de la imagen. Esto me permite colocar mis botones redondos cerca de los bordes del fondo para un aspecto ajustado y ajustado.

Eso es todo. 9 parches es súper fácil, una vez que lo consigues. No es una forma perfecta de hacer escala, pero las guías de escala de área de relleno y multilínea ofrecen más flexibilidad que las tradicionales de 9 cortes y escala9. Pruébalo y lo resolverás rápidamente.

Nivel de transparencia de color (alfa)

Valores de opacidad del hex.

    ------------------------------
   |   Alpha(%)  |   Hex Value    |
    ------------------------------
   |    100%     |      FF        |
   |     95%     |      F2        |
   |     90%     |      E6        |
   |     85%     |      D9        |
   |     80%     |      CC        |
   |     75%     |      BF        |
   |     70%     |      B3        |
   |     65%     |      A6        |
   |     60%     |      99        |
   |     55%     |      8C        |
   |     50%     |      80        |
   |     45%     |      73        |
   |     40%     |      66        |
   |     35%     |      59        |
   |     30%     |      4D        |
   |     25%     |      40        |
   |     20%     |      33        |
   |     15%     |      26        |
   |     10%     |      1A        |
   |      5%     |      0D        |
   |      0%     |      00        |
    ------------------------------   

Si desea configurar el 45% al ​​color rojo.

<color name="red_with_alpha_45">#73FF0000</color> 

valor hexadecimal para rojo - # FF0000

Puede agregar 73 para una opacidad del 45% en el prefijo - # 73FF0000

Trabajando con el archivo strings.xml

Un recurso de cadena proporciona cadenas de texto para su aplicación con un estilo y formato de texto opcionales. Hay tres tipos de recursos que pueden proporcionar a su aplicación cadenas:

Cuerda

XML resource that provides a single string.

Sintaxis:

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

Y para usar esta cadena en el diseño:

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

Array de cuerdas

XML resource that provides an array of strings.

Sintaxis:

    <resources>
<string-array name="planets_array">
    <item>Mercury</item>
    <item>Venus</item>
    <item>Earth</item>
    <item>Mars</item>
</string-array>

Uso

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

Cantidad de cadenas (plurales)

XML resource that carries different strings for pluralization. 

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>

Uso:

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