Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Manual de Programacion en Android PDF
Manual de Programacion en Android PDF
EN ANDROID
Noviembre de 2011
Si an no tienes instalado Eclipse, puedes descargar la versin 3.5 desde este enlace (Ojo,
la versin 3.6 parece que an no se lleva muy bien con Android). Recomiendo descargar
por ejemplo la versin Eclipse IDE for Java Developers. La instalacin consiste
simplemente en descomprimir el zip en la ubicacin deseada.
Paso 2. Descargar el SDK de Android.
El SDK de la plataforma Android se puede descargar desde aqu. Una vez descargado, de
nuevo bastar con descomprimir el zip en cualquier ubicacin.
Paso 3. Descargar el plugin Android para Eclipse.
Google pone a disposicin de los desarrolladores un plugin para Eclipse llamado Android
Development Tools (ADT) que facilita en gran medida el desarrollo de aplicaciones para la
plataforma. Podis descargarlo mediante las opciones de actualizacin de Eclipse,
accediendo al men Help / Install new software e indicando la URL de descarga
https://dl-ssl.google.com/android/eclipse/. Se debe seleccionar e instalar el paquete
completo Developer Tools, formado por Android DDMS y Android Development Tools.
Paso 4. Configurar el plugin ADT.
En la ventana de configuracin de Eclipse, se debe acceder a la seccin de Android e
indicar la ruta en la que se ha instalado el SDK (paso 2).
Y con este paso ya estamos preparados para crear nuestro primer proyecto para Android.
Esta accin crear toda la estructura de carpetas necesaria para compilar un proyecto para
Android. Hablaremos de ella ms adelante.
Para ejecutar el proyecto tal cual podremos hacerlo como cualquier otro proyecto java
configurando una nueva entrada de tipo Android Applications en la ventana de Run
Configurations. Al ejecutar el proyecto, se abrir un nuevo emulador Android y se cargar
automticamente nuestra aplicacin.
Carpeta /res/
Contiente todos los ficheros de recursos necesarios para el proyecto: imgenes, vdeos,
cadenas de texto, etc. Los diferentes tipos de recursos de debern distribuir entre las
siguientes carpetas:
Como ejemplo, para un proyecto nuevo Android, se crean los siguientes recursos para la
aplicacin:
Carpeta /gen/
Contiene una serie de elementos de cdigo generados automticamente al compilar el
proyecto. Cada vez que generamos nuestro proyecto, la maquinaria de compilacin de
Android genera por nosotros una serie de ficheros fuente en java dirigidos al control de los
recursos de la aplicacin.
Esta clase R contendr en todo momento una serie de constantes con los ID de todos los
recursos de la aplicacin incluidos en la carpeta /res/, de forma que podamos acceder
facilmente a estos recursos desde nuestro cdigo a traves de este dato. As, por ejemplo, la
constante R.drawable.icon contendr el ID de la imagen icon.png contenida en
la carpeta /res/drawable/. Veamos como ejemplo la clase R creada por defecto para
un proyecto nuevo:
1
2
3 package net.sgoliver;
public final class R {
4 public static final class attr {
5 }
6 public static final class drawable {
7 public static final int icon=0x7f020000;
8 }public static final class layout {
9 public static final int main=0x7f030000;
10}
11public static final class string {
12public static final int app_name=0x7f040001;
public static final int hello=0x7f040000;
13}
14}
15
16
Carpeta /assets/
Contiene todos los dems ficheros auxiliares necesarios para la aplicacin (y que se
incluirn en su propio paquete), como por ejemplo ficheros de configuracin, 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 mtodos de acceso a recursos. Para los segundos sin
embargo no se generarn ID y se podr acceder a ellos por su ruta como a cualquier otro
fichero del sistema. Usaremos uno u otro segn las necesidades de nuestra aplicacin.
Fichero AndroidManifest.xml
Contiene la definicin en XML de los aspectos principales de la aplicacin, como por
ejemplo su identificacin (nombre, versin, icono, ), sus componentes (pantallas,
mensajes, ), o los permisos necesarios para su ejecucin. Veremos ms adelante ms
detalles de este fichero.
Widget
Los widgets son elementos visuales, normalmente interactivos, que pueden mostrarse en la
pantalla principal (home screen) del dispositivo Android y recibir actualizaciones
peridicas. Permiten mostrar informacin de la aplicacin al usuario directamente sobre la
pantalla principal.
Intent
Un intent es el elemento bsico de comunicacin 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 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.
Desarrollar una aplicacin sencilla
En un principio me plante analizar en este post el clsico Hola Mundo pero ms tarde me
pareci que se iban a quedar algunas cosas bsicas en el tintero. As que he versionado a mi
manera el Hola Mundo transformndolo en algo as como un Hola Usuario, que es igual de
sencilla pero aade un par de cosas interesantes de contar. La aplicacin 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. Sencillo,
intil, pero aprenderemos muchos conceptos bsicos, que para empezar no est mal.
En primer lugar vamos a crear un nuevo proyecto Android tal como vimos al final del
primer post de la serie. Llamaremos al proyecto HolaUsuario, indicaremos como target
por ejemplo Android 1.6, daremos un nombre a la aplicacin e indicaremos que se cree
una actividad llamada HolaUsuario.
9
Como ya vimos esto nos crea la estructura de carpetas del proyecto y todos los ficheros
necesarios de un Hola Mundo bsico, es decir, una sola pantalla 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. Pero dnde y cmo se define cada pantalla de la
aplicacin? En Android, el diseo y la lgica de una pantalla estan separados en dos
ficheros distintos. Por un lado, en el fichero /res/layout/main.xml tendremos el
diseo puramente visual de la pantalla definido como fichero XML y por otro lado, en el
fichero /src/paquetejava/HolaUsuario.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 aplicacin
aadiendo los controles (views) que vemos en la primera captura de pantalla. Para ello,
vamos a sustituir el contenido del fichero main.xml por el siguiente:
1 <?xml version="1.0" encoding="utf-8"?>
2 <LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
3 android:orientation="vertical"
4 android:layout_width="fill_parent"
5 android:layout_height="fill_parent" >
6 <TextView android:text="@string/nombre"
android:layout_width="fill_parent"
7 android:layout_height="wrap_content" />
8 <EditText android:id="@+id/TxtNombre"
9 android:layout_height="wrap_content"
10android:layout_width="fill_parent" />
android:id="@+id/BtnHola"
11<Button
android:layout_width="wrap_content"
12android:layout_height="wrap_content"
13android:text="@string/hola" />
10
14</LinearLayout>
15
16
17
18
19
20
21
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 en
cada detalle porque se ser tema de otro artculo, 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 cmo se van a distribuir en el espacio los controles
que incluyamos en su interior. Los programadores java, y ms concretamente de Swing,
conocern este concepto perfectamente. En este caso, un LinearLayout distribuir los
controles uno tras otro y en la orientacin que indique su propiedad
android:orientation.
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 siguientes
propiedades:
1
2
3 <?xml version="1.0" encoding="utf-8"?>
<LinearLayout
4 xmlns:android="http://schemas.android.com/apk/res/android"
5 android:layout_width="wrap_content"
6 android:layout_height="wrap_content">
7 <TextView android:id="@+id/TxtMensaje"
8 android:layout_height="wrap_content"
android:layout_width="fill_parent"
9 android:text="$mensaje"></TextView>
10</LinearLayout>
11
12
Una vez definida la interfaz de las pantallas de la aplicacin deberemos implementar la
lgica de la misma. Como ya hemos comentado, la lgica de la aplicacin se definir en
ficheros java independientes. Para la pantalla principal ya tenemos creado un fichero por
defecto llamado HolaUsuario.java. Empecemos por comentar su cdigo por defecto:
1
public class HolaUsuario extends Activity {
2/** Called when the activity is first created. */
3@Override
4public void onCreate(Bundle savedInstanceState) {
5super.onCreate(savedInstanceState);
6setContentView(R.layout.main);
}
7}
8
Como ya vimos en un post anterior, las diferentes pantallas de una aplicacin Android se
definen mediante objetos de tipo Activity. Por tanto, lo primero que encontramos en
nuestro fichero java es la definicin de una nueva clase HolaUsuario que extiende a
Activity. El nico mtodo que sobreescribiremos de esta clase ser el mtodo
OnCreate, llamado cuando se crea por primera vez la actividad. En este mtodo lo nico
que encontramos en principio, adems de la llamada a su implementacin en la clase padre,
es la llamada al mtodo setContentView(R.layout.main). Con esta llamada
estaremos indicando a Android que debe establecer como interfaz grfica de esta actividad
la definida en el recurso R.layout.main, que no es ms que la que hemos especificado
en el fichero /res/layout/main.xml. Una vez ms vemos la utilidad de las diferentes
constantes de recursos creadas automticamente en la clase R al compilar el proyecto.
En principio vamos a crear una nueva actividad para la segunda pantalla de la aplicacin
anloga a sta primera, para lo que crearemos una nueva clase FrmMensaje que exienda
de Activity y que implemente el mtodo onCreate indicando que utilice la interfaz
definida en R.layout.frmmensaje.
1public class FrmMensaje extends Activity {
2@Override
12
Bundle, que puede contener una lista de pares clave-valor con toda la informacin a pasar
entre las actividades. En nuestro caso slo aadiremos un dato de tipo String mediante el
mtodo putString(clave, valor). Tras esto aadiremos la informacin al intent
mediante el mtodo putExtras(bundle).
Finalizada la actividad principal de la aplicacin pasamos ya a la secundaria.
Comenzaremos de forma anloga a la anterior, ampliando el mtodo onCreate
obteniendo las referencias a los objetos que manipularemos, esta vez slo la etiqueta de
texto. Tras esto viene lo ms interesante, debemos recuperar la informacin pasada desde la
actividad principal y asignarla como texto de la etiqueta. Para ello accederemos en primer
lugar al intent que ha originado la actividad actual mediante el mtodo getIntent() y
recuperaremos su informacin asociada (objeto Bundle) mediante el mtodo
getExtras().
Hecho esto tan slo nos queda construir el texto de la etiqueta mediante su mtodo
setText(texto) y recuperando el valor de nuestra clave almacenada en el objeto
Bundle mediante getString(clave).
1
2
3
4 public class FrmMensaje extends Activity {
@Override
5 public void onCreate(Bundle savedInstanceState) {
6 super.onCreate(savedInstanceState);
7 setContentView(R.layout.frmmensaje);
8 TextView txtMensaje = (TextView)findViewById(R.id.TxtMensaje);
9 Bundle bundle = getIntent().getExtras();
txtMensaje.setText("Hola " + bundle.getString("NOMBRE"));
10}
11}
12
13
14
Con esto hemos concluido la lgica de las dos pantallas de nuestra aplicacin y tan slo nos
queda un paso importante para finalizar nuestro desarrollo. Como indicamos en uno de los
artculos anteriores, cualquier aplicacin Android utiliza un fichero especial en formato
XML (AndroidManifest.xml) para definir, entre otras cosas, los diferentes elementos que la
componen. Por tanto, todas las actividades de nuestra aplicacin deben quedar
convenientemente recogidas en este fichero. La actividad principal ya debe aparecer puesto
que se cre de forma automtica al crear el nuevo proyecto Android, por lo que debemos
aadir tan slo la segunda. Para este ejemplo nos limitaremos a incluir la actividad en el
XML, ms adelante veremos que opciones adicionales podemos especificar.
1
2
3
14
4 android:versionName="1.0">
5 <application android:icon="@drawable/icon"
android:label="@string/app_name">
6 <activity android:name=".HolaUsuario"
7 android:label="@string/app_name">
8 <intent-filter>
9 <action android:name="android.intent.action.MAIN" />
android:name="android.intent.category.LAUNCHER" />
10<category
</intent-filter>
11</activity>
12<activity android:name=".FrmMensaje"></activity>
13</application>
14<uses-sdk android:minSdkVersion="4" />
</manifest>
15
16
17
18
19
20
21
Una vez llegado aqu, si todo ha ido bien, deberamos poder ejecutar el proyecto sin errores
y probar nuestra aplicacin en el emulador.
Descarga el cdigo fuente de este artculo.
Espero que esta aplicacin de ejemplo os haya servido para aprender temas bsicos en el
desarrollo para Android, como por ejemplo la definicin de la interfaz grfica, el cdigo
java necesario para acceder y manipular los elementos de dicha interfaz, o la forma de
comunicar diferentes actividades de Android. En los artculos siguientes veremos algunos
de estos temas de forma ms especfica y ampliaremos con algunos temas ms avanzados.
ello, suele utilizarse para mostrar un nico control en su interior, a modo de contenedor
(placeholder) sencillo para un slo elemento sustituible, por ejemplo una imagen.
Los componentes incluidos en un FrameLayout podrn establecer sus propiedades
android:layout_width y android:layout_height, que podrn tomar los
valores fill_parent (para que el control hijo tome la dimensin de su layout
contenedor) o wrap_content (para que el control hijo tome la dimensin de su
contenido).
Ejemplo:
1
2
<FrameLayout
3 xmlns:android="http://schemas.android.com/apk/res/android"
4 android:layout_width="fill_parent"
5 android:layout_height="fill_parent">
6 <EditText android:id="@+id/TxtNombre"
7 android:layout_width="fill_parent"
android:layout_height="fill_parent" />
8 </FrameLayout>
9
10
LinearLayout
El siguiente layout Android en cuanto a nivel de complejidad es el LinearLayout. Este
layout apila uno tras otro todos sus elementos hijos de forma horizontal o vertical segn se
establezca su propiedad android:orientation.
Al igual que en un FrameLayout, los elementos contenidos en un LinearLayout
pueden establecer sus propiedades android:layout_width y
android:layout_height para determinar sus dimensiones dentro del layout. Pero en
el caso de un LinearLayout, tendremos otro parmetro con el que jugar, la propiedad
android:layout_weight.
1
2 <LinearLayout
3 xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
4 android:layout_height="fill_parent"
5 android:orientation="vertical">
6 <EditText android:id="@+id/TxtNombre"
7 android:layout_width="fill_parent"
8 android:layout_height="fill_parent" />
<Button android:id="@+id/BtnAceptar"
9 android:layout_width="wrap_content"
10android:layout_height="fill_parent" />
11</LinearLayout>
12
16
13
14
15
Esta propiedad nos va a permitir dar a los elementos contenidos en el layout unas
dimensiones proporcionales entre ellas. Esto es ms dificil de explicar que de comprender
con un ejemplo. Si incluimos en un LinearLayout vertical dos cuadros de texto
(EditText) y a uno de ellos le establecemos un layout_weight=1 y al otro un
layout_weight=2 conseguiremos como efecto que toda la superficie del layout
quede ocupada por los dos cuadros de texto y que adems el segundo sea el doble (relacin
entre sus propiedades weight) de alto que el primero.
1
2
3
4 <LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
5 android:layout_width="fill_parent"
6 android:layout_height="fill_parent"
7 android:orientation="vertical">
8 <EditText android:id="@+id/TxtDato1"
android:layout_width="fill_parent"
9 android:layout_height="fill_parent"
10android:layout_weight="1" />
11<EditText android:id="@+id/TxtDato2"
12android:layout_width="fill_parent"
13android:layout_height="fill_parent"
android:layout_weight="2" />
14</LinearLayout>
15
16
17
As pues, a pesar de la simplicidad aparente de este layout resulta ser lo suficiente verstil
como para sernos de utilidad en muchas ocasiones.
TableLayout
Un TableLayout permite distribuir sus elementos hijos de forma tabular, definiendo las
filas y columnas necesarias, y la posicin de cada componente dentro de la tabla.
La estructura de la tabla se define de forma similar a como se hace en HTML, es decir,
indicando las filas que compondrn la tabla (objetos TableRow), y dentro de cada fila las
columnas necesarias, con la salvedad de que no existe ningn objeto especial para definir
una columna (algo as como un TableColumn) sino que directamente insertaremos los
controles necesarios dentro del TableRow y cada componente insertado (que puede ser un
control sencillo o incluso otro ViewGroup) corresponder a una columna de la tabla. De
esta forma, el nmero final de filas de la tabla se corresponder con el nmero de elementos
17
Todas estas propiedades del TableLayout pueden recibir una lista de ndices de
columnas separados por comas (ejemplo: android:stretchColumns=1,2,3) o
un asterisco para indicar que debe aplicar a todas las columnas (ejemplo:
android:stretchColumns=*).
Otra caracterstica importante es la posibilidad de que una celda determinada pueda ocupar
el espacio de varias columnas de la tabla (anlogo al atributo colspan de HTML). Esto
se indicar mediante la propiedad android:layout_span del componente concreto
que deber tomar dicho espacio.
Veamos un ejemplo con varios de estos elementos:
1
2
3
<TableLayout
4 xmlns:android="http://schemas.android.com/apk/res/android"
5 android:layout_width="fill_parent"
6 android:layout_height="fill_parent"
7 android:stretchColumns="1" >
<TableRow>
8 <TextView android:text="Celda 1.1" />
9 <TextView android:text="Celda 1.2" />
10</TableRow>
11<TableRow>
12<TextView android:text="Celda 2.1" />
<TextView android:text="Celda 2.2" />
13</TableRow>
14<TableRow>
15<TextView android:text="Celda 3"
16android:layout_span="2" />
17</TableRow>
</TableLayout>
18
19
20
18
21
22
RelativeLayout
El ltimo tipo de layout que vamos a ver es el RelativeLayout. Este layout permite
especificar la posicin de cada elemento de forma relativa a su elemento padre o a
cualquier otro elemento incluido en el propio layout. De esta forma, al incluir un nuevo
elemento X podremos indicar por ejemplo que debe colocarse debajo del elemento Y y
alineado a la derecha del layout padre. Veamos esto en el ejemplo siguiente:
1
2
3
<RelativeLayout
4 xmlns:android="http://schemas.android.com/apk/res/android
5 android:layout_width="fill_parent"
6 android:layout_height="fill_parent" >
7 <EditText android:id="@+id/TxtNombre"
8 android:layout_width="fill_parent"
android:layout_height="wrap_content" />
9 <Button android:id="@+id/BtnAceptar"
10android:layout_width="wrap_content"
11android:layout_height="wrap_content"
12android:layout_below="@id/TxtNombre"
android:layout_alignParentRight="true" />
13</RelativeLayout>
14
15
16
En el ejemplo, el botn BtnAceptar se colocar debajo del cuadro de texto
TxtNombre (android:layout_below=@id/TxtNombre) y alineado a la
derecha del layout padre (android:layout_alignParentRight=true),
adems de dejar un margen a su izquierda de 10 pixeles
(android:layout_marginLeft=10px).
Al igual que estas tres propiedades, en un RelativeLayout tendremos un sinfn de
propiedades para colocar cada control justo donde queramos. Veamos las principales [creo
que sus propios nombres explican perfectamente la funcin de cada una]:
Posicin relativa a otro control:
android:layout_above.
android:layout_below.
android:layout_toLeftOf.
android:layout_toRightOf.
android:layout_alignLeft.
android:layout_alignRight.
19
android:layout_alignTop.
android:layout_alignBottom.
android:layout_alignBaseline.
android:layout_alignParentLeft.
android:layout_alignParentRight.
android:layout_alignParentTop.
android:layout_alignParentBottom.
android:layout_centerHorizontal.
android:layout_centerVertical.
android:layout_centerInParent.
android:layout_margin.
android:layout_marginBottom.
android:layout_marginTop.
android:layout_marginLeft.
android:layout_marginRight.
android:padding.
android:paddingBottom.
android:paddingTop.
android:paddingLeft.
android:paddingRight.
No vamos a comentar mucho sobre ellos dado que son controles de sobra conocidos por
todos, ni vamos a enumerar todas sus propiedades porque existen decenas. A modo de
referencia, a medida que los vayamos comentando ir poniendo enlaces a su pgina de la
documentacin oficial de Android para poder consultar todas sus propiedades en caso de
necesidad.
Control Button [API]
Un control de tipo Button es el botn ms bsico que podemos utilizar. En el ejemplo
siguiente definimos un botn con el texto Plsame asignando su propiedad
android:text. Adems de esta propiedad podramos utilizar muchas otras como el
color de fondo (android:background), estilo de fuente (android:typeface),
color de fuente (android:textcolor), tamao de fuente (android:textSize),
etc.
1<Button android:id="@+id/BtnBoton1"
2android:text="Plsame"
3android:layout_width="wrap_content"
4android:layout_height="wrap_content" />
Control ToggleButton [API]
Un control de tipo ToggleButton es un tipo de botn que puede permanecer en dos
estados, pulsado/no_pulsado. En este caso, en vez de definir un slo texto para el control
definiremos dos, dependiendo de su estado. As, podremos asignar las propiedades
android:textOn y android:textoOff para definir ambos textos. Veamos un
ejemplo a continuacin.
1<ToggleButton android:id="@+id/BtnBoton2"
2android:textOn="ON"
3android:textOff="OFF"
4android:layout_width="wrap_content"
5android:layout_height="wrap_content" />
Control ImageButton [API]
En un control de tipo ImageButton podremos definir una imagen a mostrar en vez de
un texto, para lo que deberemos asignar la propiedad android:src. Normalmente
21
asignaremos esta propiedad con el descriptor de algn recurso que hayamos incluido en la
carpeta /res/drawable. As, por ejemplo, en nuestro caso hemos incluido una imagen
llamada ok.png por lo que haremos referencia al recurso @drawable/ok.
1<ImageButton android:id="@+id/BtnBoton3"
2android:layout_width="wrap_content"
3android:layout_height="wrap_content"
4android:src="@drawable/ok" />
Eventos de un botn
Como podis imaginar, aunque estos controles pueden lanzar muchos otros eventos, el ms
comn de todos ellos y el que querremos capturar en la mayora de las ocasiones es el
evento onClick. Para definir la lgica de este evento tendremos que implementarla
definiendo un nuevo objeto View.OnClickListener() y asocindolo al botn
mediante el mtodo setOnClickListener(). La forma ms habitual de hacer esto es
la siguiente:
1
2final Button btnBoton1 = (Button)findViewById(R.id.BtnBoton1);
3btnBoton1.setOnClickListener(new View.OnClickListener() {
4@Override
public void onClick(View arg0)
5{
6lblMensaje.setText("Botn 1 pulsado!");
7}
8});
9
En el caso de un botn de tipo ToggleButton suele ser de utilidad conocer en qu estado ha
quedado el botn tras ser pulsado, para lo que podemos utilizar su mtodo isChecked().
En el siguiente ejemplo se comprueba el estado del botn tras ser pulsado y se realizan
acciones distintas segn el resultado.
1
2 final ToggleButton btnBoton2 =
3 (ToggleButton)findViewById(R.id.BtnBoton2);
btnBoton2.setOnClickListener(new View.OnClickListener() {
4 @Override
5 public void onClick(View arg0)
6 {
7 if(btnBoton2.isChecked())
8 lblMensaje.setText("Botn 2: ON");
else
9 lblMensaje.setText("Botn 2: OFF");
10}
11});
12
22
23
texto plano sino tambin texto enriquecido o con formato. Veamos cmo y qu opciones
tenemos, y para empezar comentemos algunas cosas sobre los objetos Spannable.
Interfaz Spanned
Un objeto de tipo Spanned es algo as como una cadena de caracteres (deriva de la
interfaz CharSequence) en la que podemos insertar otros objetos a modo de marcas o
etiquetas (spans) asociados a rangos de caracteres. De esta interfaz deriva la interfaz
Spannable, que permite la modificacin de estas marcas, y a su vez de sta ltima deriva
la interfaz Editable, que permite adems la modificacin del texto.
Aunque en el apartado en el que nos encontramos nos interesaremos principalmente por las
marcas de formato de texto, en principio podramos insertar cualquier tipo de objeto.
Existen muchos tipos de spans predefinidos en la plataforma que podemos utilizar para dar
formato al texto, entre ellos:
De esta forma, para crear un nuevo objeto Editable e insertar una marca de formato
podramos hacer lo siguiente:
1//Creamos un nuevo objeto de tipo Editable
2Editable str = Editable.Factory.getInstance().newEditable("Esto es un
simulacro.");
3//Marcamos cono fuente negrita la palabra "simulacro"
4str.setSpan(new StyleSpan(android.graphics.Typeface.BOLD), 11, 19,
5Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
En este ejemplo estamos insertando un span de tipo StyleSpan para marcar un
fragmento de texto con estilo negrita. Para insertarlo utilizamos el mtodo setSpan(),
que recibe como parmetro el objeto Span a insertar, la posicin inicial y final del texto a
marcar, y un flag que indica la forma en la que el span se podr extender al insertarse nuevo
texto.
Texto con formato en controles TextView y EditText
Hemos visto cmo crear un objeto Editable y aadir marcas de formato al texto que
contiene, pero todo esto no tendra ningn sentido si no pudiramos visualizarlo. Como ya
podis imaginar, los controles TextView y EditText nos van a permitir hacer esto. Vemos
qu ocurre si asignamos al nuestro control EditText el objeto Editable que hemos creado
antes:
1txtTexto.setText(str);
26
Tras ejecutar este cdigo veremos como efectivamente en el cuadro de texto aparece el
mensaje con el formato esperado:
Ya hemos visto cmo asignar texto con y sin formato a un cuadro de texto, pero qu
ocurre a la hora de recuperar texto con formato desde el control?. Ya vimos que la funcin
getText() devuelve un objeto de tipo Editable y que sobre ste podamos hacer un
toString(). Pero con esta solucin estamos perdiendo todo el formato del texto, por lo
que no podramos por ejemplo salvarlo a una base de datos.
La solucin a esto ltimo pasa obviamente por recuperar directamente el objeto
Editable y serializarlo de algn modo, mejor an si es en un formato estandar. Pues
bien, en Android este trabajo ya nos viene hecho de fbrica a travs de la clase Html
[API], que dispone de mtodos para convertir cualquier objeto Spanned en su
representacin HTML equivalente. Veamos cmo. Recuperemos el texto de la ventana
anterior y utilicemos el mtodo Html.toHtml(Spannable) para convertirlo a formato
HTML:
1//Obtiene el texto del control con etiquetas de formato HTML
2String aux2 = Html.toHtml(txtTexto.getText());
Haciendo esto, obtendramos una cadena de texto como la siguiente, que ya podramos por
ejemplo almacenar en una base de datos o publicar en cualquier web sin perder el formato
de texto establecido:
1<p>Esto es un <b>simulacro</b>.</p>
La operacin contraria tambin es posible, es decir, cargar un cuadro de texto de Android
(EditText) o una etiqueta (TextView) a partir de un fragmento de texto en formato
27
1if (checkBox.isChecked()) {
2checkBox.setChecked(false);
3}
En cuanto a los posibles eventos que puede lanzar este control, el ms interesante es sin
duda el que informa de que ha cambiado el estado del control, que recibe el nombre de
onCheckedChanged. Para implementar las acciones de este evento podramos utilizar
por tanto la siguiente lgica:
1
2
final CheckBox cb = (CheckBox)findViewById(R.id.chkMarcame);
3 cb.setOnCheckedChangeListener(
4 new CheckBox.OnCheckedChangeListener() {
5 public void onCheckedChanged(CompoundButton buttonView,
6 boolean isChecked) {
(isChecked) {
7 if
cb.setText("Checkbox marcado!");
8 }
9 else {
10cb.setText("Checkbox desmarcado!");
11}
}
12});
13
14
Control RadioButton [API]
Al igual que los controles checkbox, un radiobutton puede estar marcado o desmarcado,
pero en este caso suelen utilizarse dentro de un grupo de opciones donde una, y slo una, de
ellas debe estar marcada obligatoriamente, es decir, que si se marca una de ellas se
desmarcar automticamente la que estuviera activa anteriormente. En Android, un grupo
de botones radiobutton se define mediante un elemento RadioGroup, que a su vez
contendr todos los elementos RadioButton necesarios. Veamos un ejemplo de cmo
definir un grupo de dos controles radiobutton en nuestra interfaz:
1
<RadioGroup android:id="@+id/gruporb"
2 android:orientation="vertical"
3 android:layout_width="fill_parent"
4 android:layout_height="fill_parent" >
5 <RadioButton android:id="@+id/radio1"
6 android:layout_width="wrap_content"
android:layout_height="wrap_content"
7 android:text="Opcin 1" />
8 <RadioButton android:id="@+id/radio2"
9 android:layout_width="wrap_content"
10android:layout_height="wrap_content"
android:text="Opcin 2" />
11</RadioGroup>
12
29
13
14
15
16
En primer lugar vemos cmo podemos definir el grupo de controles indicando su
orientacin (vertical u horizontal) al igual que ocurra por ejemplo con un LinearLayout.
Tras esto, se aaden todos los objetos RadioButton necesarios indicando su ID mediante la
propiedad android:id y su texto mediante android:text.
Una vez definida la interfaz podremos manipular el control desde nuestro cdigo java
haciendo uso de los diferentes mtodos del control RadioGroup, los ms importantes:
check(id) para marcar una opcin determinada mediante su ID, clearCheck() para
desmarcar todas las opciones, y getCheckedRadioButtonId() que como su nombre
indica devolver el ID de la opcin marcada (o el valor -1 si no hay ninguna marcada).
Veamos un ejemplo:
1final RadioGroup rg = (RadioGroup)findViewById(R.id.gruporb);
2rg.clearCheck();
3rg.check(R.id.radio1);
4int idSeleccionado = rg.getCheckedRadioButtonId();
En cuanto a los eventos lanzados, al igual que en el caso de los checkboxes, el ms
importante ser el que informa de los cambios en el elemento seleccionado, llamado
tambin en este caso onCheckedChange. Vemos cmo tratar este evento del objeto
RadioGroup:
1
2final RadioGroup rg = (RadioGroup)findViewById(R.id.gruporb);
3rg.setOnCheckedChangeListener(
RadioGroup.OnCheckedChangeListener() {
4new
public void onCheckedChanged(RadioGroup group, int checkedId) {
5lblMensaje.setText("ID opcion seleccionada: " + checkedid);
6}
7});
8
Veamos finalmente una imagen del aspecto de estos dos nuevos tipos de controles bsicos
que hemos comentado en este artculo:
30
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 adaptadores en contextos ms
especficos.
Veamos cmo crear un adaptador de tipo ArrayAdapter para trabajar con un array genrico
de java:
1
2final String[] datos =
String[]{"Elem1","Elem2","Elem3","Elem4","Elem5"};
3new
ArrayAdapter<String> adaptador =
4new ArrayAdapter<String>(this,
5android.R.layout.simple_spinner_item, datos);
6
Comentemos un poco el cdigo. Sobre la primera lnea no hay nada que decir, es tan slo la
definicin del array java que contendr los datos a mostrar en el control, en este caso un
array sencillo con cinco cadenas de caracteres. En la segunda lnea creamos el adaptador en
s, al que pasamos 3 parmetros:
1. El contexto, que normalmente ser simplemente una referencia a la actividad 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.simple_spinner_item), formado nicamente por
un control TextView, pero podramos pasarle el ID de cualquier layout de nuestro
proyecto con cualquier estructura y conjunto de controles, ms adelante veremos
cmo.
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 mostrase los
datos en la aplicacin.
Control Spinner [API]
32
33
34
Como podis comprobar el uso bsico del control ListView es completamente anlogo
al ya comentado para el control Spinner.
Si quisiramos realizar cualquier accin al pulsarse sobre un elemento de la lista creada
tendremos que implementar el evento onItemClick. Veamos cmo con un ejemplo:
1lstOpciones.setOnItemClickListener(new OnItemClickListener() {
2@Override
3public void onItemClick(AdapterView<?> a, View v, int position, long id) {
4//Acciones necesarias al hacer click
5}
});
6
Hasta aqu todo sencillo. Pero, y si necesitamos mostrar datos ms complejos en la lista?
qu ocurre si necesitamos que cada elemento de la lista est formado a su vez por varios
elementos? Pues vamos a provechar este artculo dedicado a los ListView para ver
cmo podramos conseguirlo, aunque todo lo que comentar es extensible a otros controles
de seleccin.
Para no complicar mucho el tema vamos a hacer que cada elemento de la lista muestre por
ejemplo dos lneas de texto a modo de ttulo y subttulo con formatos diferentes (por
supuesto se podran aadir muchos ms elementos, por ejemplo imgenes, checkboxes, etc).
En primer lugar vamos a crear una nueva clase java para contener nuestros datos de prueba.
Vamos a llamarla Titular y tan slo va a contener dos atributos, ttulo y subttulo.
1
2
3
package net.sgoliver;
public class Titular
{
private String titulo;
36
cmo debe utilizar ambas cosas para generar nuestra interfaz de usuario final. Para ello
vamos a crear nuestro propio adaptador extendiendo de la clase ArrayAdapter.
1
2
3
4
5 class AdaptadorTitulares extends ArrayAdapter {
6 Activity context;
7 AdaptadorTitulares(Activity context) {
8 super(context, R.layout.listitem_titular, datos);
this.context = context;
9 }
10public View getView(int position, View convertView, ViewGroup parent) {
11LayoutInflater inflater = context.getLayoutInflater();
12View item = inflater.inflate(R.layout.listitem_titular, null);
13TextView lblTitulo = (TextView)item.findViewById(R.id.LblTitulo);
lblTitulo.setText(datos[position].getTitulo());
14TextView lblSubtitulo = (TextView)item.findViewById(R.id.LblSubTitulo);
15lblSubtitulo.setText(datos[position].getSubtitulo());
16return(item);
17}
18}
19
20
21
22
Analicemos el cdigo anterior. Lo primero que encontramos es el constructor para nuestro
adaptador, al que slo pasaremos el contexto (que ser la actividad desde la que se crea el
adaptador). En este constructor tan slo guardaremos el contexto para nuestro uso posterior
y llamaremos al constructor padre tal como ya vimos al principio de este artculo,
pasndole el ID del layout que queremos utilizar (en nuestro caso el nuevo que hemos
creado, listitem_titular) y el array que contiene los datos a mostrar.
Posteriormente, redefinimos el mtodo encargado de generar y rellenar con nuestros datos
todos los controles necesarios de la interfaz grfica de cada elemento de la lista. Este
mtodo es getView().
El mtodo getView() se llamar cada vez que haya que mostrar un elemento de la lista. Lo
primero que debe hacer es inflar el layout XML que hemos creado. Esto consiste en
consultar el XML de nuestro layout y crear e inicializar la estructura de objetos java
equivalente. Para ello, crearemos un nuevo objeto LayoutInflater y generaremos la
estructura de objetos mediante su mtodo inflate(id_layout).
Tras esto, tan slo tendremos que obtener la referencia a cada una de nuestras etiquetas
como siempre lo hemos hecho y asignar su texto correspondiente segn los datos de nuestro
array y la posicin del elemento actual (parmetro position del mtodo getView()).
38
de este tipo, algo que los usuarios de nuestra aplicacin agradecern enormemente al
mejorarse la respuesta de la aplicacin y reducirse el consumo de batera.
acceder a dichos objetos para modificar sus propiedades. Sin embargo, hay que tener en
cuenta que esto se hace todas y cada una de las veces que se necesita mostrar un elemento
de la lista en pantalla, se haya mostrado ya o no con anterioridad, ya que Android no
guarda los elementos de la lista que desaparecen de pantalla (por ejemplo al hacer scroll
sobre la lista). El efecto de esto es obvio, dependiendo del tamao de la lista y sobre todo
de la complejidad del layout que hayamos definido esto puede suponer la creacin y
destruccin de cantidades ingentes de objetos (que puede que ni siquiera nos sean
necesarios), es decir, que la accin de inflar un layout XML puede ser bastante costosa, lo
que podra aumentar mucho, y sin necesidad, el uso de CPU, de memoria, y de batera.
Para aliviar este problema, Android nos propone un mtodo que permite reutilizar algn
layout que ya hayamos inflado con anterioridad y que ya no nos haga falta por algn
motivo, por ejemplo porque el elemento correspondiente de la lista ha desaparecido de la
pantalla al hacer scroll. De esta forma evitamos todo el trabajo de crear y estructurar todos
los objetos asociados al layout, por lo que tan slo nos quedara obtener la referencia a ellos
mediante findViewById() y modificar sus propiedades.
Pero cmo podemos reutilizar estos layouts obsoletos? Pues es bien sencillo, siempre
que exista algn layout que pueda ser reutilizado ste se va a recibir a travs del parmetro
convertView del mtodo getView(). De esta forma, en los casos en que ste no sea
null podremos obviar el trabajo de inflar el layout. Veamos cmo quedara el mtod
getView() tras esta optimizacin:
1
2
3
4 public View getView(int position, View convertView, ViewGroup parent)
5 {
6 View item = convertView;
if(item == null)
7 {
8 LayoutInflater inflater = context.getLayoutInflater();
9 item = inflater.inflate(R.layout.listitem_titular, null);
10}
11TextView lblTitulo = (TextView)item.findViewById(R.id.LblTitulo);
lblTitulo.setText(datos[position].getTitulo());
12TextView lblSubtitulo = (TextView)item.findViewById(R.id.LblSubTitulo);
13lblSubtitulo.setText(datos[position].getSubtitulo());
14return(item);
15}
16
17
18
Si aadimos ms elementos a la lista y ejecutamos ahora la aplicacin podemos comprobar
que al hacer scroll sobre la lista todo sigue funcionando con normalidad, con la diferencia
de que le estamos ahorrando gran cantidad de trabajo a la CPU.
41
1
2
3
4
5 public View getView(int position, View convertView, ViewGroup parent)
6 {
7 View item = convertView;
8 ViewHolder holder;
if(item == null)
9 {
10LayoutInflater inflater = context.getLayoutInflater();
11item = inflater.inflate(R.layout.listitem_titular, null);
12holder = new ViewHolder();
= (TextView)item.findViewById(R.id.LblTitulo);
13holder.titulo
holder.subtitulo = (TextView)item.findViewById(R.id.LblSubTitulo);
14item.setTag(holder);
15}
16else
17{
holder = (ViewHolder)item.getTag();
18}
19holder.titulo.setText(datos[position].getTitulo());
20holder.subtitulo.setText(datos[position].getSubtitulo());
21return(item);
22}
23
24
25
26
Con estas dos optimizaciones hemos conseguido que la aplicacin sea mucho ms
respetuosa con los recursos del dispositivo de nuestros usuarios, algo que sin duda nos
agradecern.
43
44
46
Como vemos, en la esquina superior derecha del cuadro de texto vamos a mostrar el
nmero de caracteres del mensaje de texto introducido, que ira actualizndose a medida que
modificamos el texto.
Para empezar, vamos a crear una nueva clase java que extienda del control que queremos
utilizar como base, en este caso EditText.
1public class ExtendedEditText extends EditText
2{
3//...
4}
Tras esto, sobreescribiremos siempre los tres constructores heredados, donde por el
momento nos limitaremos a llamar al mismo constructor de la clase padre.
1
2 public ExtendedEditText(Context context, AttributeSet attrs, int
3 defStyle){
4 super(context, attrs,defStyle);
5 }
public ExtendedEditText(Context context, AttributeSet attrs) {
6 super(context, attrs);
7 }
8 public ExtendedEditText(Context context) {
9 super(context);
10}
11
Por ltimo el paso ms importante. Dado que queremos modificar el aspecto del control
para aadir el contador de caracteres tendremos que sobreescribir el evento onDraw(),
que es llamado por Android cada vez que hay que redibujar el control en pantalla. Este
mtodo recibe como parmetro un objeto Canvas, que no es ms que el lienzo sobre el
que podemos dibujar todos los elementos extra necesarios en el control. El objeto Canvas,
proporciona una serie de mtodos para dibujar cualquier tipo de elemento (lineas,
rectngulos, elipses, texto, bitmaps, ) sobre el espacio ocupado por el control. En nuestro
caso tan slo vamos a necesitar dibujar sobre el control un rectngulo que sirva de fondo
para el contador y el texto del contador con el nmero de caracteres actual del cuadro de
texto. No vamos a entrar en muchos detalles sobre la forma de dibujar grficos ya que se
ser tema de otro artculo, pero vamos a ver al menos las acciones principales.
En primer lugar definiremos los pinceles (objetos Paint) que utilizaremos para dibujar,
uno de ellos (p1) de color negro y relleno slido para el fondo del contador, y otro (p2) de
color blanco para el texto.
1Paint p1 = new Paint(Paint.ANTI_ALIAS_FLAG);
p1.setColor(Color.BLACK);
2p1.setStyle(Style.FILL);
3Paint p2 = new Paint(Paint.ANTI_ALIAS_FLAG);
47
4p2.setColor(Color.WHITE);
5
6
Dado que estos elementos tan slo har falta crearlos la primera vez que se dibuje el
control, para evitar trabajo innecesario no incluiremos su definicin en el mtodo
onDraw(), sino que los definiremos como atributos de la clase y los inicializaremos en el
constructor del control (en los tres).
Una vez definidos los diferentes pinceles necesarios, dibujaremos el fondo y el texto del
contador mediante los mtodos drawRect() y drawText(), respectivamente, del
objeto canvas recibido en el evento.
1
2
3 @Override
4 public void onDraw(Canvas canvas)
{
5 //Llamamos al mtodo de la clase base (EditText)
6 super.onDraw(canvas);
7 //Dibujamos el fondo negro del contador
8 canvas.drawRect(this.getWidth()-30, 5,
9 this.getWidth()-5, 20, p1);
//Dibujamos el nmero de caracteres sobre el contador
10canvas.drawText("" + this.getText().toString().length(),
11this.getWidth()-28, 17, p2);
12}
13
14
Como puede comprobarse, a estos mtodos se les pasar como parmetro las coordenadas
del elemento a dibujar relativas al espacio ocupado por el control y el pincel a utilizar en
cada caso.
Hecho esto, ya tenemos finalizado nuestro cuadro de texto personalizado con contador de
caracteres. Para aadirlo a la interfaz de nuestra aplicacin lo incluiremos en el layout
XML de la ventana tal como haramos con cualquier otro control, teniendo en cuenta que
deberemos hacer referencia a l con el nombre completo de la nueva clase creada (incluido
el paquete java), que en mi caso particular sera
net.sgoliver.ExtendedEditText.
1<net.sgoliver.ExtendedEditText
2android:id="@+id/TxtPrueba"
3android:layout_width="fill_parent"
4android:layout_height="wrap_content" />
En el siguiente artculo veremos cmo crear un control personalizado utilizando la segunda
de las opciones expuestas, es decir, combinando varios controles ya existentes.
48
49
1
2
3
4
5
6
7
8 <LinearLayout
9 xmlns:android="http://schemas.android.com/apk/res/android"
10android:layout_width="fill_parent"
11android:layout_height="wrap_content"
12android:orientation="vertical"
android:padding="10dip">
13<TextView android:id="@+id/TextView01"
14android:layout_width="wrap_content"
15android:layout_height="wrap_content"
16android:text="Usuario:"
android:textStyle="bold" />
17<EditText android:id="@+id/TxtUsuario"
18android:layout_height="wrap_content"
19android:layout_width="fill_parent" />
20<TextView android:id="@+id/TextView02"
21android:layout_width="wrap_content"
android:layout_height="wrap_content"
22android:text="Contrasea:"
23android:textStyle="bold" />
24<EditText android:id="@+id/TxtPassword"
25android:layout_height="wrap_content"
/>
26android:layout_width="fill_parent"
<LinearLayout android:orientation="horizontal"
27android:layout_width="fill_parent"
28android:layout_height="fill_parent" >
29<Button
30android:layout_width="wrap_content"
android:layout_height="wrap_content"
31android:id="@+id/BtnAceptar"
32android:text="Login"
33android:paddingLeft="20dip"
34android:paddingRight="20dip" />
android:id="@+id/LblMensaje"
35<TextView
android:layout_width="wrap_content"
36android:layout_height="wrap_content"
37android:paddingLeft="10dip"
38android:textStyle="bold" />
39</LinearLayout>
</LinearLayout>
40
41
42
43
44
45
46
47
50
48
Visualmente, nuestro control ya quedara como se observa en la siguiente imagen:
51
9 txtPassword = (EditText)findViewById(R.id.TxtPassword);
10btnLogin = (Button)findViewById(R.id.BtnAceptar);
lblMensaje = (TextView)findViewById(R.id.LblMensaje);
11//Asociamos los eventos necesarios
12asignarEventos();
13}
14
15
16
17
Dejaremos por ahora a un lado el mtodo asignarEventos(), volveremos sobre l ms
tarde.
Con esto ya tenemos definida la interfaz y la funcionalidad bsica del nuevo control por lo
que ya podemos utilizarlo desde otra actividad como si se tratase de cualquier otro control
predefinido. Para ello haremos referencia a l utilizando la ruta completa del paquete java
utilizado, en nuestro caso quedara como net.sgoliver.ControlLogin. Vamos a
insertar nuestro nuevo control en la actividad principal de la aplicacin:
1
2 <LinearLayout
3 xmlns:android="http://schemas.android.com/apk/res/android"
4 android:orientation="vertical"
5 android:layout_width="fill_parent"
6 android:layout_height="fill_parent"
android:padding="10dip" >
7 <net.sgoliver.ControlLogin android:id="@+id/CtlLogin"
8 android:layout_width="fill_parent"
9 android:layout_height="wrap_content"
10android:background="#0000AA" />
</LinearLayout>
11
12
Dado que estamos heredando de un LinearLayout podemos utilizar en principio
cualquier atributo permitido para dicho tipo de controles, en este caso hemos establecido
por ejemplo los atributos layout_width, layout_height y background. Si
ejecutamos ahora la aplicacin veremos cmo ya hemos conseguido gran parte de nuestro
objetivo:
52
Vamos a aadir ahora algo ms de funcionalidad. En primer lugar, podemos aadir algn
mtodo pblico exclusivo de nuestro control. Como ejemplo podemos aadir un mtodo
que permita modificar el texto de la etiqueta de resultado del login. Esto no tiene ninguna
dificultad:
1public void setMensaje(String msg)
2{
3lblMensaje.setText(msg);
4}
En segundo lugar, todo control que se precie debe tener algunos eventos que nos permitan
responder a las acciones del usuario de la aplicacin. As por ejemplo, los botones tienen un
evento OnClick, las listas un evento OnItemSelected, etc. Pues bien, nosotros vamos
a dotar a nuestro control de un evento personalizado, llamado OnLogin, que se lance
cuando el usuario introduce sus credenciales de identificacin y pulsa el botn Login.
Para ello, lo primero que vamos a hacer es concretar los detalles de dicho evento, creando
una interfaz java para definir su listener. Esta interfaz tan slo tendr un mtodo llamado
onLogin() que devolver los dos datos introducidos por el usuario (usuario y
contrasea). Vemos cmo queda:
1
2package net.sgoliver;
interface OnLoginListener
3public
{
4void onLogin(String usuario, String password);
5}
6
53
Para ello, implementaremos el evento OnClick como ya hemos hecho en otras ocasiones
y como acciones generaremos el evento OnLogin de nuestro listener pasndole los datos
que ha introducido el usuario en los cuadros de texto Usuario y Contrasea:
1
2
3
4
5
54
6 listener.onLogin(txtUsuario.getText().toString(),
7 txtPassword.getText().toString());
}
8 });
9 }
10
11
Con todo esto, la aplicacin principal ya puede implementar el evento OnLogin de nuestro
control, haciendo por ejemplo la validacin de las credenciales del usuario y modificando
convenientemente el texto de la etiqueta de resultado:
1
2
3
@Override
4 public void onCreate(Bundle savedInstanceState)
5 {
6 super.onCreate(savedInstanceState);
7 setContentView(R.layout.main);
8 ctlLogin = (ControlLogin)findViewById(R.id.CtlLogin);
ctlLogin.setOnLoginListener(new OnLoginListener()
9 {
10@Override
11public void onLogin(String usuario, String password)
12{
el usuario y la contrasea
13//Validamos
if (usuario.equals("demo") && password.equals("demo"))
14ctlLogin.setMensaje("Login correcto!");
15else
16ctlLogin.setMensaje("Vuelva a intentarlo.");
17}
});
18}
19
20
21
Veamos lo que ocurre al ejecutar ahora la aplicacin principal e introducir las credenciales
correctas:
55
Como resumen, en este artculo hemos visto cmo construir un control android
personalizado a partir de otros controles estandar, componiendo su interfaz, aadiendo
mtodos y eventos personalizados, e incluso aadiendo nuevas opciones en tiempo de
diseo aadiendo atributos xml exclusivos.
58
Por supuesto este control no tiene mucha utilidad prctica dada su sencillez, pero creo que
puede servir como ejemplo para comentar los pasos necesarios para construir cualquier otro
control ms complejo. Empecemos.
En las anteriores ocasiones vimos cmo el nuevo control creado siempre heredaba de algn
otro control o contenedor ya existente. En este caso sin embargo, vamos a heredar nuestro
contro directamente de la clase View (clase padre de la gran mayora de elementos
visuales de Android). Esto implica, entre otras cosas, que por defecto nuestro control no va
a tener ningn tipo de interfaz grfica, por lo que todo el trabajo de dibujar la interfaz lo
vamos a tener que hacer nosotros. Adems, como paso previo a la representacin grfica de
la interfaz, tambin vamos a tener que determinar las dimensiones que nuestro control
tendr dentro de su elemento contenedor. Como veremos ahora, ambas cosas se llevarn a
cabo redefiniendo dos eventos de la clase View, onDraw() para el dibujo de la interfaz, y
onMeasure() para el clculo de las dimensiones.
Por llevar un orden cronolgico, empecemos comentando el evento onMeasure(). Este
evento se ejecuta automticamente cada vez que se necesita recalcular el tamao de un
control. Pero como ya hemos visto en varias ocasiones, los elementos grficos incluidos en
una aplicacin Android se distribuyen por la pantalla de una forma u otra dependiendo del
tipo de contenedor o layout utilizado. Por tanto, el tamao de un control determinado en la
pantalla no depender slo de l, sino de ciertas restricciones impuestas por su elemento
contenedor o elemento padre. Para resolver esto, en el evento onMeasure() recibiremos
como parmetros las restricciones del elemento padre en cuanto a ancho y alto del control,
con lo que podremos tenerlas en cuenta a la hora de determinar el ancho y alto de nuestro
control personalizado. Estas restricciones se reciben en forma de objetos MeasureSpec,
que contiene dos campos: modo y tamao. El significado del segundo de ellos es obvio, el
primero por su parte sirve para matizar el significado del segundo. Me explico. Este campo
modo puede contener tres valores posibles:
59
AT_MOST: indica que el control podr tener como mximo el tamao especificado.
EXACTLY: indica que al control se le dar exactamente el tamao especificado.
UNSPECIFIED: indica que el control padre no impone ninguna restriccin sobre el
tamao.
Dependiendo de esta pareja de datos, podremos calcular el tamao deseado para nuestro
control. Para nuestro control de ejemplo, apuraremos siempre el tamao mximo disponible
(o un tamao por defecto de 200*100 en caso de no recibir ninguna restriccin), por lo que
en todos los casos elegiremos como tamao de nuestro control el tamao recibido como
parmetro:
1
2
3
4
5 @Override
void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
6 protected
{
7 int ancho = calcularAncho(widthMeasureSpec);
8 int alto = calcularAlto(heightMeasureSpec);
9 setMeasuredDimension(ancho, alto);
10}
private int calcularAlto(int limitesSpec)
11{
12int res = 100; //Alto por defecto
13int modo = MeasureSpec.getMode(limitesSpec);
14int limite = MeasureSpec.getSize(limitesSpec);
15if (modo == MeasureSpec.AT_MOST) {
res = limite;
16}
17else if (modo == MeasureSpec.EXACTLY) {
18res = limite;
19}
res;
20return
}
21private int calcularAncho(int limitesSpec)
22{
23int res = 200; //Ancho por defecto
24int modo = MeasureSpec.getMode(limitesSpec);
int limite = MeasureSpec.getSize(limitesSpec);
25if (modo == MeasureSpec.AT_MOST) {
26res = limite;
27}
28else if (modo == MeasureSpec.EXACTLY) {
= limite;
29res
}
30return res;
31}
32
33
34
35
60
36
37
38
39
40
41
42
Como nota importante, al final del evento onMeasure() siempre debemos llamar al mtodo
setMeasuredDimension() pasando como parmetros el ancho y alto calculados para
nuestro control.
Con esto ya hemos determinado las dimensiones del control, por lo que tan slo nos queda
dibujar su interfaz grfica. Como hemos indicado antes, esta tarea se realiza dentro del
evento onDraw(). Este evento recibe como parmetro un objeto de tipo Canvas, sobre el
que podremos ejecutar todas las operaciones de dibujo de la interfaz. No voy a entrar en
detalles de la clase Canvas, porque se ser tema central de un prximo artculo. Por
ahora nos vamos a conformar sabiendo que es la clase que contiene la mayor parte de los
mtodos de dibujo en interfaces Android, por ejemplo drawRect() para dibujar
rectngulos, drawCircle() para crculos, drawBitmap() para imagenes,
drawText() para texto, e infinidad de posibilidades ms. Para consultar todos los
mtodos disponibles puedes dirigirte a la documentacin oficial de la clase Canvas de
Android. Adems de la clase Canvas, tambin me gustara destacar la clase Paint, que
permite definir el estilo de dibujo a utilizar en los metodos de dibujo de Canvas, por
ejemplo el ancho de trazado de las lneas, los colores de relleno, etc.
Para nuestro ejemplo no necesitaramos conocer nada ms, ya que la interfaz del control es
relativamente sencilla. Vemos primero el cdigo y despus comentamos los pasos
realizados:
1 @Override
protected void onDraw(Canvas canvas)
2 {
3 //Obtenemos las dimensiones del control
4 int alto = getMeasuredHeight();
5 int ancho = getMeasuredWidth();
//Colores Disponibles
6 Paint pRelleno = new Paint();
7 pRelleno.setStyle(Style.FILL);
8 pRelleno.setColor(Color.RED);
9 canvas.drawRect(0, 0, ancho/4, alto/2, pRelleno);
10pRelleno.setColor(Color.GREEN);
canvas.drawRect(ancho/4, 0, 2*(ancho/4), alto/2, pRelleno);
11pRelleno.setColor(Color.BLUE);
12canvas.drawRect(2*(ancho/4), 0, 3*(ancho/4), alto/2, pRelleno);
13pRelleno.setColor(Color.YELLOW);
14canvas.drawRect(3*(ancho/4), 0, 4*(ancho/4), alto/2, pRelleno);
Seleccionado
15//Color
pRelleno.setColor(colorSeleccionado);
16canvas.drawRect(0, alto/2, ancho, alto, pRelleno);
61
1
2
3
4 @Override
5 public boolean onTouchEvent(MotionEvent event)
6 {
//Si se ha pulsado en la zona superior
7 if (event.getY() > 0 && event.getY() < (getMeasuredHeight()/2))
8 {
9 //Si se ha pulsado dentro de los lmites del control
10if (event.getX() > 0 && event.getX() < getMeasuredWidth())
{
11//Determinamos el color seleccionado segn el punto pulsado
12if(event.getX() > (getMeasuredWidth()/4)*3)
13colorSeleccionado = Color.YELLOW;
14else if(event.getX() > (getMeasuredWidth()/4)*2)
15colorSeleccionado = Color.BLUE;
else if(event.getX() > (getMeasuredWidth()/4)*1)
16colorSeleccionado = Color.GREEN;
17else
18colorSeleccionado = Color.RED;
19//Refrescamos el control
20this.invalidate();
}
21}
22return super.onTouchEvent(event);
23}
24
25
26
En segundo lugar crearemos un evento externo personalizado, que lanzaremos cuando el
usuario pulse sobre la zona inferior del control, como una forma de aceptar definitivamente
el color seleccionado. Llamaremos a este evento onSelectedColor(). Para crearlo
actuaremos de la misma forma que ya vimos en el artculo anterior. Primero definiremos
una interfaz para el listener de nuestro evento:
1
2package net.sgoliver.android;
interface OnColorSelectedListener
3public
{
4void onColorSelected(int color);
5}
6
Posteriormente, definiremos un objeto de este tipo como atributo de nuestro control y
escribiremos un nuevo mtodo que permita a las aplicaciones suscribirse al evento:
1
2
3
63
1 {
2 private SelectorColor ctlColor;
3 @Override
4 public void onCreate(Bundle savedInstanceState)
5 {super.onCreate(savedInstanceState);
6 setContentView(R.layout.main);
7 ctlColor = (SelectorColor)findViewById(R.id.scColor);
8 ctlColor.setOnColorSelectedListener(new OnColorSelectedListener()
9 {
@Override
10public void onColorSelected(int color)
64
11{
12//Aqu se tratara el color seleccionado (parmetro 'color'
//...
13}
14});
15}
16}
17
18
19
20
21
22
23
Con esto, tendramos finalizado nuestro control completamente personalizado, que hemos
construido sin utilizar como base ningn otro control predefinido, definiendo desde cero
tanto su aspecto visual como su funcionalidad interna o sus eventos pblicos.
posteriormente hacer referencia a ellos fcilmente (en mi caso he utilizado por ejemplo los
ids tab1, tab2, ). A continuacin represento de forma grfica toda la estructura
descrita.
66
21android:layout_height="match_parent" >
22<TextView android:id="@+id/textView2"
android:text="Contenido Tab 2"
23android:layout_width="wrap_content"
24android:layout_height="wrap_content" />
25</LinearLayout>
26</FrameLayout>
27</LinearLayout>
</TabHost>
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Como podis ver, como contenido de las pestaas tan slo he aadido por simplicidad una
etiqueta de texto con el texto Contenido Tab NTab. Esto nos permitir ver que el
conjunto de pestaas funciona correctamente cuando ejecutemos la aplicacin.
Con esto ya tendramos montada toda la estructura de controles necesaria para nuestra
interfaz de pestaas. Sin embargo, como ya dijimos al principio del artculo, con esto no es
suficiente. Necesitamos asociar de alguna forma cada pestaa con su contenido, de forma
que el el control se comporte correctamente cuando cambiamos de pestaa. Y esto
tendremos que hacerlo mediante cdigo en nuestra actividad principal.
Empezaremos obteniendo una referencia al control principal TabHost y preparndolo
para su configuracin llamando a su mtodo setup(). Tras esto, crearemos un objeto de
tipo TabSpec para cada una de las pestaas que queramos aadir mediante el mtodo
newTabSpec(), al que pasaremos como parmetro una etiqueta identificativa de la
pestaa (en mi caso de ejemplo mitab1, mitab2, ). Adems, tambin le asignaremos
el layout de contenido correspondiente a la pestaa llamando al mtodo setContent(),
e indicaremos el texto y el icono que queremos mostrar en la pestaa mediante el mtodo
setIndicator(texto, icono). Veamos el cdigo completo.
1
2
3
4
5
67
6 res.getDrawable(android.R.drawable.ic_btn_speak_now));
7 tabs.addTab(spec);
spec=tabs.newTabSpec("mitab2");
8 spec.setContent(R.id.tab2);
9 spec.setIndicator("TAB2",
10res.getDrawable(android.R.drawable.ic_dialog_map));
11tabs.addTab(spec);
12tabs.setCurrentTab(0);
13
14
15
16
17
18
Si vemos el cdigo, vemos por ejemplo como para la primera pestaa creamos un objeto
TabSpec con la etiqueta mitab1, le asignamos como contenido uno de los
LinearLayout que incluimos en la seccin de contenido (en este caso R.id.tab1) y
finalmente le asignamos el texto TAB1 y el icono
android.R.drawable.ic_btn_speak_now (ste es un icono incluido con la
propia plataforma Android. Si no existiera en vuestra versin podis sustituirlo por
cualquier otro icono). Finalmente aadimos la nueva pestaa al control mediante el mtodo
addTab().
Si ejecutamos ahora la aplicacin tendremos algo como lo que muestra la siguiente imagen,
donde podremos cambiar de pestaa y comprobar cmo se muestra correctamente el
contenido de la misma.
En cuanto a los eventos disponibles del control TabHost, aunque no suele ser necesario
capturarlos, podemos ver a modo de ejemplo el ms interesante de ellos, OnTabChanged,
68
que se lanza cada vez que se cambia de pestaa y que nos informa de la nueva pestaa
visualizada. Este evento podemos implementarlo y asignarlo mediante el mtodo
setOnTabChangedListener() de la siguiente forma:
1tabs.setOnTabChangedListener(new OnTabChangeListener() {
2@Override
3public void onTabChanged(String tabId) {
4Log.i("AndroidTabsDemo", "Pulsada pestaa: " + tabId);
5}
});
6
En el mtodo onTabChanged() recibimos como parmetro la etiqueta identificativa de
la pestaa (no su ID), que debimos asignar cuando creamos su objeto TabSpec
correspondiente. Para este ejemplo, lo nico que haremos al detectar un cambio de pestaa
ser escribir en el log de la aplicacin un mensaje informativo con la etiqueta de la nueva
pestaa visualizada. As por ejemplo, al cambiar a la segunda pestaa recibiremos el
mensaje de log: Pulsada pestaa: mitab2.
En este primer artculo sobre el tema veremos cmo trabajar con los dos primeros tipos de
mens. En el siguiente, comentaremos los mens contextuales y algunos caractersticas ms
avanzadas.
Como casi siempre, vamos a tener dos alternativas a la hora de mostrar un men en nuestra
aplicacin Android. La primera de ellas mediante la definicin del men en un fichero
XML, y la segunda creando el men directamente mediante cdigo. En este artculo
veremos ambas alternativas.
Veamos en primer lugar cmo crear un men a partir de su definicin en XML. Los
ficheros XML de men se deben colocar en la carpeta res\menu de nuestro proyecto y
tendrn una estructura anloga a la del siguiente ejemplo:
1 <?xml version="1.0" encoding="utf-8"?>
69
2 <menu
3 xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/MnuOpc1" android:title="Opcion1"
4 android:icon="@drawable/tag"></item>
5 <item android:id="@+id/MnuOpc2" android:title="Opcion2"
6 android:icon="@drawable/filter"></item>
7 <item android:id="@+id/MnuOpc3" android:title="Opcion3"
8 android:icon="@drawable/chart"></item>
</menu>
9
10
11
12
Como vemos, la estructura bsica de estos ficheros es muy sencilla. Tendremos un
elemento principal <menu> que contendr una serie de elementos <item> que se
correspondern con las distintas opciones a mostrar en el men. Estos elementos <item>
tendrn a su vez varias propiedades bsicas, como su ID (android:id), su texto
(android:title) o su icono (android:icon). Los iconos utilizados debern estar
por supuesto en las carpetas res\drawable- de nuestro proyecto (al final del
artculo os paso unos enlaces donde podis conseguir algunos iconos de men Android
gratuitos).
Una vez definido el men en el fichero XML, tendremos que implementar el evento
onCreateOptionsMenu() de la actividad que queremos que lo muestre. En este
evento deberemos inflar el men de forma parecida a cmo ya hemos hecho otras veces
con otro tipo de layouts. Primero obtendremos una referencia al inflater mediante el mtodo
getMenuInflater() y posteriormente generaremos la estructura del men llamando a
su mtodo infate() pasndole como parmetro el ID del menu definido en XML, que en
nuestro caso ser R.menu.menu_principal. Por ltimo devolveremos el valor true
para confirmar que debe mostrarse el men.
1
@Override
2public boolean onCreateOptionsMenu(Menu menu) {
3//Alternativa 1
4MenuInflater inflater = getMenuInflater();
5inflater.inflate(R.menu.menu_principal, menu);
true;
6return
}
7
Y ya hemos terminado, con estos sencillos pasos nuestra aplicacin ya debera mostrar sin
problemas el men que hemos construdo, aunque todava nos faltara implementar la
funcionalidad de cada una de las opciones mostradas.
70
Como hemos comentado antes, este mismo men tambin lo podramos crear directamente
mediante cdigo, tambin desde el evento onCreateOptionsMenu(). Para ello, para
aadir cada opcin del men podemos utilizar el mtodo add() sobre el objeto de tipo
Menu que nos llega como parmetro del evento. Este mtodo recibe 4 parmetros: ID del
grupo asociado a la opcin (veremos qu es esto en el siguiente artculo, por ahora
utilizaremos Menu.NONE), un ID nico para la opcin (que declararemos como constantes
de la clase), el orden de la opcin (que no nos interesa por ahora, utilizaremos
Menu.NONE) y el texto de la opcin. Por otra aprte, el icono de cada opcin lo
estableceremos mediante el mtodo setIcon() pasndole el ID del recurso. Veamos
cmo quedara el cdigo utilizando esta alternativa, que generara un men exactamente
igual al del ejemplo anterior:
1
2 private static final int MNU_OPC1 = 1;
private static final int MNU_OPC2 = 2;
3 private static final int MNU_OPC3 = 3;
4 //...
5 @Override
6 public boolean onCreateOptionsMenu(Menu menu) {
2
7 //Alternativa
menu.add(Menu.NONE, MNU_OPC1, Menu.NONE,
8 "Opcion1").setIcon(R.drawable.tag);
9 menu.add(Menu.NONE, MNU_OPC1, Menu.NONE,
10"Opcion2").setIcon(R.drawable.filter);
11menu.add(Menu.NONE, MNU_OPC1, Menu.NONE,
"Opcion3").setIcon(R.drawable.chart);
12return true;
13}
14
Construido el men, la implementacin de cada una de las opciones se incluir en el evento
onOptionsItemSelected() de la actividad que mostrar el men. Este evento
71
recibe como parmetro el item de men que ha sido pulsado por el usuario, cuyo ID
podemos recuperar con el mtodo getItemId(). Segn este ID podremos saber qu
opcin ha sido pulsada y ejecutar unas acciones u otras. En nuestro caso de ejemplo, lo
nico que haremos ser modificar el texto de una etiqueta (lblMensaje) colocada en la
pantalla principal de la aplicacin.
1
2 @Override
3 public boolean onOptionsItemSelected(MenuItem item) {
4 switch (item.getItemId()) {
5 case R.id.MnuOpc1:
lblMensaje.setText("Opcion 1 pulsada!");
6 return true;
7 case R.id.MnuOpc2:
8 lblMensaje.setText("Opcion 2 pulsada!");;
9 return true;
10case R.id.MnuOpc3:
lblMensaje.setText("Opcion 3 pulsada!");;
11return true;
12default:
13return super.onOptionsItemSelected(item);
14}
15}
16
Con esto, hemos conseguido ya un men completamente funcional. Si ejecutamos el
proyecto en el emulador comprobaremos cmo al pulsar el botn de menu del telfono
aparece el men que hemos definido y que al pulsar cada opcin se muestra el mensaje de
ejemplo.
Pasemos ahora a comentar los submens. Un submen no es ms que un men secundario
que se muestra al pulsar una opcin determinada de un men principal. Los submens en
Android se muestran en forma de lista emergente, cuyo ttulo contiene el texto de la opcin
elegida en el men principal. Como ejemplo, vamos a aadir un submen a la Opcin 3 del
ejemplo anterior, al que aadiremos dos nuevas opciones secundarias. Para ello, bastar con
insertar en el XML de men un nuevo elemento <menu> dentro del item correspondiente a
la opcin 3. De esta forma, el XML quedara ahora como sigue:
<?xml version="1.0" encoding="utf-8"?>
1 <menu
2 xmlns:android="http://schemas.android.com/apk/res/android">
3 <item android:id="@+id/MnuOpc1" android:title="Opcion1"
4 android:icon="@drawable/tag"></item>
android:id="@+id/MnuOpc2" android:title="Opcion2"
5 <item
android:icon="@drawable/filter"></item>
6 <item android:id="@+id/MnuOpc3" android:title="Opcion3"
7 android:icon="@drawable/chart">
8 <menu>
9 <item android:id="@+id/SubMnuOpc1"
android:title="Opcion 3.1" />
10<item android:id="@+id/SubMnuOpc2"
72
Comprobamos como efectivamente aparecen las dos nuevas opciones en la lista emergente,
y que el ttulo de la lista se corresponde con el texto de la opcin elegida en el men
principal (Opcion3).
Para conseguir esto mismo mediante cdigo procederamos de forma similar a la anterior,
con la nica diferencia de que la opcin de men 3 la aadiremos utilizando el mtodo
addSubMenu() en vez de add(), y guardando una referencia al submenu. Sobre el
submen aadido insertaremos las dos nuevas opciones utilizando una vez ms el mtodo
add(). Vemos cmo quedara:
1//Alternativa 2
2menu.add(Menu.NONE, MNU_OPC1, Menu.NONE,
"Opcion1").setIcon(R.drawable.tag);
3menu.add(Menu.NONE, MNU_OPC1, Menu.NONE,
4"Opcion2").setIcon(R.drawable.filter);
5//menu.add(Menu.NONE, MNU_OPC1, Menu.NONE,
73
6"Opcion3").setIcon(R.drawable.chart);
7SubMenu smnu = menu.addSubMenu(Menu.NONE, MNU_OPC1, Menu.NONE,
"Opcion3")
8.setIcon(R.drawable.chart);
9smnu.add(Menu.NONE, SMNU_OPC1, Menu.NONE, "Opcion 3.1");
smnu.add(Menu.NONE, SMNU_OPC2, Menu.NONE, "Opcion 3.2");
http://www.androidicons.com/freebies.php
http://www.glyfx.com/products/free_android2.html
74
4 lblMensaje = (TextView)findViewById(R.id.LblMensaje);
5 //Asociamos los mens contextuales a los controles
registerForContextMenu(lblMensaje);
6 }
7
8
9
10
1
2
<?xml version="1.0" encoding="utf-8"?>
3 <menu
4 xmlns:android="http://schemas.android.com/apk/res/android">
5 <item android:id="@+id/CtxLblOpc1"
6 android:title="OpcEtiqueta1"></item>
7 <item android:id="@+id/CtxLblOpc2"
android:title="OpcEtiqueta2"></item>
8 </menu>
9
10
1
2@Override
3public void onCreateContextMenu(ContextMenu menu, View v,
4ContextMenuInfo menuInfo)
{
5super.onCreateContextMenu(menu, v, menuInfo);
6MenuInflater inflater = getMenuInflater();
7inflater.inflate(R.menu.menu_ctx_etiqueta, menu);
8}
9
Por ltimo, para implementar las acciones a realizar tras pulsar una opcin
determinada del men contextual vamos a implementar el evento
onContextItemSelected() de forma anloga a cmo hacamos con
onOptionsItemSelected() para los mens bsicos:
75
1
2
@Override
3 public boolean onContextItemSelected(MenuItem item) {
4 switch (item.getItemId()) {
5 case R.id.CtxLblOpc1:
6 lblMensaje.setText("Etiqueta: Opcion 1 pulsada!");
true;
7 return
case R.id.CtxLblOpc2:
8 lblMensaje.setText("Etiqueta: Opcion 2 pulsada!");
9 return true;
10default:
11return super.onContextItemSelected(item);
}
12}
13
14
Con esto, ya tendramos listo nuestro men contextual para la etiqueta de texto de la
actividad principal, y como veis todo es prcticamente anlogo a cmo construimos
los mens y submens bsicos en el artculo anterior. En este punto ya podramos
ejecutar el proyecto en el emulador y comprobar su funcionamiento.
Ahora vamos con algunas particularidades. Los mens contextuales se utilizan a
menudo con controles de tipo lista, lo que aade algunos detalles que conviene
mencionar. Para ello vamos a aadir a nuestro ejemplo una lista con varios datos de
muestra y vamos a asociarle un nuevo men contextual. Modificaremos el layout
XML de la ventana principal para aadir el control ListView y modificaremos el
mtodo onCreate() para obtener la referencia al control, insertar vaios datos de
ejemplo, y asociarle un men contextual:
1
2
3 public void onCreate(Bundle savedInstanceState) {
4 super.onCreate(savedInstanceState);
5 setContentView(R.layout.main);
6 //Obtenemos las referencias a los controles
7 lblMensaje = (TextView)findViewById(R.id.LblMensaje);
lstLista = (ListView)findViewById(R.id.LstLista);
8 //Rellenamos la lista con datos de ejemplo
9 String[] datos =
10new String[]{"Elem1","Elem2","Elem3","Elem4","Elem5"};
11ArrayAdapter<String> adaptador =
new ArrayAdapter<String>(this,
12android.R.layout.simple_list_item_1, datos);
13lstLista.setAdapter(adaptador);
14//Asociamos los mens contextuales a los controles
15registerForContextMenu(lblMensaje);
16registerForContextMenu(lstLista);
}
17
18
19
76
20
21
22
Como en el caso anterior, vamos a definir en XML otro men para asociarlo a los
elementos de la lista, lo llamaremos menu_ctx_lista:
1
2
<?xml version="1.0" encoding="utf-8"?>
3 <menu
4 xmlns:android="http://schemas.android.com/apk/res/android">
5 <item android:id="@+id/CtxLstOpc1"
6 android:title="OpcLista1"></item>
7 <item android:id="@+id/CtxLstOpc2"
android:title="OpcLista2"></item>
8 </menu>
9
10
Como siguiente paso, y dado que vamos a tener varios mens contextuales en la
misma actividad, necesitaremos modificar el evento onCreateContextMenu()
para que se construya un men distinto dependiendo del control asociado. Esto lo
haremos obteniendo el ID del control al que se va a asociar el men contextual, que
se recibe en forma de parmetro (View v) en el evento
onCreateContextMenu(). Utilizaremos para ello una llamada al mtodo
getId() de dicho parmetro:
1
2
3
4 @Override
5 public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenuInfo menuInfo)
6 {
7 super.onCreateContextMenu(menu, v, menuInfo);
8 MenuInflater inflater = getMenuInflater();
9 if(v.getId() == R.id.LblMensaje)
menu);
10inflater.inflate(R.menu.menu_ctx_etiqueta,
else if(v.getId() == R.id.LstLista)
11{
12AdapterView.AdapterContextMenuInfo info =
13(AdapterView.AdapterContextMenuInfo)menuInfo;
14menu.setHeaderTitle(
lstLista.getAdapter().getItem(info.position).toString());
15inflater.inflate(R.menu.menu_ctx_lista, menu);
16}
17}
18
19
20
77
21
Vemos cmo en el caso del men para el control lista hemos ido adems un poco
ms all, y hemos personalizado el ttulo del men contextual [mediante
setHeaderTitle()] para que muestre el texto del elemento seleccionado en la
lista. Para hacer esto nos hace falta saber la posicin en la lista del elemento
seleccionado, algo que podemos conseguir haciendo uso del ltimo parmetro
recibido en el evento onCreateContextMenu(), llamado menuInfo. Este
parmetro contiene informacin adicional del control que se ha pulsado para
mostrar el men contextual, y en el caso particular del control ListView contiene
la posicin del elemento concreto de la lista que se ha pulsado. Para obtenerlo,
convertimos el parmetro menuInfo a un objeto de tipo
AdapterContextMenuInfo y accedemos a su atributo position tal como
vemos en el cdigo anterior.
La respuesta a este nuevo men se realizar desde el mismo evento que el anterior,
todo dentro de onContextItemSelected(). Por tanto, incluyendo las
opciones del nuevo men contextual para la lista el cdigo nos quedara de la
siguiente forma:
1
2
3
4 @Override
public boolean onContextItemSelected(MenuItem item) {
5 AdapterContextMenuInfo info =
6 (AdapterContextMenuInfo) item.getMenuInfo();
7 switch (item.getItemId()) {
8 case R.id.CtxLblOpc1:
9 lblMensaje.setText("Etiqueta: Opcion 1 pulsada!");
return true;
10case R.id.CtxLblOpc2:
11lblMensaje.setText("Etiqueta: Opcion 2 pulsada!");
12return true;
13case R.id.CtxLstOpc1:
+ info.position + "]: Opcion 1 pulsada!");
14lblMensaje.setText("Lista["
return true;
15case R.id.CtxLstOpc2:
16lblMensaje.setText("Lista[" + info.position + "]: Opcion 2 pulsada!");
17return true;
18default:
return super.onContextItemSelected(item);
19}
20}
21
22
23
A modo de resumen, en este artculo hemos visto cmo crear mens contextuales
asociados a determinados elementos y controles de nuestra interfaz de la aplicacin.
Hemos visto cmo crear mens bsicos y algunas particularidades que existen a la
hora de asociar mens contextuales a elementos de un control de tipo lista. Para no
alargar este artculo dedicaremos un tercero a comentar algunas opciones menos
frecuentes, pero igualmente tiles, de los mens en Android.
<menu
xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/MnuOpc1" android:title="Opcion1"
android:icon="@drawable/tag"></item>
<item android:id="@+id/MnuOpc2" android:title="Opcion2"
android:icon="@drawable/filter"></item>
<item android:id="@+id/MnuOpc3" android:title="Opcion3"
android:icon="@drawable/chart">
<menu>
<group android:id="@+id/grupo1">
<item android:id="@+id/SubMnuOpc1"
android:title="Opcion 3.1" />
<item android:id="@+id/SubMnuOpc2"
android:title="Opcion 3.2" />
</group>
</menu>
</item>
</menu>
Como vemos, las dos opciones del submen se han incluido dentro de un elemento
<group>. Esto nos permitir ejecutar algunas acciones sobre todas las opciones del
grupo de forma conjunta, por ejemplo deshabilitarlas u ocultarlas:
1
2
3
4
5
80
81
30
31
32
33
34
35
36
37
38
39
40
Como vemos, al final del mtodo nos ocupamos de marcar manualmente la opcin
seleccionada actualmente, que debemos conservar en algn atributo interno (en mi caso
lo he llamado opcionSeleccionada) de nuestra actividad. Esta marcacin manual
la hacemos mediante el mtodo getItem() para obtener una opcin determinada del
submen y sobre sta el mtodo setChecked() para establecer su estado. Por qu
debemos hacer esto? No guarda Android el estado de las opciones de menu
seleccionables? La respuesta es s, s lo hace, pero siempre que no reconstruyamos el
men entre una visualizacin y otra. Pero no dijimos que la creacin del men slo se
realiza una vez en la primera llamada a onCreateOptionsMenu()? Tambin es
cierto, pero despus veremos cmo tambin es posible preparar nuestra aplicacin para
poder modificar de forma dinmica un men segn determinadas condiciones, lo que s
podra implicar reconstruirlo previamente a cada visualizacin. En definitiva, si
guardamos y restauramos nosotros mismos el estado de las opciones de men
seleccionables estaremos seguros de no perder su estado bajo ninguna circunstancia.
Por supuesto, para mantener el estado de las opciones har falta actualizar el atributo
opcionSeleccionada tras cada pulsacin a una de las opciones. Esto lo haremos
como siempre en el mtodo onOptionItemSelected().
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
//...
//Omito el resto de opciones por simplicidad
case SMNU_OPC1:
opcionSeleccionada = 1;
item.setChecked(true);
return true;
case SMNU_OPC2:
opcionSeleccionada = 2;
item.setChecked(true);
return true;
//...
}
}
82
16
17
18
19
Con esto ya podramos probar cmo nuestro men funciona de la forma esperada,
permitiendo marcar slo una de las opciones del submen. Si visualizamos y marcamos
varias veces distintas opciones veremos cmo se mantiene correctamente el estado de
cada una de ellas entre diferentes llamadas.
El segundo tema que quera desarrollar en este artculo trata sobre la modificacin
dinmica de un men durante la ejecucucin de la aplicacin de forma que ste sea
distinto segun determinadas condiciones. Supongamos por ejemplo que normalmente
vamos a querer mostrar nuestro men con 3 opciones, pero si tenemos marcada en
pantalla una determinada opcin queremos mostrar en el men una opcin adicional.
Cmo hacemos esto si dijimos que el evento onCreateOptionsMenu() se ejecuta
una sola vez? Pues esto es posible ya que adems del evento indicado existe otro
llamado onPrepareOptionsMenu() que se ejecuta cada vez que se va a mostrar el
men de la aplicacin, con lo que resulta el lugar ideal para adaptar nuestro men a las
condiciones actuales de la aplicacin.
Para mostrar el funcionamiento de esto vamos a colocar en nuestra aplicacin de
ejemplo un nuevo checkbox (lo llamar en mi caso chkMenuExtendido). Nuestra
intencin es que si este checkbox est marcado el men muestre una cuarta opcin
adicional, y en caso contrario slo muestre las tres opciones ya vistas en los ejemplos
anteriores.
En primer lugar prepararemos el mtodo construirMenu() para que reciba un
parmetro adicional que indique si queremos construir un men extendido o no, y slo
aadiremos la cuarta opcin si este parmetro llega activado.
1
2
3
83
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Override
public boolean onPrepareOptionsMenu(Menu menu)
{
menu.clear();
if(chkMenuExtendido.isChecked())
construirMenu(menu, true);
else
construirMenu(menu, false);
return super.onPrepareOptionsMenu(menu);
}
Como vemos, en primer lugar debemos resetear el men mediante el mtodo clear()
y posteriormente llamar de nuevo a nuestro mtodo de construccin del men indicando
si queremos un men extendido o no segn el valor de la check.
Si ejecutamos nuevamente la aplicacin de ejemplo, marcamos el checkbox y
mostramos la tecla de men podremos comprobar cmo se muestra correctamente la
cuarta opcin aadida.
84
Y con esto cerramos ya todos los temas referentes a mens que tena intencin de
incluir en este Curso de Programacin en Android. Espero que sea suficiente para cubrir
las necesidades de muchas de vuestras aplicaciones.
85
Los pasos principales para la creacin de un widget Android son los siguientes:
1. Definicin de su interfaz grfica (layout).
2. Configuracin XML del widget (AppWidgetProviderInfo).
3. Implementacin de la funcionalidad del widget (AppWidgetProvider) ,
especialmente su evento de actualizacin.
4. Declaracin del widget en el Android Manifest de la aplicacin.
En el primer paso no nos vamos a detener mucho ya que es anlogo a cualquier definicin
de layout de las que hemos visto hasta ahora en el curso. En esta ocasin, la interfaz del
widget estar compuesta nicamente por un par de frames (FrameLayout), uno negro
exterior y uno blanco interior algo ms pequeo para simular el marco, y una etiqueta de
texto (TextView) que albergar el mensaje a mostrar. Veamos cmo queda el layout xml,
que para este ejemplo llamaremos miwidget.xml:
1 <LinearLayout
2 xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
3 android:layout_height="fill_parent"
4 android:padding="5dip">
5 <FrameLayout
6 android:layout_width="fill_parent"
7 android:layout_height="fill_parent"
android:background="#000000"
8 android:padding="10dip" >
9 <FrameLayout
10android:layout_width="fill_parent"
11android:layout_height="fill_parent"
android:background="#FFFFFF"
12android:padding="5dip" >
13<TextView android:id="@+id/txtMensaje"
14android:layout_width="fill_parent"
86
15android:layout_height="fill_parent"
16android:textColor="#000000"
android:text="Mi Primer Widget" />
17</FrameLayout>
18</FrameLayout>
19</LinearLayout>
20
21
22
23
24
25
26
27
28
29
Cabe destacar aqu que, debido a que el layout de los widgets de Android est basado en un
tipo especial de componentes llamados RemoteViews, no es posible utilizar en su
interfaz todos los contenedores y controles que hemos visto en artculos anteriores sino
unos pocos bsicos que se indican a continuacin:
Aunque la lista de controles soportados no deja de ser curiosa (al menos en mi humilde
opinin), debera ser suficiente para crear todo tipo de widgets.
Como segundo paso del proceso de construccin vamos a crear un nuevo fichero XML
donde definiremos un conjunto de propiedades del widget, como por ejemplo su tamao en
pantalla o su frecuencia de actualizacin. Este XML se deber crear en la carpeta
\res\xml de nuestro proyecto. En nuestro caso de ejemplo lo llamaremos
miwidget_wprovider.xml y tendr la siguiente estructura:
1<?xml version="1.0" encoding="utf-8"?>
2<appwidget-provider
3xmlns:android="http://schemas.android.com/apk/res/android"
4android:initialLayout="@layout/miwidget"
android:minWidth="146dip"
5android:minHeight="72dip"
6android:label="Mi Primer Widget"
7android:updatePeriodMillis="3600000"
8/>
Para nuestro widget estamos definiendo las siguientes propiedades:
87
Atendiendo a esta frmula, si queremos que nuestro widget ocupe un tamao mnimo de 2
celdas de ancho por 1 celda de alto, deberemos indicar unas dimensiones de 146dp x 72dp.
Vamos ahora con el tercer paso. ste consiste en implementar la funcionalidad de nuestro
widget en su clase java asociada. Esta clase deber heredar de AppWidgetProvider,
que a su vez no es ms que una clase auxiliar derivada de BroadcastReceiver, ya que
los widgets de Android no son ms que un caso particular de este tipo de componentes.
En esta clase deberemos implementar los mensajes a los que vamos a responder desde
nuestro widget, entre los que destacan:
89
Con esto habramos terminado de escribir los distintos elementos necesarios para hacer
funcionar nuestro widget bsico de ejemplo. Para probarlo, podemos ejecutar el proyecto de
Eclipse en el emulador de Android, esperar a que se ejecute la aplicacin principal (que
estar vaca, ya que no hemos incluido ninguna funcionalidad para ella), ir a la pantalla
principal del emulador y aadir nuestro widget al escritorio tal cmo lo haramos en nuestro
telfono (pulsacin larga sobre el escritorio o tecla Men, seleccionar la opcin Widgets, y
por ltimo seleccionar nuestro Widget). Os dejo una demostracin en video.
Como podis ver en el video, ya hemos conseguido la funcionalidad bsica de un widget, es
posible aadir varias instancias al escritorio, desplazarlos por la pantalla y eliminarlos
envindolos a la papelera.
En el prximo artculo veremos cmo podemos mejorar este widget aadiendo una pantalla
de configuracin inicial, mostraremos algn dato que se actualice peridicamente, y
aadiremos la posibilidad de capturar eventos de pulsacin sobre el widget.
Como sabis, intento simplificar al mximo todos los ejemplos que utilizo en este curso
para que podamos centrar nuestra atencin en los aspectos realmente importantes. En esta
ocasin utilizar el mismo criterio y las nicas caractersticas (aunque suficientes para
demostrar los tres conceptos anteriores) que aadiremos a nuestro widget sern las
siguientes:
1. Aadiremos una pantalla de configuracin inicial del widget, que aparecer cada
vez que se aada una nueva instancia del widget a nuestro escritorio. En esta
pantalla podr configurarse nicamente el mensaje de texto a mostrar en el widget.
2. Aadiremos un nuevo elemento de texto al widget que muestre la hora actual. Esto
nos servir para comprobar que el widget se actualiza periodicamente.
3. Aadiremos un botn al widget, que al ser pulsado forzar la actualizacin
inmediata del mismo.
Empecemos por el primer punto, la pantalla de configuracin inicial del widget. Y
procederemos igual que para el diseo de cualquier otra actividad android, definiendo su
layout xml. En nuestro caso ser muy sencilla, un cuadro de texto para introducir el
mensaje a personalizar y dos botones, uno para aceptar la configuracin y otro para
90
cancelar (en cuyo caso el widget no se aade al escritorio). En esta ocasin llamaremos a
este layout widget_config.xml. Veamos como queda:
1
2
3
4
5
6
7 <?xml version="1.0" encoding="utf-8"?>
8 <LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
9 android:layout_width="fill_parent"
10android:layout_height="fill_parent"
11android:orientation="vertical">
12<TextView android:id="@+id/LblMensaje"
android:layout_width="wrap_content"
13android:layout_height="wrap_content"
14android:text="Mensaje personalizado:" />
15<EditText android:id="@+id/TxtMensaje"
16android:layout_height="wrap_content"
/>
17android:layout_width="fill_parent"
<LinearLayout
18android:layout_width="fill_parent"
19android:layout_height="fill_parent"
20android:orientation="horizontal" >
21<Button android:id="@+id/BtnAceptar"
android:layout_width="wrap_content"
22android:layout_height="wrap_content"
23android:text="Aceptar" />
24<Button android:id="@+id/BtnCancelar"
25android:layout_width="wrap_content"
26android:layout_height="wrap_content"
android:text="Cancelar" />
27</LinearLayout>
28</LinearLayout>
29
30
31
32
33
34
Una vez diseada la interfaz de nuestra actividad de configuracin tendremos que
implementar su funcionalidad en java. Llamaremos a la clase WidgetConfig, su
estructura ser anloga a la de cualquier actividad de Android, y las acciones a realizar
sern las comentadas a continuacin. En primer lugar nos har falta el identificador de la
instancia concreta del widget que se configurar con esta actividad. Este ID nos llega como
parmetro del intent que ha lanzado la actividad. Como ya vimos en un artculo anterior del
curso, este intent se puede recuperar mediante el mtdo getIntent() y sus parmetros
mediante el mtodo getExtras(). Conseguida la lista de parmetros del intent,
91
92
Con estas indicaciones, veamos cmo quedara el cdigo del botn Aceptar:
1
2
3 //Implementacin del botn "Aceptar"
4 btnAceptar.setOnClickListener(new OnClickListener() {
5 @Override
6 public void onClick(View arg0) {
el mensaje personalizado en las preferencias
7 //Guardamos
SharedPreferences prefs =
8 getSharedPreferences("WidgetPrefs", Context.MODE_PRIVATE);
9 SharedPreferences.Editor editor = prefs.edit();
10editor.putString("msg_" + widgetId, txtMensaje.getText().toString());
11editor.commit();
//Actualizamos el widget tras la configuracin
12AppWidgetManager appWidgetManager =
13AppWidgetManager.getInstance(WidgetConfig.this);
14MiWidget.actualizarWidget(WidgetConfig.this, appWidgetManager,
15widgetId);
como resultado: ACEPTAR (RESULT_OK)
16//Devolvemos
Intent resultado = new Intent();
17resultado.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, widgetId);
18setResult(RESULT_OK, resultado);
19finish();
20}
});
21
22
23
Ya hemos terminado de implementar nuestra actividad de configuracin. Pero para su
correcto funcionamiento an nos quedan dos detalles ms por modificar. En primer lugar
tendremos que declarar esta actividad en nuestro fichero AndroidManifest.xml, indicando
que debe responder a los mensajes de tipo APPWIDGET_CONFIGURE:
1<activity android:name=".WidgetConfig">
2<intent-filter>
3<action android:name="android.apwidget.action.APPWIDGET_CONFIGURE"/>
4</intent-filter>
5</activity>
Por ltimo, debemos indicar en el XML de configuracin de nuestro widget
(xml\miwidget_wprovider.xml) que al aadir una instancia de este widget debe mostrarse la
actividad de configuracin que hemos creado. Esto se consigue estableciendo el atributo
android:configure del provider. Aprovecharemos adems este paso para establecer
el tiempo de actualizacin automtica del widget al mnimo permitido por este parmetro
(30 minutos) y el tamao del widget a 22 celdas. Veamos cmo quedara finalmente:
version="1.0" encoding="utf-8"?>
1<?xml
<appwidget-provider
2xmlns:android="http://schemas.android.com/apk/res/android"
94
3android:initialLayout="@layout/miwidget"
4android:minWidth="146dip"
android:minHeight="146dip"
5android:label="Mi Primer Widget"
6android:updatePeriodMillis="1800000"
7android:configure="net.sgoliver.android.WidgetConfig"
8/>
9
Con esto, ya tenemos todo listo para que al aadir nuestro widget al escritorio se muestre
automticamente la pantalla de configuracin que hemos construido. Podemos ejecutar el
proyecto en este punto y comprobar que todo funciona correctamente.
Como siguiente paso vamos a modificar el layout del widget que ya construimos en el
artculo anterior para aadir una nueva etiqueta de texto donde mostraremos la hora actual,
y un botn que nos servir para forzar la actualizacin de los datos del widget:
1
2 <?xml version="1.0" encoding="utf-8"?>
3 <LinearLayout
4 xmlns:android="http://schemas.android.com/apk/res/android"
5 android:layout_width="fill_parent"
6 android:layout_height="fill_parent"
android:padding="5dip">
7 <FrameLayout
8 android:layout_width="fill_parent"
9 android:layout_height="fill_parent"
10android:background="#000000"
>
11android:padding="10dip"
<LinearLayout
12android:layout_width="fill_parent"
13android:layout_height="fill_parent"
14android:background="#FFFFFF"
15android:padding="5dip"
android:orientation="vertical">
16<TextView android:id="@+id/LblMensaje"
17android:layout_width="fill_parent"
18android:layout_height="wrap_content"
19android:textColor="#000000"
20android:text="mensaje" />
<TextView android:id="@+id/LblHora"
21android:layout_width="fill_parent"
22android:layout_height="wrap_content"
23android:textColor="#000000"
24android:text="hora_actual" />
<Button android:id="@+id/BtnActualizar"
25android:layout_width="fill_parent"
26android:layout_height="wrap_content"
27android:text="Actualizar" />
28</LinearLayout>
29</FrameLayout>
</LinearLayout>
30
31
95
32
33
34
35
36
37
38
39
40
41
42
Hecho esto, tendremos que modificar la implementacin de nuestro provider
(MiWidget.java) para que en cada actualizacin del widget se actualicen sus controles
con los datos correctos (recordemos que en el artculo anterior dejamos este evento de
actualizacin vaco ya que no mostrbamos datos actualizables en el widget). Esto lo
haremos dentro del evento onUpdate() de nuestro provider.
Como ya dijimos, los componentes de un widget se basan en un tipo especial de vistas que
llamamos Remote Views. Pues bien, para acceder a la lista de estos componentes que
constituyen la interfaz del widget construiremos un nuevo objeto RemoteViews a partir
del ID del layout de cada widget. Obtenida la lista de componentes, tendremos disponibles
una serie de mtodos set (uno para cada tipo de datos bsicos) para establecer las
propiedades de cada control del widget. Estos mtodos reciben como parmetros el ID del
control, el nombre del mtodo que queremos ejecutar sobre el control, y el valor a
establecer. Adems de estos mtodos, contamos adicionalmente con una serie de mtodos
ms especficos para establecer directamente el texto y otras propiedades sencillas de los
controles TextView, ImageView, ProgressBar y Chronometer, como por
ejemplo setTextViewText(idControl, valor) para establecer el textode un
control TextView. Pueden consultarse todos los mtodos disponibles en la
documentacin oficial de la clase RemoteViews. De esta forma, si por ejemplo queremos
establecer el texto del control cuyo id es LblMensaje haramos lo siguiente:
controles = new RemoteViews(context.getPackageName(),
1RemoteViews
R.layout.miwidget);
2controles.setTextViewText(R.id.LblMensaje, "Mensaje de prueba");
El proceso de actualizacin habr que realizarlo por supuesto para todas las instancias del
widget que se hayan aadido al escritorio. Recordemos aqu que el evento onUpdate()
recibe como parmetro la lista de widgets que hay que actualizar.
Dicho esto, creo que ya podemos mostrar cmo quedara el cdigo de actualizacin de
nuestro widget:
1 @Override
public void onUpdate(Context context,
2 AppWidgetManager appWidgetManager,
96
3 int[] appWidgetIds) {
4 //Iteramos la lista de widgets en ejecucin
for (int i = 0; i < appWidgetIds.length; i++)
5 {
6 //ID del widget actual
7 int widgetId = appWidgetIds[i];
8 //Actualizamos el widget actual
appWidgetManager, widgetId);
9 actualizarWidget(context,
}
10}
11public static void actualizarWidget(Context context,
12AppWidgetManager appWidgetManager, int widgetId)
13{
//Recuperamos el mensaje personalizado para el widget actual
14SharedPreferences prefs =
15context.getSharedPreferences("WidgetPrefs", Context.MODE_PRIVATE);
16String mensaje = prefs.getString("msg_" + widgetId, "Hora actual:");
17//Obtenemos la lista de controles del widget actual
controles =
18RemoteViews
new RemoteViews(context.getPackageName(), R.layout.miwidget);
19//Actualizamos el mensaje en el control del widget
20controles.setTextViewText(R.id.LblMsg, mensaje);
21//Obtenemos la hora actual
22Calendar calendario = new GregorianCalendar();
String hora = calendario.getTime().toLocaleString();
23//Actualizamos la hora en el control del widget
24controles.setTextViewText(R.id.LblHora, hora);
25//Notificamos al manager de la actualizacin del widget actual
26appWidgetManager.updateAppWidget(widgetId, controles);
27}
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Como vemos, todo el trabajo de actualzacin para un widget lo hemos extraido a un mtodo
esttico independiente, de forma que tambin podamos llamarlo desde otras partes de la
aplicacin (como hacemos por ejemplo desde la actividad de configuracin para forzar la
primera actualizacin del widget).
Adems quiero destacar la ltima linea del cdigo, donde llamamos al mtodo
updateAppWidget() del widget manager. Esto es importante y necesario, ya que de no
97
98
Por ltimo, vamos a implementar el evento onReceive() del widget para actuar en caso
de recibir nuestro mensaje de actualizacin personalizado. Dentro de este evento
comprobaremos si la accin del menasje recibido es la nuestra, y en ese caso recuperaremos
el ID del widget que lo ha lanzado, obtendremos una referencia al widget manager, y por
ltimo llamaremos nuestro mtodo esttico de actualizacin pasndole estos datos.
1
2
3 @Override
4 public void onReceive(Context context, Intent intent) {
5 if (intent.getAction().equals("net.sgoliver.ACTUALIZAR_WIDGET")) {
6 //Obtenemos el ID del widget a actualizar
int widgetId = intent.getIntExtra(
7 AppWidgetManager.EXTRA_APPWIDGET_ID,
8 AppWidgetManager.INVALID_APPWIDGET_ID);
9 //Obtenemos el widget manager de nuestro contexto
10AppWidgetManager widgetManager =
11AppWidgetManager.getInstance(context);
//Actualizamos el widget
12if (widgetId != AppWidgetManager.INVALID_APPWIDGET_ID) {
13actualizarWidget(context, widgetManager, widgetId);
14}
15}
16
17
Con esto, por fin, hemos ya finalizado la construccin de nuestro widget android y
podemos ejecutar el proyecto de Eclipse para comprobar que todo funciona correctamente,
tanto para una sola instancia como para varias instancias simultaneas.
Un comentario final, la actualizacin automtica del widget se ha establecido a la
frecuencia mnima que permite el atributo updatePeriodMillis del widget provider,
que son 30 minutos. Por tanto es dificil y aburrido esperar para verla en funcionamiento
mientras probamos el widget en el emulador. Pero funciona, os lo aseguro. De cualquier
forma, esos 30 minutos pueden ser un periodo demasiado largo de tiempo segn la
funcionalidad que queramos dar a nuestro widget, que puede requerir tiempos de
actualizacin mucho ms cortos (ojo con el rendimiento y el gasto de batera). Ms
adelante, cuando hablemos de Alarmas, veremos una tcnica que nos permitir actualizar
los widgets sin esa limitacin de 30 minutos. Hasta entonces, espero que el tema os sea de
utilidad y que os haya parecido interesante.
99
no slo para la construccin de widgets, sino para cualquier tipo de aplicacin Android.
Este tema es la administracin de preferencias.
Las preferencias no son ms que datos que una aplicacin debe guardar para personalizar la
experiencia del usuario, por ejemplo informacin personal, opciones de presentacin, etc.
En artculos anteriores vimos ya uno de los mtodos disponibles en la plataforma Android
para almacenar datos, como son las bases de datos SQLite. Las preferencias de una
aplicacin se podran almacenar por su puesto utilizando este mtodo, y no tendra nada de
malo, pero Android proporciona otro mtodo alternativo diseado especficamente para
administrar este tipo de datos: las preferencias compartidas o shared preferences. Cada
preferencia se almacenar en forma de clave-valor, es decir, cada una de ellas estar
compuesta por un identificador nico (p.e. email) y un valor asociado a dicho
identificador (p.e. prueba@email.com). Adems, y a diferencia de SQLite, los datos no
se guardan en un fichero de binario de base de datos, sino en ficheros XML como veremos
al final de este artculo.
La API para el manejo de estas preferencias es muy sencilla. Toda la gestin se centraliza
en la clase SharedPrefences, que representar a una coleccin de preferencias. Una
aplicacin Android puede gestionar varias colecciones de preferencias, que se diferenciarn
mediante un identificador nico. Para obtener una referencia a una coleccin determinada
utilizaremos el mtodo getSharedPrefences() al que pasaremos el identificador de
la coleccin y un modo de acceso. El modo de acceso indicar qu aplicaciones tendrn
acceso a la coleccin de preferencias y qu operaciones tendrn permitido realizar sobre
ellas. As, tendremos tres posibilidades principales:
Teniedo todo esto en cuenta, para obtener una referencia a una coleccin de preferencias
llamada por ejemplo MisPreferencias y como modo de acceso exclusivo para nuestra
aplicacin haramos lo siguiente:
1SharedPreferences prefs =
2getSharedPreferences("MisPreferencias",Context.MODE_PRIVATE);
Una vez hemos obtenido una referencia a nuestra coleccin de preferencias, ya podemos
obtener, insertar o modificar preferencias utilizando los mtodos get o put correspondientes
al tipo de dato de cada preferencia. As, por ejemplo, para obtener el valor de una
preferencia llamada email de tipo String escribiramos lo siguiente:
1SharedPreferences prefs =
2getSharedPreferences("MisPreferencias",Context.MODE_PRIVATE);
3String correo = prefs.getString("email", "por_defecto@email.com");
100
4
Como vemos, al mtodo getString() le pasamos el nombre de la preferencia que
queremos recuperar y un segundo parmetro con un valor por defecto. Este valor por
defecto ser el devuelto por el mtodo getString() si la preferencia solicitada no existe
en la coleccin. Adems del mtodo getString(), existen por supuesto mtodos
anlogos para el resto de tipos de datos bsicos, por ejemplo getInt(), getLong(),
getFloat(), getBoolean(),
Para actualizar o insertar nuevas preferencias el proceso ser igual de sencillo, con la nica
diferencia de que la actualizacin o insercin no la haremos directamente sobre el objeto
SharedPreferences, sino sobre su objeto de edicin
SharedPreferences.Editor. A este ltimo objeto accedemos mediante el mtodo
edit() de la clase SharedPreferences. Una vez obtenida la referencia al editor,
utilizaremos los mtodos put correspondientes al tipo de datos de cada preferencia para
actualizar/insertar su valor, por ejemplo putString(clave, valor), para actualizar
una preferencia de tipo String. De forma anloga a los mtodos get que ya hemos visto,
tendremos disponibles mtodos put para todos los tipos de datos bsicos: putInt(),
putFloat(), putBoolean(), etc. Finalmente, una vez actualizados/insertados todos
los datos necesarios llamaremos al mtodo commit() para confirmar los cambios.
Veamos un ejemplo sencillo:
1
2SharedPreferences prefs =
3getSharedPreferences("MisPreferencias",Context.MODE_PRIVATE);
SharedPreferences.Editor editor = prefs.edit();
4editor.putString("email", "modificado@email.com");
5editor.putString("nombre", "Prueba");
6editor.commit();
7
Donde se almacenan estas preferencias compartidas? Como dijimos al comienzo del
artculo, las preferencias no se almacenan en ficheros binarios como las bases de datos
SQLite, sino en ficheros XML. Estos ficheros XML se almacenan en una ruta con el
siguiente patrn:
/data/data/paquetejava/shared_prefs/nombre_coleccion.xml
As, por ejemplo, en nuestro caso encontraramos nuestro fichero de preferencias en la ruta:
/data/data/net.sgoliver.android/shared_prefs/MisPreferencias.
xml
Si descargamos este fichero desde el DDMS y lo abrimos con cualquier editor de texto
veremos un contenido como el siguiente:
1<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
101
2<map>
3<string name="nombre">prueba</string>
<string name="email">modificado@email.com</string>
4</map>
5
En este XML podemos observar cmo se han almacenado las dos preferencias de ejemplo
que insertamos anteriormente, con sus claves y valores correspondientes.
Y nada ms, as de fcil y prctico. Con esto hemos aprendido una forma sencilla de
almacenar determinadas opciones de nuestra aplicacin sin tener que recurrir para ello a
definir bases de datos SQLite, que aunque tampoco aaden mucha dificultad s que
requieren algo ms de trabajo por nuestra parte.
En una segunda parte de este tema dedicado a las preferencias veremos cmo Android nos
ofrece otra forma de gestionar estos datos, que se integra adems fcilmente con la interfaz
grfica necesaria para solicitar los datos al usuario.
102
Si observamos la imagen anterior vemos cmo las diferentes opciones se organizan dentro
de la pantalla de opciones en varias categoras (General Settings y Slideshow
Settings). Dentro de cada categora pueden aparecer varias opciones de diversos tipos,
como por ejemplo de tipo checkbox (Confirm deletions) o de tipo lista de seleccin
(Display size). He resaltado las palabras pantalla de opciones, categoras, y tipos de
opcin porque sern estos los tres elementos principales con los que vamos a definir el
conjunto de opciones o preferencias de nuestra aplicacin. Empecemos.
Como hemos indicado, nuestra pantalla de opciones la vamos a definir mediante un XML,
de forma similar a como definimos cualquier layout, aunque en este caso deberemos
colocarlo en la carpeta /res/xml. El contenedor principal de nuestra pantalla de
preferencias ser el elemento <PreferenceScreen>. Este elemento representar a la
pantalla de opciones en s, dentro de la cual incluiremos el resto de elementos. Dentro de
ste podremos incluir nuestra lista de opciones organizadas por categoras, que se
representar mediante el elemento <PreferenceCategory> al que daremos un texto
descriptivo utilizando su atributo android:title. Dentro de cada categora podremos
aadir cualquier nmero de opciones, las cuales pueden ser de distintos tipos, entre los que
destacan:
Cada uno de estos tipos de preferencia requiere la definicin de diferentes atributos, que
iremos viendo en los siguientes apartados.
CheckBoxPreference
103
Representa un tipo de opcin que slo puede tomar dos valores distintos: activada o
desactivada. Es el equivalente a un control de tipo checkbox. En este caso tan slo
tendremos que especificar los atributos: nombre interno de la opcin (android:key),
texto a mostrar (android:title) y descripcin de la opcin (android:summary).
Veamos un ejemplo:
1<CheckBoxPreference
2android:key="opcion1"
3android:title="Preferencia 1"
4android:summary="Descripcin de la preferencia 1" />
EditTextPreference
Representa un tipo de opcin que puede contener como valor una cadena de texto. Al pulsar
sobre una opcin de este tipo se mostrar un cuadro de dilogo sencillo que solicitar al
usuario el texto a almacenar. Para este tipo, adems de los tres atributos comunes a todas
las opciones (key, title y summary) tambin tendremos que indicar el texto a mostrar
en el cuadro de dilogo, mediante el atributo android:dialogTitle. Un ejemplo sera
el siguiente:
1<EditTextPreference
2android:key="opcion2"
3android:title="Preferencia 2"
4android:summary="Descripcin de la preferencia 2"
5android:dialogTitle="Introduce valor" />
ListPreference
Representa un tipo de opcin que puede tomar como valor un elemento, y slo uno,
seleccionado por el usuario entre una lista de valores predefinida. Al pulsar sobre una
opcin de este tipo se mostrar la lista de valores posibles y el usuario podr seleccionar
uno de ellos. Y en este caso seguimos aadiendo atributos. Adems de los cuatro ya
comentados (key, title, summary y dialogTitle) tendremos que aadir dos ms,
uno de ellos indicando la lista de valores a visualizar en la lista y el otro indicando los
valores internos que utilizaremos para cada uno de los valores de la lista anterior (Ejemplo:
al usuario podemos mostrar una lista con los valores Espaol y Francs, pero
internamente almacenarlos como ESP y FRA).
Estas listas de valores las definiremos tambin como ficheros XML dentro de la carpeta
/res/xml. Definiremos para ello los recursos de tipos <string-array> necesarios,
en este caso dos, uno para la lista de valores visibles y otro para la lista de valores internos,
cada uno de ellos con su ID nico correspondiente. Veamos cmo quedaran dos listas de
ejemplo, en un fichero llamado codigospaises.xml:
version="1.0" encoding="utf-8" ?>
1 <?xml
<resources>
2 <string-array name="pais">
104
3 <item>Espaa</item>
4 <item>Francia</item>
<item>Alemania</item>
5 </string-array>
6 <string-array name="codigopais">
7 <item>ESP</item>
8 <item>FRA</item>
9 <item>ALE</item>
</string-array>
10</resources>
11
12
13
En la preferencia utilizaremos los atributos android:entries y
android:entryValues para hacer referencia a estas listas, como vemos en el ejemplo
siguiente:
1
<ListPreference
2android:key="opcion3"
3android:title="Preferencia 3"
4android:summary="Descripcin de la preferencia 3"
5android:dialogTitle="Indicar Pais"
6android:entries="@array/pais"
android:entryValues="@array/codigopais" />
7
MultiSelectListPreference
[A partir de Android 3.0.x / Honeycomb] Las opciones de este tipo son muy similares a las
ListPreference, con la diferencia de que el usuario puede seleccionar varias de las opciones
de la lista de posibles valores. Los atributos a asignar son por tanto los mismos que para el
tipo anterior.
1
<MultiSelectListPreference
2android:key="opcion4"
3android:title="Preferencia 4"
4android:summary="Descripcin de la preferencia 4"
5android:dialogTitle="Indicar Pais"
6android:entries="@array/pais"
android:entryValues="@array/codigopais" />
7
Como ejemplo completo, veamos cmo quedara definida una pantalla de opciones con las
3 primeras opciones comentadas (ya que probar con Android 2.2), divididas en 2
categoras llamadas por simplicidad Categora 1 y Categora 2. Llamaremos al fichero
opciones.xml.
1 <PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android">
2 <PreferenceCategory android:title="Categora 1">
105
3 <CheckBoxPreference
4 android:key="opcion1"
android:title="Preferencia 1"
5 android:summary="Descripcin de la preferencia 1" />
6 <EditTextPreference
7 android:key="opcion2"
8 android:title="Preferencia 2"
de la preferencia 2"
9 android:summary="Descripcin
android:dialogTitle="Introduce valor" />
10</PreferenceCategory>
11<PreferenceCategory android:title="Categora 2">
12<ListPreference
13android:key="opcion3"
android:title="Preferencia 3"
14android:summary="Descripcin de la preferencia 3"
15android:dialogTitle="Indicar Pais"
16android:entries="@array/pais"
17android:entryValues="@array/codigopais" />
18</PreferenceCategory>
</PreferenceScreen>
19
20
21
22
23
Ya tenemos definida la estructura de nuestra pantalla de opciones, pero an nos queda un
paso ms para poder hacer uso de ella desde nuestra aplicacin. Adems de la definicin
XML de la lista de opciones, debemos implementar una nueva actividad, que ser a la que
hagamos referencia cuando queramos mostrar nuestra pantalla de opciones y la que se
encargar internamente de gestionar todas las opciones, guardarlas, modificarlas, etc, a
partir de nuestra definicin XML.
Android nos facilita las cosas ofrecindonos una clase de la que podemos derivar
facilmente la nuestra propia y que hace todo el trabajo por nosotros. Esta clase se llama
PreferenceActivity. Tan slo deberemos crear una nueva actividad (yo la he
llamado PantallaOpciones) que extienda a esta clase e implementar su evento
onCreate() para aadir una llamada al mtodo
addPreferencesFromResource(), mediante el que indicaremos el fichero XML en
el que hemos definido la pantalla de opciones. Lo vemos mejor directamente en el cdigo:
1
2public class PantallaOpciones extends PreferenceActivity {
3@Override
void onCreate(Bundle savedInstanceState) {
4public
super.onCreate(savedInstanceState);
5addPreferencesFromResource(R.xml.opciones);
6}
7}
8
106
107
Por ltimo, la opcin 3 de tipo lista, nos mostrar una ventana emergente con la lista de
valores posibles, donde podremos seleccionar slo uno de ellos.
108
Una vez establecidos los valores de las preferencias podemos salir de la ventana de
opciones simplemente pulsando el botn Atrs del dispositivo o del emulador. Nuestra
actividad PantallaOpciones se habr ocupado por nosotros de guardar correctamente
los valores de las opciones haciendo uso de la API de preferencias compartidas (Shared
Preferences). Y para comprobarlo vamos a aadir otro botn (btnObtenerOpciones) a
la aplicacin de ejemplo que recupere el valor actual de las 3 preferencias y los escriba al
log de la aplicacin.
La forma de acceder a las preferencias compartidas de la aplicacin ya la vimos en el
artculo anterior sobre este tema. Obtenemos la lista de preferencias mediante el mtodo
getDefaultSharedPreferences() y posteriormente utilizamos los distintos
mtodos get() para recuperar el valor de cada opcin dependiendo de su tipo.
1
2 btnObtenerPreferencias.setOnClickListener(new OnClickListener() {
3 @Override
4 public void onClick(View v) {
5 SharedPreferences pref =
6 PreferenceManager.getDefaultSharedPreferences(
AndroidPrefScreensActivity.this);
7 Log.i("", "Opcin 1: " + pref.getBoolean("opcion1", false));
8 Log.i("", "Opcin 2: " + pref.getString("opcion2", ""));
9 Log.i("", "Opcin 3: " + pref.getString("opcion3", ""));
10}
});
11
12
Si ejecutamos ahora la aplicacin, establecemos las preferencias y pulsamos el nuevo botn
de consulta que hemos creado veremos cmo en el log de la aplicacin aparecen los valores
correctos de cada preferencia. Se mostrara algo como lo siguiente:
109
111
19}
20public void setLink(String l) {
link = l;
21}
22public void setDescripcion(String d) {
23descripcion = d;
24}
void setGuid(String g) {
25public
guid = g;
26}
27public void setFecha(String f) {
28fecha = f;
29}
}
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
Una vez conocemos la estructura del XML a leer y hemos definido las clases auxiliares que
nos hacen falta para almacenar los datos, pasamos ya a comentar el primero de los modelos
de tratamiento de XML.
SAX en Android
En el modelo SAX, el tratamiento de un XML se basa en un analizador (parser) que a
medida que lee secuencialmente el documento XML va generando diferentes eventos con la
informacin de cada elemento leido. Asi, por ejemplo, a medida que lee el XML, si
encuentra el comienzo de una etiqueta <title> generar un evento de comienzo de
etiqueta, startElement(), con su informacin asociada, si despus de esa etiqueta
encuentra un fragmento de texto generar un evento characters() con toda la
informacin necesaria, y as sucesivamente hasta el final del documento. Nuestro trabajo
consistir por tanto en implementar las acciones necesarias a ejecutar para cada uno de los
eventos posibles que se pueden generar durante la lectura del documento XML.
112
Los principales eventos que se pueden producir son los siguientes (consultar aqu la lista
completa):
116
Para esto ltimo, nos apoyamos en un mtodo privado auxiliar getInputStream(), que
se encarga de abrir la conexin con la URL especificada [mediante
openConnection()] y obtener el stream de entrada [mediante
getInputStream()].
Con esto ya tenemos nuestra aplicacin Android preparada para parsear un documento
XML online utilizando el modelo SAX. Veamos lo simple que sera ahora llamar a este
parser por ejemplo desde nuestra actividad principal:
1
2
3 public void onCreate(Bundle savedInstanceState)
4 {
5 super.onCreate(savedInstanceState);
6 setContentView(R.layout.main);
RssParserSax saxparser =
7 new RssParserSax("http://www.europapress.es/rss/rss.aspx");
8 List<Noticia> noticias = saxparser.parse();
9 //Manipulacin del array de noticias
10//...
11}
12
13
Las lineas 6 y 9 del cdigo anterior son las que hacen toda la magia. Primero creamos el
parser SAX pasndole la URL del documento XML y posteriormente llamamos al mtodo
parse() para obtener una lista de objetos de tipo Noticia que posteriormente
podremos manipular de la forma que queramos. As de sencillo.
Tan slo una anotacin final. Para que este ejemplo funcione debemos aadir previamente
permisos de acceso a internet para la aplicacin. Esto se hace en el fichero
AndroidManifest.xml, que quedara de la siguiente forma:
1 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
2 package="net.sgoliver"
android:versionCode="1"
3 android:versionName="1.0">
4 <uses-permission
5 android:name="android.permission.INTERNET" />
6 <application android:icon="@drawable/icon"
7 android:label="@string/app_name">
<activity android:name=".AndroidXml"
8 android:label="@string/app_name">
9 <intent-filter>
10<action android:name="android.intent.action.MAIN" />
11<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
12</activity>
13</application>
14<uses-sdk android:minSdkVersion="7" />
117
15</manifest>
16
17
18
19
20
21
En la linea 6 del cdigo podis ver cmo aadimos el permiso de acceso a la red mediante
el elemento <uses-permission> con el parmetro
android.permission.INTERNET
Podis descargar el cdigo fuente de este artculo pulsando aqu.
En los siguientes artculos veremos los otros dos mtodos de tratamiento XML en Android
que hemos comentado (DOM y StAX) y por ltimo intentaremos comentar las diferencias
entre ellos dependiendo del contexto de la aplicacin.
ACTUALIZACIN: Android propone un modelo SAX alternativo que puede ayudar a
simplicar algunas acciones y disminuir la complejidad del handler necesario. En este
artculo puedes aprender a utilizar esta nueva variante de SAX para Android.
Para evitar estos problemas, Android propone una variante del modelo SAX que evita
definir una clase separada para el handler y que permite asociar directamente las acciones a
etiquetas concretas dentro de la estructura del documento XML, lo que alivia en gran
medida los inconvenientes mencionados.
Veamos cmo queda nuestro parser XML utilizando esta variante simplificada de SAX
para Android y despus comentaremos los aspectos ms importantes del mismo.
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
28
29
30
31
32
33
34
35
36
37
38
39
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import org.xml.sax.Attributes;
import android.sax.Element;
import android.sax.EndElementListener;
import android.sax.EndTextElementListener;
import android.sax.RootElement;
import android.sax.StartElementListener;
import android.util.Xml;
public class RssParserSax2
{
private URL rssUrl;
private Noticia noticiaActual;
public RssParserSax2(String url)
{
try
{
this.rssUrl = new URL(url);
}
catch (MalformedURLException e)
{
throw new RuntimeException(e);
}
}
public List<Noticia> parse()
{
final List<Noticia> noticias = new ArrayList<Noticia>();
RootElement root = new RootElement("rss");
Element channel = root.getChild("channel");
Element item = channel.getChild("item");
item.setStartElementListener(new StartElementListener(){
public void start(Attributes attrs) {
noticiaActual = new Noticia();
}
});
item.setEndElementListener(new EndElementListener(){
public void end() {
noticias.add(noticiaActual);
}
});
item.getChild("title").setEndTextElementListener(
new EndTextElementListener(){
public void end(String body) {
119
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
noticiaActual.setTitulo(body);
}
});
item.getChild("link").setEndTextElementListener(
new EndTextElementListener(){
public void end(String body) {
noticiaActual.setLink(body);
}
});
item.getChild("description").setEndTextElementListener(
new EndTextElementListener(){
public void end(String body) {
noticiaActual.setDescripcion(body);
}
});
item.getChild("guid").setEndTextElementListener(
new EndTextElementListener(){
public void end(String body) {
noticiaActual.setGuid(body);
}
});
item.getChild("pubDate").setEndTextElementListener(
new EndTextElementListener(){
public void end(String body) {
noticiaActual.setFecha(body);
}
});
try
{
Xml.parse(this.getInputStream(),
Xml.Encoding.UTF_8,
root.getContentHandler());
}
catch (Exception ex)
{
throw new RuntimeException(ex);
}
return noticias;
}
private InputStream getInputStream()
{
try
{
return rssUrl.openConnection().getInputStream();
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
}
120
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
Debemos atender principalmente al mtodo parse(). En el modelo SAX clsico nos
limitamos a instanciar al handler definido en una clase independiente y llamar al
correspondiente mtodo parse() de SAX. Por el contrario, en este nuevo modelo SAX
simplificado de Android, las acciones a realizar para cada evento las vamos a definir en esta
misma clase y adems asociadas a etiquetas concretas del XML. Y para ello lo primero que
haremos ser navegar por la estructura del XML hasta llegar a las etiquetas que nos
interesa tratar y una vez all, asignarle algunos de los listeners disponibles [de apertura
(StartElementListener) o cierre (EndElementListener) de etiqueta]
incluyendo las acciones oportunas. De esta forma, para el elemento <item> navegaremos
hasta l obteniendo en primer lugar el elemento raz del XML (<rss>) declarando un
nuevo objeto RootElement y despus accederemos a su elemento hijo <channel> y a
su vez a su elemento hijo <item>, utilizando en cada paso el mtodo getChild(). Una
vez heos llegado a la etiqueta deseada, asignaremos los listeners necesarios, en nuestro caso
uno de apertura de etiqueta y otro de cierre, donde inicializaremos la noticia actual y la
aadiremos a la lista final respectivamente, de forma anloga a lo que hacamos para el
modelo SAX clsico. Para el resto de etiquetas actuaremos de la misma forma, accediendo
a ellas con getChild() y asignado los listeners necesarios.
121
Como vemos, este rbol conserva la misma informacin contenida en el fichero XML pero
en forma de nodos y transiciones entre nodos, de forma que se puede navegar fcilmente
por la estructura. Adems, este rbol se conserva persistente en memoria una vez leido el
documento completo, lo que permite procesarlo en cualquier orden y tantas veces como sea
necesario (a diferencia de SAX, donde el tratamiento era secuencial y siempre de principio
a fin del documento, no pudiendo volver atrs una vez finalizada la lectura del XML).
Para todo esto, el modelo DOM ofrece una serie de clases y mtodos que permiten
almacenar la informacin de la forma descrita y facilitan la navegacin y el tratamiento de
la estructura creada.
Veamos cmo quedara nuestro parser utilizando el modelo DOM y justo despus
comentaremos los detalles ms importantes.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
123
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
{
//Creamos un nuevo parser DOM
DocumentBuilder builder = factory.newDocumentBuilder();
//Realizamos lalectura completa del XML
Document dom = builder.parse(this.getInputStream());
//Nos posicionamos en el nodo principal del rbol (<rss>)
Element root = dom.getDocumentElement();
//Localizamos todos los elementos <item>
NodeList items = root.getElementsByTagName("item");
//Recorremos la lista de noticias
for (int i=0; i<items.getLength(); i++)
{
Noticia noticia = new Noticia();
//Obtenemos la noticia actual
Node item = items.item(i);
//Obtenemos la lista de datos de la noticia actual
NodeList datosNoticia = item.getChildNodes();
//Procesamos cada dato de la noticia
for (int j=0; j<datosNoticia.getLength(); j++)
{
Node dato = datosNoticia.item(j);
String etiqueta = dato.getNodeName();
if (etiqueta.equals("title"))
{
String texto = obtenerTexto(dato);
noticia.setTitulo(texto);
}
else if (etiqueta.equals("link"))
{
noticia.setLink(dato.getFirstChild().getNodeValue());
}
else if (etiqueta.equals("description"))
{
String texto = obtenerTexto(dato);
noticia.setDescripcion(texto);
}
else if (etiqueta.equals("guid"))
{
noticia.setGuid(dato.getFirstChild().getNodeValue());
}
else if (etiqueta.equals("pubDate"))
{
noticia.setFecha(dato.getFirstChild().getNodeValue());
}
}
noticias.add(noticia);
}
}
catch (Exception ex)
{
throw new RuntimeException(ex);
}
return noticias;
}
private String obtenerTexto(Node dato)
{
StringBuilder texto = new StringBuilder();
124
111
112
113
Nos centramos una vez ms en el mtodo parse(). Al igual que hacamos para SAX, el
primer paso ser instanciar una nueva fbrica, esta vez de tipo
DocumentBuilderFactory, y posteriormente crear un nuevo parser a partir de ella
mediante el mtodo newDocumentBuilder().
Tras esto, ya podemos realizar la lectura del documento XML llamando al mtod
parse() de nuestro parser DOM, pasndole como parmetro el stream de entrada del
fichero. Al hacer esto, el documento XML se leer completo y se generar la estructura de
rbol equivalente, que se devolver como un objeto de tipo Document. ste ser el objeto
que podremos navegar para realizar eltratamiento necesario del XML.
Para ello, lo primero que haremos ser acceder al nodo principal del rbol (en nuestro caso,
la etiqueta <rss>) utilizando el mtodo getDocumentElement(). Una vez
posicionados en dicho nodo, vamos a buscar todos los nodos cuya etiqueta sea <item>.
Esto lo conseguimos utilizando el mtodo de bsqueda por nombre de etiqueta,
getElementsByTagName(nombre_de_etiqueta), que devolver una lista (de
tipo NodeList) con todos los nodos hijos del nodo actual cuya etiqueta coincida con la
pasada como parmetro.
Una vez tenemos localizados todos los elementos <item>, que representan a cada noticia,
los vamos a recorrer uno a uno para ir generando todos los objetos Noticia necesarios.
Para cada uno de ellos, se obtendrn los nodos hijos del elemento mediante
getChildNodes() y se recorrern stos obteniendo su texto y almacenndolo en el
atributo correspondiente del objeto Noticia. Para saber a qu etiqueta corresponde cada
nodo hijo utilizamos el mtodo getNodeName().
Merece la pena pararnos un poco en comentar la forma de obtener el texto contenido en un
nodo. Como vimos al principio del artculo en el ejemplo grfico de rbol DOM, el texto de
un nodo determinado se almacena a su vez como nodo hijo de dicho nodo. Este nodo de
texto suele ser nico, por lo que la forma habitual de obtener el texto de un nodo es obtener
su primer nodo hijo y de ste ltimo obtener su valor:
1String texto = nodo.getFirstChild().getNodeValue();
Sin embargo, en ocasiones, el texto contenido en el nodo viene fragmentado en varios
nodos hijos, en vez de slo uno. Esto ocurre por ejemplo cuando se utilizan en el texto
entidades HTML, como por ejemplo " . En estas ocasiones, para obtener el texto
completo hay que recorrer todos los nodos hijos e ir concatenando el texto de cada uno para
formar el texto completo. Esto es lo que hace nuestra funcin auxiliar obtenerTexto():
private String obtenerTexto(Node dato)
1 {
126
127
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
{
try
{
this.rssUrl = new URL(url);
}
catch (MalformedURLException e)
{
throw new RuntimeException(e);
}
}
public List<Noticia> parse()
{
List<Noticia> noticias = null;
XmlPullParser parser = Xml.newPullParser();
try
{
parser.setInput(this.getInputStream(), null);
int evento = parser.getEventType();
Noticia noticiaActual = null;
while (evento != XmlPullParser.END_DOCUMENT)
{
String etiqueta = null;
switch (evento)
{
case XmlPullParser.START_DOCUMENT:
noticias = new ArrayList<Noticia>();
break;
case XmlPullParser.START_TAG:
etiqueta = parser.getName();
if (etiqueta.equals("item"))
{
noticiaActual = new Noticia();
}
else if (noticiaActual != null)
{
if (etiqueta.equals("link"))
{
noticiaActual.setLink(parser.nextText());
}
else if (etiqueta.equals("description"))
{
noticiaActual.setDescripcion(parser.nextText());
}
else if (etiqueta.equals("pubDate"))
{
noticiaActual.setFecha(parser.nextText());
}
else if (etiqueta.equals("title"))
{
noticiaActual.setTitulo(parser.nextText());
}
else if (etiqueta.equals("guid"))
{
noticiaActual.setGuid(parser.nextText());
}
}
break;
128
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
case XmlPullParser.END_TAG:
etiqueta = parser.getName();
if (etiqueta.equals("item") && noticiaActual != null)
{
noticias.add(noticiaActual);
}
break;
}
evento = parser.next();
}
}
catch (Exception ex)
{
throw new RuntimeException(ex);
}
return noticias;
}
private InputStream getInputStream()
{
try
{
return rssUrl.openConnection().getInputStream();
}
catch (IOException e)
{
throw new RuntimeException(e);
}
}
}
129
98
99
100
101
102
103
104
105
106
107
Centrndonos una vez ms en el mtodo parse(), vemos que tras crear el nuevo parser
XmlPull y establecer el fichero de entrada en forma de stream [mediante
XmlPull.newPullParser() y parser.setInput(...)] nos metemos en un
buble en el que iremos solicitando al parser en cada paso el siguiente evento encontrado en
la lectura del XML, utilizando para ello el mtodo parser.next(). Para cada evento
devuelto como resultado consultaremos su tipo mediante el mtodo
parser.getEventType() y responderemos con las acciones oportunas segn dicho
tipo (START_DOCUMENT, END_DOCUMENT, START_TAG, END_TAG). Una vez
identificado el tipo concreto de evento, podremos consultar el nombre de la etiqueta del
elemento XML mediante parser.getName() y su texto correspondiente mediante
parser.nextText(). En cuanto a la obtencin del texto, con este modelo tenemos la
ventaja de no tener que preocuparnos por recolectar todos los fragmentos de texto
contenidos en el elemento XML, ya que nextText() devolver todo el texto que
encuentre hasta el prximo evento de fin de etiqueta (ENT_TAG).
Y sobre este modelo de tratamiento no queda mucho ms que decir, ya que las acciones
ejecutadas en cada caso son anlogas a las que ya vimos en los artculos anteriores.
El cdigo fuente completo de este artculo podis descargarlo pulsando aqu.
Espero haber sido capaz de mostrar con claridad en estos cuatro artculos todas las
posibilidades existentes a la hora de leer y procesar documentos XML en aplicaciones
Android.
Content Providers
En estos prximos artculos nos centraremos en la primera opcin, SQLite, que abarcar
todas las tareas relacionadas con el almacenamiento de los datos propios de nuestra
aplicacin. El segundo de los mecanismos, los Content Providers, que trataremos ms
adelante, nos facilitarn la tarea de hacer visibles esos datos a otras aplicaciones y, de
forma recproca, de permitir la consulta de datos publicados por terceros desde nuestra
aplicacin.
SQLite es un motor de bases de datos muy popular en la actualidad por ofrecer
caractersticas tan interesantes como su pequeo tamao, no necesitar servidor, precisar
poca configuracin, ser transaccional y por supuesto ser de cdigo libre.
Android incorpora de serie todas las herramientas necesarias para la creacin y gestin de
bases de datos SQLite, y entre ellas una completa API para llevar a cabo de manera sencilla
todas las tareas necesarias. Sin embargo, en este primer artculo sobre bases de datos en
Android no vamos a entrar en mucho detalle con esta API. Por el momento nos limitaremos
a ver el cdigo necesario para crear una base de datos, insertaremos algn dato de prueba, y
veremos cmo podemos comprobar que todo funciona correctamente.
En Android, la forma tpica para crear, actualizar, y conectar con una base de datos SQLite
ser a travs de una clase auxiliar llamada SQLiteOpenHelper, o para ser ms exactos,
de una clase propia que derive de ella y que debemos personalizar para adaptarnos a las
necesidades concretas de nuestra aplicacin.
La clase SQLiteOpenHelper tiene tan slo un constructor, que normalmente no
necesitaremos sobrescribir, y dos mtodos abstractos, onCreate() y onUpgrade(),
que deberemos personalizar con el cdigo necesario para crear nuestra base de datos y para
actualizar su estructura respectivamente.
Como ejemplo, nosotros vamos a crear una base de datos muy sencilla llamada
BDUsuarios, con una sla tabla llamada Usuarios que contendr slo dos campos:
nombre e email. Para ellos, vamos a crear una clase derivada de
SQLiteOpenHelper que llamaremos UsuariosSQLiteHelper, donde
sobrescribiremos los mtodos onCreate() y onUpgrade() para adaptarlos a la
estructura de datos indicada:
1
2
3
4
5
6
7
8
9
package net.sgoliver.android;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
public class UsuariosSQLiteHelper extends SQLiteOpenHelper {
//Sentencia SQL para crear la tabla de Usuarios
String sqlCreate = "CREATE TABLE Usuarios (codigo INTEGER, nombre
TEXT)";
public UsuariosSQLiteHelper(Context contexto, String nombre,
CursorFactory factory, int version) {
131
133
1
2
3
4
5
6
7 package net.sgoliver.android;
8 import android.app.Activity;
9 import android.database.sqlite.SQLiteDatabase;
10import android.os.Bundle;
class AndroidBaseDatos extends Activity
11public
{
12@Override
13public void onCreate(Bundle savedInstanceState)
14{
15super.onCreate(savedInstanceState);
setContentView(R.layout.main);
16//Abrimos la base de datos 'DBUsuarios' en modo escritura
17UsuariosSQLiteHelper usdbh =
18new UsuariosSQLiteHelper(this, "DBUsuarios", null, 1);
19SQLiteDatabase db = usdbh.getWritableDatabase();
hemos abierto correctamente la base de datos
20//Si
if(db != null)
21{
22//Insertamos 5 usuarios de ejemplo
23for(int i=1; i<=5; i++)
24{
//Generamos los datos
25int codigo = i;
26String nombre = "Usuario" + i;
27//Insertamos los datos en la tabla Usuarios
28db.execSQL("INSERT INTO Usuarios (codigo, nombre) " +
29"VALUES (" + codigo + ", '" + nombre +"')");
}
30//Cerramos la base de datos
31db.close();
32}
33}
}
34
35
36
37
38
39
40
Vale, y ahora qu? dnde est la base de datos que acabamos de crear? cmo podemos
comprobar que todo ha ido bien y que los registros se han insertado correctamente?
Vayamos por partes.
En primer lugar veamos dnde se ha creado nuestra base de datos. Todas las bases de datos
SQLite creadas por aplicaciones Android se almacenan en la memoria del telfono en un
134
fichero con el mismo nombre de la base de datos situado en una ruta que sigue el siguiente
patrn:
/data/data/paquete.java.de.la.aplicacion/databases/nombre_bas
e_datos
En el caso de nuestro ejemplo, la base de datos se almacenara por tanto en la ruta
siguiente:
/data/data/net.sgoliver.android/databases/DBUsuarios
Para comprobar esto podemos hacer lo siguiente. Una vez ejecutada por primera vez desde
Eclipse la aplicacin de ejemplo sobre el emulador de Android (y por supuesto antes de
cerrarlo) podemos ir a la perspectiva DDMS (Dalvik Debug Monitor Server) de Eclipse y
en la solapa File Explorer podremos acceder al sistema de archivos del emulador, donde
podremos buscar la ruta indicada de la base de datos. Podemos ver esto en la siguiente
imagen (click para ampliar):
Con esto ya comprobamos al menos que el fichero de nuestra base de datos se ha creado en
la ruta correcta. Ya slo nos queda comprobar que tanto las tablas creadas como los datos
insertados tambin se han incluido correctamente en la base de datos. Para ello podemos
recurrir a dos posibles mtodos:
1. Trasnferir la base de datos a nuestro PC y consultarla con cualquier administrador
de bases de datos SQLite.
2. Acceder directamente a la consola de comandos del emulador de Android y utilizar
los comandos existentes para acceder y consultar la base de datos SQLite.
El primero de los mtodos es sencillo. El fichero de la base de datos podemos transferirlo a
nuestro PC utilizando el botn de descarga situado en la esquina superior derecha del
explorador de archivos (remarcado en rojo en la imagen anterior). Junto a este botn
aparecen otros dos para hacer la operacin contraria (copiar un fichero local al sistema de
archivos del emulador) y para eliminar ficheros del emulador. Una vez descargado el
fichero a nuestro sistema local, podemos utilizar cualquier administrador de SQLite para
abrir y consultar la base de datos, por ejemplo SQLite Administrator (freeware).
135
El segundo mtodo utiliza una estrategia diferente. En vez de descargar la base de datos a
nuestro sistema local, somos nosotros los que accedemos de forma remota al emulador a
travs de su consola de comandos (shell). Para ello, con el emulador de Android an
abierto, debemos abrir una consola de MS-DOS y utilizar la utilidad adb.exe (Android
Debug Bridge) situada en la carpeta platform-tools del SDK de Android (en mi caso:
c:\android-sdk-windows\platform-tools\). En primer lugar consultaremos
los identificadores de todos los emuladores en ejecucin mediante el comando adb
devices. Esto nos debe devolver una nica instancia si slo tenemos un emulador
abierto, que en mi caso particular se llama emulator-5554.
Tras conocer el identificador de nuestro emulador, vamos a acceder a su shell mediante el
comando adb -s identificador-del-emulador shell. Una vez
conectados, ya podemos acceder a nuestra base de datos utilizando el comando sqlite3
pasndole la ruta del fichero, para nuestro ejemplo sqlite3
/data/data/net.sgoliver.android/databases/DBUsuarios. Si todo ha
ido bien, debe aparecernos el prompt de SQLite sqlite>, lo que nos indicar que ya
podemos escribir las consultas SQL necesarias sobre nuestra base de datos. Nosotros vamos
a comprobar que existe la tabla Usuarios y que se han insertado los cinco registros de
ejemplo. Para ello haremos la siguiente consulta: SELECT * FROM Usuarios;. Si
todo es correcto esta instruccin debe devolvernos los cinco usuarios existentes en la tabla.
En la imagen siguiente se muestra todo el proceso descrito (click para ampliar):
Con esto ya hemos comprobado que nuestra base de datos se ha creado correctamente, que
se han insertado todos los registros de ejemplo y que todo funciona segn se espera.
En los siguientes artculos comentaremos las distintas posibilidades que tenemos a la hora
de manipular los datos de la base de datos (insertar, eliminar y modificar datos) y cmo
podemos realizar consultas sobre los mismos, ya que [como siempre] tendremos varias
opciones disponibles.
vamos a describir las posibles alternativas que proporciona la API de Android a la hora de
insertar, actualizar y eliminar registros de nuestra base de datos SQLite.
La API de SQLite de Android proporciona dos alternativas para realizar operaciones sobre
la base de datos que no devuelven resultados (entre ellas la
insercin/actualizacin/eliminacin de registros, pero tambin la creacin de tablas, de
ndices, etc).
El primero de ellos, que ya comentamos brevemente en el artculo anterior, es el mtodo
execSQL() de la clase SQLiteDatabase. Este mtodo permite ejecutar cualquier
sentencia SQL sobre la base de datos, siempre que sta no devuelva resultados. Para ello,
simplemente aportaremos como parmetro de entrada de este mtodo la cadena de texto
correspondiente con la sentencia SQL. Cuando creamos la base de datos en el post anterior
ya vimos algn ejemplo de esto para insertar los registros de prueba. Otros ejemplos
podran ser los siguientes:
1
//Insertar un registro
2db.execSQL("INSERT INTO Usuarios (usuario,email) VALUES
3('usu1','usu1@email.com') ");
4//Eliminar un registro
5db.execSQL("DELETE FROM Usuarios WHERE usuario='usu1' ");
6//Actualizar un registro
db.execSQL("UPDATE Usuarios SET email='nuevo@email.com' WHERE
7usuario='usu1' ");
8
La segunda de las alternativas disponibles en la API de Android es utilizar los mtodos
insert(), update() y delete() proporcionados tambin con la clase
SQLiteDatabase. Estos mtodos permiten realizar las tareas de insercin, actualizacin
y eliminacin de registros de una forma algo ms paramtrica que execSQL(), separando
tablas, valores y condiciones en parmetros independientes de estos mtodos.
Empecemos por el mtodo insert() para insertar nuevos registros en la base de datos.
Este mtodo recibe tres parmetros, el primero de ellos ser el nombre de la tabla, el tercero
sern los valores del registro a insertar, y el segundo lo obviaremos por el momento ya que
tan slo se hace necesario en casos muy puntuales (por ejemplo para poder insertar
registros completamente vacos), en cualquier otro caso pasaremos con valor null este
segundo parmetro.
Los valores a insertar los pasaremos como elementos de una coleccin de tipo
ContentValues. Esta coleccin es de tipo diccionario, donde almacenaremos parejas de
clave-valor, donde la clave ser el nombre de cada campo y el valor ser el dato
correspondiente a insertar en dicho campo. Veamos un ejemplo:
1//Creamos el registro a insertar como objeto ContentValues
ContentValues nuevoRegistro = new ContentValues();
2nuevoRegistro.put("usuario", "usu10");
3nuevoRegistro.put("email","usu10@email.com");
137
138
7
8
9
10
Esta forma de pasar a la sentencia SQL determinados datos variables puede ayudarnos
adems a escribir cdigo ms limpio y evitar posibles errores.
En el siguiente artculo veremos cmo consultar la base de datos para recuperar registros
segn un determinado criterio.
1usuario='usu1' ");
Como en el caso de los mtodos de modificacin de datos, tambin podemos aadir a este
mtodo una lista de argumentos variables que hayamos indicado en el comando SQL con el
smbolo ?, por ejemplo as:
args = new String[] {"usu1"};
1String[]
Cursor c = db.rawQuery(" SELECT usuario,email FROM Usuarios WHERE
2usuario=? ", args);
Ms adelante en este artculo veremos cmo podemos manipular el objeto Cursor para
recuperar los datos obtenidos.
139
Como segunda opcin para recuperar datos podemos utilizar el mtodo query() de la
clase SQLiteDatabase. Este mtodo recibe varios parmetros: el nombre de la tabla, un
array con los nombre de campos a recuperar, la clusula WHERE, un array con los
argumentos variables incluidos en el WHERE (si los hay, null en caso contrario), la
clusula GROUP BY si existe, la clusula HAVING si existe, y por ltimo la clusula
ORDER BY si existe. Opcionalmente, se puede incluir un parmetro al final ms indicando
el nmero mximo de registros que queremos que nos devuelva la consulta. Veamos el
mismo ejemplo anterior utilizando el mtodo query():
1String[] campos = new String[] {"usuario", "email"};
2String[] args = new String[] {"usu1"};
3Cursor c = db.query("Usuarios", campos, "usuario=?", args, null, null,
4null);
Como vemos, los resultados se devuelven nuevamente en un objeto Cursor que
deberemos recorrer para procesar los datos obtenidos.
Para recorrer y manipular el cursor devuelto por cualquiera de los dos mtodos
mencionados tenemos a nuestra disposicin varios mtodos de la clase Cursor, entre los
que destacamos dos de los dedicados a recorrer el cursor de forma secuencial y en orden
natural:
140
7 do {
8 String usuario = c.getString(0);
String email = c.getString(1);
9 } while(c.moveToNext());
10}
11
12
13
Adems de los mtodos comentados de la clase Cursor existen muchos ms que nos
pueden ser tiles en muchas ocasiones. Por ejemplo, getCount() te dir el nmero total
de registros devueltos en el cursor, getColumnName(i) devuelve el nombre de la
columna con ndice i, moveToPosition(i) mueve el puntero del cursor al registro con
ndice i, etc. Podis consultar la lista completa de mtodos disponibles en la clase Cursor en
la documentacin oficial de Android.
Con esto, terminamos la serie de artculos bsicos dedicados a las tareas de mantenimiento
de datos en aplicaciones Android mediante bases de datos SQLite. Soy consciente de que
dejamos en el tintero algunos temas algo ms avanzados (como por ejemplo el uso de
transacciones, que intentar tratar ms adelante), pero con los mtodos descritos podremos
realizar un porcentaje bastante alto de todas las tareas necesarias relativas al tratamiento de
datos estructurados en aplicaciones Android.
Una vez obtenida la lista completa de proveedores disponibles podramos acceder a las
propiedades de cualquiera de ellos (precisin, coste, consumo de recursos, o si es capaz de
obtener la altitud, la velocidad, ). As, podemos obtener una referencia al provider
mediante su nombre llamando al mtodo getProvider(nombre) y posteriormente
utilizar los mtodos disponibles para conocer sus propiedades, por ejemplo
getAccuracy() para saber su precisin (tenemos disponibles las constantes
Criteria.ACCURACY_FINE para precisin alta, y Criteria.ACCURACY_COARSE
para precisin media), supportsAltitude() para saber si obtiene la altitud, o
getPowerRequirement() para obtener el nivel de consumo de recursos del
proveedor. La lista completa de mtodos para obtener las caractersticas de un proveedor se
puede consultar en la documentacin oficial de la clase LocationProvider.
1LocationManager locManager =
2(LocationManager)getSystemService(LOCATION_SERVICE);
3List<String> listaProviders = locManager.getAllProviders();
LocationProvider provider =
4locManager.getProvider(listaProviders.get(0));
5int precision = provider.getAccuracy();
6boolean obtieneAltitud = provider.supportsAltitude();
7int consumoRecursos = provider.getPowerRequirement();
Al margen de esto, hay que tener en cuenta que la lista de proveedores devuelta por el
mtodo getAllProviders() contendr todos los proveedores de localizacin
conocidos por el dispositivo, incluso si stos no estn permitidos (segn los permisos de la
aplicacin) o no estn activados, por lo que esta informacin puede que no nos sea de
mucha ayuda.
Qu proveedor de localizacin es mejor para mi aplicacin?
Android proporciona un mecanismo alternativo para obtener los proveedores que cumplen
unos determinados requisitos entre todos los disponibles. Para ello nos permite definir un
criterio de bsqueda, mediante un objeto de tipo Criteria, en el que podremos indicar
las caractersticas mnimas del proveedor que necesitamos utilizar (podis consultar la
documentacin oficial de la clase Criteria para saber todas las caractersticas que podemos
definir). As, por ejemplo, para buscar uno con precisin alta y que nos proporcione la
altitud definiramos el siguiente criterio de bsqueda:
142
143
cmo podemos, adems de informar de que el GPS est desactivado, invitar al usuario a
activarlo dirigindolo automticamente a la pantalla de configuracin del dispositivo.
El GPS ya est activado, y ahora qu?
Una vez que sabemos que nuestro proveedor de localizacin favorito est activado, ya
estamos en disposicin de intentar obtener nuestra localizacin actual. Y aqu es donde las
cosas empiezan a ser menos intuitivas. Para empezar, en Android no existe ningn mtodo
del tipo obtenerPosicinActual(). Obtener la posicin a travs de un dispositivo de
localizacin como por ejemplo el GPS no es una tarea inmediata, sino que puede requerir
de un cierto tiempo de procesamiento y de espera, por lo que no tendra sentido
proporcionar un mtodo de ese tipo.
Si buscamos entre los mtodos disponibles en la clase LocationManager, lo ms parecido
que encontramos es un mtodo llamado getLastKnownLocation(String
provider), que como se puede suponer por su nombre, nos devuelve la ltima posicin
conocida del dispositivo devuelta por un provider determinado. Es importante entender
esto: este mtodo NO devuelve la posicin actual, este mtodo NO solicita una nueva
posicin al proveedor de localizacin, este mtodo se limita a devolver la ltima posicin
que se obtuvo a travs del proveedor que se le indique como parmetro. Y esta posicin se
pudo obtener hace pocos segundos, hace das, hace meses, o incluso nunca (si el dispositivo
ha estado apagado, si nunca se ha activado el GPS, ). Por tanto, cuidado cuando se haga
uso de la posicin devuelta por el mtodo getLastKnownLocation().
Entonces, de qu forma podemos obtener la posicin real actualizada? Pues la forma
correcta de proceder va a consistir en algo as como activar el proveedor de localizacin y
suscribirnos a sus notificaciones de cambio de posicin. O dicho de otra forma, vamos a
suscribirnos al evento que se lanza cada vez que un proveedor recibe nuevos datos sobre la
localizacin actual. Y para ello, vamos a darle previamente unas indicaciones (que no
ordenes, ya veremos esto en el prximo artculo) sobre cada cuanto tiempo o cada cuanta
distacia recorrida necesitaramos tener una actualizacin de la posicin.
Todo esto lo vamos a realizar mediante una llamada al mtodo
requestLocationUpdates(), al que deberemos pasar 4 parmetros distintos:
Tanto el tiempo como la distancia entre actualizaciones pueden pasarse con valor 0, lo que
indicara que ese criterio no se tendr en cuenta a la hora de decidir la frecuencia de
actualizaciones. Si ambos valores van a cero, las actualizaciones de posicin se recibirn
tan pronto y tan frecuentemente como estn disponibles. Adems, como ya hemos indicado,
144
Por nuestra parte, tendremos que implementar cada uno de estos mtodos para responder a
los eventos del proveedor, sobre todo al ms interesante, onLocationChanged(), que
se ejecutar cada vez que se recibe una nueva localizacin desde el proveedor. Veamos un
ejemplo de cmo implementar un listener de este tipo:
1
2
3
4 LocationListener locListener = new LocationListener() {
5 public void onLocationChanged(Location location) {
6 mostrarPosicion(location);
}
7 public void onProviderDisabled(String provider){
8 lblEstado.setText("Provider OFF");
9 }
10public void onProviderEnabled(String provider){
11lblEstado.setText("Provider ON");
}
12public void onStatusChanged(String provider, int status, Bundle extras){
13lblEstado.setText("Provider Status: " + status);
14}
15};
16
17
18
Como podis ver, en nuestro caso de ejemplo nos limitamos a mostrar al usuario la
informacin recibida en el evento, bien sea un simple cambio de estado, o una nueva
posicin, en cuyo caso llamamos al mtodo auxiliar mostrarPosicion() para
refrescar todos los datos de la posicin en la pantalla. Para este ejemplo hemos construido
una interfaz muy sencilla, donde se muestran 3 datos de la posicin (latitud, longitud y
145
precisin) y un campo para mostrar el estado del proveedor. Adems, se incluyen dos
botones para comenzar y detener la recepcin de nuevas actualizaciones de la posicin. No
incluyo aqu el cdigo de la interfaz para no alargar ms el artculo, pero puede consultarse
en el cdigo fuente suministrado al final del texto. El aspecto de nuestra ventana es el
siguiente:
146
147
La generacin de mensajes de log resulta ser una herramienta perfecta a la hora de depurar
aplicaciones del tipo que estamos tratando, ya que en estos casos el cdigo no facilita
demasiado la depuracin tpica paso a paso que podemos realizar en otras aplicaciones.
148
En nuestro caso de ejemplo slo vamos a generar mensajes de log cuando ocurran dos
ciscunstancias:
37}
38
39
40
41
42
43
44
45
46
47
48
49
50
Si ejecutamos en este momento la aplicacin en el emulador y pulsamos el botn Activar
veremos cmo los cuadros de texto se rellenan con la informacin de la ltima posicin
conocida (si existe), pero sin embargo estos datos no cambiarn en ningn momento ya que
por el momento el emulador de Android tan slo cuenta con esa informacin. Cmo
podemos simular la actualizacin de la posicin del dispositivo para ver si nuestra
aplicacin responde exactamente como esperamos?
Pues bien, para hacer esto tenemos varias opciones. La primera de ellas, y la ms sencilla,
es el envo manual de una nueva posicin al emulador de Android, para simular que ste
hubiera cambiado su localizacin. Esto se puede realizar desde la perspectiva de DDMS, en
la pestaa Emulator Control, donde podemos encontrar una seccin llamada Location
Controls, mostrada en la imagen siguiente (click para ampliar):
150
Con estos controles podemos enviar de forma manual al emulador en ejecucin unas
nuevas coordenadas de posicin, para simular que stas se hubieran recibido a travs del
proveedor de localizacin utilizado. De esta forma, si introducimos unas coordenadas de
longitud y latitud y pulsamos el botn Send mientras nuestra aplicacin se ejecuta en el
emulador, esto provocar la ejecucin del evento onLocationChanged() y por
consiguiente se mostrarn estos mismos datos en sus controles correspondientes de la
interfaz, como vemos en la siguiente captura de pantalla:
Por supuesto, si hacemos nuevos envos de coordenadas desde Eclipse veremos cmo sta
se va actualizando en nuestra aplicacin sin ningn tipo de problamas. Sin embargo este
mtodo de manual no resulta demasiado adecuado ni cmodo para probar toda la
funcionalidad de nuestra aplicacin, por ejemplo la actualizacin de posicin cada 15
segundos.
Por ello, Android proporciona otro mtodo algo menos manual de simular cambios
frecuentes de posicin para probar nuestras aplicaciones. Este mtodo consiste en
proporcionar, en vez de una sla coordenada cada vez, una lista de coordenadas que se iran
enviando automticamente al emulador una tras otra a una determinada velocidad, de forma
que podamos simular que el dispositivo se mueve constantemente y que nuestra aplicacin
responde de forma correcta y en el momento adecuado a esos cambios de posicin. Y esta
lista de coordenadas se puede proporcionar de dos formas distintas, en formato GPX o
como fichero KML. Ambos tipos de fichero son ampliamente utilizados por aplicaciones y
dispositivos de localizacin, como GPS, aplicaciones de cartografa y mapas, etc. Los
ficheros KML podemos generarlos por ejemplo a travs de la aplicacin Google Earth o
manualmente con cualquier editor de texto, pero recomiendo consultar los dos enlaces
anteriores para obtener ms informacin sobre cada formato. Para este ejemplo, yo he
generado un fichero KML de muestra con una lista de 1000 posiciones geogrficas al azar.
151
Para utilizar este fichero como fuente de datos para simular cambios en la posicin del
dispositivo, accedemos nuevamente a los Location Controls y pulsamos sobre la pestaa
GPX o KML, segn el formato que hayamos elegido, que en nuestro caso ser KML.
Pulsamos el botn Load KML para seleccionar nuestro fichero y veremos la lista de
coordenadas como en la siguiente imagen:
Una vez cargado el fichero, tendremos disponibles los cuatro botones inferiores para (de
izquierda a derecha):
Entendido esto, vamos a utilizar la lista de posiciones para probar nuestra aplicacin. Para
ello, ejecutamos la aplicacin en el emulador, pulsamos nuestro botn Activar para
comenzar a detectar cambios de posicin, y pulsamos el botn de avance automtico (botn
verde) que acabamos de comentar. Si observamos rpidamente la pantalla de nuestra
aplicacin veremos cmo se actualizan varias veces los valores de latitud y longitud
actuales. Cmo es posible? No habamos configurado el LocationListener para
obtener actualizaciones de posicin cada 15 segundos? Antes de contestar a esto, dejemos
que la aplicacin se ejecute durante un minuto ms. Tras unos 60 segundos de ejecucin
detenemos la captura de posiciones pulsando nuestro botn Desactivar.
Ahora vayamos a la ventana de log del DDMS y veamos los mensajes de log ha generado
nuestra aplicacin para intentar saber qu ha ocurrido. En mi caso, los mensajes generados
son los siguientes (en tu caso deben ser muy parecidos):
05-08 10:50:37.921: INFO/LocAndroid(251): 7.0 - -11.999998333333334
152
2 05-08 10:50:38.901:
3 11.999996666666668
05-08 10:50:39.941:
4 11.999996666666668
5 05-08 10:50:41.011:
6 11.999995000000002
7 05-08 10:50:43.011:
8 11.999993333333334
05-08 10:50:45.001:
9 11.999991666666665
1005-08 10:50:46.061:
1111.999989999999999
1205-08 10:50:47.131:
11.999989999999999
1305-08 10:50:47.182:
1405-08 10:51:02.232:
1511.999975
1605-08 10:51:02.812:
1711.999973333333333
05-08 10:51:02.872:
1805-08 10:51:03.872:
1911.999973333333333
2005-08 10:51:04.912:
2111.999971666666665
05-08 10:51:05.922:
2211.999971666666665
2305-08 10:51:06.982:
2405-08 10:51:08.032:
2511.999968333333333
2605-08 10:51:09.062:
05-08 10:51:10.132:
2711.999966666666667
2805-08 10:51:12.242:
2911.999965000000001
3005-08 10:51:13.292:
3111.999963333333335
05-08 10:51:13.342:
3205-08 10:51:28.372:
3311.999950000000002
3405-08 10:51:28.982:
3511.999950000000002
05-08 10:51:29.032:
05-08 10:51:30.002:
11.999948333333334
05-08 10:51:31.002:
11.999946666666665
05-08 10:51:33.111:
11.999944999999999
05-08 10:51:34.151:
11.999944999999999
05-08 10:51:35.201:
11.999943333333333
05-08 10:51:36.251:
11.999941666666667
05-08 10:51:37.311:
11.999941666666667
05-08 10:51:38.361:
INFO/LocAndroid(251): 7.000001666666666 - INFO/LocAndroid(251): 7.000001666666666 - INFO/LocAndroid(251): 7.000003333333333 - INFO/LocAndroid(251): 7.000005000000001 - INFO/LocAndroid(251): 7.000006666666667 - INFO/LocAndroid(251): 7.000008333333333 - INFO/LocAndroid(251): 7.000008333333333 - INFO/LocAndroid(251): Provider Status: 1
INFO/LocAndroid(251): 7.000023333333333 - INFO/LocAndroid(251): 7.000023333333333 - INFO/LocAndroid(251): Provider Status: 2
INFO/LocAndroid(251): 7.000024999999999 - INFO/LocAndroid(251): 7.000026666666668 - INFO/LocAndroid(251): 7.000026666666668 - INFO/LocAndroid(251): 7.000028333333334 - -11.99997
INFO/LocAndroid(251): 7.000028333333334 - INFO/LocAndroid(251): 7.00003 - -11.999968333333333
INFO/LocAndroid(251): 7.000031666666667 - INFO/LocAndroid(251): 7.000033333333333 - INFO/LocAndroid(251): 7.000033333333333 - INFO/LocAndroid(251): Provider Status: 1
INFO/LocAndroid(251): 7.000048333333333 - INFO/LocAndroid(251): 7.000048333333333 - INFO/LocAndroid(251): Provider Status: 2
INFO/LocAndroid(251): 7.000050000000001 - INFO/LocAndroid(251): 7.000051666666667 - INFO/LocAndroid(251): 7.000053333333333 - INFO/LocAndroid(251): 7.000053333333333 - INFO/LocAndroid(251): 7.000055 - INFO/LocAndroid(251): 7.0000566666666675 - INFO/LocAndroid(251): 7.0000566666666675 - INFO/LocAndroid(251): 7.0000583333333335 - -
153
11.99994
05-08 10:51:38.431: INFO/LocAndroid(251): Provider Status: 1
Estudiemos un poco este log. Si observamos las marcas de fecha hora vemos varias cosas:
Por tanto ya podemos sacar algunas conclusiones. Indicar al location listener una
frecuencia de 15 segundos entre actualizaciones no quiere decir que vayamos a tener una
sola lectura cada 15 segundos, sino que al menos tendremos una nueva con dicha
frecuencia. Sin embargo, como podemos comprobar en los logs, las lecturas se recibirn
por grupos separados entre s por el intervalo de tiempo indicado.
Ms conclusiones, ahora sobre el estado del proveedor de localizacin. Si buscamos en el
log los momentos donde cambia el estado del proveedor vemos dos cosas importantes:
artculo vamos a empezar a hablar de un complemento ideal para este tipo de servicios y
aplicaciones, como es la utilizacin de mapas en nuestras aplicaciones haciendo uso de la
API Android de Google Maps.
Antes de empezar a utilizar el servicio de mapas de Google es necesario realizar algunas
tareas previas. En primer lugar, debemos asegurarnos de que tenemos instalado el paquete
correspondiente a la versin de Android para la que desarrollamos enriquecido con las
APIs de Google. Estos paquetes se llaman normalmente Google APIs by Google, Android
API x, revisin y. Esto podemos comprobarlo y descargarlo si es necesario desde Eclipse
accediendo al Android SDK and AVD Manager. En mi caso, utilizar el paquete
correspondiente a Android 2.1 (API 7) + APIs de Google:
Para poder probar nuestras aplicaciones en el emulador tambin tendremos que crear un
nuevo AVD que utilice este paquete como target:
155
Y por supuesto, al crear nuestro proyecto de Eclipse tambin tendremos que seleccionarlo
como target en las propiedades:
Con todo esto ya tendramos creado nuestro proyecto de Eclipse y estaramos preparados
para poder ejecutar aplicaciones en el emulador sobre la versin correcta de Android y las
APIs necesarias de Google. Por tanto, ya podemos centrarnos en la utilizacin de dichas
APIs.
Esto ltimo tambin requiere algunos pasos previos. Para poder utilizar la API de Google
Maps se requiere la obtencin previa de una clave de uso (API Key), que estar asociada al
certificado con el que firmamos digitalmente nuestra aplicacin. Esto quiere decir que si
cambiamos el certificado con el que firmamos nuestra aplicacin (algo que se hace
normalmente como paso previo a la publicacin de la aplicacin en el Market) tendremos
que cambiar tambin la clave de uso de la API.
En el tema de los certificados no voy a entrar mucho puesto que lo trataremos en un
artculo posterior, por ahora tan slo diremos que durante la construccin y depuracin de
nuestras aplicaciones en el emulador de Android se utiliza automticamente un certificado
de depuracin creado por defecto. Por tanto, para poder depurar aplicaciones en el
emulador que hagan uso de Google Maps tendremos que solicitar una clave asociada a
nuestro certificado de depuracin.
Para ello, en primer lugar debemos localizar el fichero donde se almacenan los datos de
nuestro certificado de depuracin, llamado debug.keystore. Podemos saber la ruta de
este fichero accediendo a las preferencias de Eclipse, seccin Android, apartado Build
(mostrado en la siguiente imagen), y copiar la ruta que aparece en el campo Default Debug
Keystore:
156
Copiaremos el dato que aparece identificado como Huella digital de certificado (MD5) y
con ste accederemos a la web de Google (http://code.google.com/android/maps-apisignup.html) para solicitar una clave de uso de la API de Google Maps para depurar
nuestras aplicaciones (Insisto, si posteriormente vamos a publicar nuestra aplicacin en el
Market deberemos solicitar otra clave asociada al certificado real que utilicemos). Dicha
web nos solicitar la marca MD5 de nuestro certificado y nos proporcionar la clave de uso
de la API, como se muestra en la siguiente imagen:
157
Con esto, terminamos con todos los pasos previos para la utilizacin de los servicios de
Google Maps dentro de nuestras aplicaciones Android.
Una vez contamos con la clave de uso de la API, la inclusin de mapas en nuestra
aplicacin es una tarea relativamente sencilla y directa. En este primer artculo sobre mapas
nos vamos a limitar a mostrar el mapa en la pantalla inicial de la aplicacin, habilitaremos
su manipulacin (desplazamientos y zoom), y veremos cmo centrarlo en una coordenadas
concretas. En prximos artculos aprenderemos a manipular de forma dinmica estos
mapas, a mostrar marcas sobre ellos, y a realizar otras operaciones ms avanzadas.
Para incluir un mapa de Google Maps en una ventana de nuestra aplicacin utilizaremos el
control MapView. Estos controles se pueden aadir al layout de la ventana como cualquier
otro control visto hasta el momento, tan slo teniendo en cuenta que tendremos que indicar
la clave de uso de Google Maps en su propiedad android:apiKey como se muestra a
cotinuacin:
1
2
3 <?xml version="1.0" encoding="utf-8"?>
4 <LinearLayout
5 xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
6 android:layout_width="fill_parent"
7 android:layout_height="fill_parent">
8 <com.google.android.maps.MapView
9 android:id="@+id/mapa"
android:layout_width="fill_parent"
10android:layout_height="fill_parent"
11android:apiKey="0ss-5q6s3FKYkkp3atMUH..."
12android:clickable="true" />
13</LinearLayout>
14
15
158
159
160
En los prximos artculos aprenderemos a manipular las caractersticas de este mapa desde
nuestro cdigo a travs de sus mtodos y propiedades, veremos cmo aadir marcas
visuales para resaltar lugares especficos en el mapa, y comentaremos algunas otras
opciones ms avanzadas.
setSatellite(true)
setStreetView(true)
setTraffic(true)
161
Por supuesto existen tambin otros tres mtodos para consultar el estado de cada uno de
estos modos: isSatellite(), isStreetView() e isTraffic().
En este artculo voy a continuar ampliando la aplicacin de ejemplo que construimos en el
artculo anterior, al que aadiremos varios botones para realizar diferentes acciones. As,
por ejemplo vamos a incluir un botn para alternar en nuestro mapa entre vista normal y
vista de satlite.
1
2 private Button btnSatelite = null;
3 //...
4 btnSatelite = (Button)findViewById(R.id.BtnSatelite);
//...
5 btnSatelite.setOnClickListener(new OnClickListener() {
6 @Override
7 public void onClick(View arg0) {
8 if(mapa.isSatellite())
9 mapa.setSatellite(false);
else
10mapa.setSatellite(true);
11}
12});
13
Si ejecutamos la aplicacin en este momento y probamos el nuevo botn veremos cmo se
visualiza sin problemas nuestro mapa en vista de satlite:
Adems de la eleccin del tipo de vista de mapa a mostrar en el control, tambin podemos
elegir si queremos mostrar controles de zoom sobre el mapa. Para ello llamaremos al
mtodo setBuiltInZoomControls() indicando si queremos que se muestren o no
los controles de zoom:
162
163
7 btnCentrar.setOnClickListener(new OnClickListener() {
8 @Override
public void onClick(View arg0) {
9 Double latitud = 37.40*1E6;
10Double longitud = -5.99*1E6;
11GeoPoint loc =
12new GeoPoint(latitud.intValue(), longitud.intValue());
13controlMapa.setCenter(loc);
controlMapa.setZoom(10);
14}
15});
16
17
18
19
20
Como vemos, para establecer el punto central del mapa construiremos un objeto
GeoPoint a partir de los valores de latitud y longitud y lo pasaremos como parmetro al
mtodo setCenter().
Teniendo esto en cuenta, aadamos un nuevo botn para hacer algo anlogo al anterior pero
de forma progresiva:
1
2
3
4 private Button btnAnimar = null;
5 //...
6 btnAnimar = (Button)findViewById(R.id.BtnAnimar);
7 //...
8 btnAnimar.setOnClickListener(new OnClickListener() {
@Override
9 public void onClick(View arg0) {
10Double latitud = 37.40*1E6;
11Double longitud = -5.99*1E6;
12GeoPoint loc =
GeoPoint(latitud.intValue(), longitud.intValue());
13new
controlMapa.animateTo(loc);
14int zoomActual = mapa.getZoomLevel();
15for(int i=zoomActual; i<10; i++)
16controlMapa.zoomIn();
17}
});
18
19
20
21
Por ltimo, disponemos de otro mtodo que en ocasiones puede ser interesante y que nos
permitir desplazar el mapa, no a una posicin especfica, sino un determinado nmero de
pixeles en una u otra direccin, al igual que conseguiramos mediante gestos con el dedo
sobre el mapa. Este mtodo se llama scrollBy() y recibe como parmetros el nmero
de pixeles que queremos desplazarnos en horizontal y en vertical.
As, por ejemplo, podemos aadir un nuevo botn a la aplicacin de ejemplo, que desplace
el mapa 40 pxeles hacia la derecha y hacia abajo, de la siguiente forma:
1
2 private Button btnMover = null;
//...
3 btnMover = (Button)findViewById(R.id.BtnMover);
4 //...
5 btnMover.setOnClickListener(new OnClickListener() {
6 @Override
7 public void onClick(View arg0) {
controlMapa.scrollBy(40, 40);
8 }
9 });
10
165
En este artculo hemos aprendido a manipular desde nuestro cdigo un control MapView,
tanto a travs de sus propiedades como de las acciones disponibles desde su controlador. En
el prximo artculo veremos cmo podemos aadir capas a nuestro mapa de forma que
podamos dibujar sobre l por ejemplo marcas de posicin, o responder eventos de pulsacin
sobre el control.
GeoPoint que los encapsule. Por otro lado, crearemos un nuevo objeto Projection
mediante el mtod getProjection() de la clase MapView (objeto recibido tambin
como parmetro del mtodo draw()). Este nuevo objeto Projection creado tendr en
cuenta la posicin sobre la que est centrada el mapa en este momento y el nivel de zoom
aplicado para convertir convenientemente entre latitud-longitud en grados y coordenadas xy en pixeles. Para hacer la conversin, llamaremos al mtodo toPixels() que devolver
el resultado sobre un objeto Point de salida.
1
2
Double latitud = 37.40*1E6;
3Double longitud = -5.99*1E6;
4Projection projection = mapView.getProjection();
5GeoPoint geoPoint =
6new GeoPoint(latitud.intValue(), longitud.intValue());
centro = new Point();
7Point
projection.toPixels(geoPoint, centro);
8
9
Una vez que tenemos las coordenadas convertidas a pixeles, ya podemos dibujar sobre ellas
utilizando cualquier mtodo de dibujo. Veamos en primer lugar cmo podramos por
ejemplo aadir un crculo y una etiqueta de texto sobre las coordenadas calculadas:
1
2//Definimos el pincel de dibujo
3Paint p = new Paint();
p.setColor(Color.BLUE);
4//Marca Ejemplo 1: Crculo y Texto
5canvas.drawCircle(centro.x, centro.y, 5, p);
6canvas.drawText("Sevilla", centro.x+10, centro.y+5, p);
7
Para que nadie se pierda, veamos el cdigo completo de nuestra clase derivada de
Overlay (en un alarde de creatividad la he llamado OverlayMapa) hasta el momento:
1 public class OverlayMapa extends Overlay {
Double latitud = 37.40*1E6;
2 private
private Double longitud = -5.99*1E6;
3 @Override
4 public void draw(Canvas canvas, MapView mapView, boolean shadow)
5 {
6 Projection projection = mapView.getProjection();
GeoPoint geoPoint =
7 new GeoPoint(latitud.intValue(), longitud.intValue());
8 if (shadow == false)
9 {
10Point centro = new Point();
centro);
11projection.toPixels(geoPoint,
//Definimos el pincel de dibujo
12Paint p = new Paint();
13p.setColor(Color.BLUE);
167
168
Una posible variante podra ser incluir algn tipo de marcador grfico sobre el mapa, al
estilo del propio Google Maps. Para conseguir esto, deberemos colocar la imagen del
marcador en las distintas carpetas /res/drawable y dibujarlo sobre la capa utilizando el
mtodo drawBitmap(). Para cargar el bitmap a partir del fichero de imagen colocado en
la carpeta de recursos utilizaremos la clase BitmapFactory y su mtodo
decodeResource(), al que tendremos que pasar como parmetro el ID del recurso.
Veamos cmo quedara esto en el cdigo del mtodo draw() de nuestra capa
personalizada [para mayor claridad, ms abajo podis descargar como siempre el cdigo
fuente completo]:
1
2//Marca Ejemplo 2: Bitmap
3Bitmap bm = BitmapFactory.decodeResource(
mapView.getResources(),
4R.drawable.marcador_google_maps);
5canvas.drawBitmap(bm, centro.x - bm.getWidth(),
6centro.y - bm.getHeight(), p);
7
En mi caso, como imagen para el marcador he utilizado una similar al que se muestra en
Google Maps. Si ejecutamos ahora la aplicacin, veremos cmo hemos sustituido la marca
textual anterior por el nuevo marcador grfico:
169
Ya hemos visto lo sencillo que resulta mostrar informacin personalizada sobre un mapa.
Tan slo nos falta saber cmo podemos tambin reacionar ante pulsaciones del usuario
sobre nuestro control.
Para conseguir esto, tendremos que sobrescribir tambin el mtodo onTap() de nuestra
capa personalizada. Este mtodo nos proporciona directamente como parmetro las
coordenadas de latitud y longitud sobre las que el usuario ha pulsado (en forma de objeto
GeoPoint), con lo que podremos actuar en consecuencia desde nuestra aplicacin.
Como ejemplo, nosotros nos vamos a limitar a mostrar en una notificacin de tipo Toast,
las coordenadas sobre las que se ha pulsado.
1
2
3 @Override
public boolean onTap(GeoPoint point, MapView mapView)
4 {
5 Context contexto = mapView.getContext();
6 String msg = "Lat: " + point.getLatitudeE6()/1E6 + " - " +
7 "Lon: " + point.getLongitudeE6()/1E6;
8 Toast toast = Toast.makeText(contexto, msg, Toast.LENGTH_SHORT);
toast.show();
9 return true;
10}
11
12
El mtodo debe devolver el valor true siempre que haya tratado la pulsacin y NO sea
necesario notificarla al resto de capas o al propio control MapView, y false en caso
contrario.
170
Podis descargar el cdigo fuente completo de este artculo pulsando este enlace.
Con esto terminamos por el momento la serie de artculos dedicados a la geolocalizacin y
la visualizacin de mapas en nuestras aplicaciones Android, aunque no descarto dedicar
alguno ms a este tema un poco ms adelante. Como siempre estoy abierto a propuestas
sobre el contenido del curso, podis utilizar los comentarios del blog o mi direccin de
correo electrnico para hacrmelas llegar.
Por otra parte, leer ficheros desde la memoria interna es igual de sencillo, y procederemos
de forma anloga, con la nica diferencia de que utilizaremos el mtodo
openFileInput() para abrir el fichero, y los mtodos de lectura de java.io para leer
el contenido.
1
2
try
3 {
4 BufferedReader fin =
5 new BufferedReader(
6 new InputStreamReader(
7 openFileInput("prueba_int.txt")));
String texto = fin.readLine();
8 fin.close();
9 }
10catch (Exception ex)
11{
Log.e("Ficheros", "Error al leer fichero desde memoria interna");
12}
13
14
La segunda forma de almacenar ficheros en la memoria interna del dispositivo es incluirlos
como recurso en la propia aplicacin. Aunque este mtodo es til en muchos casos, slo
debemos utilizarlo cuando no necesitemos realizar modificaciones sobre los ficheros, ya
que tendremos limitado el acceso a slo lectura.
Para incluir un fichero como recurso de la aplicacin debemos colocarlo en la carpeta
/res/raw de nuestro proyecto de Eclipse. Esta carpeta no suele estar creada por
defecto, por lo que deberemos crearla manualmente en Eclipse desde el men contextual
con la opcin New / Folder.
173
Una vez creada la carpeta /raw podremos colocar en ella cualquier fichero que queramos
que se incluya con la aplicacin en tiempo de compilacin en forma de recurso. Nosotros
incluiremos como ejemplo un fichero de texto llamado prueba_raw.txt. Ya en tiempo de
ejecucin podremos acceder a este fichero, slo en modo de lectura, de una forma similar a
la que ya hemos visto para el resto de ficheros en memoria interna.
Para acceder al fichero, accederemos en primer lugar a los recursos de la aplicacin con el
mtodo getResources() y sobre stos utilizaremos el mtodo
openRawResource(id_del_recurso) para abrir el fichero en modo lectura. Este
mtodo devuelve un objeto InputStream, que ya podremos manipular como queramos
mediante los mtodos de la API java.io. Como ejemplo, nosotros convertiremos el
stream en un objeto BufferedReader para leer el texto contenido en el fichero de
ejemplo (por supuesto los ficheros de recurso tambin pueden ser binarios, como por
ejemplo ficheros de imagen, video, etc). Veamos cmo quedara el cdigo:
1
2
3
try
4 {
5 InputStream fraw =
6 getResources().openRawResource(R.raw.prueba_raw);
7 BufferedReader brin =
BufferedReader(new InputStreamReader(fraw));
8 new
String linea = brin.readLine();
9 fraw.close();
10}
11catch (Exception ex)
12{
Log.e("Ficheros", "Error al leer fichero desde recurso raw");
13}
14
15
16
Como puede verse en el cdigo anterior, al mtodo openRawResource() le pasamos
como parmetro el ID del fichero incluido como recurso, que seguir el patrn
R.raw.nombre_del_fichero, por lo que en nuestro caso particular ser
R.raw.prueba_raw.
174
175
Con todo esto en cuenta, podramos realizar un chequeo previo del estado de la memoria
externa del dispositivo de la siguiente forma:
1
2
3
boolean sdDisponible = false;
4 boolean sdAccesoEscritura = false;
5 //Comprobamos el estado de la memoria externa (tarjeta SD)
6 String estado = Environment.getExternalStorageState();
7 if (estado.equals(Environment.MEDIA_MOUNTED))
8 {
sdDisponible = true;
9 sdAccesoEscritura = true;
10}
11else if (estado.equals(Environment.MEDIA_MOUNTED_READ_ONLY))
12{
= true;
13sdDisponible
sdAccesoEscritura = false;
14}
15else
16{
17sdDisponible = false;
sdAccesoEscritura = false;
18}
19
20
21
Una vez chequeado el estado de la memoria externa, y dependiendo del resultado obtenido,
ya podremos leer o escribir en ella cualquier tipo de fichero.
Empecemos por la escritura. Para escribir un fichero a la tarjeta SD tenemos que obtener en
primer lugar la ruta al directorio raz de esta memoria. Para ello utilizaremos el mtodo
getExternalStorageDirectory() de la clase Environment, que nos devolver
un objeto File con la ruta de dicho directorio. A partir de este objeto, podremos construir
otro con el nombre elegido para nuestro fichero (como ejemplo prueba_sd.txt), creando
un nuevo objeto File que combine ambos elementos. Tras esto, ya slo queda
encapsularlo en algn objeto de escritura de ficheros de la API de java y escribir algn dato
de prueba. En nuestro caso de ejemplo lo convertiremos una vez ms a un objeto
OutputStreamWriter para escribir al fichero un mensaje de texto. Veamos cmo
quedara el cdigo:
1
2
3
4
5
6
7
try
{
File ruta_sd = Environment.getExternalStorageDirectory();
File f = new File(ruta_sd.getAbsolutePath(), "prueba_sd.txt");
OutputStreamWriter fout =
new OutputStreamWriter(
new FileOutputStream(f));
fout.write("Texto de prueba.");
fout.close();
176
8 }
9 catch (Exception ex)
{
10Log.e("Ficheros", "Error al escribir fichero a tarjeta SD");
11}
12
13
14
15
16
17
Adems de esto, tendremos que especificar en el fichero AndroidManifest.xml que nuestra
aplicacin necesita permiso de escritura en la memoria externa. Para aadir un nuevo
permiso usaremos como siempre la clusula <uses-permission> utilizando el valor
concreto android.permission.WRITE_EXTERNAL_STORAGE. Con esto, nuestro
AndroidManifest.xml quedara de forma similar a ste:
1
2
3
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
4 package="net.sgoliver.android"
5 android:versionCode="1"
6 android:versionName="1.0">
7 <uses-sdk android:minSdkVersion="7" />
8 <uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
9 </uses-permission>
10<application android:icon="@drawable/icon"
11android:label="@string/app_name">
12<activity android:name=".AndroidFicheros"
13android:label="@string/app_name">
<intent-filter>
14<action android:name="android.intent.action.MAIN" />
15<category android:name="android.intent.category.LAUNCHER" />
16</intent-filter>
17</activity>
</application>
18</manifest>
19
20
21
Si ejecutamos ahora el cdigo y nos vamos al explorador de archivos del DDMS podremos
comprobar cmose ha creado correctamente el fichero en el directorio raiz de nuestra SD
(carpeta /sdcard/).
177
178
Jose
900123123 email2@correo.com
Luis
900123987 email3@correo.com
Sabiendo esto, es interesante que nuestros datos tambin cuenten internamente con este
campo _ID (no tiene por qu llamarse igual) de forma que nos sea ms sencillo despus
generar los resultados del content provider.
Con todo esto, y para tener algo desde lo que partir, vamos a construir en primer lugar una
aplicacin de ejemplo muy sencilla con una base de datos SQLite que almacene los datos
de una serie de clientes con una estructura similar a la tabla anterior. Para ello seguiremos
los mismos pasos que ya comentamos en los artculos dedicados al tratamiento de bases de
datos SQLite en Android (consultar ndice del curso).
Por volver a recordarlo muy brevemente, lo que haremos ser crear una nueva clase que
extienda a SQLiteOpenHelper, definiremos las sentencias SQL para crear nuestra tabla
de clientes, e implementaremos finalmente los mtodos onCreate() y onUpgrade().
El cdigo de esta nueva clase, que yo he llamado ClientesSqliteHelper, quedara
como sigue:
1
2
3
4
5
180
181
Ntese el campo _id que hemos incluido en la base de datos de clientes por lo
motivos indicados un poco ms arriba. Este campo lo declaramos como INTEGER
PRIMARY KEY AUTOINCREMENT, de forma que se incremente automticamente
cada vez que insertamos un nuevo registro en la base de datos.
En el mtodo onCreate(), adems de ejecutar la sentencia SQL para crear la
tabla Clientes, tambin inserta varios registros de ejemplo.
Para simplificar el ejemplo, el mtodo onUpgrade() se limita a eliminar la tabla
actual y crear una nueva con la nueva estructura. En una aplicacin real habra que
hacer probblemente la migracin de los datos a la nueva base de datos.
Dado que la clase anterior ya se ocupa de todo, incluso de insertar algunos registro de
ejemplo con los que podamos hacer pruebas, la aplicacin principal de ejemplo no mostrar
en principio nada en pantalla ni har nada con la informacin. Esto lo he decidido as para
no complicar el cdigo de la aplicacin innecesariamente, ya que no nos va a interesar el
tratamiento directo de los datos por parte de la aplicacin principal, sino su utilizacin a
travs del content provider que vamos a construir.
Una vez que ya contamos con nuestra aplicacin de ejemplo y su base de datos, es hora de
empezar a construir el nuevo content provider que nos permitir compartir sus datos con
otras aplicaciones.
Lo primero que vamos a comentar es la forma con que se hace referencia en Android a los
content providers. El acceso a un content provider se realiza siempre mediante una URI.
Una URI no es ms que una cadena de texto similar a cualquiera de las direcciones web que
utilizamos en nuestro navegador. Al igual que para acceder a mi blog lo hacemos mediante
la direccin http://www.sgoliver.net, para acceder a un content provider utilizaremos una
direccin similar a content://net.sgoliver.android.ejemplo/clientes.
Las direcciones URI de los content providers estn formadas por 3 partes. En primer lugar
el prefijo content:// que indica que dicho recurso deber ser tratado por un content
provider. En segundo lugar se indica el identificador en s del content provider, tambin
llamado authority. Dado que este dato debe ser nico es una buena prctica utilizar un
authority de tipo nombre de clase java invertido, por ejemplo en mi caso
net.sgoliver.android.ejemplo. Por ltimo, se indica la entidad concreta a la que queremos
acceder dentro de los datos que proporciona el content provider. En nuestro caso ser
simplemente la tabla de clientes, ya que ser la nica existente, pero dado que un content
provider puede contener los datos de varias entidades distintas en este ltimo tramo de la
URI habr que especificarlo. Indicar por ltimo que en una URI se puede hacer referencia
directamente a un registro concreto de la entidad seleccionada. Esto se hara indicando al
final de la URI el ID de dicho registro. Por ejemplo la uri
content://net.sgoliver.android.ejemplo/clientes/23 hara referencia directa al cliente con
_ID = 23.
Todo esto es importante ya que ser nuestro content provider el encargado de
interpretar/parsear la URI completa para determinar los datos que se le estn solicitando.
Esto lo veremos un poco ms adelante.
182
onCreate()
query()
insert()
update()
delete()
getType()
El primero de ellos nos servir para inicializar todos los recursos necesarios para el
funcionamiento del nuevo content provider. Los cuatro siguientes sern los mtodos que
permitirn acceder a los datos (consulta, insercin, modificacin y eliminacin,
respectivamente) y por ltimo, el mtodo getType() permitir conocer el tipo de datos
devueltos por el content provider (ms tade intentaremos explicar algo mejor esto ltimo).
Adems de implementar estos mtodos, tambin definiremos una serie de constantes dentro
de nuestra nueva clase provider, que ayudarn posteriormente a su utilizacin. Veamos esto
paso a paso. Vamos a crear una nueva clase ClientesProvider que extienda de
ContentProvider.
Lo primero que vamos a definir es la URI con la que se acceder a nuestro content
provider. En mi caso he elegido la siguiente:
content://net.sgoliver.android.ejemplo/clientes. Adems, para seguir la prctica habitual
de todos los content providers de Android, encapsularemos adems esta direccin en un
objeto esttico de tipo Uri llamado CONTENT_URI.
1
2//Definicin del CONTENT_URI
private static final String uri =
3"content://net.sgoliver.android.ejemplo/clientes";
4public static final Uri CONTENT_URI = Uri.parse(uri);
5
A continuacin vamos a definir varias constantes con los nombres de las columnas de los
datos proporcionados por nuestro content provider. Como ya dijimos antes existen
columnas predefinidas que deben tener todos los content providers, por ejemplo la columna
_ID. Estas columnas estandar estn definidas en la clase BaseColumns, por lo que para
aadir la nuevas columnas de nuestro content provider definiremos una clase interna
pblica tomando como base la clase BaseColumns y aadiremos nuestras nuevas
columnas.
1
2
3
4
183
184
@Override
public Cursor query(Uri uri, String[] projection,
String selection, String[] selectionArgs, String sortOrder) {
//Si es una consulta a un ID concreto construimos el WHERE
185
25
26
27
28
29
30
31
32
33
34
35
36
El mtodo insert() s es algo diferente, aunque igual de sencillo. La diferencia en este
caso radica en que debe devolver la URI que hace referencia al nuevo registro insertado.
Para ello, obtendremos el nuevo ID del elemento insertado como resultado del mtodo
insert() de SQLiteDatabase, y posteriormente construiremos la nueva URI
mediante el mtodo auxiliar ContentUris.withAppendedId() que recibe como
parmetro la URI de nuestro content provider y el ID del nuevo elemento.
1
2
3
4 @Override
5 public Uri insert(Uri uri, ContentValues values) {
6 long regId = 1;
SQLiteDatabase db = clidbh.getWritableDatabase();
7 regId = db.insert(TABLA_CLIENTES, null, values);
8 Uri newUri = ContentUris.withAppendedId(CONTENT_URI, regId);
9 return newUri;
10}
11
12
13
Por ltimo, tan slo nos queda implementar el mtodo getType(). Este mtodo se utiliza
para identificar el tipo de datos que devuelve el content provider. Este tipo de datos se
expresar como un MIME Type, al igual que hacen los navegadores web para determinar el
tipo de datos que estn recibiendo tras una peticin a un servidor. Identificar el tipo de
datos que devuelve un content provider ayudar por ejemplo a Android a determinar qu
aplicaciones son capaces de procesar dichos datos.
Una vez ms existirn dos tipos MIME distintos para cada entidad del content provider,
uno de ellos destinado a cuando se devuelve una lista de registros como resultado, y otro
para cuando se devuelve un registro nico concreto. De esta forma, seguiremos los
siguientes patrones para definir uno y otro tipo de datos:
187
vnd.android.cursor.item/vnd.sgoliver.cliente
vnd.android.cursor.dir/vnd.sgoliver.cliente
Con esto en cuenta, la implementacin del mtodo getType() quedara como sigue:
1
2
3 @Override
4 public String getType(Uri uri) {
5 int match = uriMatcher.match(uri);
switch (match)
6 {
7 case CLIENTES:
8 return "vnd.android.cursor.dir/vnd.sgoliver.cliente";
9 case CLIENTES_ID:
"vnd.android.cursor.item/vnd.sgoliver.cliente";
10return
default:
11return null;
12}
13}
14
15
Como se puede observar, utilizamos una vez ms el objeto UriMatcher para determinar el
tipo de URI que se est solicitando y en funcin de sta devolvemos un tipo MIME u otro.
Pues bien, con esto ya hemos completado la implementacin del nuevo content provider.
Pero an nos queda un paso ms, como indicamos al principio del artculo. Debemos
declarar el content provider en nuestro fichero AndroidManifest.xml de forma que
una vez instalada la aplicacin en el dispositivo Android conozca la existencia de dicho
recurso.
Para ello, bastar insertar un nuevo elemento <provider> dentro de <application>
indicando el nombre del content provider y su authority.
1
2<application android:icon="@drawable/icon"
3android:label="@string/app_name">
4...
5<provider android:name="ClientesProvider"
6android:authorities="net.sgoliver.android.ejemplo"/>
</application>
7
8
188
9
Ahora s hemos completado totalmente la construccin de nuestro nuevo content provider
mediante el cual otras aplicaciones del sistema podrn acceder a los datos almacenados por
nuestra aplicacin.
En el siguiente artculo veremos cmo utilizar este nuevo content provider para acceder a
los datos de nuestra aplicacin de ejemplo, y tambin veremos cmo podemos utilizar
alguno de los content provider predefinidos por Android para consultar datos del sistema,
como por ejemplo la lista de contactos o la lista de llamadas realizadas.
El cdigo fuente completo de la aplicacin lo publicar junto al siguiente artculo, pero por
el momento podis descargar desde este enlace los fuentes de las dos clases implementadas
en este artculo y el fichero AndroidManifest.xml modificado.
Comenzaremos por definir un array con los nombres de las columnas de la tabla que
queremos recuperar en los resultados de la consulta, que en nuestro caso sern el ID, el
nombre, el telfono y el email. Tras esto, obtendremos como dijimos antes una referencia al
content resolver y utilizaremos su mtodo query() para obtener los resultados en forma
de cursor. El mtodo query() recibe, como ya vimos en el artculo anterior, la Uri del
content provider al que queremos acceder, el array de columnas que queremos recuperar, el
criterio de seleccin, los argumentos variables, y el criterio de ordenacin de los resultados.
En nuestro caso, para no complicarnos utilizaremos tan slo los dos primeros, pasndole el
CONTENT_URI de nuestro provider y el array de columnas que acabamos de definir.
1
2
3
de la tabla a recuperar
4 //Columnas
String[] projection = new String[] {
5 Clientes._ID,
6 Clientes.COL_NOMBRE,
7 Clientes.COL_TELEFONO,
8 Clientes.COL_EMAIL };
Uri clientesUri = ClientesProvider.CONTENT_URI;
9 ContentResolver cr = getContentResolver();
10//Hacemos la consulta
11Cursor cur = cr.query(clientesUri,
12projection, //Columnas a devolver
13null, //Condicin de la query
null, //Argumentos variables de la query
14null); //Orden de los resultados
15
16
17
Hecho esto, tendremos que recorrer el cursor para procesar los resultados. Para nuestro
ejemplo, simplemente los escribiremos en un cuadro de texto (txtResultados) colocado bajo
los tres botones de ejemplo. Una vez ms, si tienes dudas sobre cmo recorrer un cursor,
puedes consultar los artculos del curso dedicados al tratamiento de bases de datos SQLite,
por ejemplo ste. Veamos cmo quedara el cdigo:
1 if (cur.moveToFirst())
{
2 String nombre;
3 String telefono;
4 String email;
5 int colNombre = cur.getColumnIndex(Clientes.COL_NOMBRE);
colTelefono = cur.getColumnIndex(Clientes.COL_TELEFONO);
6 int
int colEmail = cur.getColumnIndex(Clientes.COL_EMAIL);
7 txtResultados.setText("");
8 do
9 {
10nombre = cur.getString(colNombre);
telefono = cur.getString(colTelefono);
11email = cur.getString(colEmail);
12txtResultados.append(nombre + " - " + telefono + " - " + email + "\n");
190
191
Con esto, hemos visto lo sencillo que resulta acceder a los datos proporcionados por un
content provider. Pues bien, ste es el mismo mecanismo que podemos utilizar para acceder
a muchos datos de la propia plataforma Android. En la documentacin oficial del paquete
android.provider podemos consultar los datos que tenemos disponibles a travs de
este mecanismo, entre ellos encontramos por ejemplo: el historial de llamadas, la agenda de
contactos y telfonos, las bibliotecas multimedia (audio y video), o el historial y la lista de
favoritos del navegador.
Por ver un ejemplo de acceso a este tipo de datos, vamos a realizar una consulta al historial
de llamadas del dispositivo, para lo que accederemos al content provider
android.provider.CallLog.
En primer lugar vamos a registrar varias llamadas en el emulador de Android, de forma que
los resultados de la consulta al historial de llamadas contenga algunos registros. Haremos
por ejemplo varias llamadas salientes desde el emulador y simularemos varias llamadas
entrantes desde el DDMS. Las primeras son sencillas, simplemente ve al emulador, accede
al telfono,marca y descuelga igual que lo haras en un dispositivo fsico. Y para emular
llamadas entrantes podremos hacerlo una vez ms desde Eclipse, accediendo a la vista del
DDMS. En esta vista, si accedemos a la seccin Emulator Control veremos un apartado
llamado Telephony Actions. Desde ste, podemos introducir un nmero de telfono
origen cualquiera y pulsar el botn Call para conseguir que nuestro emulador reciba una
llamada entrante. Sin aceptar la llamada en elemulador pulsaremos Hang Up para teminar
la llamada simulando as una llamada perdida.
192
18telefono = cur.getString(colTelefono);
19if(tipo == Calls.INCOMING_TYPE)
tipoLlamada = "ENTRADA";
20else if(tipo == Calls.OUTGOING_TYPE)
21tipoLlamada = "SALIDA";
22else if(tipo == Calls.MISSED_TYPE)
23tipoLlamada = "PERDIDA";
+ " - " + telefono + "\n");
24txtResultados.append(tipoLlamada
} while (cur.moveToNext());
25}
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
Lo nico fuera de lo normal que hacemos en el cdigo anterior es la decodificacin del
valor del tipo de llamada recuperado, que la hacemos comparando el resultado con las
constantes Calls.INCOMING_TYPE (entrante), Calls.OUTGOING_TYPE (saliente),
Calls.MISSED_TYPE (perdida) proporcionadas por la propia clase provider.
Un ltimo detalle importante. Para que nuestra aplicacin pueda acceder al historial de
llamadas del dispositivo tendremos que incluir en el fichero AndroidManifest.xml el
permiso READ_CONTACTS utilizando la clusula <uses-permission>
correspondiente.
<uses-permission android:name="android.permission.READ_CONTACTS"></uses-
1permission>
194
Y con esto terminamos con el tema dedicado a los content providers. Espero que os haya
sido til para aprender a incluir esta funcionalidad a vuestras aplicaciones y a utilizar este
mecanismo para acceder a datos propios del sistema.
195
Toast a travs de este mtodo, ya slo nos quedara mostrarlo en pantalla mediante el
mtodo show().
Vamos a construir una aplicacin de ejemplo para demostrar el funcionamiento de este tipo
de notificaciones. Y para empezar vamos a incluir un botn que muestre un toast bsico de
la forma que acabamos de describir:
1
2 btnDefecto.setOnClickListener(new OnClickListener() {
3 @Override
4 public void onClick(View arg0) {
toast1 =
5 Toast
Toast.makeText(getApplicationContext(),
6 "Toast por defecto", Toast.LENGTH_SHORT);
7 toast1.show();
8 }
9 });
10
Si ejecutamos esta sencilla aplicacin en el emulador y pulsamos el botn que acabamos de
aadir veremos como en la parte inferior de la pantalla aparece el mensaje Toast por
defecto, que tras varios segundos desaparecer automticamente.
Como hemos comentado, ste es el comportamiento por defecto de las notificaciones toast,
sin embargo tambin podemos personalizarlo un poco cambiando su posicin en la
pantalla. Para esto utilizaremos el mtodo setGravity(), al que podremos indicar en
qu zona deseamos que aparezca la notificacin. La zona deberemos indicarla con alguna
de las constantes definidas en la clase Gravity: CENTER, LEFT, BOTTOM, o con
alguna combinacin de stas.
196
197
4 android:layout_width="fill_parent"
5 android:layout_height="fill_parent"
android:orientation="horizontal"
6 android:background="#555555"
7 android:padding="5dip" >
8 <ImageView android:id="@+id/imgIcono"
9 android:layout_height="wrap_content"
10android:layout_width="wrap_content"
android:src="@drawable/marcador" />
11<TextView android:id="@+id/txtMensaje"
12android:layout_width="wrap_content"
13android:layout_height="wrap_content"
14android:layout_gravity="center_vertical"
android:textColor="#FFFFFF"
15android:paddingLeft="10dip" />
16</LinearLayout>
17
18
19
20
21
22
23
Guardaremos este layout con el nombre toast_layout.xml, y como siempre lo
colocaremos en la carpeta res\layout de nuestro proyecto.
Para asignar este layout a nuestro toast tendremos qeu actuar de una forma algo diferente a
las anteriores. En primer lugar deberemos inflar el layout mediante un objeto
LayoutInflater, como ya vimos en varias ocasiones al tratar los artculos de interfaz
grfica. Una vez construido el layout modificaremos los valores de los distintos controles
para mostrar la informacin que queramos. En nuestro caso, tan slo modificaremos el
mensaje de la etiqueta de texto, ya que la imagen ya la asignamos de forma esttica en el
layout XML mediante el atributo android:src. Tras esto, slo nos quedar establecer la
duracin de la notificacin con setDuration() y asignar el layout personalizado al
toast mediante el mtodo setView(). Veamos cmo quedara todo el cdigo incluido en
un tercer botn de ejemplo:
OnClickListener() {
1 btnLayout.setOnClickListener(new
@Override
2 public void onClick(View arg0) {
3 Toast toast3 = new Toast(getApplicationContext());
4 LayoutInflater inflater = getLayoutInflater();
5 View layout = inflater.inflate(R.layout.toast_layout,
(ViewGroup) findViewById(R.id.lytLayout));
6 TextView txtMsg = (TextView)layout.findViewById(R.id.txtMensaje);
7 txtMsg.setText("Toast Personalizado");
8 toast3.setDuration(Toast.LENGTH_SHORT);
9 toast3.setView(layout);
10toast3.show();
}
11});
198
12
13
14
15
16
17
Si ejecutamos ahora la aplicacin de ejemplo y pulsamos el nuevo botn, veremos como
nuestro toast aparece con la estructura definida en nuestro layout personalizado.
fecha/hora que podemos consultar desplegando la bandeja del sistema. A modo de ejemplo,
cuando tenemos una llamada perdida en nuestro terminal, se nos muestra por un lado un
icono en la barra de estado
1
2//Configuramos la notificacin
3int icono = android.R.drawable.stat_sys_warning;
CharSequence textoEstado = "Alerta!";
4long hora = System.currentTimeMillis();
5Notification notif =
6new Notification(icono, textoEstado, hora);
7
El segundo paso ser utilizar el mtodo setLatestEventInfo() para asociar a
nuestra notificacin la informacin a mostrar al desplegar la bandeja del sistema (ttulo y
descripcin) e indicar la actividad a la cual debemos dirigir al usuario automticamente si
ste pulsa sobre la notificacin. Los dos primeros datos son simples cadenas de texto, pero
cmo indicamos la aplicacin a ejecutar si se pulsa sobre la notificacin?
Para esto ltimo debemos construir un objeto PendingIntent, que ser el que contenga
la informacin de la actividad asociada a la notificacin y que ser lanzado al pulsar sobre
ella. Para ello definiremos en primer lugar un objeto Intent, indicando la clase de la
actividad concreta a lanzar, que en nuestro caso ser la propia actividad principal de
ejemplo (AndroidNotificacionesActivity.class). Este intent lo utilizaremos
para construir el PendingIntent final mediante el mtodo
PendingIntent.getActivity().
Veamos cmo quedara esta ltima parte comentada:
1
2
3 //Configuramos el Intent
4 Context contexto = getApplicationContext();
5 CharSequence titulo = "Mensaje de Alerta";
6 CharSequence descripcion = "Ejemplo de notificacin.";
Intent notIntent = new Intent(contexto,
7 AndroidNotificacionesActivity.class);
8 PendingIntent contIntent = PendingIntent.getActivity(
9 contexto, 0, notIntent, 0);
10notif.setLatestEventInfo(
11contexto, titulo, descripcion, contIntent);
12
13
Como opciones adicionales, tambin podemos indicar por ejemplo que nuestra notificacin
desaparezca automticamente de la bandeja del sistema cuando se pulsa sobre ella. Esto lo
hacemos aadiendo al atributo flags de nuestra notificacin el valor
Notification.FLAG_AUTO_CANCEL.
Tambin podramos indicar que al generarse la notificacin el dispositivo debe emitir un
sonido, vibrar o encender el LED de estado presente en muchos terminales. Esto lo
201
Mostrar un mensaje.
Pedir una confirmacin rpida.
Solicitar al usuario una eleccin (simple o mltiple) entre varias alternativas.
204
1
2
3 private Dialog crearDialogoAlerta()
4 {
AlertDialog.Builder builder = new AlertDialog.Builder(this);
5 builder.setTitle("Informacion");
6 builder.setMessage("Esto es un mensaje de alerta.");
7 builder.setPositiveButton("OK", new OnClickListener() {
8 public void onClick(DialogInterface dialog, int which) {
9 dialog.cancel();
}
10});
11return builder.create();
12}
13
14
Como vemos, al mtodo setPositiveButton() le pasamos como argumentos el texto
a mostrar en el botn, y la implementacin del evento onClick en forma de objeto
OnClickListener. Dentro de este evento, nos limitamos a cerrar el dilogo mediante
su mtodo cancel(), aunque podramos realizar cualquier otra accin.
El aspecto de nuestro dilogo de alerta sera el siguiente:
Dilogo de Confirmacin
Un dilogo de confirmacin es muy similar al anterior, con la diferencia de que lo
utilizaremos para solicitar al usuario que nos confirme una determinada accin, por lo que
las posibles respuestas sern del tipo S/No.
La implementacin de estos dilogos ser prcticamente igual a la ya comentada para las
alertas, salvo que en esta ocasin aadiremos dos botones, uno de ellos para la respuesta
afirmativa (setPositiveButton()), y el segundo para la respuesta negativa
(setNegativeButton()). Veamos un ejemplo:
1
2
3
205
Dilogo de Seleccin
Cuando las opciones a seleccionar por el usuario no son slo dos, como en los dilogos de
confirmacin, sino que el conjunto es mayor podemos utilizar los dilogos de seleccin
para mostrar una lista de opciones entre las que el usuario pueda elegir.
Para ello tambin utilizaremos la clase AlertDialog, pero esta vez no asignaremos
ningn mensaje ni definiremos las acciones a realizar por cada botn individual, sino que
directamente indicaremos la lista de opciones a mostrar (mediante el mtodo
setItems()) y proporcionaremos la implementacin del evento onClick() sobre
dicha lista (mediante un listener de tipo DialogInterface.OnClickListener),
206
evento en el que realizaremos las acciones oportunas segn la opcin elegida. La lista de
opciones la definiremos como un array tradicional. Veamos cmo:
1
2
3 private Dialog crearDialogoSeleccion()
4 {
5 final String[] items = {"Espaol", "Ingls", "Francs"};
6 AlertDialog.Builder builder = new AlertDialog.Builder(this);
7 builder.setTitle("Seleccin");
builder.setItems(items, new DialogInterface.OnClickListener() {
8 public void onClick(DialogInterface dialog, int item) {
9 Log.i("Dialogos", "Opcin elegida: " + items[item]);
10}
11});
builder.create();
12return
}
13
14
15
En este caso el dilogo tendr un aspecto similar a la interfaz mostrada para los controles
Spinner.
Este dilogo permite al usuario elegir entre las opciones disponibles cada vez que se
muestra en pantalla. Pero, y si quisiramos recordar cul es la opcin u opciones
seleccionadas por el usuario para que aparezcan marcadas al visualizar de nuevo el cuadro
de dilogo? Para ello podemos utilizar los mtodos setSingleChoiceItems() o
setMultiChiceItems(), en vez de el setItems() utilizado anteriormente. La
diferencia entre ambos mtodos, tal como se puede suponer por su nombre, es que el
primero de ellos permitir una seleccin simple y el segundo una seleccin mltiple, es
decir, de varias opciones al mismo tiempo, mediante controles CheckBox.
207
208
Tanto si utilizamos la opcin de seleccin simple como la de seleccin mltiple, para salir
del dilogo tendremos que pulsar la tecla Atrs de nuestro dispositivo, pero no
perderemos el estado de las opciones. Si volvemos a abrir el dilogo stas debern
continuar en el mismo estado que la ltima vez que se cerr. Esto por supuesto se cumple
mientras no se cierre la actividad asociada o se salga de la aplicacin.
Y con esto terminamos con el apartado dedicado a notificaciones en Android. Hemos
comentado los tres principales mecanismos de Android a la hora de mostrar mensajes y
notificaciones al usuario (Toast, Barra de Estado, y Dilogos), todos ellos muy tiles para
cualquier tipo de aplicacin y que es importante conocer bien para poder decidir entre ellos
dependiendo de las necesidades que tengamos.
209
De forma similar a como ocurre con otros frameworks de logging, en Android los mensajes
de log se van a clasificar por su criticidad, existiendo as varias categorias (ordenadas de
mayor a menor criticidad):
1.
2.
3.
4.
5.
Error
Warning
Info
Debug
Verbose
Para cada uno de estos tipos de mensaje existe un mtodo esttico independiente que
permite aadirlo al log de la aplicacin. As, para cada una de las categoras anteriores
tenemos disponibles los mtodos e(), w(), i(), d() y v() respectivamente.
Cada uno de estos mtodos recibe como parmetros la etiqueta (tag) y el texto en s del
mensaje. Como etiqueta de los mensajes, aunque es un campo al que podemos pasar
cualquier valor, suele utilizarse el nombre de la aplicacin o de la actividad concreta que
genera el mensaje. Esto nos permitir ms tarde crear filtros personalizados para identificar
y poder visualizar nicamente los mensajes de log que nos interesan, entre todos los
generados por Android [que son muchos] durante la ejecucin de la aplicacin.
Hagamos un miniprograma de ejemplo para ver cmo fuenciona esto. El programa ser tan
simple como aadir varios mensajes de log dentro del mismo onCreate de la actividad
principal y ver qu ocurre. Os muestro el cdigo completo:
1
2
3
public class LogsAndroid extends Activity {
4 private static final String LOGTAG = "LogsAndroid";
5 @Override
6 public void onCreate(Bundle savedInstanceState) {
7 super.onCreate(savedInstanceState);
8 setContentView(R.layout.main);
Log.e(LOGTAG, "Mensaje de error");
9 Log.w(LOGTAG, "Mensaje de warning");
10Log.i(LOGTAG, "Mensaje de informacin");
11Log.d(LOGTAG, "Mensaje de depuracin");
12Log.v(LOGTAG, "Mensaje de verbose");
}
13}
14
15
16
Si ejecutamos la aplicacin anterior en el emulador veremos cmo se abre la pantalla
principal que crea Eclipse por defecto y aparentemente no ocurre nada ms. Dnde
podemos ver los mensajes que hemos aadido al log? Pues para ver los mensajes de log nos
tenemos que ir a la perspectiva de Eclipse llamada DDMS. Una vez en esta perspectiva,
210
podemos acceder a los mensajes de log en la parte inferior de la pantalla, en una vista
llamada LogCat. En esta ventana se muestran todos los mensajes de log que genera
Android durante la ejecucin de la aplicacin, que son muchos, pero si buscamos un poco
en la lista encontraremos los generados por nuestra aplicacin, tal como se muestra en la
siguiente imagen (click para ampliar):
Como se puede observar, para cada mensaje se muestra toda la informacin que indicamos
al principio del artculo, adems de estar diferenciados por un color distinto segn su
criticidad.
En este caso de ejemplo, los mensajes mostrados son pocos y fciles de localizar en el log,
pero para una aplicacin real, el nmero de estos mensajes puede ser mucho mayor y
aparecer intercalados caticamente entre los dems mensajes de Android. Para estos casos,
la ventada de LogCat ofrece una serie de funcionalidades para facilitar la visualizacin y
bsqueda de determinados mensajes.
Por ejemplo, podemos restringir la lista para que slo muestre mensajes con una
determinada criticidad mnima. Esto se consigue pulsando alguno de los 5 primeros botones
que se observan en la parte superior derecha de la ventana de log. As, si por ejemplo
pulsamos sobre el botn de la categora Info (en verde), en la lista slo se mostrarn los
mensajes con criticidad Error, Warning e Info.
Otro mtodo de filtrado ms interesante es la definicin de filtros personalizados (botn
+ verde), donde podemos filtrar la lista para mostrar nicamente los mensajes con un PID
o Tag determinado. Si hemos utilizado como etiqueta de los mensajes el nombre de nuestra
aplicacin o de nuestras actividades esto nos proporcionar una forma sencilla de visualizar
slo los mensajes generados por nuestra aplicacin.
As, para nuestro ejemplo, podramos crear un filtro indicando como Tag la cadena
LogsAndroid, tal como se muestra en la siguiente imagen:
211
Esto crear una nueva ventana de log con el nombre que hayamos especificado en el filtro,
donde slo aparecern nuestros 5 mensajes de log de ejemplo (click para ampliar):
Por ltimo, cabe mencionar que existe una variante de cada uno de los mtodos de la clase
Log que recibe un parmetro ms en el que podemos pasar un objeto de tipo excepcin.
Con esto conseguimos que, adems del mensaje de log indicado, se muestre tambin la
traza de error generada con la excepcin.
Veamos esto con un ejemplo, y para ello vamos a forzar un error de divisin por cero,
vamos a capturar la excepcin y vamos a generar un mensaje de log con la variante
indicada:
1
try
2{
3int a = 1/0;
4}
5catch(Exception ex)
6{
Log.e(LOGTAG, "Divisin por cero!", ex);
7}
8
Si volvemos a ejecutar la aplicacin y vemos el log generado, podermos comprobar cmo
se muestra la traza de error corespondiente generada con la excepcin (click para ampliar).
212
En definitiva, podemos comprobar como la generacin de mensajes de log puede ser una
herramienta sencilla pero muy efectiva a la hora de depurar aplicaciones que no se ajustan
mucho a la depuracin paso a paso, o simplemente para generar trazas de ejecucin de
nuestras aplicaciones para comprobar de una forma sencilla cmo se comportan.
213