13.

Interfaz de usuario en Android: Fragments [v3]

14. Interfaz de usuario en Android: ActionBar (I): Introduccin [v3]
15. Interfaz de usuario en Android: ActionBar (II): Tabs [v3]
16. Interfaz de usuario en Android: ActionBar Compat [Nuevo!]
17. Interfaz de usuario en Android: Navigation Drawer [Nuevo!]
Mens en Android
1. Mens en Android (I): Mens y Submens bsicos [v3]
2. Mens en Android (II): Mens Contextuales [v3]
3. Mens en Android (III): Opciones avanzadas [v3]
Widgets en Android
1. Interfaz de usuario en Android: Widgets (I) [v3]
2. Interfaz de usuario en Android: Widgets (II) [v3]
Gestin de Preferencias en Android
1. Preferencias en Android I: SharedPreferences [v3]
2. Preferencias en Android II: PreferenceActivity [v3]
Bases de Datos en Android
1. Bases de datos en Android (I): Primeros pasos con SQLite [v3]
2. Bases de datos en Android (II): Insercin, actualizacin y eliminacin de regi
stros [v3]
3. Bases de datos en Android (III): Consulta y recuperacin de registros [v3]
Ficheros en Android
1. Ficheros en Android (I): Memoria Interna [v3]
2. Ficheros en Android (II): Memoria Externa (Tarjeta SD) [v3]
Tratamiento de XML en Android
1. Tratamiento de XML en Android (I): SAX [v3]
2. Tratamiento de XML en Android (II): SAX simplicado [v3]
3. Tratamiento de XML en Android (III): DOM [v3]
4. Tratamiento de XML en Android (IV): XmlPull [v3]
5. Alternativas para leer y escribir XML (y otros ficheros) en Android [v3]
Localizacin Geogrfica en Android
1. Localizacin geogrfica en Android (I) [v3]
2. Localizacin geogrfica en Android (II) [v3]
Content Providers en Android
1. Content Providers en Android (I): Construccin [v3]
2. Content Providers en Android (II): Utilizacin [v3]
Notificaciones en Android
1. Notificaciones en Android (I): Toast [v3]
2. Notificaciones en Android (II): Barra de Estado [v3]
3. Notificaciones en Android (III): Dilogos [v3]
Acceso a Servicios Web en Android
1. Servicios Web SOAP en Android (1/2) [v3]
2. Servicios Web SOAP en Android (2/2) [v3]
3. Servicios Web REST en Android (1/2) [v3]
4. Servicios Web REST en Android (2/2) [v3]
Tareas en segundo plano en Android
1. Tareas en segundo plano I: Thread y AsyncTask [v3]
2. Tareas en segundo plano II: IntentService [v3]
Depuracin de aplicaciones en Android
1. Depuracin en Android: Logging [v3]
Google Play Services
I. Introduccin y Preparativos
1. Introduccin y Preparativos [Nuevo!]
II. Mapas en Android
1. Mapas en Android API v1 (I): Preparativos y ejemplo bsico [Obsoleto. Ver
API v2]
2. Mapas en Android API v1 (II): Control MapView [Obsoleto. Ver API v2]
3. Mapas en Android API v1 (III): Overlays (Capas) [Obsoleto. Ver API v2]
4. Mapas en Android (Google Maps Android API v2) I [v3] [Actualizado]
5. Mapas en Android (Google Maps Android API v2) II [v3] [Actualizado]
6. Mapas en Android (Google Maps Android API v2) III [v3] [Actualizado]
III. Notificaciones Push en Android Google Cloud Messaging (GCM / C2DM)
1. Introduccin [v3]
2. Implementacin del Servidor [v3]
3. Implementacin del Cliente Android [v3] [Ver nueva versin]
4. Implementacin del Cliente Android (Nueva Versin) [Nuevo!]
IV. Integracin con Google+
1. Inicio de Sesin con Google+ (Sign-In) [Nuevo!]
2. Acceso a datos del perfil y crculos [Nuevo!]
Entorno de desarrollo Android
por Sgoliver a las 04/08/2010 en Android, Programacin
Para empezar con este Curso de Programacin Android, vamos a describir los pasos bs
icos para disponer en nuestro PC del entorno y las herramientas necesarias para
comenzar a programar aplicaciones para la plataforma Android.
No voy a ser exhaustivo, ya existen muy buenos tutoriales sobre la instalacin de
Eclipse y Android, incluida la documentacin oficial de la plataforma. Adems, si ha
s llegado hasta aqu quiero suponer que tienes unos conocimientos bsicos de Eclipse
y Java, por lo que tan slo enumerar los pasos necesarios de instalacin y configura
cin, y proporcionar los enlaces a las distintas herramientas. Vamos all.
Paso 1. Descarga e instalacin de Java.
Si an no tienes instalado ninguna versin del JDK (Java Development Kit) puedes des
cargar la ltima versin desde la web de Oracle.
En el momento de escribir este manual la versin ms reciente disponible es la 7 upd
ate11, que podremos descargar para nuestra versin concreta del sistema operativo.
Por ejemplo, para Windows 64 bits descargaremos el ejecutable marcado como Windo
ws x64 cuyo nombre de fichero es jdk-7u11-windows-x64.exe.
La instalacin no tiene ninguna dificultad ya que es un instalador estndar de Windo
ws donde tan slo hay que aceptar las opciones que ofrece por defecto.
Paso 2. Descarga e instalacin de Eclipse.
Si an no tienes instalado Eclipse, puedes descargar la ltima versin, la 4.2.1 [Ecli
pse Juno SR1] en la ltima revisin de este artculo, desde este enlace. Recomiendo de
scargar la versin Eclipse IDE for Java Developers, y por supuesto descargar la ve
rsin apropiada para tu sistema operativo (Windows/Mac OS/Linux, y 32/64 bits). Du
rante el curso siempre utilizar Windows 64 bits.
La instalacin consiste simplemente en descomprimir el zip descargado en la ubicac
in deseada. Para ejecutarlo accederemos al fichero eclipse.exe dentro de la ruta
donde hayamos descomprimido la aplicacin, por ejemplo c:\eclipse\eclipse.exe. Du
rante la primera ejecucin de la aplicacin nos preguntar cul ser la carpeta donde quer
emos almacenar nuestros proyectos. Indicaremos la ruta deseada y marcaremos la c
heck Use this as the default para que no vuelva a preguntarlo.

Paso 3. Descargar el SDK de Android.
El SDK de la plataforma Android se puede descargar desde aqu (en el momento de re
visar este artculo la ltima versin es la r21, que funciona perfectamente con Eclips
e 4.2.1). Con las ltimas versiones, Google proporciona un paquete que contiene Ec
lipse, el SDK y varios de los componentes necesarios ya instalados (el paquete s
e llama ADT Bundle for Windows), pero nosotros descargaremos e instalaremos cada c
osa por separado, por lo que entraremos en el apartado Use an existing IDE y desca
rgaremos el ADT pulsando sobre el botn Download the SDK Tools for Windows. Una vez
descargado, bastar con ejecutar el instalador estndar de Windows.
Paso 4. Descargar el plugin Android para Eclipse.
Google pone a disposicin de los desarrolladores un plugin para Eclipse llamado An
droid Development Tools (ADT) que facilita en gran medida el desarrollo de aplic
aciones para la plataforma. Podis descargarlo mediante las opciones de actualizac
in de Eclipse, accediendo al men Help / Install new software e indicando la siguiente
URL de descarga:
https://dl-ssl.google.com/android/eclipse/
Seleccionaremos los dos paquetes disponibles Developer Tools y NDK Plugins y pulsare
mos el botn Next> para comenzar con el asistente de instalacin.

Durante la instalacin Eclipse te pedir que aceptes la licencia de los componentes
de Google que vas a instalar y es posible que aparezca algn mensaje de warning qu
e simplemente puedes aceptar para continuar con la instalacin. Finalmente el inst
alador te pedir que reinicies Eclipse.
Paso 5. Configurar el plugin ADT.
Una vez instalado el plugin, tendremos que configurarlo indicando la ruta en la
que hemos instalado el SDK de Android. Para ello, iremos a la ventana de configu
racin de Eclipse (Window / Preferences), y en la seccin de Android indicaremos la r
uta en la que se ha instalado. Finalmente pulsaremos OK para aceptar los cambios
. Si aparece algn mensaje de warning aceptamos sin ms, ya que se son problemas que
se solucionarn en el siguiente paso.

Paso 6. Instalar las Platform Tools y los Platforms necesarios.
Adems del SDK de Android comentado en el paso 2, que contiene las herramientas bsi
cas para desarrollar en Android, tambin deberemos descargar las llamadas Platflor
m Tools, que contiene herramientas especficas de la ltima versin de la plataforma,
y una o varias plataformas (SDK Platforms) de Android, que no son ms que las libr
eras necesarias para desarrollar sobre cada una de las versiones concretas de And
roid. As, si queremos desarrollar por ejemplo para Android 2.2 tendremos que desc
argar su plataforma correspondiente. Mi consejo personal es siempre instalar al
menos 2 plataformas: la correspondiente a la ltima versin disponible de Android, y
la correspondiente a la mnima versin de Android que queremos que soporte nuestra
aplicacin.
Para ello, desde Eclipse debemos acceder al men Window / Android SDK Manager. En la
lista de paquetes disponibles seleccionaremos las Android SDK Platform-tools, las
plataformas Android 4.2 (API 17) y Android 2.2 (API 8), y el paquete extra Android S
upport Library, que es una librera que nos permitir utilizar en versiones antiguas
de Android caractersticas introducidas por versiones ms recientes. Pulsaremos el b
otn Install packages y esperaremos a que finalice la descarga.

Paso 7. Configurar un AVD.
A la hora de probar y depurar aplicaciones Android no tendremos que hacerlo nece
sariamente sobre un dispositivo fsico, sino que podremos configurar un emulador o
dispositivo virtual (Android Virtual Device, o AVD) donde poder realizar fcilmen
te estas tareas. Para ello, accederemos al AVD Manager (men Window / AVD Manager)
, y en la seccin Virtual Devices podremos aadir tantos AVD como se necesiten (por
ejemplo, configurados para distintas versiones de Android o distintos tipos de d
ispositivo). Nuevamente, mi consejo ser configurar al menos dos AVD, uno para la
mnima versin de Android que queramos soportar, y otro para la versin ms reciente dis
ponible.

Para configurar el AVD tan slo tendremos que indicar un nombre descriptivo, la ve
rsin de la plataforma Android que utilizar, y las caractersticas de hardware del di
spositivo virtual, como por ejemplo su resolucin de pantalla o el tamao de la tarj
eta SD. Adems, marcaremos la opcin Snapshot, que nos permitir arrancar el emulador ms
rpidamente en futuras ejecuciones.

Y con este paso ya tendramos preparadas todas las herramientas necesarias para co
menzar a desarrollar aplicaciones Android. En prximos apartados veremos como crea
r un nuevo proyecto, la estructura y componentes de un proyecto Android, y crear
emos una aplicacin sencilla para poner en prctica todos los conceptos aprendidos.
Estructura de un proyecto Android
por Sgoliver a las 09/08/2010 en Android, Programacin
Seguimos con el Curso de Programacin Android. Para empezar a comprender cmo se con
struye una aplicacin Android vamos a crear un nuevo proyecto Android en Eclipse y
echaremos un vistazo a la estructura general del proyecto creado por defecto.
Para crear un nuevo proyecto abriremos Eclipse e iremos al men File / New / Andro
id Application Project.

De esta forma iniciaremos el asistente de creacin del proyecto, que nos guiar por
las distintas opciones de creacin y configuracin de un nuevo proyecto.
En la primera pantalla indicar
Content Provider
Un proveedor de contenidos (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 aplicacin sin mostrar detalles
sobre su almacenamiento interno, su estructura, o su implementacin. De la misma
forma, nuestra aplicacin podr acceder a los datos de otra a travs de los content pr
ovider que se hayan definido.
Broadcast Receiver
Un broadcast receiver es un componente destinado a detectar y reaccionar ante de
terminados mensajes o eventos globales generados por el sistema (por ejemplo: Ba
tera baja, SMS recibido, Tarjeta SD insertada, ) o por otras aplicaciones (cualquier ap
licacin puede generar mensajes (intents, en terminologa Android) broadcast, es dec
ir, no dirigidos a una aplicacin concreta sino a cualquiera que quiera escucharlo
).
Widget
Los widgets son elementos visuales, normalmente interactivos, que pueden mostrar
se en la pantalla principal (home screen) del dispositivo Android y recibir actu
alizaciones peridicas. Permiten mostrar informacin de la aplicacin al usuario direc
tamente sobre la pantalla principal.
Intent
Un intent es el elemento bsico de comunicacin entre los distintos componentes Andr
oid que hemos descrito anteriormente. Se pueden entender como los mensajes o pet
iciones que son enviados entre los distintos componentes de una aplicacin o entre
distintas aplicaciones. Mediante un intent se puede mostrar una actividad desde
cualquier otra, iniciar un servicio, enviar un mensaje broadcast, iniciar otra
aplicacin, etc.
En el siguiente artculo empezaremos ya a ver algo de cdigo, analizando al detalle
una aplicacin sencilla.
Desarrollando una aplicacin Android sencilla
por Sgoliver a las 16/08/2010 en Android, Programacin
Despus de instalar nuestro entorno de desarrollo para Android y comentar la estru
ctura bsica de un proyecto y los diferentes componentes software que podemos util
izar ya es hora de empezar a escribir algo de cdigo. Y como siempre lo mejor es e
mpezar por escribir una aplicacin sencilla.
En un principio me plante analizar en este captulo el clsico Hola Mundo pero ms tard
e me pareci que se iban a quedar algunas cosas bsicas en el tintero. As que he vers
ionado a mi manera el Hola Mundo transformndolo en algo as como un Hola Usuario, q
ue es igual de sencilla pero aade un par de cosas interesantes de contar. La apli
cacin 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 personal
izado para el usuario. As de sencillo e intil, pero aprenderemos muchos conceptos
bsicos, que para empezar no est mal.
Por dibujarlo para entender mejor lo que queremos conseguir, sera algo tan sencil
lo como lo siguiente:

Vamos a partir del proyecto de ejemplo que creamos en un apartado anterior, al q
ue casualmente llamamos HolaUsuario.
Como ya vimos Eclipse haba creado por nosotros la estructura de carpetas del proy
ecto y todos los ficheros necesarios de un Hola Mundo bsico, es decir, una sola p
antalla donde se muestra nicamente un mensaje fijo.
Lo primero que vamos a hacer es disear nuestra pantalla principal modificando la
que Eclipse nos ha creado por defecto. Aunque ya lo hemos comentado de pasada, r
ecordemos dnde y cmo se define cada pantalla de la aplicacin. En Android, el diseo y
la lgica de una pantalla estn separados en dos ficheros distintos. Por un lado, e
n el fichero /res/layout/activity_main.xmltendremos el diseo puramente visual de
la pantalla definido como fichero XML y por otro lado, en el fichero /src/paqu
ete.java/MainActivity.java, encontraremos el cdigo java que determina la lgica de
la pantalla.
Vamos a modificar en primer lugar el aspecto de la ventana principal de la aplic
acin aadiendo los controles (views) que vemos en el esquema mostrado al principio
del apartado. Para ello, vamos a sustituir el contenido del fichero activity_mai
n.xml por el siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 <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">
</EditText>

<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 nuestr
a 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 fic
hero.
Lo primero que nos encontramos es un elemento LinearLayout. Los layout son eleme
ntos no visibles que determinan cmo se van a distribuir en el espacio los control
es que incluyamos en su interior. Los programadores java, y ms concretamente de S
wing, conocern este concepto perfectamente. En este caso, un LinearLayout distrib
uir los controles simplemente uno tras otro y en la orientacin que indique su prop
iedad 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 botn (Button). En todos ellos hemos establecido las si
guientes propiedades:
android:id. ID del control, con el que podremos identificarlo ms tarde en nuestro
cdigo. Vemos que el identificador lo escribimos precedido de @+id/. Esto tendr como
efecto que al compilarse el proyecto se genere automticamente una nueva constant
e en la clase R para dicho control. As, por ejemplo, como al cuadro de texto le h
emos asignado el ID TxtNombre, podremos ms tarde acceder al l desde nuestro cdigo h
aciendo referencia a la constanteR.id.TxtNombre.
android:layout_height y android:layout_width. Dimensiones del control con respec
to al layout que lo contiene. Esta propiedad tomar normalmente los valores wrap_co
ntent para indicar que las dimensiones del control se ajustarn al contenido del mi
smo, o bien match_parent para indicar que el ancho o el alto del control se ajusta
r al ancho o alto del layout contenedor respectivamente.
Adems de estas propiedades comunes a casi todos los controles que utilizaremos, e
n el cuadro de texto hemos establecido tambin la propiedad android:inputType, que
indica qu tipo de contenido va a albergar el control, en este caso texto normal
(valor text), aunque podra haber sido una contrasea (textPassword), un telfono (phone
), una fecha (date), .
Por ltimo, en la etiqueta y el botn hemos establecido la propiedad android:text, q
ue 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 indicaremo
s como valor de la propiedad android:text su identificador precedido del prefijo
@string/. Dicho de otra forma, la primera alternativa habra sido indicar directame
nte el texto como valor de la propiedad, por ejemplo en la etiqueta de esta form
a:
1
2
3
4
5 <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, consistira en definir prime
ro una nueva cadena de texto en el fichero de recursos /res/values/strings.xml,
por ejemplo con identificador nombre y valor Escribe tu nombre:.
1
2
3
4
5
6
7
8
9 <resources>

. . .

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

. . .

</resources>
Y posteriormente indicar el identificador de la cadena como valor de la propieda
d android:text, siempre precedido del prefijo @string/, de la siguiente forma:
1
2
3
4
5 <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 aplicacin, lo que nos podra facilitar
por ejemplo la traduccin de la aplicacin a otro idioma.Con esto ya tenemos defini
da la presentacin visual de nuestra ventana principal de la aplicacin. De igual fo
rma definiremos la interfaz de la segunda pantalla, creando un nuevo fichero lla
mado activity_saludo.xml, y aadiendo esta vez tan solo una etiqueta (TextView) pa
ra mostrar el mensaje personalizado al usuario.
Para aadir el fichero, pulsaremos el botn derecho del ratn sobre la carpeta de recu
rsos/res/layout y pulsaremos la opcin New Android XML file.

En el cuadro de dilogo que nos aparece indicaremos como tipo de recurso Layout, ind
icaremos el nombre del fichero (con extensin .xml) y como elemento raz seleccionarem
os LinearLayout. Finalmente pulsamos Finish para crear el fichero.

Eclipse crear entonces el nuevo fichero y lo abrir en el editor grfico, aunque como
ya indicamos, nosotros accederemos a la solapa de cdigo para modificar directame
nte el contenido XML del fichero.
Para esta segunda pantalla el cdigo que incluiramos sera el siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13 <?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 aplicacin deberemos implement
ar la lgica de la misma. Como ya hemos comentado, la lgica de la aplicacin se defin
ir en ficheros java independientes. Para la pantalla principal ya tenemos creado
un fichero por defecto llamadoMainActivity.java. Empecemos por comentar su cdigo
por defecto:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package net.sgoliver.android.holausuario;

import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;

public class MainActivity extends Activity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.activity_main, menu);
return true;
}
}
dedicar los prximos artculos a describir los diferentes controles de seleccin dispo
nibles en la plataforma. Al igual que en otros frameworks Android dispone de div
ersos controles que nos permiten seleccionar una opcin dentro de una lista de pos
ibilidades. As, podremos utilizar listas desplegables (Spinner), listas fijas (Li
stView), tablas (GridView) y otros controles especficos de la plataforma como por
ejemplo las galeras de imgenes (Gallery).
En este primer artculo dedicado a los controles de seleccin vamos a describir un e
lemento importante y comn a todos ellos, los adaptadores, y lo vamos a aplicar al
primer control de los indicados, las listas desplegables.
Adaptadores en Android (adapters)
Para los desarrolladores de java que hayan utilizado frameworks de interfaz grfic
a como Swing, el concepto de adaptador les resultar familiar. Un adaptador repres
enta algo as como una interfaz comn al modelo de datos que existe por detrs de todo
s los controles de seleccin que hemos comentado. Dicho de otra forma, todos los c
ontroles de seleccin accedern a los datos que contienen a travs de un adaptador.
Adems de proveer de datos a los controles visuales, el adaptador tambin ser respons
able de generar a partir de estos datos las vistas especficas que se mostrarn dent
ro del control de seleccin. Por ejemplo, si cada elemento de una lista estuviera
formado a su vez por una imagen y varias etiquetas, el responsable de generar y
establecer el contenido de todos estos sub-elementos a partir de los datos ser el p
ropio adaptador.
Android proporciona de serie varios tipos de adaptadores sencillos, aunque podem
os extender su funcionalidad facilmente para adaptarlos a nuestras necesidades.
Los ms comunes son los siguientes:
ArrayAdapter. Es el ms sencillo de todos los adaptadores, y provee de datos a un
control de seleccin a partir de un array de objetos de cualquier tipo.
SimpleAdapter. Se utiliza para mapear datos sobre los diferentes controles defin
idos en un fichero XML de layout.
SimpleCursorAdapter. Se utiliza para mapear las columnas de un cursor abierto so
bre una base de datos sobre los diferentes elementos visuales contenidos en el c
ontrol de seleccin.
Para no complicar excesivamente los tutoriales, por ahora nos vamos a conformar
con describir la forma de utilizar un ArrayAdapter con los diferentes controles
de seleccin disponibles. Ms adelante aprenderemos a utilizar el resto de adaptador
es en contextos ms especficos.
Veamos cmo crear un adaptador de tipo ArrayAdapter para trabajar con un array genr
ico de java:
1
2
3
4
5
6 final String[] datos =
new String[]{"Elem1","Elem2","Elem3","Elem4","Elem5"};

ArrayAdapter<String> adaptador =
new ArrayAdapter<String>(this,
android.R.layout.simple_spinner_item, datos);
Comentemos un poco el cdigo. Sobre la primera lnea no hay nada que decir, es tan sl
o la definicin del array java que contendr los datos a mostrar en el control, en e
ste caso un array sencillo con cinco cadenas de caracteres. En la segunda lnea cr
eamos el adaptador en s, al que pasamos 3 parmetros:
1. El contexto, que normalmente ser simplemente una referencia a la activida
d donde se crea el adaptador.
2. El ID del layout sobre el que se mostrarn los datos del control. En este
caso le pasamos el ID de un layout predefinido en Android (android.R.layout.simp
le_spinner_item), formado nicamente por un control TextView, pero podramos pasarle
el ID de cualquier layout personalizado de nuestro proyecto con cualquier estru
ctura y conjunto de controles, ms adelante veremos cmo (en el apartado dedicado a
las listas fijas).
3. El array que contiene los datos a mostrar.
Con esto ya tendramos creado nuestro adaptador para los datos a mostrar y ya tan
slo nos quedara asignar este adaptador a nuestro control de seleccin para que ste mo
strase los datos en la aplicacin.
Una alternativa a tener en cuenta si los datos a mostrar en el control son esttic
os sera definir la lista de posibles valores como un recurso de tipo string-array
. Para ello, primero crearamos un nuevo fichero XML en la carpeta /res/values lla
mado por ejemplo valores_array.xml e incluiramos en l los valores seleccionables d
e la siguiente forma:
1
2
3
4
5
6
7
8
9
10 <?xml version="1.0" encoding="utf-8"?>
<resources>
<string-array name="valores_array">
<item>Elem1</item>
<item>Elem2</item>
<item>Elem3</item>
<item>Elem4</item>
<item>Elem5</item>
</string-array>
</resources>
Tras esto, a la hora de crear el adaptador, utilizaramos el mtodo createFromResour
ce() para hacer referencia a este array XML que acabamos de crear:
1
2
3
4 ArrayAdapter<CharSequence> adapter =
ArrayAdapter.createFromResource(this,
R.array.valores_array,
android.R.layout.simple_spinner_item);
Control Spinner [API]
Las listas desplegables en Android se llaman Spinner. Funcionan de forma similar
al de cualquier control de este tipo, el usuario selecciona la lista, se muestr
a una especie de lista emergente al usuario con todas las opciones disponibles y
al seleccionarse una de ellas sta queda fijada en el control. Para aadir una list
a de este tipo a nuestra aplicacin podemos utilizar el cdigo siguiente:
1
2
3 <Spinner android:id="@+id/CmbOpciones"
android:layout_width="match_parent"
android:layout_height="wrap_content" />
Poco vamos a comentar de aqu ya que lo que nos interesan realmente son los datos
a mostrar. En cualquier caso, las opciones para personalizar el aspecto visual d
el control (fondo, color y tamao de fuente, ) son las mismas ya comentadas para lo
s controles bsicos.
Para enlazar nuestro adaptador (y por tanto nuestros datos) a este control utili
zaremos el siguiente cdigo java:
1
2
3
4
5
6
7
8
9
10 private Spinner cmbOpciones;

//...

cmbOpciones = (Spinner)findViewById(R.id.CmbOpciones);

adaptador.setDropDownViewResource(
android.R.layout.simple_spinner_dropdown_item);

cmbOpciones.setAdapter(adaptador);