Carpeta /res/

Contiene todos los ficheros de recursos necesarios para el proyecto: imágenes, vídeos, cadenas de texto,
etc. Los diferentes tipos de recursos se distribuyen entre las siguientes subcarpetas:

Carpeta Descripción
/res/drawable/ Contiene las imágenes [y otros elementos gráficos] usados en por la aplicación.
Para definir diferentes recursos dependiendo de la resolución y densidad de la
pantalla del dispositivo se suele dividir en varias subcarpetas:

 /drawable-ldpi (densidad baja)

 /drawable-mdpi (densidad media)

 /drawable-hdpi (densidad alta)

 /drawable-xhdpi (densidad muy alta)

/res/layout/ Contiene los ficheros de definición XML de las diferentes pantallas de la interfaz
gráfica. Para definir distintos layouts dependiendo de la orientación del dispositivo
se puede dividir en dos subcarpetas:

 /layout (vertical)

 /layout-land (horizontal)
/res/anim/ Contienen la definición de las animaciones utilizadas por la aplicación.
/res/animator/
/res/color/ Contiene ficheros XML de definición de colores según estado.
/res/menu/ Contiene la definición XML de los menús de la aplicación.
/res/values/ Contiene otros ficheros XML de recursos de la aplicación, como por ejemplo
cadenas de texto (strings.xml), estilos (styles.xml), colores (colors.xml), arrays de
valores (arrays.xml), etc.
/res/xml/ Contiene otros ficheros XML de datos utilizados por la aplicación.
/res/raw/ Contiene recursos adicionales, normalmente en formato distinto a XML, que no se
incluyan en el resto de carpetas de recursos.

No todas estas carpetas tienen por qué aparecer en cada proyecto Android, tan sólo las que se necesiten.
Iremos viendo durante el curso que tipo de elementos se pueden incluir en cada una de estas carpetas.

Como ejemplo, para un proyecto nuevo Android, se crean por defecto los siguientes recursos para la
aplicación:

21
Como se puede observar, existen algunas carpetas en cuyo nombre se incluye un sufijo adicional, como por
ejemplo "values-v11" y "values-v14". Estos, y otros sufijos, se emplean para definir recursos independientes
para determinados dispositivos según sus características. De esta forma, por ejemplo, los recursos incluidos
en la carpeta "values-v11" se aplicarían tan sólo a dispositivos cuya versión de Android sea la 3.0 (API 11) o
superior. Al igual que el sufijo "–v" existen otros muchos para referirse a otras características del terminal,
puede consultarse la lista completa en la documentación oficial del Android.

Entre los recursos creados por defecto, cabe destacar el layout "activity_main.xml", que contiene la definición
de la interfaz gráfica de la pantalla principal de la aplicación. Si hacemos doble clic sobre el fichero Eclipse
nos mostrará esta interfaz en su editor gráfico (tipo arrastrar y soltar) y como podremos comprobar, en
principio contiene tan sólo una etiqueta de texto centrada en pantalla con el mensaje "Hello World!".

Durante el curso no utilizaremos demasiado este editor gráfico, sino que modificaremos la interfaz de
nuestras pantallas manipulando directamente el fichero XML asociado (al que se puede acceder pulsando

22
sobre la pestaña inferior derecha, junto la solapa "Graphical Layout" que se observa en la imagen. En este
caso, el XML asociado sería el siguiente:

Esto en principio puede parecer mucho más complicado que utilizar el editor gráfico, pero por el contrario
[además de no ser nada complicado en realidad] nos permitirá aprender los entresijos de Android más
rápidamente.

Carpeta /gen/

Contiene una serie de elementos de código generados automáticamente al compilar el proyecto. Cada
vez que generamos nuestro proyecto, la maquinaria de compilación de Android genera por nosotros una
serie de ficheros fuente java dirigidos al control de los recursos de la aplicación. Importante: dado que
estos ficheros se generan automáticamente tras cada compilación del proyecto es importante que no se
modifiquen manualmente bajo ninguna circunstancia.

A destacar sobre todo el fichero que aparece desplegado en la imagen anterior, llamado R.java, donde se
define la clase R.

23
Esta clase R contendrá en todo momento una serie de constantes con los ID de todos los recursos de la
aplicación incluidos en la carpeta /res/, de forma que podamos acceder fácilmente a estos recursos
desde nuestro código a través de este dato. Así, por ejemplo, la constante R.drawable.ic_launcher
contendrá el ID de la imagen "ic_launcher.png" contenida en la carpeta /res/drawable/. Veamos como
ejemplo la clase R creada por defecto para un proyecto nuevo:

package net.sgoliver.android.holausuario;

public final class R {

public static final class attr {
}
public static final class drawable {
public static final int ic_launcher=0x7f020001;
}
public static final class id {
public static final int menu_settings=0x7f070000;
}
public static final class layout {
public static final int activity_main=0x7f030000;
}
public static final class menu {
public static final int activity_main=0x7f060000;
}
public static final class string {
public static final int app_name=0x7f040000;
public static final int hello_world=0x7f040001;
public static final int menu_settings=0x7f040002;
}
public static final class style {
/**
Base application theme, dependent on API level. This theme is replaced
by AppBaseTheme from res/values-vXX/styles.xml on newer devices.

Theme customizations available in newer API levels can go in

res/values-vXX/styles.xml, while customizations related to
backward-compatibility can go here.

Base application theme for API 11+. This theme completely replaces
AppBaseTheme from res/values/styles.xml on API 11+ devices.

API 11 theme customizations can go here.

Base application theme for API 14+. This theme completely replaces
AppBaseTheme from BOTH res/values/styles.xml and
res/values-v11/styles.xml on API 14+ devices.

API 14 theme customizations can go here.

*/
public static final int AppBaseTheme=0x7f050000;
/** Application theme.
All customizations that are NOT specific to a particular API-level can go
here.
*/
public static final int AppTheme=0x7f050001;
}
}

24
Carpeta /assets/

Contiene todos los demás ficheros auxiliares necesarios para la aplicación (y que se incluirán en su propio
paquete), como por ejemplo ficheros de configuración, de datos, etc.

La diferencia entre los recursos incluidos en la carpeta /res/raw/ y los incluidos en la carpeta /assets/
es que para los primeros se generará un ID en la clase R y se deberá acceder a ellos con los diferentes métodos
de acceso a recursos. Para los segundos sin embargo no se generarán ID y se podrá acceder a ellos por su ruta
como a cualquier otro fichero del sistema. Usaremos uno u otro según las necesidades de nuestra aplicación.

Carpeta /bin/

Ésta es otra de ésas carpetas que en principio no tendremos por qué tocar. Contiene los elementos compilados
de la aplicación y otros ficheros auxiliares. Cabe destacar el fichero con extensión ".apk", que es el ejecutable
de la aplicación que se instalará en el dispositivo.

Carpeta /libs/

Contendrá las librerías auxiliares, normalmente en formato ".jar" que utilicemos en nuestra aplicación
Android.

Fichero AndroidManifest.xml

Contiene la definición en XML de los aspectos principales de la aplicación, como por ejemplo su identificación
(nombre, versión, icono, …), sus componentes (pantallas, mensajes, …), las librerías auxiliares utilizadas, o
los permisos necesarios para su ejecución. Veremos más adelante más detalles de este fichero.

Y con esto todos los elementos principales de un proyecto Android. No pierdas de vista este proyecto de
ejemplo que hemos creado ya que lo utilizaremos en breve como base para crear nuestra primera aplicación.
Pero antes, en el siguiente apartado hablaremos de los componentes software principales con los que
podemos construir una aplicación Android.

Componentes de una aplicación Android

En el apartado anterior vimos la estructura de un proyecto Android y aprendimos dónde colocar cada uno
de los elementos que componen una aplicación, tanto elementos de software como recursos gráficos o
de datos. En éste nuevo post vamos a centrarnos específicamente en los primeros, es decir, veremos los
distintos tipos de componentes de software con los que podremos construir una aplicación Android.

En Java o .NET estamos acostumbrados a manejar conceptos como ventana, control, eventos o servicios
como los elementos básicos en la construcción de una aplicación.

Pues bien, en Android vamos a disponer de esos mismos elementos básicos aunque con un pequeño cambio
en la terminología y el enfoque. Repasemos los componentes principales que pueden formar parte de una
aplicación Android [Por claridad, y para evitar confusiones al consultar documentación en inglés, intentaré
traducir lo menos posible los nombres originales de los componentes].

25
Activity

Las actividades (activities) representan el componente principal de la interfaz gráfica de una aplicación
Android. Se puede pensar en una actividad como el elemento análogo a una ventana o pantalla en cualquier
otro lenguaje visual.

View

Las vistas (view) son los componentes básicos con los que se construye la interfaz gráfica de la aplicación,
análogo por ejemplo a los controles de Java o .NET. De inicio, Android pone a nuestra disposición una gran
cantidad de controles básicos, como cuadros de texto, botones, listas desplegables o imágenes, aunque
también existe la posibilidad de extender la funcionalidad de estos controles básicos o crear nuestros propios
controles personalizados.

Service

Los servicios son componentes sin interfaz gráfica que se ejecutan en segundo plano. En concepto, son
similares a los servicios presentes en cualquier otro sistema operativo. Los servicios pueden realizar cualquier
tipo de acciones, por ejemplo actualizar datos, lanzar notificaciones, o incluso mostrar elementos visuales
(p.ej. actividades) si se necesita en algún momento la interacción con del usuario.

Content Provider

Un content provider es el mecanismo que se ha definido en Android para compartir datos entre aplicaciones.
Mediante estos componentes es posible compartir determinados datos de nuestra aplicación sin mostrar
detalles sobre su almacenamiento interno, su estructura, o su implementación. De la misma forma, nuestra
aplicación podrá acceder a los datos de otra a través de los content provider que se hayan definido.

Broadcast Receiver

Un broadcast receiver es un componente destinado a detectar y reaccionar ante determinados mensajes

o eventos globales generados por el sistema (por ejemplo: "Batería baja", "SMS recibido", "Tarjeta SD
insertada", …) o por otras aplicaciones (cualquier aplicación puede generar mensajes (intents, en terminología
Android) broadcast, es decir, no dirigidos a una aplicación concreta sino a cualquiera que quiera escucharlo).

Widget

Los widgets son elementos visuales, normalmente interactivos, que pueden mostrarse en la pantalla principal
(home screen) del dispositivo Android y recibir actualizaciones periódicas. Permiten mostrar información de
la aplicación al usuario directamente sobre la pantalla principal.

Intent

Un intent es el elemento básico de comunicación entre los distintos componentes Android que hemos
descrito anteriormente. Se pueden entender como los mensajes o peticiones que son enviados entre los
distintos componentes de una aplicación o entre distintas aplicaciones. Mediante un intent se puede mostrar
una actividad desde cualquier otra, iniciar un servicio, enviar un mensaje broadcast, iniciar otra aplicación,
etc.

En el siguiente apartado empezaremos ya a añadir y modificar algo de código, analizando al detalle una
aplicación sencilla.

Desarrollando una aplicación Android sencilla

Después de instalar nuestro entorno de desarrollo para Android y comentar la estructura básica de un
proyecto y los diferentes componentes software que podemos utilizar ya es hora de empezar a escribir algo
de código. Y como siempre lo mejor es empezar por escribir una aplicación sencilla.

En un principio me planteé analizar en este capítulo el clásico Hola Mundo pero más tarde me pareció que

26
se iban a quedar algunas cosas básicas en el tintero. Así que he versionado a mi manera el Hola Mundo
transformándolo en algo así como un Hola Usuario, que es igual de sencilla pero añade un par de cosas
interesantes de contar. La aplicación constará de dos pantallas, por un lado la pantalla principal que solicitará
un nombre al usuario y una segunda pantalla en la que se mostrará un mensaje personalizado para el usuario.
Así de sencillo e inútil, pero aprenderemos muchos conceptos básicos, que para empezar no está mal.

Por dibujarlo para entender mejor lo que queremos conseguir, sería algo tan sencillo como lo siguiente:

Vamos a partir del proyecto de ejemplo que creamos en un apartado anterior, al que casualmente llamamos
HolaUsuario. Como ya vimos Eclipse había creado por nosotros la estructura de carpetas del proyecto y todos
los ficheros necesarios de un Hola Mundo básico, es decir, una sola pantalla donde se muestra únicamente
un mensaje fijo.

Lo primero que vamos a hacer es diseñar nuestra pantalla principal modificando la que Eclipse nos ha creado
por defecto. Aunque ya lo hemos comentado de pasada, recordemos dónde y cómo se define cada pantalla
de la aplicación. En Android, el diseño y la lógica de una pantalla están separados en dos ficheros distintos.
Por un lado, en el fichero /res/layout/activity_main.xml tendremos el diseño puramente
visual de la pantalla definido como fichero XML y por otro lado, en el fichero /src/paquete.java/
MainActivity.java, encontraremos el código java que determina la lógica de la pantalla.

Vamos a modificar en primer lugar el aspecto de la ventana principal de la aplicación añadiendo los controles
(views) que vemos en el esquema mostrado al principio del apartado. Para ello, vamos a sustituir el contenido
del fichero activity_main.xml por el siguiente:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/LinearLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >

<TextView
android:id="@+id/LblNombre"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/nombre" />

<EditText
android:id="@+id/TxtNombre"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:inputType="text" />

27
 <Button
android:id="@+id/BtnHola"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hola" />

</LinearLayout>

En este XML se definen los elementos visuales que componen la interfaz de nuestra pantalla principal y se
especifican todas sus propiedades. No nos detendremos mucho por ahora en cada detalle, pero expliquemos
un poco lo que vemos en el fichero.

Lo primero que nos encontramos es un elemento LinearLayout. Los layout son elementos no visibles
que determinan cómo se van a distribuir en el espacio los controles que incluyamos en su interior. Los
programadores java, y más concretamente de Swing, conocerán este concepto perfectamente. En este caso,
un LinearLayout distribuirá los controles simplemente uno tras otro y en la orientación que indique su
propiedad android:orientation, que en este caso será "vertical".

Dentro del layout hemos incluido 3 controles: una etiqueta (TextView), un cuadro de texto (EditText),
y un botón (Button). En todos ellos hemos establecido las siguientes propiedades:

 android:id. ID del control, con el que podremos identificarlo más tarde en nuestro código. Vemos
que el identificador lo escribimos precedido de "@+id/". Esto tendrá como efecto que al compilarse
el proyecto se genere automáticamente una nueva constante en la clase R para dicho control. Así,
por ejemplo, como al cuadro de tecto le hemos asignado el ID TxtNombre, podremos más tarde
acceder al él desde nuestro código haciendo referencia a la constante R.id.TxtNombre.

 android:layout_height y android:layout_width. Dimensiones del control con

respecto al layout que lo contiene. Esta propiedad tomará normalmente los valores "wrap_
content" para indicar que las dimensiones del control se ajustarán al contenido del mismo, o bien
"match_parent" para indicar que el ancho o el alto del control se ajustará al ancho o alto del
layout contenedor respectivamente.

Además de estas propiedades comunes a casi todos los controles que utilizaremos, en el cuadro de texto
hemos establecido también la propiedad android:inputType, que indica qué tipo de contenido va a
albergar el control, en este caso texto normal (valor "text"), aunque podría haber sido una contraseña
(textPassword), un teléfono (phone), una fecha (date), ….

Por último, en la etiqueta y el botón hemos establecido la propiedad android:text, que indica el
texto que aparece en el control. Y aquí nos vamos a detener un poco, ya que tenemos dos alternativas a
la hora de hacer esto. En Android, el texto de un control se puede especificar directamente como valor
de la propiedad android:text, o bien utilizar alguna de las cadenas de texto definidas en los recursos
del proyecto (como ya vimos, en el fichero strings.xml), en cuyo caso indicaremos como valor de la
propiedad android:text su identificador precedido del prefijo "@string/". Dicho de otra forma, la
primera alternativa habría sido indicar directamente el texto como valor de la propiedad, por ejemplo en la
etiqueta de esta forma:

<TextView
android:id="@+id/LblNombre"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Escribre tu nombre:" />

Y la segunda alternativa, la utilizada en el ejemplo, consistiría en definir primero una nueva cadena de
texto en el fichero de recursos /res/values/strings.xml, por ejemplo con identificador "nombre"
y valor "Escribe tu nombre:"

28
 <resources>

. . .

<string name="nombre">Escribe tu nombre:</string>

. . .

</resources>

Y posteriormente indicar el identificador de la cadena como valor de la propiedad android:text,

siempre precedido del prefijo "@string/", de la siguiente forma:
<TextView
android:id="@+id/LblNombre"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/nombre" />

Esta segunda alternativa nos permite tener perfectamente localizadas y agrupadas todas las cadenas de
texto utilizadas en la aplicación, lo que nos podría facilitar por ejemplo la traducción de la aplicación a otro
idioma.Con esto ya tenemos definida la presentación visual de nuestra ventana principal de la aplicación.
De igual forma definiremos la interfaz de la segunda pantalla, creando un nuevo fichero llamado
activity_saludo.xml, y añadiendo esta vez tan solo una etiqueta (TextView) para mostrar el
mensaje personalizado al usuario.

Para añadir el fichero, pulsaremos el botón derecho del ratón sobre la carpeta de recursos /res/layout y
pulsaremos la opción "New Android XML file".

En el cuadro de diálogo que nos aparece indicaremos como tipo de recurso "Layout", indicaremos el nombre

29
del fichero (con extensión ".xml") y como elemento raíz seleccionaremos LinearLayout. Finalmente
pulsamos Finish para crear el fichero.

Eclipse creará entonces el nuevo fichero y lo abrirá en el editor gráfico, aunque como ya indicamos, nosotros
accederemos a la solapa de código para modificar directamente el contenido XML del fichero.

Para esta segunda pantalla el código que incluiríamos sería el siguiente:

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >

<TextView
android:id="@+id/TxtSaludo"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="" />

</LinearLayout>

Una vez definida la interfaz de las pantallas de la aplicación deberemos implementar la lógica de la misma.
30