2013

Manual Inicio Android

Pasos bsicos para crear una aplicacin
Android con ejemplos.
El presente documento trata de introducir al alumno al desarrollo de aplicaciones
Android, guindolo en el desarrollo de una aplicacin con varios ejemplos bsicos
que abarca en gran medida los conceptos bsicos en el desarrollo de aplicaciones
Android utilizando el ADT (Android Developer Tools) de Eclipse.

NELSON CROZBY PADILLA ALVAREZ

UTM
11/02/2013

Contenido
Instalacin ADT, configuracin e inicio del proyecto .......................................................................... 2
Consideraciones previas y de instalacin........................................................................................ 2
Preparar IDE .................................................................................................................................... 3
Crear nuevo proyecto Android........................................................................................................ 8
Estructura proyecto Android ............................................................................................................. 11
Creacin de un Splash de Inicio......................................................................................................... 12
Ciclo de vida de una Activity ............................................................................................................. 20
Entendiendo el flujo del ciclo de vida ........................................................................................... 20
Editar layout para crear la interfaz................................................................................................ 22
Editar el archivo java para agregar funcionalidades y acciones a los botones ............................. 23
Creacin y manejo de Base de Datos ................................................................................................ 25
Crear la BD con SQLite en Navicat................................................................................................. 25
Cargar la base de datos en el proyecto de Android ...................................................................... 30
Cargar la base de datos en la aplicacin para poder usarla .......................................................... 31
Crear un formulario para agregar datos a la base de datos.......................................................... 35
Manejo de SQLite en Android ....................................................................................................... 41
Crear clases y mtodos para guardar los datos de un formulario en una base de datos ............. 45
Crear mtodos de consulta a la base de datos y cargarlos a un ListView y un Spinner................ 47
Reutilizacin de layouts y modificacin de interfaces programticamente ................................. 54
Mapas en Android (Google Maps Android API v2) ........................................................................... 60
Pasos para instalar y/o configurar la API de Google Maps Android. ............................................ 60
Pasos para construir una aplicacin bsica usando la API de Google Maps ................................. 69
Interactuando con el Mapa (pasar coordenadas) ......................................................................... 71
Localizacin geogrfica en Android................................................................................................... 72
Qu mecanismos de localizacin tenemos disponibles? ............................................................ 72
El GPS ya est activado, y ahora qu? ......................................................................................... 75

Instalacin ADT, cnfiguracin e inici

del pryect
Consideraciones previas y de instalacin
1.

2.

Para los fines de este curso se considera que se debe de tener instalado java con la
versin jdk1.7.0_07, en caso de no tenerlo instalado ir al siguiente enlace
http://www.oracle.com/technetwork/java/javase/downloads/java-archivedownloads-javase7-521261.html#jdk-7u7-oth-JPR y escoger la opcin que ms se
apegue a su sistema.
Verificar tener instalado el ADT (Android Developer Tool), que es la herramienta (IDE)
de desarrollo basada en Eclipse que nos servir para el desarrollo de nuestra
aplicacin, en este punto tambin es bueno verificar que se tenga instalado el SDK de
Android. En caso de no tenerla instalado nada de esto, esta es la url que nos lleva a la
pgina de descarga oficial del ADT http://developer.android.com/sdk/index.html.
a. En esta pgina hacer click en el botn que se muestra en la Imagen 1.

Imagen 1

b. Aceptar los trminos y/o condiciones adems de escoger la versin de 32-bit o de

64-bit, como se muestra en la Imagen 2 esto se define basndose en la versin de
java que tengan instalado en su sistema. Es importante que escoger bien porque si
no coinciden las versiones del jdk con el ADT no se podr ni instalar.

Imagen 2

c. Ahora hacer click en el botn mostrado en la Imagen 3, y esperar a descargar para

instalarlo

Imagen 3

Preparar IDE
1. Para consideraciones de este manual se trabajar con la versin de Android 2.3.3
Gingerbread (API 10).
2. Lo primero ser ejecutar la aplicacin ADT (Imagen 4).

Imagen 4

3. Ya en marcha podremos comprobar si tenemos instalado el SDK adecuado haciendo click

en la herramienta Android SDK Manager que se puede ejecutar haciendo click en el cono
de la Imagen 5.

Imagen 5

4. La ventana mostrada en la Imagen 6 nos muestra todos los SDKs existentes y algunas
herramientas disponibles, pero lo que nos interesa es lo que est encerrado en el cuadro
rojo, hay dos opciones una que ya est instalado el SDK que ocupamos (y diga Installed),
y la otra es que an no lo est que es el caso que muy probablemente tengamos por ser
de reciente instalacin, para tal caso debemos de marcar las casillas de los checkboxes en
las opciones SDK Platform y Google APIs, seleccionadas estas opciones se procede a
seleccionar el botn Install que ahora debe de decir Install 2 packages,

Imagen 6

a. Aparecer en este momento una ventana que nos pide que aceptemos las
condiciones de uso de los paquetes a instalar y seleccionamos Accept All, y luego
click al botn Install, como se muestra en la Imagen 7

Imagen 7

b. Esperamos un tiempo mientras descarga el sdk de internet y se instala.

c. Terminada la descarga e instalacin cerramos el Android SDK Manager
5. El siguiente paso es la creacin de un AVD (Android Virtual Device), con ayuda del Android
Virtual Device Manager, esta es una herramienta que nos ayudar a crear un dispositivo
similar a un celular pero ser simulado en nuestra computadora. Para acceder al manager
es necesario hacer click en el cono que se muestra en la Imagen 8.

Imagen 8

a. Al ejecutar el Virtual Device Manager aparece una ventana como la mostrada en

la Imagen 9, como se ve no hay ningn AVD creado, por tal motivo
seleccionaremos la pestaa Device Definitions.

Imagen 9

b. Ahora veremos una ventana como la que se muestra en la Imagen 10, en esta
ventana lo que vemos es una lista de simuladores previamente ya creados que
cumplen con las caractersticas de diferentes modelos existentes as como de
otros genricos.

Imagen 10

c. Para los fines de este manual buscaremos en la lista la opcin 3.2 QVGA, y
seleccionamos la opcin Create AVD, como se muestra en la Imagen 11.

Imagen 11

d. En este siguiente paso lo que haremos en la ventana que nos aparece ser
configurar nuestro AVD como se muestra en la Imagen 12 y dar click en OK.

Imagen 12

e. Hecho lo anterior nuestro AVD ser creado y cerramos el Android Virtual Device
Manager.

Crear nuevo proyecto Android

1. Lo primero que haremos ser comprobar que ya tenemos nuestro IDE configurado, si no
es as habr que referirnos a la seccin anterior (Preparar IDE).
2. Para crear un nuevo proyecto de Android seleccionamos File-> New-> Android Application
Project, como se muestra en la Imagen 13.
3. La Imagen 14 ahora nos muestra la ventana inicial de configuracin de nuestro proyecto,
por lo cual debemos de configurarla como se muestra en esa imagen, y hacemos click en la
opcin Next>.
4. En todas las opciones de configuracin del proyecto hacemos click en Next hasta llegar a
la ltima opcin. En la ltima pantalla seleccionamos Finish.

Imagen 13

Imagen 14

5. Terminado la configuracin de la creacin del proyecto lo que aparece en la Imagen 15 es

la estructura del proyecto que se ha creado por default.

Imagen 15

6. Y en la Imagen 16 se muestra la pantalla creada por default en el proyecto en la seccin de

diseo grfico.

Imagen 16

10

Estructura pryect Andrid

1. /src: en este directorio es donde se almacenarn nuestros archivos de cdigo fuente
(archivos .java).
2. /Android 4.2: es la librera de desarrollo de Android (SDK). Podemos ir desplegando el
rbol para ver los paquetes y clases que incluye el SDK. Cuando aadamos nuevas libreras
o paquetes a nuestro proyecto, aparecern de la misma forma.
3. /gen: aqu aparecern archivos que genera Eclipse de forma automtica, como por
ejemplo el archivo R.java. Estos archivos no deberemos editarlos, ya que ser Eclipse el
que se encargar de modificarlos automticamente segn otros parmetros del proyecto.
4. /assets: es un directorio para guardar recursos que utilice tu aplicacin. Para acceder a los
recursos de este directorio necesitars usar la clase AssetManager para leer los datos
como un stream de bytes, por lo que es preferible utilizar el directorio /res ya que el
acceso a los archivos es mucho ms sencillo.
5. /res: es el directorio principal de recursos (resources). Aqu guardaremos imgenes o
archivos multimedia que utilice nuestra aplicacin. Los recursos colocados en este
directorio son fcilmente accesibles desde la clase R.
6. /res/drawable-?dpi: es el directorio de recursos grficos o imgenes que utilizar nuestra
aplicacin. Tiene cuatro subdirectorios: drawable-xhdpi, drawable-hdpi, drawable-mdpi y
drawable-ldpi, en el que guardaremos las imgenes dependiendo de la densidad de
puntos por pulgada que tenga el dispositivo en el que se ejecute la aplicacin. Puedes
consultar la seccin Supporting Multiple Screens de la gua de desarrollo para Android
para comprender mejor cmo programar para distintos tamaos de pantalla.
7. /res/layout: en Android debemos separar el cdigo de la aplicacin de la interfaz grfica.
En este directorio es donde colocaremos los archivos xml que definen las vistas que
utilizar la aplicacin. Desde el cdigo de la aplicacin le indicaremos el archivo xml que
queremos que use en cada momento, de forma que nos facilitar mucho modificar el
cdigo sin tener que tocar nada del entorno grfico, y viceversa.
8. /res/values: al igual que separamos el cdigo de la aplicacin de la interfaz grfica
mediante vistas, conviene hacer lo mismo con cadenas de texto, arrays, paleta de colores
que usar la interfaz. Este apartado cobra importancia en la localizacin de nuestra
aplicacin. Por ejemplo, podremos definir un archivo strings.xml en /res/drawable-es/ y
otro en /res/drawable/. El primero se utilizar automticamente si el usuario tiene
configurado el terminal en el idioma espaol, mientras que en el resto de casos se utilizar
el archivo que se encuentra en /res/drawable/.
9. AndroidManifest.xml: es el archivo de configuracin de nuestra aplicacin. En l
definiremos qu puede hacer nuestra aplicacin, es decir, informaremos al sistema de
que nuestra aplicacin puede abrir archivos mp3, abrir enlaces http o que es capaz de
manejar las llamadas telefnicas que recibamos. En este archivo tambin indicaremos las
actividades o servicios que ejecutar nuestra aplicacin y los permisos especiales que

11

necesita utilizar en el caso de que quiera acceder a recursos compartidos del sistema,
como el acceso a la lista de contactos, uso del GPS, o la posibilidad de enviar mensajes
SMS.
10. default.properties: es un fichero que genera automticamente Eclipse y del que no
deberemos preocuparnos inicialmente.

Creacin de un Splash de Inici

1. En la seccin src (donde van los archivos .java), crearemos una nueva activity, para lo cual
hacemos click con el botn derecho sobre src, y en el men que aparece hacemos click en
New -> Other -> Android Activity como muestra la Imagen 17 y click en Next >.

Imagen 17

2. En la siguiente opcin, como muestra la Imagen 18 dejamos las opciones por default y
seleccionamos Next >.

12

Imagen 18

3. La siguiente ventana es donde se configuran varios datos como el nombre de la actividad,

el que pone por default trae marca que ya existe por lo cual vamos a cambiar los datos, y
deben de quedar como se muestran en la Imagen 19, ya configurado como en la imagen
hacemos click en Finish.

Imagen 19

4. Esta accin nos crea dos archivos uno se llama SplashScreen.java y el otro es
activity_splash_screen.xml, el primero representa todo el control de la actividad y el
segundo se trata del diseo de la interfaz (de cmo se ver).

13

5. Ahora modificaremos nuestro archivo xml del splash y quitaremos varios elementos, hay
dos opciones una puede ser directamente desde la interfaz grfica de diseo
interactuando sobre los objetos haciendo click con el botn derecho y eliminando los
elementos. La otra opcin se puede hacer ingresando a la opcin donde se ve el cdigo
xml de la interfaz grfica y borrar la etiqueta correspondiente al elemento.

Imagen 20

6. Quitamos el mensaje Hello world!.

7. Es necesario en este punto agregar a nuestro proyecto la imagen que deseamos que
aparezca en el splash, para eso abrimos el navegador de archivos y copiamos nuestra
imagen en la carpeta workspace\ProyectoDemo\res\drawable-mdpi.
8. Ahora agregaremos la imagen que deseamos que aparezca a nuestra interfaz, para realizar
dicha tarea lo haremos desde el modo grfico. Seleccionamos en la Paleta la seccin
Images & Media (Imagen 21) y ahora arrastramos un ImageView dentro de la
representacin de la pantalla de splash y lo soltamos.

Imagen 21

9. Ahora tenemos la ventana Resource Chooser que nos ayudar a escoger la imagen que
deseamos que aparezca, seleccionamos la opcin Project Resources y en el campo de
texto inferior nos aparece un listado con los nombres de las imgenes que tenemos
disponibles en nuestro proyecto, seleccionamos la que deseamos, como se ve en la
Imagen 22, y hacemos click en el botn OK.

14

Imagen 22

10. Abrimos el archivo SplashScreen.java que tendr un cdigo como el que se muestra en la
Imagen 23

Imagen 23

11. Sobrescribiremos el cdigo del mtodo onCreate, para dejarlo como como se muestra en
la Imagen 24

15

Imagen 24

12. Tambin en el archivo SplashScreen.java se sobrescribir el mtodo onTouchEvent, pero

este mtodo no aparece por default as que hay que agregarlo, y deber de contener el
cdigo que se muestra en la Imagen 25.

Imagen 25

13. Ahora pongamos atencin en el archivo AndroidManifest.xml, este documento deber

configurado como se muestra en la Imagen 26, aqu se especifican varios parmetros en el
caso del splash se especifica cual ser la Activity que se ejecutar al arranque de la
aplicacin adems de especificar la orientacin de la pantalla y decir que esta Activity no
tendr barra de ttulo.

16

Imagen 26

14. Ahora lo que haremos ser agregar una imagen de un spinner (loading) y una animacin
que haga girar la imagen mientras est la pantalla de splash.
15. Lo primero por hacer es agregar la imagen al layout del splash (SplashScreen.xml), se har
similar a como cuando agregamos la imagen de splash.
16. La Imagen 27 muestra un ejemplo de la forma en que se agrega la imagen del spinner.
Aqu podemos acomodar la imagen a nuestro antojo. Al documento xml solo habr que
agregarle el cdigo mostrado en la Imagen 28.

17

Imagen 27

Imagen 28

17. Ahora debemos de agregar una carpeta anim en la seccin res y es ah donde se guardar
el archivo de la configuracin de la animacin, creada esta carpeta el siguiente paso es
crear el archivo rotate.xml dentro de la carpeta anim. Al final la nueva carpeta y nuevo
archivo se vern como en la Imagen 29.

Imagen 29

18. El cdigo del archivo rotate.xml se muestra en la Imagen 30.

Imagen 30

18

19. Bueno ya tenemos la imagen cargada y la animacin creada pero ahora falta mandarla
llamar y ejecutar en el momento deseado, para lo cual crearemos la funcin
runAnimations() en la clase SplashScreen.java, el cdigo del mtodo se muestra en la
Imagen 31.

Imagen 31

20. Ahora es momento de mandar llamar la animacin para eso ser necesario mandar llamar
el mtodo desde el mtodo onCreate de la Activity SplashScreen.java, justo antes de
ejecutar el hilo como se muestra en la Imagen 32

Imagen 32

21. Ahora si es momento de ejecutar el proyecto el cual corriendo en el emulador se ver

como en la Imagen 33.

Imagen 33

19

Cicl de vida de una Activity

A medida que el usuario navega a travs de, fuera de, y de regreso a su aplicacin, las instancias
de las Activities cambian entre los diferentes estados de su ciclo de vida en las transiciones de la
aplicacin. Por ejemplo, cuando su actividad se inicia por primera vez, se trata de un primer plano
del sistema y recibe la atencin del usuario. Durante este proceso, el sistema Android llama a una
serie de mtodos de ciclo de vida sobre la actividad en la que se configura la interfaz de usuario y
otros componentes. Si el usuario realiza una accin que inicia otra actividad o cambia a otra
aplicacin, el sistema llama a otro conjunto de mtodos de ciclo de vida en su activity a medida
que avanza hacia el fondo (donde la actividad ya no es visible, pero la instancia y su estado
permanecen intactos).
Dentro de los mtodos de llamadas del ciclo de vida, puedes declarar cmo se comportar tu
activity cuando el usuario abandone o reingrese a la activity. Por ejemplo, si se est construyendo
un reproductor de vdeo con streaming, se podra hacer una pausa al vdeo y terminar la conexin
de red cuando el usuario cambia a otra aplicacin. Cuando el usuario vuelve, puede volver a
conectarse a la red y permitir al usuario reanudar el vdeo desde el mismo punto.

Entendiendo el flujo del ciclo de vida

Durante la vida de una actividad, el sistema llama a un conjunto bsico de los mtodos de ciclo de
vida en una secuencia similar a una pirmide escalonada. Es decir, cada etapa del ciclo de actividad
es un paso separado en la pirmide. A medida que el sistema crea una nueva instancia de una
activity, cada mtodo de devolucin de llamada mueve el estado de activity un paso hacia la cima.
La parte superior de la pirmide es el punto en el que la actividad se ejecuta en el primer plano y
el usuario puede interactuar con l (Imagen 34).

Imagen 34

20

Dependiendo de la complejidad de la actividad, probablemente no es necesario implementar

todos los mtodos del ciclo de vida. Sin embargo, es importante que se entienda cada uno y
ponerlos en prctica garantiza que la aplicacin se comporte de la forma en que los usuarios
esperan. La implementacin de los mtodos de ciclo de vida de la activity apropiadamente asegura
que la aplicacin se comporte bien en varias situaciones, incluyendo que:

No bloquee si el usuario recibe una llamada telefnica o cambia a otra aplicacin mientras
se utiliza la aplicacin.
No consume valiosos recursos del sistema cuando el usuario no est usando activamente.
No pierde el progreso del usuario si salen de su aplicacin y volver a ella ms adelante.
No bloquee o perder el progreso del usuario cuando la pantalla cambia entre orientacin
vertical u horizontal.

Hay varias situaciones en las que las transiciones de una activity entre los diferentes estados
ocurren como se ilustran en la Imagen 34. Sin embargo, slo tres de estos estados puede ser
esttico. Es decir, la activity puede existir en uno de los tres estados para un perodo de tiempo
prolongado:

Resumed: En este estado, la activity est en el primer plano y el usuario puede interactuar
con l. (Tambin se refiere a veces como el estado "corriendo").
Paused: En este estado, la activity est parcialmente oculta por otra activity, la otra
activity que est en el primer plano es semi-transparente o no cubre toda la pantalla. La
activity que se detuvo no recibe la entrada del usuario y no se puede ejecutar ningn
cdigo.
Stopped: En este estado, la activity est completamente oculta y no visible para el usuario,
sino que se considera que est en el fondo. Mientras est detenida, la instancia de la
activity y toda la informacin de su estado como variables de miembros se mantiene, pero
no se puede ejecutar ningn cdigo.

Los otros estados (creado e iniciado) son transitorios y el sistema rpidamente cambia de ellos al
siguiente estado llamando al siguiente ciclo de vida. Es decir, despus de que el sistema llama
onCreate (), rpidamente se llama OnStart (), que rpidamente es seguido por onResume ().

Crear un menu de inici

Ahora vamos a crear una Activity que funcionar como men principal y desde este men
podremos acceder a todas las opciones que nos proporcionar nuestra aplicacin, trabajaremos
con los archivos MainActivity.java y activity_main.xml, como recordaran en el primer archivo
agregaremos la funcionalidad y en el segundo la apariencia de inicio de la activity, manos a la obra:

21

Editar layout para crear la interfaz.

1. Primero modificaremos el archivo strings.xml que se encuentra dentro de la carpeta
res/values el cdigo que agregaremos es el que se muestra en la Imagen 35 en las lneas 8,
9 , 10 y 11, este ser el texto que mostraremos en los botones de nuestro men.

Imagen 35

2. Tomamos el archivo activity_main.xml y lo editamos hasta que quede grficamente como

se muestra en la Imagen 36.

Imagen 36

3. Y la representacin del layout en xml es como se muestra en la Imagen 37.

22

Imagen 37

Editar el archivo java para agregar funcionalidades y acciones a los botones

1. Abrimos el archivo MainActivity.java para editarlo, lo primero a realizar ser crear unas
variables globales de tipo Button que representan a cada uno de los botones que tenemos
en nuestra interfaz. Esto queda como se muestra en la Imagen 38.

Imagen 38

2. Ahora en nuestro mtodo onCreate() crearemos un enlace entre nuestros objetos Button
y la representacin en el layout (archivo xml), de cada uno de los botones, esto se realiza
mediante las lneas de cdigo mostradas en la Imagen 49, en las lneas 19, 20, 21 y 22.

23

Imagen 39

3. Antes de continuar declararemos 4 nuevas activities que sern las que se llamen cuando
hagamos click en alguno de los botones de nuestro men, ya vimos como declarar una
nueva activity (similar a como lo hicimos para crear la activity del splash pero sin
seleccionar Launcher Activity, y no olvidar de declarar en el Manifest las nuevas
activities). Los nombres sern CargaActivity.java, MapasActivity.java, ListarActivity.java y
TrazarActivity.java. Por el momento quedarn as las activities, ms adelante
trabajaremos con ellas, la Imagen 40 muestra cmo deben de quedar en la estructura del
proyecto.

Imagen 40

4. El siguiente paso es agregar las acciones a los botones, o sea decirle que es lo que harn
los botones en el momento en el que suceda algn evento que en nuestro caso ser el
evento de un click. Lo que haremos ser crearle un evento onClickListener a cada uno de
los botones creados para que manden mostrar las nuevas activities creadas. En la Imagen
41 se muestra el cdigo que ser puesto inmediatamente despus de la inicializacin de
los botones dentro del mtodo onCreate().

24

Imagen 41

Creacin y manej de Base de Dats

Crear la BD con SQLite en Navicat.
1. Lo primero que hay que hacer es abrir el Navicat y crear una nueva conexin a una base de
datos SQLite, como vemos en la Imagen 42

25

Imagen 42

2. Escoger un nombre a la conexin en nuestro caso se llamar bd_alumnos, en la seccin

Type seleccionar la opcin New SQLite 3, y en la seccin de Database File debemos de
especificar un lugar donde guardaremos nuestra base de datos recientemente creada as
mismo como el nombre que le queremos dar al archivo en la Imagen 43 se muestra como
queda configurada mi base de datos.

Imagen 43

26

3. Para crear la tabla que requerimos hacemos doble-click en la nueva conexin recin
creada, despus aparece una opcin que dice main, tambin a esta le damos doble-click
y se despliegan varias opciones en la que dice Tables hacemos click con el botn derecho y
del men desplegable seleccionamos la opcin New Table (Ver Imagen 44).

Imagen 44

4.

Crearemos los campos que llevar la BD, debe de quedar igual a como se muestra
en la Imagen 45..

Imagen 45

27

5. Ahora crearemos una ndice, esto es necesario que sea realizado para todas las llaves
primarias que sean creadas con auto incremento, para realizar esto seleccionamos la
pestaa Indexes, en la columna Name pondremos un nombre al ndice en este caso ser
id_alumno, en la columna Fields al seleccionarla cambia a como se muestra en la Imagen
46 y damos un click al botn encerrado en el cuadro rojo.

Imagen 46

6. En la ventana que es mostrada ahora, ver Imagen 47, marcamos el checkbox de la llave
primaria y en la columna Sort Order, seleccionamos la opcin ASC y aceptamos los
cambios dando click en el botn encerrado en el cuadro rojo.

Imagen 47

7. Al guardar las modificaciones si no exista previamente la tabla entonces nos pide que le
pongamos un nombre a la tabla as como se muestra en la Imagen 48.

28

Imagen 48

8. En este punto al crear la nueva tabla ctl_alumnos se crea una tabla dinmica
sqlite_sequence, esta tabla lleva el control de la secuencia de las llaves principales, por
favor de no modificar esta tabla (Imagen 49).

Imagen 49

9. Android solicita que la base de datos incluya una tabla que se llama android_metadata,
esta tabla debe de contener un solo campo de nombre locale y en la Imagen 50 se
muestra cmo debe de quedar configurada dicha tabla.

29

Imagen 50

Cargar la base de datos en el proyecto de Android

1. En este punto es necesario recordar la ubicacin en la que guardamos nuestra base de
datos, porque necesitamos copiar dicho archivo a la carpeta /res/assets del proyecto
android que estemos trabajando, esto lo podemos realizar desde el navegador de archivos
del sistema operativo que estemos usando. Ya copiado el archivo, que para casos prctico
nuestro archivo se debera de llamar bd_alumnos.bd, en la Imagen 51 vemos un ejemplo
de cmo debera de verse la estructura de archivos de nuestro proyecto despus de copiar
el archivo.

Imagen 51

30

Cargar la base de datos en la aplicacin para poder usarla

1. Lo primero ser crear un paquete nuevo para separar los archivos relacionados con el
manejo de base de datos de los del manejo de las activities, el nombre del nuevo paquete
ser com.demo.proyectodemo.db.
2. Ahora crearemos la clase java DataBaseManager.java la cual tendr varias funciones y/o
mtodos:
Mtodo
DataBaseManager(Context
context)
createDataBase()
checkDataBase()
copyDataBase()

openDataBase()
close()

Funcionalidad
Constructor
Crea una base de datos vaca en el sistema y la reescribe con tu
propia base de datos
Verifica si la base de datos ya existe para evitar re-copiar el
archivo cada vez que abres la aplicacin
Copia tu base de datos desde la carpeta local assets a la base de
datos vaca recientemente creada en el sistema de carpetas, para
que pueda ser accesada y manipulada. Esto es hecho por
transferencia de flujo de bytes
Abre la base de datos
Cierra la base de datos
Tabla 1

3. Lo primero que haremos ser declarar unas variables globales que sern utilizadas en
diferentes partes de la clase, como se muestra en la Imagen 52.

Imagen 52

4. Lo siguiente que haremos ser declarar el constructor de la clase como lo vemos en la

Imagen 53.

31

Imagen 53

5. Ahora crearemos una mtodo que verificar si la base de datos ya existe, esta clase solo
regresa true si ya existe o false en caso de no existir, dicho mtodo se llamar
checkDataBase(), el cdigo necesario en esta clase se muestra en la Imagen 54.

Imagen 54

6. El siguiente mtodo necesario es uno que nos ayude a copiar la base de datos que
tenemos en la carpeta assets al sistema de archivos del proyecto para que pueda ser
usada y manipulada nuestra base de datos, este mtodo tendr el nombre
copyDataBase(), y la copia del archivo de la base de datos desde assets haca el sistema de
archivos de la aplicacin se realiza a travs de un flujo de bytes, el cdigo de dicho mtodo
lo podemos ver en la Imagen 55.

32

Imagen 55

7. Los dos mtodos anteriores son necesarios puesto que son utilizados por el mtodo
createDataBase() ya que primero valida si la base de datos ya existe y en caso de que no
exista entonces copia la base de datos. Esto lo podemos ver en la Imagen 56.

Imagen 56

33

8. Por ltimo falta agregar dos mtodos muy importantes para abrir y cerrar la base de
datos, estos mtodos son openDataBase() y close(), en la Imagen 57 podemos observar el
cdigo de estos dos mtodos.

Imagen 57

9. Ahora debemos de agregar el cdigo que se necesita para poder mandar llamar los
mtodos de comprobacin de existencia de la base de datos, esta comprobacin la
haremos en el momento en el que est ejecutndose el splash, para tal caso debemos de
agregar varias lneas de cdigo que mostraremos en la Imagen 58. Primero declararemos
una variable global de nombre db y del tipo SQLiteDatabase, de esta manera private
SQLiteDatabase db;.

34

Imagen 58

Crear un formulario para agregar datos a la base de datos

En esta parte del manual reutilizaremos una activity previamente usada, esta ser
CargaActivity.java.
1. Recordemos que los todos los textos es recomendable que los pongamos en el archivo
strings.xml, por lo cual debemos de agregar las diferentes etiquetas con sus valores en
dicho archivo, en la Imagen 59 vemos el resultado escribir los nuevos valores.

Imagen 59

2. El segundo paso a realizar ser crear un formulario en el layout correspondiente a esta

activity en este caso el layout se llama activity_carga.xml, puesto que solo tenemos una
tabla en nuestra base de datos y esta solo consta de 5 campos pero uno es la llave
primaria y este se genera automticamente no es necesario que introduzcamos ese valor,

35

por lo tanto tendremos que crear un formulario con cuatro campos de texto, cuatro
etiquetas de texto, un botn de guardar y otro de cancelar. En la Imagen 60 vemos el
resultado de cmo debe de verse grficamente este formulario.

Imagen 60

3. Ahora agregaremos las referencias al layout de los textos para que aparezcan en la
interfaz, adems de cambiar los id de los TextView por algunos que nos den una mayor
referencia, quedando el documento el xml como lo vemos en las Imgenes 61 y 62.

Imagen 61

36

Imagen 62

4. Para terminar la fase de diseo ahora vemos el resultado grfico de las ltimas
modificaciones creadas en el layout en la Imagen 63.

37

Imagen 63

5. El siguiente paso ser crear objetos globales que sern las representaciones de los objetos
que tenemos en el layout, estos objetos representarn a los botones y a los EditText (cajas
de texto), ver la Imagen 64

Imagen 64

6. Crearemos los enlaces entre nuestros objetos Button y los objetos EditText y los
elementos creados en el layout para poder interactuar con ellos, ver Imagen 65.

Imagen 65

38

7. Antes de que continuemos debemos de agregar al archivo strings.xml unos nuevos textos,
dichos textos son los que aparecern en un AlertDialog cada vez que uno de los EditText
del formulario est vaco, ver la Imagen 66.

Imagen 66

8. Lo siguiente ser asignarle un listener al btnGuardar para que pueda atender el evento de
onClick y tambin poderle asignar una accin, la accin a efectuar ser la evaluacin de
que no estn vacos los campos de texto puesto en la BD se ocupan todos los valores con
informacin. La idea bsica ser la de comparar cada uno de los EditText preguntando si
no est vaco y si est alguno vaco se muestra un AlertDialog con el mensaje de error
creado en el punto anterior. En la Imagen 67 se muestra como es el cdigo necesario para
implementar el evento del click en el botn.

Imagen 67

9. A continuacin se procede a crear el constructor del AlertDialog de la forma en que se

muestra en la Imagen 68.

Imagen 68

10. Ahora si creamos el cdigo que verifica que los EditText del formulario no vayan vacos, y
que en caso de estarlo muestren el mensaje del error, para tal caso ver el cdigo mostrado
en la Imagen 69, este cdigo va en el mtodo sobrescrito onClick del botn btnGuardar.

39

Imagen 69

11. Si en este momento corremos nuestro proyecto y dejamos algn campo vaco nos
mostrar un mensaje como el que se aprecia en la Imagen 70.

Imagen 70

40

Manejo de SQLite en Android

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. 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 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, 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.
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 la Imagen 71:

41

Imagen 71

Los mtodos update() y delete() se utilizarn de forma muy parecida a sta, con la salvedad de
que recibirn un parmetro adicional con la condicin WHERE de la sentencia SQL. Por ejemplo,
para actualizar el email del usuario de nombre usu1 haramos lo siguiente:

Imagen 72

Como podemos ver, como tercer parmetro del mtodo update() pasamos directamente la
condicin del UPDATE tal como lo haramos en la clusula WHERE en una sentencia SQL normal. El
mtodo delete() se utilizara de forma anloga. Por ejemplo para eliminar el registro del usuario
usu2 haramos lo siguiente:

Imagen 73

Como vemos, volvemos a pasar como primer parmetro el nombre de la tabla y en segundo lugar
la condicin WHERE. Por supuesto, si no necesitramos ninguna condicin, podramos dejar como
null en este parmetro.
Un ltimo detalle sobre estos mtodos. Tanto en el caso de execSQL() como en los casos de
update() o delete() podemos utilizar argumentos dentro de las condiciones de la sentencia SQL.
Esto no es ms que partes variables de la sentencia SQL que aportaremos en un array de valores
aparte, lo que nos evitar pasar por la situacin tpica en la que tenemos que construir una
sentencia SQL concatenando cadenas de texto y variables para formar el comando SQL final. Estos
argumentos SQL se indicarn con el smbolo ?, y los valores de dichos argumentos deben pasarse
en el array en el mismo orden que aparecen en la sentencia SQL. As, por ejemplo, podemos
escribir instrucciones como la siguiente:

42

Imagen 74

Esta forma de pasar a la sentencia SQL determinados datos variables puede ayudarnos adems a
escribir cdigo ms limpio y evitar posibles errores.
De forma anloga a lo que vimos para las sentencias de modificacin de datos, vamos a tener dos
opciones principales para recuperar registros de una base de datos SQLite en Android. La primera
de ellas utilizando directamente un comando de seleccin SQL, y como segunda opcin utilizando
un mtodo especfico donde parametrizremos la consulta a la base de datos.
Para la primera opcin utilizaremos el mtodo rawQuery() de la clase SQLiteDatabase. Este
mtodo recibe directamente como parmetro un comando SQL completo, donde indicamos los
campos a recuperar y los criterios de seleccin. El resultado de la consulta lo obtendremos en
forma de cursor, que posteriormente podremos recorrer para procesar los registros recuperados.
Sirva la siguiente consulta a modo de ejemplo:

Imagen 75

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:

Imagen 76

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():

43

Imagen 77

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:

moveToFirst(): mueve el puntero del cursor al primer registro devuelto.

moveToNext(): mueve el puntero del cursor al siguiente registro devuelto.

Los mtodos moveToFirst() y moveToNext() devuelven TRUE en caso de haber realizado el

movimiento correspondiente del puntero sin errores, es decir, siempre que exista un primer
registro o un registro siguiente, respectivamente.
Una vez posicionados en cada registro podremos utilizar cualquiera de los mtodos
getXXX(ndice_columna) existentes para cada tipo de dato para recuperar el dato de cada campo
del registro actual del cursor. As, si queremos recuperar por ejemplo la segunda columna del
registro actual, y sta contiene un campo alfanumrico, haremos la llamada getString(1) [NOTA:
los ndices comienzan por 0, por lo que la segunda columna tiene ndice 1], en caso de contener un
dato de tipo real llamaramos a getDouble(1), y de forma anloga para todos los tipos de datos
existentes.
Con todo esto en cuenta, veamos cmo podramos recorrer el cursor devuelto por el ejemplo
anterior:

Imagen 78

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

44

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. Podemos consultar la
lista completa de mtodos disponibles en la clase Cursor en la documentacin oficial de Android.

Crear clases y mtodos para guardar los datos de un formulario en una base
de datos
1. Por principio de cuentas lo primero ser crear una nueva clase que se encargue de todo el
manejo de consultas a la base de datos, dicha clase se encontrar ubicada en el paquete
com.digono.bayer.db y el nombre de la clase ser DataBaseSQL, ver Imagen 79.

Imagen 79

2. Ahora creamos el constructor y declaramos unas variables globales en la clase

DataBaseSQL (Imagen 80).

Imagen 80

3. El siguiente paso ser crear un mtodo para insertar los datos a la base de datos usando
los mtodos provistos por la clase SQLiteOpenHelper, veamos la Imagen 81 para ver el
cdigo de dicho mtodo que tendr por nombre InsertAlumno.

Imagen 81

45

a. Lo primero que se hace en este mtodo es declarar un objeto SQLiteDatabase

para poder crear una conexin a la base de datos.
b. El segundo paso ser crear un objeto ContentValues, estos objetos son los que
contendrn los valores a ingresar en la base de datos que obtendremos del
HashMap que se pasa al mtodo como parmetro.
c. Utilizamos el mtodo insert() para insertar los datos en la base de datos.
4. En este punto ya validamos que no tengamos datos vacos y ya creamos el mtodo que
nos ayudar a insertar los datos a la base de datos.
5. Ahora abrimos la clase CargaActivity.java y procederemos a recuperar los datos
necesarios y ponerlos en un HashMap para pasarlos como parmetro al mtodo
InsertAlumno(), as que escribiremos el cdigo mostrado en la Imagen 82, este cdigo ser
escrito inmediatamente despus de cerrar la ltima validacin de campos en el mtodo
onCreate() de la clase CargaActivity.java.

Imagen 82

6. Ya recuperados los datos en el HashMap, ahora se procede a crear la llamada al mtodo

InsertAlumno(), dentro de un try-catch esto con la finalidad de manejar cualquier error
que pueda ocurrir en el proceso de registro de datos en la base de datos, aprovechamos el
catch para llamar un AlertDialog y mostrar un mensaje en caso de ocurrir algn error, todo
esto lo podemos ver el cdigo mostrado en la Imagen 83.

Imagen 83

7. Puesto que el mtodo InsertAlumno() nos regresa un valor que representa el resultado de
la operacin de insercin la aprovecharemos para hacer una retroalimentacin al usuario
e informarle el estado y/o resultado de la operacin de insercin. Cuando la insercin ha
sido exitosa siempre regresa un valor mayor que 0, por lo tanto solo ser suficiente validar
este valor para mostrar un AlertDialog que nos diga: Alumno dado de alta y en caso
contrario: Alumno no fue dado de alta, en la Imagen 84 podemos ver cmo nos quedara
el cdigo.

46

Imagen 84

8. Recordemos de escribir los mensajes en el archivo strings.xml, como lo vemos en la

Imagen 85.

Imagen 85

9. Por ltimo crearemos un mtodo para poder cerrar la base de datos, ver Imagen 86.

Imagen 86

Crear mtodos de consulta a la base de datos y cargarlos a un ListView y un

Spinner.
En la seccin anterior creamos las clases necesarias para la conexin a la base de datos y tambin
creamos una clase en la que tenemos mtodos para realizar inserciones a la base de datos, pero
ya que tenemos almacenada informacin ahora pues es necesario ver la manera de recuperarla,
para lo cual veremos los siguientes pasos a seguir para crear algunos mtodos que nos recuperen
informacin.
1. El primer mtodo que crearemos para recuperar informacin se llama
getTodosAlumnos(), en este mtodo lo que hacemos es realizar una consulta a la tabla
ctl_alumnos, la cual nos retornar todos los alumnos que tenemos registrados en la
base de datos pero solo recuperamos las columnas id_alumno y nombre. La Imagen 87
nos muestra el cdigo de dicha clase.

47

Imagen 87

2. Ahora haremos otro mtodo que nos regrese toda la informacin de un alumno en
especfico, para esto el mtodo recibe un parmetro, este parmetro es el id del alumno
que se desea ver su informacin, el mtodo llevar por nombre getInfoAlumno(). Ver la
Imagen 88 para referencia del cdigo.

Imagen 88

3. Es momento de mostrar los resultados de las consultas de la base de datos, para lo cual
utilizaremos la activity ListarActivity, en esta clase haremos varios ejemplos de cmo
cargar la informacin desde la base de datos.
4. Ahora pasemos a editar el layout activity_listar.xml, y utilizaremos otros nuevos
elementos como son ScrollView, LinearLayout, Spinner y ListView.
5. Lo primero que haremos ser agregar un ListView y a este le pondremos en la propiedad
android:layout_height un valor de 200dp.
6. En segundo lugar lo que haremos ser agregar un elemento ScrollView (abajo del
ListView).
7. Dentro del ScrollView, el ScrollView solo acepta un elemento hijo, por lo tanto debemos
de agregar un layout que pueda contener a todos los dems elementos necesarios, por lo
tanto pondremos un LinearLayout con la propiedad android:orientation="vertical" y
dentro colocaremos el elemento Spinner, ahora el cdigo del layout activity_listar.xml
queda como se muestra en la Imagen 89 (verifica como fueron cambiados los ids de cada
elemento), y grficamente se vera como se muestra en la Imagen 90.

48

Imagen 89

Imagen 90

8. De nuevo ya terminamos con el diseo de la interfaz, es ahora necesario crear la

codificacin para poder obtener los datos y a su vez poder agregarlos a los diferentes
elementos (en este caso el ListView y el Spinner), comenzaremos con el ListView.

49

9. Comenzamos con la declaracin de un objeto ListView con el cual crearemos el enlace con
el elemento ListView que se encuentra en el layout activity_listar.xml (Imagen 91).

Imagen 91

10. En el mtodo OnCreate() de la activity ListarActivity.java inicializaremos la variable

listAlum (Imagen 92).

Imagen 92

11. Necesitamos crear un objeto ArrayAdapter, la clase ArrayAdapter puede manejar

cualquier objeto Java como una entrada. Lo que hace es mapear los datos de su entrada a
un TextView en el layout. ArrayAdapter usa el mtodo toString() del objeto de la entrada
de datos para determinar cul String debera ser desplegada. Pero esto lo haremos dentro
de un mtodo nuevo que crearemos, dicho mtodo tendr de nombre
loadListViewData(). Entre las principales funciones de este mtodo aparte de crear y
configurar el ArrayAdaper, se encuentra la de obtener una lista de todos los datos
existentes en la base de datos para que sean agregados al ArrayAdapter, estos datos sern
obtenidos con ayuda de otro mtodo que ser definido ms adelante, para ver el cdigo
de este mtodo referirnos a la Imagen 93.

Imagen 93

12. Bueno, es momento de crear el mtodo que propiamente recupera todos los datos a
mostrar en la lista desde la base de datos, dicho mtodo se llamar getAllData(), esta
clase regresa un objeto List con la informacin a mostrar. Veamos la Imagen 94 donde se
muestra el cdigo de dicho mtodo.

50

Imagen 94

13. Hemos terminado la creacin de estos mtodos que nos ayudan a obtener los datos
(getAllData()) y a agegarlos al elemnto ListView (loadListViewData()), pero ahora es
necesario mandar llamar el mtodo loadListViewData() en el mtodo onCreate() (Imagen
95).

Imagen 95

14. Para agregar un evento a cada uno de los elementos de la lista ser necesario agregarle un
Listener a nuestro ListView, por lo cual estableceremos un setOnItemClickListener a
nuestro ListView. La accin que crearemos ser que muestre un mensaje con el texto del
tem seleccionado, este cdigo se muestra en la Imagen 96, esto tambin va en el mtodo
onCreate(), y no olvidemos de agregar las libreras adecuadas con los import.

Imagen 96

15. En la Imagen 97 se muestra un ejemplo de la activity ejecutndose en el momento de

hacer click en un tem.

51

Imagen 97

16. Es momento ahora de agregar datos al elemento Spinner, esto es muy similar al proceso
realizado para agregar la informacin a la ListView, en este caso utilizaremos los mismos
mtodos para obtener los datos puesto son los mismos a mostrar solo que en diferente
elemento.
17. En el mtodo loadListViewData() agregaremos un Adapter nuevo para el Spinner y este
Adapter ser agregado al Spinner, el cdigo de cmo queda ahora el mtodo
loadListViewData() es mostrado en la Imagen 98.

Imagen 98

18. Creamos la variable global del tipo Spinner para crear el enlace con el elemento en el
layout y poder manejarlo desde el cdigo y agregarle sus eventos, ver Imagen 99.

52

Imagen 99

19. Ahora en el mtodo OnCreate() es cuando se genera el enlace del objeto Spinner con el
layout.

Imagen 100

20. Es momento de ahora si ya de agregar un evento al Spinner para que podamos interactuar
con l. El evento es disparado en el momento en el que un tem del Spinner es
seleccioando, esto lo podemos ver mejor en la Imagen 101, no olvidemos de agregar los
imports necesarios ni de seguir las sugerencias que da el IDE (Eclipse), y agregar los
mtodos que faltan.

Imagen 101

21. En las Imgenes 102 y 103 vemos el resultado de como se ve el Spinner y del resultado de
seleccionar un tem.

53

Imagen 102

Imagen 103

Reutilizacin de layouts y modificacin de interfaces programticamente

Android nos da la posibilidad de reutilizar layouts esto con la finalidad de ahorrar tiempo en el
diseo de nuestras interfaces. Es muy comn que cuando se disea una interfaz existan partes de
la interfaz que sean repetidas en varias pantallas (como pueden ser los encabezados), o tambin
es probable que tengamos una pantalla de captura de informacin y que en nuestra aplicacin

54

necesitemos posteriormente modificar esta informacin o que solo necesitemos visualizarla, en

este caso no es necesario redisear otro(s) layout(s) sino que podramos reutilizar el layout
original y modificarlo desde cdigo segn sean las necesidades de nuestra aplicacin.
Veremos ahora un ejemplo prctico de lo antes dicho, agregaremos el layout activity_carga.xml al
layout activity_listar.xml, esto con la finalidad de visualizar la informacin completa del alumno
seleccionado ya sea del Spinner o del ListView, pero esta informacin no ser editable. Bueno
manos a la obra:
1. Lo primero a realizar ser modificar el layout activity_listar.xml.
2. Para poder agregar un layout en otro existe una etiqueta especial que se llama include,
agregamos esta etiqueta dentro de las etiquetas Scrollview y LinearLayout y despus del
Spinner, veamos la Imagen 104 para comprobar cmo debe de estar colocada dicha
etiqueta, el atributo importante en este caso es layout="@layout/activity_carga" aqu se
indica cul ser el layout a incluirse.

Imagen 104

3. En la pantalla de diseo grfico se ve como muestra la Imagen 105.

55

Imagen 105

4. Y al momento de ejecutarse se ve como en la Imagen 106.

Imagen 106

5. Como se puede ver en la imagen anterior el formulario fue agregado pero est en un
modo en el cual es editable para lo cual modificaremos sus condiciones pero

56

programticamente para dejarlo no editable y adems quitar los botones de Aceptar y

Cancelar.
6. Para lograr esto debemos de agregar los objetos necesarios que coincidan con los
existentes con el layout y as poder modificarlos, (Imagen 107).

Imagen 107

7. Enlazar los objetos con los elementos del layout en el mtodo onCreate() (Imagen 108).

Imagen 108

8. El cdigo que muestra la Imagen 109 se aprecia cul es el mtodo para hacer invisible
algn elemento, en este caso los dos botones, y tambin podemos ver como dejar
inhabilitado un EditText y as no se pueda escribir en ellos, este cdigo debe de ser escrito
en el mtodo onCreate(). En el caso de los EditTexts lo que se hace es modificar tres de
sus atributos para que no puedan ser seleccionados al hacer touch en ellos, y tambin se
deshabilita el mtodo de entrada.

Imagen 109

9. Como vemos en la Imagen 110 ya no aparecen los botones y ya no son editables los
campos de texto.

57

Imagen 110

10. Ya tenemos listo nuestro formulario para recibir los datos del alumno seleccionado ya
sea en el ListView o en el Spinner para lo cual debemos de obtener el id del alumno
seleccionado, tambin recordemos que ya tenemos hecho el mtodo getInfoAlumno() en
la clase DatabaseSQL, dicho mtodo recibe de parmetro el id del alumno y nos regresa
toda la informacin de ese alumno que ser mostrada en el formulario.
11. Crearemos un mtodo nuevo que sea llamado cuando sea seleccionado alguno de los
alumnos, este mtodo recibir como parmetro la etiqueta del texto que aparece en el
ListView o en el Spiner del alumno seleccionadoy tendr por nombre getInfo(). Esta
etiqueta es importante porque es de aqu de donde obtendremos el id verdadero del
alumno, para realizar esto haremos un substring, en este mtodo tambin mandaremos
llamar el mtodo getInfoAlumno() para obtener los datos del alumno y ya recuperado el
cursor poner los datos en los EditTexts del formulario pero mejor veamos la Imagen 111
para ver el cdigo de dicho mtodo.

58

Imagen 111

12. Para poder utilizar el mtodo previamente creado es necesario que sea llamado en el
momento preciso en el que se seleccionado alguno de los alumnos ya sea en el ListView o
en el Spiner para ser ms precisos agregamos la llamada en la declaracin de sus
respectivos mtodos, veamos el cdigo de la Imagen 112.

Imagen 112

13. El resultado de seleccionar un alumno es el que se muestra en la Imagen 113.

Imagen 113

59

Mapas en Andrid (Ggle Maps

Andrid API v2)
Esta versin presenta muchas novedades interesantes, de las que cabe destacar las siguientes:

Integracin con los Servicios de Google Play (Google Play Services) y la Consola de APIs.
Utilizacin a travs de un nuevo tipo especfico de fragment (MapFragment), una mejora
muy esperada por muchos.
Utilizacin de mapas vectoriales, lo que repercute en una mayor velocidad de carga y una
mayor eficiencia en cuanto a uso de ancho de banda.
Mejoras en el sistema de cach, lo que reducir en gran medida las famosas reas en
blanco que tardan en cargar.
Los mapas son ahora 3D, es decir, podremos mover nuestro punto de vista de forma que
lo veamos en perspectiva.

Pasos para instalar y/o configurar la API de Google Maps Android.

1. En primer lugar, dado que la API v2 se proporciona como parte del SDK de Google Play
Services, ser necesario incorporar previamente a nuestro entorno de desarrollo dicho
paquete. Haremos esto accediendo desde Eclipse al Android SDK Manager y descargando
del apartado de extras el paquete llamado Google Play Services.

Imagen 114

60

Tras pulsar el botn de Install y aceptar la licencia correspondiente el paquete quedar instalado
en
nuestro
sistema,
concretamente
en
la
ruta:
<carpeta-sdkandroid>/extras/google/google_play_services/. Recordemos esto porque nos
har falta ms adelante.
2. El siguiente paso ser obtener una API Key para poder utilizar el servicio de mapas de
Google en nuestra aplicacin.
3. La nueva API de mapas de Android se ha integrado por fin en la Consola de APIs de
Google, por lo que el primer paso ser acceder a ella.
4. Es probable que si nunca hemos entrado a la consola de APIS de Google nos pida que una
pantalla como la que se muestra a continuacin, por lo que hacemos click en el botn
Create Proyect, en caso de no ser as continuamos con el punto 5 directamente.

Imagen 115

5. Una vez hemos accedido, tendremos que crear un nuevo proyecto desplegando el men
superior izquierdo y seleccionando la opcin Create.

Imagen 116

61

6. Aparecer entonces una ventana que nos solicitar el nombre del proyecto. Introducimos
algn nombre descriptivo y aceptamos sin ms.

Imagen 117

7. Una vez creado el proyecto, accederemos a la opcin Services del men izquierdo.
Desde esta ventana podemos activar o desactivar cada uno de los servicios de Google que
queremos utilizar. En este caso slo activaremos el servicio llamado Google Maps
Android API v2 pulsando sobre el botn ON/OFF situado justo a su derecha.

Imagen 118

8. Ahora aceptamos los trminos de uso de Google.

Imagen 119

9. Una vez activado aparecer una nueva opcin en el men izquierdo llamada API Access.
Accediendo a dicha opcin tendremos la posibilidad de obtener nuestra nueva API Key
que nos permita utilizar el servicio de mapas desde nuestra aplicacin particular.

62

Imagen 120

10. Para ello, pulsaremos el botn Create new Android key. Esto nos llevar a un cuadro
de dilogo donde tendremos que introducir algunos datos identificativos de nuestra
aplicacin. En concreto necesitaremos dos: la huella digital (SHA1) del certificado con el
que firmamos la aplicacin, y el paquete java utilizado. El segundo no tiene misterio, pero
el primero requiere alguna explicacin. Toda aplicacin Android debe ir firmada para
poder ejecutarse en un dispositivo, tanto fsico como emulado. Este proceso de firma es
uno de los pasos que tenemos que hacer siempre antes de distribuir pblicamente una
aplicacin. Adicionalmentes, durante el desarrollo de la misma, para realizar pruebas y la
depuracin del cdigo, aunque no seamos conscientes de ello tambin estamos firmado la
aplicacin con un certificado de pruebas. Podemos saber en qu carpeta de nuestro
sistema est almacenado este certificado accediendo desde Eclipse al men Window
/Preferences y accediendo a la seccin Android / Build.

63

Imagen 121

11. Como se puede observar, en mi caso el certificado de pruebas est en la ruta

C:\Users\NELSONCROZBY\.android\debug.keystore. Pues bien, para
obtener nuestra huella digital SHA1 deberemos acceder a dicha ruta desde la consola de
comando de Windows y ejecutar los siguientes comandos:
C:\>cd C:\Users\NELSONCROZBY\.android\
C:\Users\NELSONCROZBY\.android>"C:\Program Files (x86) \Java \jdk1.7.0_07
\bin\keytool.exe"
-list
-v
-keystore
debug.keystore
-alias
androiddebugkey -storepass android -keypass android

instalacin de Java est en la ruta C:\Program

Files\Java\jdk1.7.0_07. Si no es as slo debes sustituir sta por la correcta. Esto
nos deber devolver varios datos del certificado, entre ellos la huella SHA1.

12. Suponiendo

que

tu

64

Imagen 122

13. Pues bien, nos copiamos este dato y lo aadimos a la ventana de obtencin de la API Key
donde nos habamos quedado antes, y a continuacin separado por un punto y coma
aadimos el paquete java que vayamos a utilizar en nuestra aplicacin, que en mi caso
ser com.demo.proyectodemo.

Imagen 123

14. Pulsamos el botn Create y ya deberamos tener nuestra API Key generada, podremos
verla en la pantalla siguiente dentro del apartado Key for Android Apps (with
certificates). Apuntaremos tambin este dato para utilizarlo ms tarde.

65

Imagen 124

15. Con esto ya habramos concluido los preparativos iniciales necesarios para utilizar el
servicio de mapas de Android en nuestras propias aplicaciones, por lo que modificaremos
nuestro proyecto de ejemplo en Eclipse.
16. lo primero que haremos ser aadir al fichero AndroidManifest.xml la API Key que
acabamos de generar. Para ello aadiremos al fichero, dentro de la etiqueta
<application>, un nuevo elemento <meta-data> con los siguientes datos:

Imagen 125

17. Como valor del parmetro android:value tendremos que poner nuestra API Key
recin
generada.
En
mi
caso
mi
API
Key
generada
es:
AIzaSyDmw0rDncgMS1TbUkaXavswHdZRdMbyw6w.
18. Siguiendo con el AndroidManifest, tambin tendremos que incluir una serie de permisos
que nos permitan hacer uso de los mapas. En primer lugar tendremos que definir y utilizar
un permiso llamado tu.paquete.java.permission.MAPS_RECEIVE, estas
etiquetas deben de ser colocadas antes de la etiqueta <application, en mi caso
quedara de la siguiente forma:

Imagen 126

19. Adems, tendremos que aadir permisos adicionales que nos permitan acceder a los
servicios web de Google, a Internet, y al almacenamiento externo del dispositivo (utilizado
para la cach de los mapas), estos permisos son colocados inmediatamente despus de los
anteriores:

66

Imagen 127

20. Por ltimo, dado que la API v2 de Google Maps Android utiliza OpenGL ES versin 2,
deberemos especificar tambin dicho requisito en nuestro AndroidManifest aadiendo un
nuevo elemento <uses-feature> inmediatamente despus de los permisos
anteriores:

Imagen 128

21. Una vez hemos configurado todo lo necesario en el AndroidManifest, y antes de escribir
nuestro cdigo, tenemos que seguir aadiendo elementos externos a nuestro proyecto. El
primero de ellos ser referenciar desde nuestro proyecto la librera con el SDK de Google
Play Services que nos descargamos al principio de este tutorial. Para ello, desde Eclipse
podemos importar la librera a nuestro conjunto de proyectos mediante la opcin de
men File / Import / Existing Android Code Into Workspace.
Como ya dijimos este paquete se localiza en la ruta <carpeta-sdkandroid>/extras/google/google_play_services/libproject/google
-play-services_lib.

Imagen 129

67

22. Tras seleccionar la ruta correcta dejaremos el resto de opciones con sus valores por
defecto y pulsaremos Finish para que Eclipse importe esta librera a nuestro conjunto de
proyectos.
23. El siguiente paso ser referenciar esta librera desde nuestro proyecto de ejemplo. Para
ello iremos a sus propiedades pulsando botn derecho / Properties sobre nuestro
proyecto y accediendo a la seccin Android de las preferencias. En dicha ventana podemos
aadir una nueva librera en la seccin inferior llamada Library. Cuando pulsamos el botn
Add nos aparecer la librera recin importada y podremos seleccionarla
directamente, aadindose a nuestra lista de libreras referenciadas por nuestro proyecto.

Imagen 130

24. Como ltimo paso de configuracin de nuestro proyecto, si queremos que nuestra
aplicacin se pueda ejecutar desde versiones antiguas de Android (concretamente
desde la versin de Android 2.2) deberemos asegurarnos de que nuestro proyecto incluye
la librera android-support-v4.jar, que debera aparecer si desplegamos las seccin
Android Dependencies o la carpeta lib de nuestro proyecto.

68

Imagen 131

25. Las versiones ms recientes de ADT incluyen por defecto esta librera en nuestros
proyectos, pero si no est incluida podis hacerlo mediante la opcin del men contextual
Android Tools / Add Support Library sobre el proyecto, o bien de forma manual.

Pasos para construir una aplicacin bsica usando la API de Google Maps
Y con esto hemos terminado de configurar todo lo necesario. Ya podemos escribir nuestro cdigo.
Y para este primer ejemplo sobre el tema nos vamos a limitar a mostrar un mapa en la pantalla
principal de la aplicacin. Posteriormente veremos cmo aadir otras opciones o elementos al
mapa.
1. Para esto tendremos simplemente que aadir el control correspondiente al layout de
nuestra actividad en este caso es activity_mapa.xml. En el caso de la nueva API v2 este
control se aadir en forma de fragment (de ah que hayamos tenido que incluir la
librera android-support para poder utilizarlos en versiones de Android anteriores a la 3.0)
de
un
determinado
tipo
(concretamente
de
la
nueva
clase
com.google.android.gms.maps.SupportMapFragment),
quedando
por
ejemplo de la siguiente forma (ver Imagen 132):

Imagen 132

Grficamente el diseo de la interfaz se vera como se muestra en la Imagen 133.

69

Imagen 133

2. Por supuesto, dado que estamos utilizando fragments, la actividad MapasActivity.java

tambin tendr que extender a FragmentActivity (en vez de simplemente Activity como
es lo normal). Usaremos tambin la versin de FragmentActivity incluida en la librera
android-support para ser compatibles con la mayora de las versiones Android actuales.
Veamos la Imagen 134 para ver cmo queda el cdigo de nuestra activity.

Imagen 134

Con esto, ya podramos ejecutar y probar nuestra aplicacin. En mi caso las pruebas las he
realizado sobre un dispositivo fsico con Android 2.3.5 ya que por el momento parece haber
algunos problemas para hacerlo sobre el emulador. Por tanto tendremos que conectar nuestro

70

dispositivo a la PC mediante el cable de datos e indicar a Eclipse que lo utilice para la ejecucin de
la aplicacin.
En la Imagen 135 podemos ver una captura en pantalla de la ejecucin del cdigo que
previamente hemos creado.

Imagen 135

Interactuando con el Mapa (pasar coordenadas)

En el ejemplo anterior todo lo que hicimos fue lo necesario para configurar la API de Google y
poder cargar un mapa en nuestra pantalla, pero ahora lo que se pretende hacer es ya interactuar
con el mapa, en qu consistir esta interaccin, pues lo primero ser lograr que el mapa se
posicione sobre un punto en especfico y a este punto le colocaremos unos markers
personalizado junto a algn tipo de mensaje.
1. Bueno lo primero que haremos ser abrir el archivo MapasActivity.java para modificarlo,
de ahora en adelante en este ejemplo todo lo que hagamos ser en esta clase.
2. Como en este ejemplo ser algo demostrativa y simple pondremos las coordenadas de dos
puntos de forma manual en unas variables globales del tipo LatLng, en posteriores
ejemplos veremos cmo recuperar la posicin actual a travs del GPS del celular por lo
pronto veremos la Imagen 136 y observamos la forma de declarar las coordenadas.

71

Imagen 136

3. Ahora pasaremos a inicializar la variable del tipo GoogleMap declarada y el elemento

respectivo del layout. En la siguiente Imagen podemos ver cmo se hace (recuerda que
esto se hace en el mtodo onCreate):

Imagen 137

4. Posteriormente agregaremos los markers para cada uno de los puntos que crearemos en
el mapa y tambin pondremos el zoom de inicio sobre el mapa y declararemos un efecto
al momento de hacer zoom sobre el mapa, ver Imagen 138 para el cdigo.

Imagen 138

Lcalizacin gegrafica en Andrid

La localizacin geogrfica en Android es uno de esos servicios que, a pesar de requerir poco cdigo
para ponerlos en marcha, no son para nada intuitivos ni fciles de llegar a comprender por
completo. Y esto no es debido al diseo de la plataforma Android en s, sino a la propia naturaleza
de este tipo de servicios. Por un lado, existen multitud de formas de obtener la localizacin de un
dispositivo mvil, aunque la ms conocida y popular es la localizacin por GPS, tambin es posible
obtener la posicin de un dispositivo por ejemplo a travs de las antenas de telefona mvil o
mediante puntos de acceso Wi-Fi cercanos, y todos cada uno de estos mecanismos tiene una
precisin, velocidad y consumo de recursos distinto. Por otro lado, el modo de funcionamiento de
cada uno de estos mecanismos hace que su utilizacin desde nuestro cdigo no sea todo lo directa
e intuitiva que se deseara. Iremos comentando todo esto a lo largo del documento, pero vayamos
paso a paso.

Qu mecanismos de localizacin tenemos disponibles?

72

Lo primero que debe conocer una aplicacin que necesite obtener la localizacin geogrfica es qu
mecanismos de localizacin (proveedores de localizacin, o location providers) tiene disponibles
en el dispositivo. Como ya hemos comentado, los ms comunes sern el GPS y la localizacin
mediante la red de telefona, pero podran existir otros segn el tipo de dispositivo.
La forma ms sencilla de saber los proveedores disponibles en el dispositivo es mediante una
llamada al mtodo getAllProviders() de la clase LocationManager, clase principal en la
que nos basaremos siempre a la hora de utilizar la API de localizacin de Android. Para ello,
obtendremos
una
referencia
al
location
manager
llamando
a
getSystemService(LOCATION_SERVICE), y posteriormente obtendremos la lista de
proveedores mediante el mtodo citado para obtener la lista de nombres de los proveedores:

Imagen 139

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, etc). 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.

Imagen 140

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

73

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:

Imagen 141

Tras esto, podremos utilizar los mtodos getProviders() o getBestProvider() para

obtener la lista de proveedores que se ajustan mejor al criterio definido o el proveedor que mejor
se ajusta a dicho criterio, respectivamente. Adems, ambos mtodos reciben un segundo
parmetro que indica si queremos que slo nos devuelvan proveedores que estn activados
actualmente. Veamos cmo se utilizaran estos mtodos:

Imagen 142

Con esto, ya tenemos una forma de seleccionar en cada dispositivo aquel proveedor que mejor se
ajusta a nuestras necesidades.

Est disponible y activado un proveedor determinado?

Aunque, como ya hemos visto, tenemos la posibilidad de buscar dinmicamente proveedores de
localizacin segn un determinado criterio de bsqueda, es bastante comn que nuestra
aplicacin est diseada para utilizar uno en concreto, por ejemplo el GPS, y por tanto
necesitaremos algn mecanismo para saber si ste est activado o no en el dispositivo. Para esta
tarea, la clase LocationManager nos proporciona otro mtodo llamado
isProviderEnabled() que nos permite hacer exactamente lo que necesitamos. Para ello,
debemos pasarle el nombre del provider que queremos consultar. Para los ms comunes tenemos
varias constantes ya definidas:

LocationManager.NETWORK_PROVIDER. Localizacin por la red de telefona.

LocationManager.GPS_PROVIDER. Localizacin por GPS.

De esta forma, si quisiramos saber si el GPS est habilitado o no en el dispositivo (y actuar en

consecuencia), haramos algo parecido a lo siguiente:

74

Imagen 143

En el cdigo anterior, verificamos si el GPS est activado y en caso negativo mostramos al usuario
un mensaje de advertencia. Este mensaje podramos mostrarlo sencillamente en forma de
notificacin de tipo toast,

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, etc.).
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 son ordenes) sobre cada cuanto tiempo o
cada cuanta distancia recorrida necesitaramos tener una actualizacin de la posicin.
Todo
esto
lo
vamos
a
realizar
mediante
una
llamada
al
requestLocationUpdates(), al que deberemos pasar 4 parmetros distintos:

Nombre del proveedor de localizacin al que nos queremos suscribir.

Tiempo mnimo entre actualizaciones, en milisegundos.
Distancia mnima entre actualizaciones, en metros.

75

mtodo

Instancia de un objeto LocationListener, que tendremos que implementar

previamente para definir las acciones a realizar al recibir cada nueva actualizacin de la
posicin.

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, es
importante comprender que tanto el tiempo como la distancia especificadas se entendern como
simples indicaciones o pistas para el proveedor, por lo que puede que no se cumplan de forma
estricta.
En cuanto al listener, ste ser del tipo LocationListener y contendr una serie de mtodos
asociados a los distintos eventos que podemos recibir del proveedor:

onLocationChanged(location). Lanzado cada vez que se recibe una actualizacin

de la posicin.
onProviderDisabled(provider). Lanzado cuando el proveedor se deshabilita.
onProviderEnabled(provider). Lanzado cuando el proveedor se habilita.
onStatusChanged(provider, status, extras). Lanzado cada vez que el
proveedor cambia su estado, que puede variar entre OUT_OF_SERVICE,
TEMPORARILY_UNAVAILABLE, AVAILABLE.

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:

Imagen 144

76

Como podemos 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().
En el mtodo mostrarPosicion() nos vamos a limitar a mostrar los distintos datos de la posicin
pasada como parmetro en los controles correspondientes de la interfaz, utilizando para ello los
mtodos proporcionados por la clase Location. En nuestro caso utilizaremos
getLatitude(), getAltitude() y getAccuracy() para obtener la latitud, longitud y
precisin respectivamente. Por supuesto, hay otros mtodos disponibles en esta clase para
obtener la altura, orientacin, velocidad, etc que se pueden consultar en la documentacin
oficial de la clase Location. Veamos el cdigo:

Imagen 145

Por qu comprobamos si la localizacin recibida es null? Como ya hemos dicho anteriormente,

no tenemos mucho control sobre el momento ni la frecuencia con la que vamos a recibir las
actualizaciones de posicin desde un proveedor, por lo que tampoco estamos seguros de tenerlas
disponibles desde un primer momento. Por este motivo, una tcnica bastante comn es utilizar la
posicin que devuelve el mtodo getLastKnownLocation() como posicin provisional de
partida y a partir de ah esperar a recibir la primera actualizacin a travs del
LocationListener. Y como tambin dijimos, la ltima posicin conocida podra no existir en
el dispositivo, de ah que comprobemos si el valor recibido es null. Para entender mejor esto, a
continuacin tenis la estructura completa del mtodo que lanzamos al comenzar la recepcin de
actualizaciones de posicin:

77

Imagen 146

Como se puede observar, al comenzar la recepcin de posiciones, mostramos en primer lugar la

ltima posicin conocida, y posteriormente solicitamos al GPS actualizaciones de posicin cada 30
segundos.
En las Imgenes 147 - 149 podemos ver la el diseo grfico y el archivo xml que utilizaremos para
la pantalla de la interfaz grfica.

78

Imagen 147

Imagen 148

79

Imagen 149

En las siguientes Imgenes 150 - 154 podemos ver el cdigo de los diferentes mtodos que
conforman nuestra activity TrazarActivity.java.

Imagen 150. Declaracin de variables globales.

80

Imagen 151. Mtodo onCreate()

Imagen 152. Mtodos trazarRuta() y mostrarDestino()

81

Imagen 153. Mtodo comenzarLocalizacion()

Imagen 154. Mtodos mostrarAvisoGpsDeshabilitado() y mostrarPosicion()

82