Resources

Haciendo una gran separación de lo que nos podemos encontrar en un proyecto de Android, podemos decir que tenemos dos cosas; el código JAVA y los recursos.

El código JAVA todos (o casi todos) sabemos lo que es y lo que hace...pero y los recursos?. Pues los recursos no son más que ficheros en XML (la gran mayoría) y algún que otro binario (para imágenes, audio, etc). Estos ficheros serán los encargados de contener la información para pintar nuestra interfaz, cargar una lista desplegable con valores predeterminados, mostrar cadenas de texto, etc.

En Android, todo tiene su sitio y como tal, debemos establecer cada recurso en su lugar correspondiente (podemos inventarnos los nombres de los directorios, pero si lo hicieramos, no estaríamos siguiendo las Best-Practices de Android y sería un verdadero caos a la hora de trabajar en equipo). La gran mayoría de los recursos están contenidos en el directorio RES de nuestra aplicación, a excepción de los RAW que se alojan en un directorio aparte con ese mismo nombre. Para acceder a dichos recursos tenemos la famosa clase R, la cual indexa y da acceso a todos los recursos definidos. Vamos a ver qué subdirectorios y ficheros podemos tener y qué podemos almacenar en cada uno de ellos:

• VALUES: 
• strings.xml: almacena texto estático definido en formato XML como pares de clave-valor.

<?xml version="1.0" encoding="utf-8"?>
<Resources>
 <!-- Pre-defined Strings -->
    <string name="hello">Hello World!</string>
    <string name="app_name">Resources</string>
    <!-- Own Strings -->
    <string name="txtAceptar">Aceptar</string>
</Resources>

El atributo "name" identifica cada entrada y será el nombre por el que nos referiremos a ella cada vez que queramos hacer uso de su valor.  
Accediendo a su valor
-XML: por ejemplo para establecer el texto de un control en la definición de un layout con el formato "@string/[Name]":

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

-JAVA: usamos el método getString([String-Name]) 

String str = this.getString(R.string.txtAceptar);

 
• arrays.xml: como su propio nombre indica, almacena arrays definidos en formato XML.

<?xml version="1.0" encoding="utf-8"?>
 <resources>
     <array name="miarray">
         <item>Item1</item>
         <item>Item2</item>
     </array>
 </resources>

El atributo "item" identifica cada entrada.  
Accediendo a su valor
-XML: por ejemplo para establecer el contenido de una lista desplegable (Spinner) a traves de la propiedad "entries" con el formato "@array/[Name]":

<Spinner
     android:layout_width="fill_parent"
     android:layout_height="wrap_content"
     android:entries="@array/miarray"/>

-JAVA: para acceder a la matriz, necesitamos un "ContextWrapper" (getResources), otorgándonos acceso a todos los recursos.

//Arrays de cadena
String[] str_arr = this.getResources().getStringArray(R.array.miarray);
//Arrays de enteros
int[] int_arr = this.getResources().getIntArray(R.array.my_int_array);

• colors.xml: almacenaremos los distintos colores que vayamos a usar en la aplicación. Se define en formato XML.

<?xml version="1.0" encoding="utf-8"?>
 <resources>
     <!-- definición hexadecimal como HTML: -->
     <color name="error">#FF0000</color>
     <!-- definición hexadecimal (#AARRGGBB) definiendo el canal alfa -->
     <color name="fondo">#F0053781</color>
 </resources>

El atributo "name" identifica cada entrada y será el nombre por el que nos referiremos a ella cada vez que queramos hacer uso de su valor.  
Accediendo a su valor
-XML: por ejemplo para establecer el color de fondo y del texto de un control en la definición de un layout con el formato "@color/[Name]":

<TextView 
     android:layout_width="fill_parent"
     android:layout_height="wrap_content"
     android:text="@string/hello"
     android:background="@color/fondo"
     android:textColor="@color/error"/>

-JAVA: a traves del ContextWrapper.

TextView tex = (TextView) this.findViewById(R.id.text);
tex.setTextColor( this.getResources().getColor(R.color.error) );

• dimens.xml: almacena dimensiones predefinidas en formato XML. Las unidades pueden ser in, mm y pt (pulgadas, milímetros y puntos respectivamente basados en la pantalla) y dp y sp (píxeles independientes del dispositivo y de la escala) que permiten un trabajo más facil con la variada gama de tamaños de los diversos dispositivos.

<?xml version="1.0" encoding="utf-8"?>
 <resources>
     <dimen name="dimension_milimetros">12mm</dimen>
     <dimen name="dimension_pulgadas">12in</dimen>
 </resources>

El atributo "name" identifica cada entrada y será el nombre por el que nos referiremos a ella cada vez que queramos hacer uso de su valor.  
Accediendo a su valor
-XML: por ejemplo para establecer el tamaño de un control en la definición de un layout con el formato "@dimen/[Name]":

<TextView 
     android:layout_width="@dimen/dimension_milimetros"
     android:layout_height="@dimen/dimension_pulgadas"
 />

-JAVA: a traves del ContextWrapper.

float dim = this.getResources().getDimension(R.dimen.dimension_pulgadas);

 
• styles.xml: almacena estilos y temas en formato XML. Debido a la extensión de los mismos, los estilos y temas los trataremos en un post a parte.

• DRAWABLE: aquí se almacenaran los iconos e imagenes de nuestra aplicación. Dependiendo de la resolución de la pantalla de nuestro terminal, podemos diferenciar tres subcarpetas:
• drawable-hdpi: alta definición, formato WVGA(480 X 800 DPI).
• drawable-mdpi: media definición, formato HVGA(320 X 480 DPI).
• drawable-ldpi: baja definición, formato QVGA(240 X 320 DPI).

Accediendo a su valor

-XML: sólo hay que especificar el nombre de la imagen con el formato "@drawable/[NombreArchivo]":

<ImageView
     android:layout_width="fill_parent"
     android:layout_height="wrap_content"
     android:src="@drawable/imagen_policia"
  />

-JAVA: a traves del ContextWrapper con el formato "R.drawable/[Name]".

ImageView view = (ImageView) this.findViewById(R.id.drawme);
view.setImageResource(R.drawable.imagen_policia);

• RAW: como comentamos antes, este directorio se aloja fuera del RES. Aquí se almacenaran archivos binarios de nuestra aplicación tales como videos, audios, páginas html, etc.

Accediendo a su valor

-JAVA: a traves del ContextWrapper con el formato "R.raw/[Name]".

//Abrimos el fichero y vemos si tenemos algo
InputStream ins = getResources().openRawResource(R.raw.config_db);
int size = ins.available();
//Leemos el contenido a un array de bytes.
byte[] buffer = new byte[size];
ins.read(buffer);
ins.close();
//Guardamos la copia del fichero
FileOutputStream fos = new FileOutputStream("copia_config_db.db");
fos.write(buffer);
fos.close();

• LAYOUT: son archivos XML generadores de las pantallas de nuestra aplicación. Esto ya ha quedado explicado en anteriores post.

• MENU: aquí se almacenarán archivos XML para formar los menús de nuestra aplicación. Debido a la extensión de los mismos, estos menús los trataremos en un post a parte.

• XML: en esta carpeta almacenaremos en formato XML los ficheros de configuración de nuestra aplicación. Debido a que son ficheros generados por nosotros, pueden tener la apariencia y estructura que nosotros queramos.

<?xml version="1.0" encoding="UTF-8"?>
 <root>
     <item>
         <titulo>Google</title>
         <descripcion>Buscador web.</abstract>
         <link standalone="true">http://www.google.es</link>
     </item>
 </root>

Para analizar el XML, usamos la clase "XmlResourceParser" que la veremos en otro post.

Una muestra de nuestro proyecto con los recursos la tenemos a continuación en la siguiente captura:

Maikel.

Estructura de un proyecto Android

Cuando creamos un nuevo proyecto para android, nos encontramos con esta estructura:

¿Qué contiene cada carpeta?:

SRC: esta carpeta contiene las clases y paquetes de nuestra aplicación, en definitiva, todo el código fuente que nosotros generemos. 

GEN: esta carpeta almacena código autogenerado al compilar el proyecto. Lo más importante de aquí es el fichero R.java, donde vamos a tener identificadores de todos los recursos que disponemos en nuestra aplicación. Mediante esta clase, podremos acceder a dichos recursos en nuestra aplicación a través de ella mediante R.”clase”.”objeto”. 

Android x.x.x: almacena las clases del SDK de Android de la versión que hayamos indicado en el target al comenzar el proyecto.

RES: almacena todos los recursos de la aplicación, como iconos, imágenes, vídeos, cadenas de  valores,  layouts (que son componentes gráficos definidos en XML (estos componentes también se pueden definir mediante Java)), etc. 

Las carpetas drawable-ldpi, drawable-mdpi y drawable-hdpi almacenarán las imágenes de nuestra aplicación dependiendo si la queremos en baja, media o alta resolución (low, medium, high)

La carpeta “layouts” contendrá tantos ficheros como pantallas tenga nuestra aplicación. Almacena, por tanto, los ficheros de definición de nuestras interfaces gráficas.

La carpeta “values” almacenará recursos de textos, estilos, etc.

La carpeta RES al compilarse, genera un archivo R.java en la carpeta “GEN” con todo el contenido de dicha carpeta.

AndroidManifest.xml: es un fichero XML esencial en un proyecto Android, ya que contiene información necesaria del proyecto, como el nombre del paquete JAVA de la aplicación, los componentes (actividades, servicios, broadcast receivers y content providers), permisos, API de Android, etc.

ASSETS: contiene otros ficheros de configuración pero que no generarán código en el fichero R.

BIN: contiene una carpeta COM, que almacena el compilado de Java con los .class.

El fichero DEX es otra compilación realizada por Android a partir de la carpeta COM para que la Dalvik (la máquina virtual de Android) pueda ejecutarlo

El APK es un paquete de todo lo que contiene el BIN. Este fichero es el que necesitamos para instalar la aplicación en el teléfono.

Se puede profundizar mucho más en cada fichero, como se utiliza, etc, pero creo que a partir de aquí, podemos tener una idea un poco clara de cómo se estructura nuestra aplicación. A partir de aquí, solo queda empezar a programar.

Maikel.