Curso Android

Desarrollo en Android por Luis Miguel Soria 1

DESARROLLO DE APLICACIONES EN

DISPOSITIVOS MÓVILES Por Juan Antonio Álvarez García, Luis Miguel Soria Morillo e Iván Reina Conde

Desarrollo en Android

Por Luis Miguel Soria


Índice de contenido

DESARROLLO DE APLICACIONES EN DISPOSITIVOS MÓVILES...........................................1

Por Juan Antonio Álvarez García, Luis Miguel Soria Morillo e Iván Reina Conde............................1 Desarrollo en Android..........................................................................................................................1 - El sistema operativo de Google: Android..........................................................................................4

- ¿Qué es Android?..........................................................................................................................4 - Estructura de Android....................................................................................................................4

- Programación en Android..................................................................................................................6 - Características de Android.............................................................................................................6 - Herramientas de desarrollo............................................................................................................7 - Componentes de una aplicación Android......................................................................................7 - Programación en Eclipse...............................................................................................................8

- Instalación de los programas necesarios...................................................................................8 - Creación de un proyecto...........................................................................................................9 - Creación de un emulador. ...................................................................................................................................................10 - Instalación de un dispositivo móvil para usarlo en el desarrollo. (Probado con HTC Magic). ...................................................................................................................................................11 - Hola Android..........................................................................................................................12

- Descripción de la aplicación del curso.............................................................................................20 - Interfaces gráficas en Android................................................................................................21

- Estructura de una interfaz en Android.........................................................................................21 - Views de nuestra aplicación........................................................................................................22 - Ejercicios. Interfaces de la aplicación.........................................................................................23

- Ejercicio 1:..............................................................................................................................23 - Ejercicio 2:..............................................................................................................................25 - Ejercicio 3:..............................................................................................................................25

- Actividades en Android....................................................................................................................28 - Creación de una actividad en Eclipse..........................................................................................28 - Uso de actividades.......................................................................................................................28 - Actividades especiales.................................................................................................................30 - Comunicación entre actividades..................................................................................................31 - Ejercicio. Actividades de la aplicación del curso........................................................................32

- Ejercicio 4:..............................................................................................................................33 -Menús y diálogos en Android...........................................................................................................34

- Creación y uso de menús.............................................................................................................34 - Creación y uso de diálogos..........................................................................................................35

- Secuencia para crear un AlertDialog......................................................................................36 - Secuencia para crear un Dialog..............................................................................................36

- Ejercicio. Creación de diálogos y menús en la actividad. Comunicación entre actividades.......37 - Ejercicio 5:..............................................................................................................................37 - Ejercicio 6:..............................................................................................................................39 - Ejercicio 7:..............................................................................................................................39 - Ejercicio 8:..............................................................................................................................40 - Ejercicio 9:..............................................................................................................................40

- Mapas en Android............................................................................................................................42 - La clase MapView.......................................................................................................................42


- Elementos de un MapView..........................................................................................................42 - Overlay....................................................................................................................................42 - ItemizedOverlay......................................................................................................................43 - MyLocationOverlay................................................................................................................44

- Ejercicio. Mapa de la aplicación del curso..................................................................................44 - Ejercicio 10:............................................................................................................................44 - Ejercicio 11:............................................................................................................................45 - Ejercicio 12:............................................................................................................................45

- GPS en Android................................................................................................................................47 - Descripción de las clases para la geolocalización.......................................................................47

- GeoPoint.................................................................................................................................47 - GeoCoder................................................................................................................................47 - Address...................................................................................................................................48 - Location..................................................................................................................................48 - LocationListener.....................................................................................................................48 - LocationManager....................................................................................................................48

- Ejercicio. GPS en la aplicación del curso....................................................................................49 - Ejercicio 13:............................................................................................................................49 - Ejercicio 14:............................................................................................................................50 - Ejercicio 15:............................................................................................................................53

- Bases de datos en Android...............................................................................................................54 - Creación de una base de datos.....................................................................................................54 - Uso de bases de datos..................................................................................................................56 - Ejercicio. Base de datos de la aplicación del curso. Finalizando la aplicación...........................56

- Ejercicio 16:............................................................................................................................56 - Ejercicio 17;............................................................................................................................57 - Ejercicio 18:............................................................................................................................59 - Ejercicio 19:............................................................................................................................60 - Ejercicio 20:............................................................................................................................60 - Ejercicio 21:............................................................................................................................60 - Ejercicio 22:............................................................................................................................61 - Ejercicio 23:............................................................................................................................62 - Ejercicio 24:............................................................................................................................63 - Ejercicio 25:............................................................................................................................63

- Extra 1: El simulador de GPS y cómo crear rutas para él................................................................64 - Extra 2: Configurar regiones para el funcionamiento del simulador GPS.......................................64


- El sistema operativo de Google: Android.

- ¿Qué es Android?.

Android es un sistema operativo para móviles del tipo smartphone y está orientado, sobre todo, a móviles táctiles. Android se basa en un kernel de Linux, la versión 2.6 exactamente. El sistema operativo además trae un paquete inicial de utilidades para el usuario, entre estas aplicaciones hay: - Cliente de correo electrónico. - Programa de SMS. - Calendario. - Mapas. - Explorador de Internet. - Organizador de contactos.

Android ha sido desarrollado por el grupo Open Handset Alliance (http://www.openhandsetalliance.com/) formado por más de 30 empresas de tecnología y móviles. Entre ellas se encuentra Google, con todo lo que ello conlleva, facilidad de programar en mapas o cualquier otra API de esta empresa, apoyo de una de las más grandes empresas del sector, tanto en la solución de problemas con la plataforma en la que desarrollamos, como en la posterior venta de la aplicación. Además, tenemos la seguridad de que este sistema operativo no será flor de un día y continuará expandiéndose por el mercado de la telefonía móvil.

Android ofrece un sistema de desarrollo totalmente abierto y gratuito al programador.

- Estructura de Android.

En la siguiente figura podemos observar la arquitectura del sistema operativo Android:

http://www.openhandsetalliance.com/


Los principales componentes del sistema operativo Android son:

- Aplicaciones: Todas escritas en un lenguaje Java adaptado para Android. Ya mencionamos, en el punto anterior, varias de ellas.

- Framework de aplicaciones: Los programadores pueden acceder a las mismas API que las aplicaciones creadas por Google para el móvil. La arquitectura de las aplicaciones de Android está orientada a una división en componentes que ayuda al aprovechamiento del mismo código en distintas aplicaciones.

- Librerías: Android incluye un conjunto de librerías C/C++ que usan varios componentes de su sistema operativo y que podemos usar desde el framework de Android. Entre ellas podemos encontrar librerías de gráficos 2D y 3D, librerías de bases de datos (SQLite), etc.

- Runtime de Android: Android incluye librerías base que dan casi todas las funcionalidades de las librerías base de Java. Android usa la máquina virtual Dalvik para correr sus aplicaciones, pudiendo, cada aplicación tener su propia instancia de la máquina virtual. Además, se ha optimizado el uso de recursos, por parte de la máquina virtual, para adaptarla a dispositivos con pocos recursos como los dispositivos móviles.

- Núcleo Linux: Como dijimos antes, el núcleo es la versión 2.6 de Linux, además el núcleo trabaja como capa traductora entre el hardware y el resto del software del móvil.


- Programación en Android.

- Características de Android.

Android es una plataforma neutral en cuanto al desarrollo de aplicaciones, es decir, el programador tiene las mismas posibilidades para crear una aplicación que Google o que cualquier empresa perteneciente al Open Handset Alliance. La siguiente lista destaca las características más importantes de Android:

- No existen costes de licencias, distribución o desarrollo.

- Acceso al hardware WiFi.

- Conexión GSM, EDGE y 3G para telefonía o transferencia de datos.

- API GPS fácil de utilizar.

- Control total sobre el hardware multimedia, pudiendo usar tanto la cámara como el

micrófono.

- API para el acelerómetro y el compás.

- Acceso total al almacenamiento del sistema.

- Acceso al explorador de Internet que es gratuito.

- Soporte total para aplicaciones que integran el uso de la API maps de Google.

- Gráficos 3D y 2D optimizados para hardware de móvil usando OpenGL ES.

- Un Framework que te permite el reciclaje de componentes, de una aplicación, para

varias aplicaciones y el reemplazo de aplicaciones nativas al sistema operativo. A destacar entre todas estas características es el soporte de Google con la API Google maps. Se pueden crear una gran cantidad de aplicaciones basadas en mapas de una forma fácil y potente, superando a cualquier otra opción en el mercado actual. Los servicios de localización de Android se basan en el GPS y en la localización mediante las antenas del operador móvil.


- Herramientas de desarrollo.

Existen una gran variedad de herramientas de desarrollo que nos aporta Android. A continuación, se listará las más importantes dando una pequeña descripción.

- El plugin de herramientas de desarrollo de Android: Es una extensión para la

plataforma Eclipse, permitiéndote desarrollar aplicaciones Android en ella.

- El emulador de Android: Es un simulador de móvil que se instala al instalar

Android en tu sistema y que te ayuda a poder probar tus aplicaciones.

- Configuraciones de dispositivos virtuales de Android: Son configuraciones de dispositivos que el programador puede crear en el emulador y que configuran su funcionamiento (programas instalados, skins, posibilidad de añadir tarjetas SD, etc.)

- Visor de Interfaces: Ayuda a poder crear las interfaces de nuestra aplicación,

dándonos la opción de ver el resultado de nuestro diseño de interfaces sin tener que ejecutar la aplicación.

- El monitor de depuración sobre Dalvik: Está integrado con la máquina virtual

Dalvik y se encarga de dar al programador todas las opciones de control sobre la máquina virtual.

- El puente de depuración de Android: Es la herramienta que te permite instalar

aplicaciones en el emulador y poder acceder a éste desde línea de comando, además da soporte a depuradores estándar, como puede ser el de Eclipse.

- Mksdcard: Te ayuda a crear una imagen de disco para que el emulador la tome

como su tarjeta SD.

- Componentes de una aplicación Android.

Debido a que Android permite el uso de elementos de unas aplicaciones por parte de otras sin necesidad de agregar el código del elemento, el sistema debe ser capaz de arrancar una aplicación cuando cualquier parte de ésta sea llamada. Así que las aplicaciones de Android no tienen sólo un punto de entrada si no que tendrán componentes que el sistema puede arrancar cuando sea necesario. Los 4 tipos de componentes son:

- Actividades: Las actividades son como aplicaciones dentro de una aplicación,

muestran al usuario una interfaz y controlan las acciones que tome éste dentro de esa interfaz. Las actividades son independientes unas de otras y todas son subclases de la clase Activity.


Las aplicaciones pueden componerse de una o varias actividades. Cada actividad tiene una ventana en la cual mostrar su interfaz, también independiente del resto de las ventanas de otras actividades. Las interfaces se componen de objetos llamados Views. Un objeto View puede ser, desde un botón hasta un recuadro mostrando Google maps. Estos objetos representan la interactividad del usuario con la aplicación.

- Servicios: Los servicios a diferencia de las actividades no ofrecen la opción de una

interfaz. Estos se ejecutan en segundo plano por un tiempo indefinido. Por lo demás, se podría decir que son iguales a las actividades. En este curso no se usarán este tipo de componentes, y directamente usaremos clases que implementen hilos secundarios para ejecución en segundo plano.

- Receptores de broadcast: Son componentes que sólo escuchan a mensajes de

otros y dependiendo del mensaje ejecutan un proceso. Estos mensajes son enviados normalmente por las aplicaciones, pueden ser desde avisos del sistema operativo a mensajes creados por el propio programador. Así podremos usar los receptores de broadcast como medio para que, dependiendo del caso, nuestra aplicación ejecute otra aplicación distinta.

- Proveedores de contenido: Los proveedores de contenido son los componentes

que guardan la información en disco de una aplicación, así esta información puede ser usada por otras aplicaciones. Los datos de los proveedores pueden estar guardados en bases de dato tipo SQLite, en los directorios del móvil, o en cualquier otro tipo de formato.

- Programación en Eclipse.

- Instalación de los programas necesarios.

Para realizar este curso necesitaremos los siguientes programas (versiones de finales de 2009).

• Eclipse IDE 3.5 (Galileo): http://www.eclipse.org/downloads/

• JDK 6: http://java.sun.com/javase/downloads/index.jsp

• Android SDK 2.1: http://developer.android.com/sdk/download.html?v=android-sdk_r04- windows.zip

Primero instalaremos el JDK de java y tras ello extraeremos los archivos comprimidos de Eclipse y de Android en las carpetas que creamos convenientes.

Ahora, debemos de añadir Android al PATH de Windows. Para ello hacemos botón derecho sobre Mi PC y vamos a la pestaña de “Opciones avanzadas”. Pulsamos sobre “Variables de entorno” y en la parte de variables de sistema, modificamos la variable path,

http://www.eclipse.org/downloads/

http://java.sun.com/javase/downloads/index.jsp

http://developer.android.com/sdk/download.html?v=android-sdk_r04-windows.zip




añadiendo la ruta completa a la carpeta /tools dentro del SDK de Android.

Tras estos pasos de instalación arrancamos Eclipse. Lo primero que haremos será instalar el plugin de desarrollo de Android o ADT para Eclipse. Para ello, vamos a Help/Install new software y en la nueva ventana que aparece pulsamos sobre “Add...”. Aquí ponemos un nombre para el repositorio de donde vamos a descargar el plugin y metemos la dirección https://dl-ssl.google.com/android/eclipse/ . Tras añadir la nueva dirección deberemos de ver como nos aparece en la ventana de software disponible el plugin de Android o ADT. Lo seleccionamos y pulsamos sobre “Next”. Para las siguientes ventanas pulsamos “Next” hasta finalizar la instalación. Para finalizar reiniciamos Eclipse.

Cuando Eclipse arranca de nuevo necesitamos, configurar la localización del SDK de Android. Para ello vamos a Window/Preferences y pulsando sobre Android en la parte izquierda. En el menú que nos aparece pulsamos sobre Browse... y seleccionamos la carpeta donde se encuentra el SDK. Pulsamos sobre Apply y cerramos la ventana.

Como paso final debemos de lanzar el ADT y desde él en Aviable Packages instalar la última versión (o la que queramos usar) del SDK de Android.

- Creación de un proyecto.

Necesitaremos tener instalado las últimas versiones de Java, Eclipse y Android. Cuando tengamos instalado todo lo necesario para desarrollar nuestra aplicación, arrancaremos Eclipse, marcando una dirección para el directorio de trabajo. Con eclipse arrancado, realizaremos los siguientes pasos:

1. Vamos a la zona de menú File/New/Android Project y pulsamos en este último.

2. En la siguiente ventana configuramos las opciones del proyecto, como son su

nombre, el nombre de la actividad, nombre del paquete, etc.

https://dl-ssl.google.com/android/eclipse/


0

Cuando hemos pulsado “Finish” ya tenemos nuestro proyecto.

- Creación de un emulador.

Para crear un emulador en el que ejecutar nuestras aplicaciones, necesitamos acceder al “Android SDK and AVD Manager” dentro de Eclipse. Para abrir esta venta, podemos, o pulsar sobre el icono de teléfono en la parte superior izquierda de la ventana de Eclipse, o bien abrirlo desde el menú Window.


1

Dentro de ésta ventana pulsamos sobre Virtual Devices y después sobre el botón New... En la siguiente ventana que aparece debemos definir las características del emulador que vamos a crear (nombre, resolución, a que servicios tendrá acceso, memoria SD, etc.), tras configurar el emulador pulsaremos sobre Create AVD y ya tendremos nuestro emulador creado.

- Instalación de un dispositivo móvil para usarlo en el desarrollo. (Probado con HTC

Magic).

Para los que tengan un dispositivo móvil con sistema operativo Android, siempre tienen la recomendable opción de desarrollar sus aplicaciones usando éste como sustituto del emulador.


2

Para instalar el dispositivo móvil, primero necesitaremos el driver de Windows. El driver lo podemos descargar con el “Android SDK and AVD Manager" que antes usamos para instalar el emulador. Tenemos que abrir éste plugin y en él pulsamos sobre Available Packages. Buscamos el controlador, que tendrá que venir con un nombre parecido a “Usb Driver package, revision X”, lo seleccionamos y pulsamos sobre el botón Install Selected. El plugin de desarrollo de Android te habrá creado en la carpeta del SDK un directorio con el nombre “Usb_driver”. Donde se encuentra el driver para el dispositivo móvil.

Con el driver ya descargado, debemos ahora conectar el dispositivo móvil al ordenador. Primero, antes que nada, deberemos asegurarnos que nuestro móvil Android está configurado para permitir depuración de aplicaciones en él. Hecho esto conectamos el móvil. Cuando salga el menú de instalación de nuevo hardware de Windows pulsamos sobre “Instalar desde una lista o lugar” y pulsamos Siguiente. En el siguiente menú seleccionamos manualmente el driver desde la dirección de nuestro SDK y pulsamos Siguiente para finalizar la instalación.

- Hola Android.

Para hacer nuestra primera aplicación en Android, vamos a crear un proyecto para Android en Eclipse. Tenemos que pulsar sobre el menú “File/New/Android Project” donde nos aparecerá una ventana para la creación del proyecto.


3

En esta ventana debemos de darle un nombre al proyecto (HolaAndroid), seleccionar una versión destino, que en nuestro caso será “Android 2.1” y darle nombre tanto a la aplicación como al paquete y a la actividad principal del programa (en nuestro caso podemos darles HolaAndroid, curso.android.holandroid y HolaAndroid respectivamente). La versión mínima permitida, la configuraremos a 4. Hay que tener en cuenta que si decimos que la versión mínima permitida es N, la aplicación deberá funcionar perfectamente desde N hasta la versión del SDK usado por la aplicación.

Tras toda la configuración de nuestro proyecto, pulsamos sobre Finish.

Ya tenemos el proyecto creado. Si vamos a la izquierda, en el explorador de paquetes de


4

Eclipse podemos encontrar la estructura de carpetas y ficheros que forma nuestro proyecto. En “src/curso.android.holaandroid” nos aparecerá el fichero java de nuestra actividad. Pulsando dos veces sobre él se visualizará en pantalla.

Antes de entrar a comentar el código que nos aparece nos centramos en la parte izquierda de la pantalla donde nos aparece la siguiente imagen.


5

Vamos a explicar un poco más en detalle algunas cosas de las que aparecen:

– La carpeta “res” y “assets”, son carpetas donde guardaremos nuestros recursos del

programa, desde imágenes hasta cadenas de texto, pasando por xml, tipos de colores... (Nosotros no usaremos la carpeta “assets” ya que las dos carpetas se usan para recursos y, en principio, tienen casi la misma funcionalidad. La carpeta “res” se puede acceder directamente con un método en el código y se compila junto a la aplicación y la carpeta “assets” debes crear un objecto administrador para acceder a ella).

Aunque podemos organizar nuestros recursos como queramos, por defecto, se organizan de la siguiente forma:

– Carpeta anim: Aquí se guardan las animaciones de la aplicación. Suelen ser

creadas con ficheros XML.

– Carpeta drawable: Aquí se guardan las imágenes usadas en la aplicación. En el

código se puede acceder a esta carpeta mediante la instrucción


6

mContext.getResources().getDrawable(R.drawable.imageId).

– Carpeta layout: Aquí se guardan los ficheros xml que representan las interfaces de cada actividad de la aplicación.

– Carpeta values: Distintos tipos de recursos, suele contener ficheros XML del

tipo:

– arrays.xml: Para arrays de datos.

– colors.xml: Para guardar distintos tipos de colores. Se puede acceder en código a éste fichero mediante Resources.getDrawable() and Resources.getColor().

– strings.xml: Aquí se pueden definir los textos que aparezcan en la herramienta, como por ejemplo texto de botones o de etiquetas.

– styles.xml: Aquí se definen los los estilos para nuestra aplicación.

– Carpeta xml: Otro tipo de XML que cree el programador y que se pueden acceder en código mediante Resources.getXML().

– Carpeta raw: Cualquier otro tipo de fichero que son accesibles en código mediante Resources.openRawResource().

Una forma rápida de tener acceso rápido en código a todos los recursos que contienen estas carpetas es directamente accediendo a sus Ids (cada recurso dentro de cada fichero dentro de cada carpeta distinta, tiene una ID) mediante

la instrucción R.IdContenedorRecurso.IdRecurso que nos devuelve un identificador único de un recurso en concreto y que muchas de las clases de la SDK de Android admiten como sustituto del recurso en sí en sus métodos.

– El fichero AndroidManifest.xml contiene información referida al proyecto en sí y a la

organización de las actividades. Este fichero no puede faltar en ninguna aplicación Android ya que da información de la aplicación al sistema cuando se ejecuta en éste. Algunas funcionalidades del manifiesto son:

– Contiene el nombre del paquete para la aplicación y que le sirve al sistema como identificador de la aplicación.

– El manifiesto describe los componentes de la aplicación (Actividades, Servicios, Proveedores de contenido,...). Así el manifiesto guarda las capacidades de cada componente para que la aplicación sepa como ejecutarlos y qué condiciones son necesarias para hacerlo.

– En el manifiesto se declaran los permisos que necesita la aplicación sobre componentes protegidos del sistema operativo y sobre la API de Android.

Volviendo a la creación de nuestra primera aplicación, habíamos acabado de crear el proyecto, el código que tenemos en el fichero java es:

package curso.android.HolaAndroid;

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

public class HolaAndroid extends Activity {


7

/** Called when the activity is first created. */

@Override public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState); setContentView(R.layout.main);

} }

Como vemos nuestra clase HolaAndroid implementa la clase Activity que como ya explicamos antes es el componente principal de una aplicación. Dentro de la clase tenemos el método onCreate, que se ejecutará cuando la actividad comience por primera vez a ejecutarse (esto será cuando lo haga la aplicación). El método setContentView se encarga de representar la interfaz, pasada como R.layout.main, de la actividad.

Pasaremos ahora a crear esa interfaz que se muestra en nuestra Actividad. Para ello abrimos el fichero main.xml dentro de res/layout. Podemos ver como se nos abre un editor especial para interfaces, donde podemos crear nuestras interfaces sin tener que escribir pesado código (aunque también podemos hacerlo de esta manera), en vez de ello arrastrando los Views a la pantalla que aparece y configurando sus propiedades podremos obtener la interfaz que buscamos.

Para crear nuestro programa HolaAndroid necesitaremos un TextView que mostrará nuestro saludo. Como vemos ya viene añadido por defecto dentro del proyecto. Vamos a observar un poco más de cerca el XML del layout.

<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent"

http://schemas.android.com/apk/res/android


8

>

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

</LinearLayout>

Vemos que el primer objeto que está descrito en el XML es un LinearLayout. Este tipo de objeto tiene la función de organizar al resto de Views que se inserten en la interfaz (ya hablaremos de él más adelante). El siguiente objeto, que es hijo de LinearLayout, es un TextView, el cual tiene la función de presentar texto en pantalla (también hablaremos de él más adelante). En cuanto a las propiedades de cada elemento dentro del XML, hay que tener claro que todas empiezan con la etiqueta android y que, al menos, todo objeto debe de contener las propiedades android:layout_width y android:layout_height.

Lo último que nos queda por hacer es arrancar la aplicación en el emulador o en el dispositivo móvil (depende de lo que estemos usando para depurar ésta). Vamos al menú Run/Run Configurations donde vamos a crear nuestra configuración de ejecución. Dentro de la nueva ventana pulsamos con botón derecho sobre Android Application y pulsamos sobre New.


9

Se nos crea una nueva configuración para ejecutar la aplicación, dentro de ésta escribimos un nombre y seleccionamos el proyecto que se ejecutará (pulsando sobre Browse), en nuestro caso será HolaAndroid. En la pestaña Target seleccionamos el dispositivo sobre el que se ejcutará nuestra aplicación. Si seleccionamos el dispositivo móvil, tendremos que escribir en el campo Additional Emulator Command Line Options, el comando “-d”, para marcar que es un dispositivo externo. Ya tenemos todo configurado, así que pulsamos sobre Run para ejecutar la aplicación. Así debería de quedar nuestro HolaAndroid en nuestro emulador/móvil.


0

- Descripción de la aplicación del curso.

Durante los siguientes puntos teóricos del curso, vamos a ir desarrollando una aplicación en la que podamos aplicar los conocimientos que vamos a ir adquiriendo. Esto servirá para reafirmar los conceptos aprendidos y para explicar de una forma mas entretenida el funcionamiento de la SDK de Android.

La aplicación a desarrollar se basará en el uso de mapas y de geolocalización, y su objetivo será mostrar a los amigos que el usuario agregue a la aplicación, en un mapa para que el usuario pueda saber donde se encuentran en cualquier momento.

La aplicación dispondrá de opciones de configuración, así podremos ver cómo funcionan los menús y las listas de opciones. Algunas de estas opciones serán, el tipo de vista de mapa, la distancia máxima para buscar amigos, el tiempo de refresco para la posición de los amigos...

Además añadiremos otro tipo de funcionalidades que no tendrán un uso práctico, sino más bien un uso académico. Por ejemplo, añadiremos una barra de búsqueda de lugares y explicaremos como realizar el proceso de búsqueda hasta llegar a “pinchar” una chincheta donde se encuentra el lugar.

La aplicación usará un servidor SOAP que guardará las posiciones actualizadas de los usuarios del sistema. Las conexiones al servidor SOAP, no se explicarán en el curso, aunque si que se dará en la solución de la aplicación la clase que realiza las conexiones con el servidor.

La aplicación se construirá a base de ejercicios que iremos realizando en cada tema, cada ejercicio tendrá una solución que se enviará al alumno al acabar el tiempo del ejercicio.


1

- Interfaces gráficas en Android.

- Estructura de una interfaz en Android.

La interfaz de usuario, en una aplicación Android,está formada por Views. La clase View sirve como la clase base para unos widgets que ofrecen objetos totalmente implementados para ser usados en la interfaz (estos widgets pueden ser botones, cuadros de texto, listas de elementos, listas desplegables,…). Aparte de la clase View existe otra clase que también es unidad básica de la interfaz, esta clase es ViewGroup, clase base para los layouts, que ofrecen distintos tipos de capas organizadas para distribuir los objetos (lineal, relativa, tabular, etc.) Toda la interacción del usuario con la interfaz será soportada por los objetos tipo View, siendo dentro de estos donde tendremos que implementar los eventos relacionados con las acciones del usuario dentro la interfaz. En la siguiente imagen podemos ver una jerarquía típica de clases dentro de una interfaz:

Los objetos Views siempre han de ser hijos de objetos ViewGroup, por lo tanto, siempre hemos de comenzar el diseño de la interfaz con un objeto ViewGroup, a partir de ahí, se pueden hacer los árboles que queramos para organizar la interfaz. Todo este árbol se implementa en archivos XML, donde cada elemento del XML es un objeto View o ViewGroup y los atributos del elemento son las propiedades de los objetos. Así para que Android cargue una interfaz, solo tendrá que leer este archivo e iniciar los objetos ahí marcados. Un ejemplo simple de un archivo XML sería:

<?xml versión="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" >

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

http://schemas.android.com/apk/res/android


2

android:layout_height="wrap_content" android:text="Hello, I am a TextView" />

<Button android:id="@+id/button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Hello, I am a Button" />

</LinearLayout>

- Views de nuestra aplicación.

Vamos a comentar los Views más importantes que vamos a usar dando una pequeña descripción de cada uno. Tras ello veremos como acceder a ellos en código y como controlar los eventos que generan por código.

– LinearLayout: Este tipo de layout añade cada View hijo en una linea recta, se puede elegir entre hacerlo en horizontal o en vertical. Dentro de un LinearLayout podemos configurar un “peso” para cada View dentro de él, que servirá para asignar a cada View hijo un tamaño que pueden tomar en pantalla.

– RelativeLayout: Usando este tipo de layout podemos definir la posición de cada View hijo respecto al resto de Views hijos y respecto al padre y el borde de pantalla.

– Button: Este tipo de View representa un botón en pantalla.

– TextView: Este tipo de View representa una etiqueta en pantalla.

– EditText: Este tipo de View representa un texto editable por el usuario.

– MapView: Este tipo de View representa un mapa que usa Google maps. Será explicado más adelante en el curso.

Para poder acceder a cualquier View que tengamos en una interfaz, en el código, deberemos de ejecutar la siguiente línea:

View v = ( View ) findViewById( R.id.view_id );

Con esto hemos recogido el View con id igual a view_id y ahora podemos acceder, tanto a sus propiedades, como a sus eventos de interfaz.

Los Views tiene muchos tipos de métodos y de propiedades que usaremos, pero no entraremos ahora a explicarlos (se irá explicando en el curso cuando sea necesario).

Para usar los eventos de un View y así poder hacer interfaces dinámicas y que ejecuten procesos, según desee el usuario, deberemos de implementarlos de la siguiente forma.

v.eventoInterfaz( new InterfazImplementaEvento() {

métodoParaEjecucciónEvento( parámetrosEntrada ) {

Ejecución del evento.


3

}

});

Como vemos lo que hemos hecho es implementar la interfaz del evento, para que así se ejecute el proceso deseado cuando el evento se produzca en el View v.

Un ejemplo, para entender mejo esto, sería: //Primero tenemos que recoger los botones creados en main.xml

final Button entrar = (Button) findViewById(R.id.ButtonPresentacion1); final Button salir = (Button) findViewById(R.id.ButtonPresentacion2);

//Agregamos a cada botón un evento click para cuando se produzca su pulsación. entrar.setOnClickListener(new OnClickListener() {

/** Se llama a este método cuando se produzca el click en el botón.

* * @param v Será el View clickeado, en nuestro caso, un Button. */ @Override public void onClick(View v) { //Mostramos un diálogo para introducir el usuario y llamamos al lanzador //de la actividad ActividadMapa pasándole el nombre de usuario //introducido.

showDialog(0); }

}); salir.setOnClickListener(new OnClickListener() {

/** Se llama a este método cuando se produzca el click en el botón.

* * @param v Será el View clickeado, en nuestro caso, un Button. */

@Override public void onClick(View v) {

//Salimos de la aplicación. finish();

} });

- Ejercicios. Interfaces de la aplicación.

- Ejercicio 1:

Implementar la interfaz de la pantalla de presentación de nuestra aplicación en el curso.

Abrimos el proyecto ya creado de Aplicación curso que puedes encontrar en la carpeta de ésta documentación.

Con el proyecto ya abierto vamos a editar el fichero main.xml. Lo primero que tenemos que hacer es borrar el TextView que nos viene por defecto.

Ahora vamos a crear la interfaz intentando que se parezca lo más posible a la que


4

podemos ver en la siguiente imagen.

Pistas para poder hacer la interfaz:

– Hay que usar dos RelativeLayout. El primero contendrá a dos TextView y al segundo RelativeLayout, mientras que el segundo RelativeLayout contendrá a los botones.

– Usar la propiedad gravity para colocar cualquier View o cualquier texto de cualquier View.

– Usar la propiedad Text size para dar el tamaño al texto de un View, el tamaño viene dado en “sp” unidades.

– Usar la propiedad Text color para dar el color al texto.

– Usar las propiedades de Layout... para alinear los View.

– Para poner los textos de los Views usar los recursos que vienen con el proyecto (Ver fichero strings.xml dentro de res/values/). Para acceder a ellos escribiremos en la propiedad “@string/id_string”

– Cambiar las ids de los Views a unas que podamos reconocer más tarde. Una id se declara de la siguiente forma: “@+id/id_View”.


5

- Ejercicio 2:

Implementar el funcionamiento de la interfaz del ejercicio 1.

Vamos a abrir el fichero AplicacionCurso.java y guardaremos los Views de la interfaz en variables para después poder implementar sus eventos. Alguna pista:

– Acordarse de usar el método findViewById para acceder a la interfaz.

– Ctr+Shift+O cuando os falte un import en la clase y os lo importará sólo.

– Primero, siempre se guardan referencias a los Views de la interfaz y después se trabaja sobre esos objetos View.

– Usar la clase Toast para enviar mensajes por pantalla. Crear una instrucción del tipo:

Toast.makeText( NombreClase.this, TextoAMostrar, Toast.LENGH_SHORT).show();

Para el evento de pulsar sobre Cancelar llamaremos al método finish() que cierra nuestra aplicación.

- Ejercicio 3:

Crear la interfaz de la actividad que llevará el mapa.

Necesitamos crear un nuevo fichero XML de interfaz y agregarlo a la carpeta res/layout /. Para crear un fichero nuevo XML, pulsamos botón derecho sobre la carpeta del proyecto y en el menú desplegable pulsamos sobre New / File. Dentro de la nueva ventana que aparece seleccionamos la carpeta donde vamos a guardar el fichero (layout) y el nombre del fichero (escribir la extensión .xml). Hecho esto, pulsamos sobre Finish y ya tenemos el XML vacío añadido al proyecto.

Tras crear el nuevo fichero, lo abrimos, y Eclipse , automáticamente, abrirá el editor de layouts de la SDK de Android. La interfaz que vamos a crear debería de parecerse a la siguiente:


6

Para esta interfaz necesitaremos realizar un paso extra. Crear una clave de acceso para nuestra aplicación a Google maps (el elemento MapView en el XML de interfaz, posee una propiedad llamada android:apiKey donde hay que introducir la clave de acceso a Google maps).

Para crear la clave de Google maps, deberemos de realizar los siguientes pasos:

1. Crear la clave MD5 del certificado del SDK en modo Debug (como vamos a desarrollar la aplicación usaremos esta). Necesitamos para ello ejecutar el fichero keystore que tenemos por defecto para modo debug. La ruta por defecto, donde encontrar ese fichero, es C:\Document and Settings \ <usuario> \ .android \ debug.keystore. También podemos comprobar la localización de keystore mediante Eclipse es el menú Windows/Prefs/Android/Build. Cuando tenemos la ruta completa al fichero, deberemos de ejecutar el siguiente comando en consola para cread la clave MD5:

$ keytool -list -alias androiddebugkey -keystore <path_to_debug_keystore>.keystore -storepass android -keypass android

Este comando nos devolverá la deseada clave MD5 que deberemos de guardar


7

para crear nuestra clave de Google maps.

2. Cargamos la siguiente página web:

http://code.google.com/android/maps-api-signup.html

Necesitaremos tener una cuenta de Google (con una de Gmail basta). Introducimos la clave MD5 y pulsamos sobre Generate API Key. En la página que se abra, aparecerá la clave que necesitamos. Guardamos la clave.

Ahora ya podemos crear nuestra interfaz, aquí se pueden ver algunas pistas para ello:

– El layout que usaremos para nuestra interfaz será un RelativeLayout, dentro de él tendremos un elemento MapView, dos elementos ImageButton y un elemento EditText.

– Crear el elemento MapView desde el siguiente ejemplo:

<com.google.android.maps.MapView

android:id="@+id/mapa" android:layout_width="fill_parent" android:layout_height="fill_parent" android:clickable="true" android:fitsSystemWindows="true" android:apiKey="Tu_API_Key"/>

– Usar las propiedades de alineación para colocar los ImageButton y el EditText

donde querramos.

– Para cargar las imágenes en en los ImageButton usar la propiedad android:src, a las imágenes se accede con @drawable/menu_map y @drawable/menu_search.

– Un fondo transparente se consigue configurando la propiedad android:background a valor #00000000.

– Recordar poner ids a todos los elementos que vayamos a usar más adelante en código.

http://code.google.com/android/maps-api-signup.html


8

- Actividades en Android.

- Creación de una actividad en Eclipse.

Para crear una actividad en Eclipse hay que realizar dos pasos:

1. Primero deberemos de crear una clase que extienda a Activity. Pulsamos botón derecho sobre el paquete donde están nuestros archivos java y vamos a New/Class/ en la ventana que aparece deberemos de escribir un nombre para nuestra clase y hacerla que extienda de Activity, para ello, vamos a la propiedad superclass y escribimos Activity, sólo tendremos que pulsar ctrl + espacio para que aparezca la ruta de paquetes de la clase. Escrito el nombre de la clase y añadida la superclase sólo nos queda pulsar sobre Finish.

2. Ya tenemos creada nuestra nueva actividad, ahora debemos hacerle saber a la aplicación que existe una nueva actividad. Tenemos que añadirla en el manifiesto de la aplicación. Abrimos el manifiesto, y en la primera pestaña que aparece, en la parte de Application nodes pulsamos sobre Add... y seleccionamos Activity. Creado el nuevo nodo de nuestra aplicación, sólo tendremos que asignarle la clase que acabamos de crear. Pulsamos sobre el botón Browse... de la propiedad Name y añadimos nuestra clase creada.

Con estos dos rápidos pasos, ya tenemos creada una actividad, ahora veremos cómo funcionan las actividades y algunas actividades especiales que nos ayudarán a crear nuestra aplicación.

- Uso de actividades.

Ya se explicó que una actividad se podía considerar, casi, como una aplicación dentro de la aplicación que desarrollamos. Las actividades representan el proceso en ejecución que el usuario ve en el dispositivo móvil en un momento dado. Por lo tanto, una aplicación sólo puede tener a la vez una actividad en ejecución, esto provoca que las actividades tengan unos ciclos de vida y puedan pasar por diversos estados, mientras están en ejecución, en segundo plano, pausadas, etc.

Vamos a ver los distintos tipos de estado (y los eventos que se producen al llegar a ellos) que puede tomar una actividad, con una pequeña reseña de cada uno.


9

En este dibujo, podemos ver los distintos estados, y métodos que los implementan, que puede tomar una actividad. Pasemos a describirlos:

– Activity onCreate: Se llama al método onCreate cuando la actividad es creada por primera vez. En esta zona de código es donde debemos de configurar todos los Views de la interfaz y dar valores a los objetos y variables que vayamos a usar. Éste método tiene un parámetro de entrada de tipo Bundle que contiene el estado de la última ejecución de la actividad, si esta fue ejecutada hace poco tiempo.

– Activity onRestart: Método que se ejecuta justo antes de que una actividad comience de nuevo y después de haber sido parada.


0

– Activity onStart: Método que se ejecuta cuando la actividad se está convirtiendo en visible al usuario.

– Activity onResume: Método que se ejecuta cuando la actividad se convierte en la visible por el usuario y éste puede empezar a interactuar con ella.

– Activity onPause: Método que se ejecuta cuando otra actividad va a pasar a primer plano o esta actividad va a ser cerrada.

– Activity onStop: Método que se ejecuta cuando la actividad ya no es visible al usuario y hay otra ya en primer plano, o esta actividad va a ser destruida.

– Activity onDestroy: Método que se ejecuta cuando la actividad está siendo destruida, y va a desaparecer de la cola de actividades del móvil. Una actividad puede ser destruida por el usuario, al salir de ésta, o por Android si ésta actividad no está en primer plano y el sistema operativo necesita más recursos.

Al ser Android un sistema multitarea, se pueden estar ejecutando varias actividades de distintas aplicaciones a la vez. El sistema administra ésto con una cola de actividades, en la que la posición más alta la ocupa la actividad que se muestra por pantalla en el momento, y la posición más baja la ocupa la actividad más cercana a ser destruida.

Una actividad no puede ser destruida si se encuentra en los estados de onCreate, onRestart, onStart y onResume. En el resto de estados, la actividad puede ser destruida por el sistema, si éste lo considera necesario (necesidad de recursos).

Para nuestra aplicación usaremos, solamente, los estados de onCreate (para abrir la aplicación) y de onDestroy (para cerrar la aplicación). El resto de estados no los tomaremos en cuenta en este curso.

- Actividades especiales.

En Android existen varias actividades que podríamos calificar de especiales. Este tipo de actividades suelen servir para un funcionamiento concreto, implementan funcionalidad de distintos tipos de Views para que así le sea más fácil al programador desarrollar una interfaz usando principalmente ese tipo de View. Nosotros usaremos dos tipos de actividades especiales:

– ListActivity: Implementa una interfaz tipo lista de Views. Para poder usar esta actividad, no se necesita ningún tipo de XML de interfaz, ya que la actividad tiene una interfaz por defecto. Pero, si se desea implementar una interfaz algo diferente, siempre se puede asignar un XML de interfaz, siempre y cuando, éste contenga un ListView con el ID “@id/android:list”. Dentro de la clase que implementa a la atividad será necesario, que tras añadir la interfaz a la actividad llamemos al método:

setListAdapter(ArrayAdapter);

La clase ArrayAdapter es la clase que le dará la funcionalidad a la lista, es decir,


1

los eventos de interfaz y el acceso a los elementos se harán a través de ésta clase. Para crear un ArrayAdapter se llama al constructor:

new ArrayAdapter<Tipo>( Context, tipo_de_lista, String[]);

El parámetro tipo_de_lista es un ID para un recurso proveniente del paquete android.R.layout, en nuestra aplicación usaremos el ID simple_list_item_1.

– MapActivity: Este tipo de actividad implementa una actividad con mapa. Si se desea usar un mapa en una aplicación hay que usar ésta actividad obligatoriamente. Para que este tipo de actividad funcione, la clase que extienda a MapActivity necesita implementar el método isRouteDisplayed.

También existe otro tipo de actividad especial, como el TabActivity, que implementa una actividad con varias pestañas.

Siempre hay que tener en cuenta que una Actividad sólo puede extender a una actividad especial, es decir, no podemos, por ejemplo, mezclar mapas con organización por pestañas.

- Comunicación entre actividades.

Es normal que queramos dividir nuestra aplicación en varias actividades (actividades para la ejecución principal, para las opciones, para la pantalla de incio, etc.), por ello es necesario tener a mano recursos que nos permitan ejecutar actividades desde otras actividades y que puedan usarse para comunicar datos entre ellas.

Para el caso de la aplicación del curso, usaremos la clase Intent, que es la clase encargada de llamar a una actividad desde otra, pudiendo pasar parámetros. No haremos un uso avanzado de esta clase ni de varias otras que ayudan a la comunicación entre actividades y procesos. Nos basaremos en la ejecución de una aplicación con una actividad “principal” que llamará a otras para que ejecuten diversas operaciones y tras ello le devuelvan un resultado a la actividad principal. Mientras una actividad “secundaria”, esté ejecutándose, la actividad “principal” estará pausada, esperando el resultado de la “secundaria”.

Podemos definir la clase Intent como la descripción de una operación a ser realizada. La clase Intent es la encargada de lanzar una actividad desde otra, y es la que guarda los datos que queremos pasar entre actividades. Una llamada estándar de una actividad a otra sería (código de la solución de la aplicación del curso):

//Creamos el objeto intent para realizar la llamada.

Intent actividadMapa = new Intent(this, ActividadMapa.class); actividadMapa.putExtra(BaseDatosCurso.CLAVE_USUARIO, usuario); actividadMapa.putExtra(BaseDatosCurso.CLAVE_PASSWORD, password); actividadMapa.putExtra(BaseDatosCurso.CLAVE_VISTA, vista); actividadMapa.putExtra(BaseDatosCurso.CLAVE_RADIO, radio); actividadMapa.putExtra(BaseDatosCurso.CLAVE_TIEMPO_ACTUALIZACION, tiempo); //Realizamos la llamada y cerramos esta actividad. startActivity(actividadMapa);


2

finish();

Hemos creado el objeto Intent (pasando this, contexto de la actividad y ActividadMapa.class clase que implementa a la actividad) y hemos añadido varios parámetros con el método putExtra(NombreParámetro, parámetro). Cuando hemos finalizado de cargar el objeto Intent hemos comenzado la actividad nueva usando el método startActivity(ObjetoIntent) y hemos finalizado la que se estaba ejecutando con el método finish().

En la actividad lanzada, si queremos recoger los datos enviados por la actividad lanzadora, deberemos de usar el siguiente método:

getIntent().getTipoExtra(clave_param);

Donde tipo, será el tipo de datos que tiene el parámetro con clave igual a clave_param.

Si queremos que la actividad que lanzamos nos devuelva algún tipo de resultado, en vez de llamar a starActivity, debemos de llamar a startActivityForResult(ObjetoIntent), e implementar un nuevo método en la actividad lanzadora, el método onActivityResult, podemos ver su declaración en el siguiente ejemplo:

protected void onActivityResult(int requestCode, int resultCode, Intent data)

Este método es el que recibe el evento de fin de actividad, setResult(codigoResultado, intent), cuando la actividad lanzada finaliza su ejecución. Si tenemos que recibir algún tipo de resultado, lo haremos por el parámetro de entrada data. Para recoger los datos, tendremos que hacerlo con el método getTipoExtra(NombreDeParámetro) del objeto Intent. Ejemplo:

String pass = data.getStringExtra("password")

- Ejercicio. Actividades de la aplicación del curso.

Dentro de la aplicación que estamos desarrollando tendremos las siguientes actividades:

– Una actividad de presentación, que ya hemos creado, por defecto el nombre será “AplicacionCurso”.

– Una actividad principal, que contendrá el mapa y por lo tanto extenderá de MapActivity.

– Una actividad que será lanzada de la principal, donde tendremos listadas las opciones de la aplicación y extenderá de ListActivity.


3

Ya tenemos creada la actividad AplicacionCurso, la creamos al crear el proyecto, y será la actividad que se ejecutará al comenzar la aplicación. Vamos ahora a crear las otras dos actividades.

- Ejercicio 4:

Crear las dos actividades que faltan, siguiendo los pasos explicados anteriormente. Recordar que las clases deben de extender a MapActivity y a ListActivity.

Crear la interfaz para ListActivity e implementar el método onCreate de las actividades. Algunas pistas que seguir en este desarrollo:

– Acordarse de asignarle la id android:list al ListView que añadamos en la interfaz de ListActivity.

– Al escribir el método onCreate de ambas clases, debemos de comenzar por llamar a super.onCreate, pasando el parámetro de entrada de onCreate y seguidamente llamar a stContentView( layout ) para darle un layout a la actividad.

– Añadir las clases al manifiesto de la aplicación. Y como vamos a usar mapas, añadir una referencia al uso de las librerias de mapas, dentro del XML, dentro del elemento application. La refrencia es:

<uses-library android:name="com.google.android.maps"></uses-library>


4

-Menús y diálogos en Android.

- Creación y uso de menús.

Un menú es una parte importante de nuestra actividad, provee al usuario de funcionalidades y configuraciones para la aplicación dentro de una actividad. En Android podemos encontrar 3 tipos de menús, menú de opciones, menú contextual y submenús. En nuestro caso sólo usaremos el menú de opciones, que es el que más se usa en Android. Este menú es accesible pulsando sobre el botón menu del móvil o del emulador.

Para poder implementar un menú dentro de una actividad necesitamos añadir dos métodos de tipo evento, en nuestra clase de la actividad. Los métodos son:

– onCreateOptionsMenu(Menu menu): Este evento se ejecuta cuando el usuario pulsa sobre el botón menu del móvil. Dentro de él deberemos llenar el parámetro menu de entrada con las opciones que queramos meter en nuestro menú. Usaremos el método add() que tiene varias declaraciones, de ellas nosotros usaremos la siguiente:

menu.add(idGrupo, idElemento, orden, idRecursoCadena)

De estos parámetros de entrada, sólo usaremos idElemento e idRecursoCadena, en los otro dos siempre introduciremos el valor 0. En la misma línea donde escribamos el método add() añadiremos a la instrucción, el método setIcon(IdRecursoIcono). En resumen, una línea que crea un elemento en un menú con icono sería:

menu.add(idGrupo, idElemento, orden, idRecursoCadena).setIcon(IdRecursoCadena);

– onOptionsItemSelected(MenuItem item): Este método se ejecuta cuando el usuario pulsa sobre alguna de las opciones que contiene el menú. El parámetro de entrada item contiene la opción pulsada. Por lo que dentro del método deberemos tener un switch que compruebe cual elem ento es el pulsado. Ejemplo:

@Override

public boolean onOptionsItemSelected(MenuItem item) {

switch (item.getItemId()) {

case 0: //Si se ha pulsado el botón de buscar amigos.

return true;


5

case 1: //Si se ha pulsado el botón de añadir amigo.

return true;

case 2: //Si se ha pulsado el botón de cambiar búsqueda.

return true;

case 3: //Si se ha pulsado el botón de opciones.

return true; }

return super.onOptionsItemSelected(item);

}

Como vemos en el ejemplo tenemos que comprobar qué item se ha pulsado, usando el método getItemId(). Importante recordar, que si no se cumple ninguna opción del switch hay que retornar el resultado de la ejecución del método por parte del padre de la clase, en nuestro caso, Activity.

- Creación y uso de diálogos.

Un dialogo, es una pequeña ventana que aparece dentro de nuestra actividad cuando queremos ejecutar algún tipo de operación simple que implica algún tipo de acción necesaria por parte del usuario, o algún tipo de mensaje informativo al usuario.

Existen varios tipos de diálogos, AlertDialog, ProgressDialog, DatePickerDialog, TimePickerDialog y la clase padre de todas ellas, Dialog. Vamos a dar una breve explicación de los dos más importantes y que usaremos en nuestra aplicación, AlertDialog y Dialog.

AlertDialog es un diálogo que puede aceptar hasta tres botones y una lista de elementos seleccionables (radioButtons, checkBoxes, etc.), es el diálogo que se aconseja usar en la mayoría de casos, ya que puede implementar casi todas las operaciones que necesitemos que realice el usuario.

Dialog es un diálogo en blanco, es decir, un diálogo que no contiene Views, para poder mostrar un diálogo necesitamos asociarle una interfaz e implementar el comportamiento de todos sus Views (casi como con las actividades). La interfaz de un diálogo construido con Dialog puede ser tan complicada como queramos, al contrario que AlertDialog que está pensado para interfaces más simples.

Como hemos dicho, un diálogo pertenece a una actividad y por lo tanto son creados y lanzados dentro de ésta. Para poder lanzar un diálogo se debe de llamar al método showDialog( IdDialogo ), que a su vez llama a onCreateDialog( IdDialogo ) para crear el diálogo a mostrar (devuelve el diálogo a mostrar).

Ambos métodos disponen un parámetro id, y es que, todos los diálogos son llamados y creados por esos dos métodos, de ahí que necesitemos una forma de identificar cuál


6

queremos mostrar en un momento dado.

Vamos a mostrar qué pasos hay que seguir para crear un diálogo de cada tipo en Android.

- Secuencia para crear un AlertDialog.

1. Primero declaramos el constructor de AlertDialog, AlertDialog.Builder. Al constructor de la clase le deberemos de pasar como parámetro de entgrada el contexto de la actividad, para que el diálogo sepa desde qué actividad se ejecuta. Esto se hace pasando el .this de la clase Ejemplo:

AlertDialog.Builder constructor = new AlertDialog.Builder(NombreClase.this);

2. Configuramos las propiedades del constructor, como el título del diálogo, con el método setTitle( String ), si se puede cerrar el diálogo pulsando fuera de él, con el método setCancelable( bool ), etc.

3. Configuramos los Views que van a formar parte. Podemos introducir cualquier View con setView(View) o podemos introducir uno de los que vienen por defecto con métodos como setSingleChoiceItems( ArrayString, selectedItem, clickListener ).

4. Configuramos los botones que va a tener el diálogo (máximo 3). Con los métodos setPositiveButton( nombreBoton, clickListener ), setNegativeButton( nombreBoton, clickListener ), etc.

5. Cuando el constructor está configurado por completo sólo nos quedara llamar al método create() del constructor y asignarlo a un AlertDialog donde llamaremos al método show(). O también podemos hacerlo en una linea:

constructor.create().show();

- Secuencia para crear un Dialog.

1. Declaramos el objeto Dialog, pasando en el constructor el contexto de la actividad. Ejemplo:

Dialog d = new Dialog(NombreClase.this);

2. Configuramos las propiedades del diálogo, ídem que para AlertDialog.

3. Condifuramos el layout que va a mostrar el diálogo. El layout se lo asignaremos con el método .setContentView( idRecursoLayout ).

4. Será necesario implementar el funcionamiento de todos los Views del layout


7

agregado, esto se hará como si el diálogo fuera una actividad ( configurar propiedades, configurar eventos de interfaz, etc. )

5. Cuando el dálogo está configurado sólo deberemos de mostrarlo por pantalla con el método show().

- Ejercicio. Creación de diálogos y menús en la actividad. Comunicación entre actividades.

- Ejercicio 5:

Crear un diálogo para la actividad inicial de la aplicación donde nos pida un usuario y una contraseña, al pulsar el botón entrar. Usar la clase Dialog para ello.

Algunas pistas para el ejercicio:

– Primero hemos de crear una interfaz (un XML de layout) que contenga dos cuadros de texto para usuario y contraseña y dos botones (aceptar y cancelar). Ejemplo:


8

– Ahora debemos de implementar el evento de pulsar sobre el botón entrar, donde llamaremos al método showDialog(idDialogo) para crear el diálogo.

– Crear el evento onCreateDialog en la clase de la actividad.

– Sólo tendremos un diálogo así que se crea el objeto Dialog directamente.

– Configurar el título del diálogo con setTitle y darle la interfaz con setContentView.

– Crear los objetos que van a implementar el funcionamiento de los Views de la interfaz con findViewById.

– Implementar los eventos onClick de los botones y también los eventos onKey de las líneas de texto. Ejemplo de método onKey:

usuario.setOnKeyListener(new OnKeyListener(){

/** Se llama a este método cuando se produce la presión de una tecla

* y estamos dentro de este View. * * @param v Será el View donde estamos escribiendo, en nuestro caso, * un EditText. * @param keyCode Será el código de la tecla pulsada. * @param key Objeto que contiene información del evento producido. */

@Override public boolean onKey(View v, int keyCode, KeyEvent key ){

//Si la tecla pulsada es el enter, entonces vamos a //entrar en el mapa. if(KeyEvent.KEYCODE_ENTER==keyCode){

password.requestFocus(); return true;

}

});

} //El evento no ha sido consumido. return false;

– Creamos un método que se llame lanzaActividad y que tenga como parámetros de

entrada dos String (usuario y password) y tres int (vistaMapa, radio y tiempoActualizacion). Éste método se encargará de crear el Intent e introducirle los parámetros de entrada junto a sus claves. Recordar como se hacía:

Intent i = new Intent(this, ActividadMapa.this); i.putExtra(clave1, param1); …

– Creado el lanzador, sólo faltará llamar a startActivity(Intent) y finish() para lanzar la nueva actividad y finalizar la actual.

– En la actividad mapa, hay que crear 5 variables globales a la clase, para guardar los datos pasados desde la actividad de presentación.

– Debemos de darle permisos a la aplicación de acceso a internet, gps y gps a través de antenas. Esto se modifica en el manifiesto, añadiendo dentro del elemento manifest el siguiente código:


9

<uses-permission android:name="android.permission.INTERNET" />

<uses-permission android:name="android.permission.ACCESS_MOCK_LOCATION" /> <uses-permission

android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS" /> <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"

/>

- Ejercicio 6:

Crear el menú de la actividad mapa y el lanzador para la actividad lista. Pistas para realizar el ejercicio:

– Para crear el menú debemos de usar los métodos onCreateOptionsMenu onOptionsItemSelected ya explicados anteriormente.

– En onCreateOptionsMenu no se puede olvidar llamar al método .add del objeto menú, para añadir los elementos al menú, y llamar a showIcon para mostrar los iconos. Crearemos botones para: buscar amigos, añadir amigos, cambiar búsqueda y opciones de aplicación.

– En onOptionsItemSelected crear un switch-case para ver qué botón del menú fue pulsado, según el código que viene como parámetro de entrada. Los casos los dejaremos vacíos, excepto el de opciones de aplicación, que ejecutaremos el lanzador de actividades (Intent).

– El lanzador, en vez de ejecutarse con el método startActivity se ejecutará con el método startActivityForResult para esperar el resultado. Hay que crear el método onActivityResult para cuando la actividad lanzada devuelva un resultado.

– Al lanzador habrá que añadir todos los elementos que se añadieron para el lanzador de la actividad presentación, dos String (usuario y password) y tres int (vistaMapa, radio y tiempoActualizacion) que pasaremos a la actividad lista.

- Ejercicio 7:

Crear el adaptador de la lista y los eventos de pulsación para cada uno de los elementos de ella. Pistas para realizar el ejercicio:

– Para declarar el adaptador lo primero que necesitaremos será un array de cadenas, que representen los textos de cada elemento que va a tener la lista de opciones. La lista tendrá estos elementos: Distancia de amigos, Cambiar usuario, Resetear mapa amigos, Resetear mapa lugares, Tiempo actualización amigos. Tras crear el array, crearemos el adaptador.

– Creamos el evento de pulsación sobre un elemento de la lista. Como usamos la actividad ListActivity, podremos crear el evento, directamente, en la clase, con:

onListItemClick( ListView l, View v, int position, long id);


0

– Dentro del evento de pulsación deberemos de comprobar qué elemento ha sido pulsado, comprobando el id de entrada. Tendremos 5 casos.

– Ejecutar para cada caso una operación distinta:

Para Distancia de amigos: Crear un diálogo de tipo AlertDialog, usando su propiedad setSingleChoiceItems(arrayItems, selectedItem, clickListener) para configurar una lista de radioButtons donde aparezcan las distancias que queramos, siendo el elemento seleccionado de inicio el de valor de la variable de la clase radioActualizacion. Para Cambiar usuario: Lo dejamos vacío por el momento Para Resetear mapa amigos: Sólo tendremos que cambiar de estado a verdadero una variable pública, para después enviarla como resultado a la actividad mapa. Para Resetear mapa lugares: Idem. Para Tiempo actualización amigos: Crear un diálogo de tipo AlertDialog, usando su propiedad setSingleChoiceItems(arrayItems, selectedItem, clickListener) para configurar una lista de radioButtons donde aparezcan los tiempos que queramos, siendo el elemento seleccionado de inicio, el de valor de la variable de la clase tiempoActualizacion.

- Ejercicio 8:

Modificar la interfaz del diálogo de la actividad presentación (añadiendo nuevos Views), para poder ser usado como interfaz del diálogo que debe aparecer al pulsar sobre el elemento Cambiar usuario de la actividad lista, en la actividad presentación cambiar la visibilidad de los nuevos Views añadidos, para que no se vean en la actividad presentación. Pistas para hacer el ejercicio:

– Hay que añadir editores de texto y etiquetas nuevas para un campo nueva contraseña y otro campo email.

– Añadir la llamada showDialog dentro del caso de pulsar Cambiar usuario en la lista y añadir el método onCreateDialog a la clase.

– Dentro de onCreateDialog crear el diálogo usando la interfaz modificada. Se deben ocultar los Views que no usemos (los referentes a usuario), usar el método setVisibility(View.GONE), que hace que la aplicación no tome en cuenta el View al pintar la interfaz.

– Modificar la actividad presentación para que ahora oculte los Views extras añadidos a la interfaz del diálogo, los referentes a nueva contraseña y email.

- Ejercicio 9:

Crear un menú para salvar los cambios hechos en las opciones, y que al salvar devuelva los nuevos valores como resultado a la actividad mapa (que es quien lanzó a la actividad


1

lista). Cargar esos valores en las variables de la clase de la actividad mapa. Pistas:

- Primero implementar el menú y después el lanzador de la actividad, escribiendo

antes del finish de la actividad, setResult(codigoResultado, intent).

- Segundo, ir a la actividad mapa, e implementar el método vacío de onActivityResult

recogiendo los datos del parámetro de entrada, llamando a:

intent.getTipoExtra(codigoParam);


2

- Mapas en Android.

- La clase MapView.

MapView es un View que muestra un mapa usando el servicio de Google maps. Ésta clase es capaz de captar todo tipo de eventos de pulsación y movimientos de arrastre que realice el usuario automáticamente. Por lo tanto sólo tendremos que implementar los eventos en los que queramos que se ejecute algún proceso especial.

Hay que recordar que esta clase sólo se puede usar dentro de un MapActivity, ésto es debido a que ésta clase accede a la red y a procesos en background que deben de ser correctamente controlados, lo cuál hace MapActivity.

Los métodos y propiedades de un MapView son algo especiales, y distintos, al resto de Views que vamos a ver en el curso. A continuación mencionaremos los usados en la aplicación:

– setSatellite( boolean ): Activa o desactiva la vista satélite ( desactivado muestra la vista de mapa híbrido. )

– setBuiltInZoomControls( boolean ): Activa o desactiva los controles de zoom.

– getController(): Devuelve el controlador del mapa, un MapController, que nos ayuda a controlar y a configurar aspectos visuales y de animación del mapa. Usaremos métodos como animateTo( lugar ) para ir a un lugar con una animación de desplazamiento, setCenter( lugar ) para posicionar el centro del mapa en un lugar, setZoom( zoom ) para configurar el zoom del mapa.

– getOverlays(): Devuelve una lista de overlays (figuras insertadas en el mapa), que mostrará el mapa.

– postInvalidate(): Este método ejecuta un refresco en el mapa. Nos será útil para actualizar el mapa tras añadirle figuras a su lista de elementos.

- Elementos de un MapView.

Un mapa puede contener distintos tipos de elementos, incluso puede contener Views. En las siguientes líneas se explicarán los elementos, específicamente diseñados para ser añadidos a un mapa. Estos son Overlay, ItemizedOverlay (OverlayItem) y MyLocationOverlay.

- Overlay.


3

Clase que representa un elemento que se mostrará encima de un mapa.

Ésta clase necesita ser extendida para poder usarla. Así deberemos de crearnos una clase que extienda de Overlay y que implemente su método draw. A esta clase podremos añadir todos los parámetros asociados al Overlay que consideremos necesario para poder operar con él posteriormente.

No se nos debe de olvidar implementar el método onTap del Overlay si queremos ejecutar algún tipo de operación, cuando el usuario pulse sobre ese Overlay.

Las declaraciones de estgos dos métodos imprescindibles para usar overlays son:

public boolean onTap(GeoPoint, MapView)

public void draw(Canvas, MapView, boolean)

Los distintos parámetros de entrada que vemos son:

– Canvas: Marco para dibujar la imágen del overlay.

– MapView: La clase que implementa el mapa donde está el overlay.

– Boolean: Si se tiene que dibujar sobra del dibujo o no.

– GeoPoint: Geopunto, en el mapa, que ha sido pulsado.

- ItemizedOverlay.

Esta clase representa una lista de overlays que se encuentran en un mapa. Éstos overlays serán todos del mismo tipo, es decir. Se dibujarán de la misma forma y actuarán antes las interacciones del usuario, de la misma manera. Su funcionamiento es casi idéntico al de la clase Overlay, aunque ésta clase no contiene método de dibujado (lo hace ella) y el método de pulsado tiene distintos parámetros de entrada:

protected boolean onTap(int i)

El método onTap ahora sólo tiene como parámetro de entrada el elemento que ha sido pulsado.

La clase ItemizedOverlay necesita tener implementados los métodos de creaItem( int ) y size() para poder devolver tanto un elemento de la lista, como el tamaño de la lista.

Los elementos que se añaden a una lista de éste tipo son objetos OverlayItem. Un objeto de éste tipo contiene su localización, una etiqueta y su título. El constructor de un OverlayItem es:


4

new OverlayItem(GeoPoint lugar, String etiqueta,String titulo);

- MyLocationOverlay.

Es un overlay especial que viene en nuestra SDK y que se usa para representar nuestra posición dentro del mapa. También se puede usar para representar rotaciones del compás del móvil, pero es una característica que no usaremos.

Para crear un objeto de ésta clase necesitamos ejecutar la siguiente instrucción.

new MyLocationOverlay(Conexto, MapView)

Los métodos que usaremos para operar con ésta clase son:

– enableMyLocation(): Para activar la localización del usuario en el mapa.

– disableMyLocation(): Para desactivar la localización del usuario en el mapa.

– runOnFirstFix(new Runnable()): Para realizar una operación nada más llegar los primeros datos desde el GPS. Runnable es la clase que implementa a un proceso.

– getMyLocation(): Devuelve la localización actual del usuario.

Si se deseara implementar el evento de pulsación sobre un objeto de la clase MyLocationOverlay tendríamos que crear una nueva clase que extendiera de ésta, e implementar nosotros el evento de pulsación.

- Ejercicio. Mapa de la aplicación del curso.

- Ejercicio 10:

Crear los objetos que recojan los Views de la interfaz. Crear desde el View MapView el MapController. Configurar los controles de zoom del mapa, el tipo de vista y el zoom del mapa. Crear los eventos onClick y onKey de los botones y campos de texto.


5

- Ejercicio 11:

Crear el overlay tipo MyLocationOverlay, habilitar en el overlay la localización del usuario, marcar como primera ejecución del overlay que el mapa se mueva hasta la posición de ese overlay.

Crear la variable de control de overlays (una lista de overlays), añadir el overlay de posición a la lista.

Crear una nueva clase que implemente a la interfaz itemizedOverlay (LugaresOverlay), con los siguientes métodos y objetos:

– Un ArrayList de OverlayItem y un Context.

– Constructor que reciba un Drawable y un Context.

– createItem, donde se comprueba si el índice de entrada es correcto y en ese caso se devuelve el Overlay de la lista.

– size, que devuelve el tamaño de la lista.

– añadeOverlay, que añade un overlay a la lista y actualiza dicha lista.

– borraTodo, que borra toda la lista.

– onTap, evento que se ejecuta cuando el usuario pulsa sobre un overlay de esta clase.

Crear un objeto de la clase LugaresOverlay pasándole un Drawable y el contexto de la clase del mapa.

Pistas:

– El objeto Drawable es un objeto que representa un dibujo, para cargar una imágen sobre este tipo de objetos, hemos de llamar al método:

this.getResources().getDrawable(R.drawable.idImagen);

– Para crear la primera ejecución del overlay de MyLocationOVerlay tenemos que llamar a runOnFirstFix y pasar un objeto del tipo Runnable.

- Ejercicio 12:

Llamar a showDialog en el evento de pulsar del botón del mapa para la vista, e implementar el diálogo que se va a mostrar para cambiar la vista del mapa. Pistas:

– Vamos a usar un View nuevo para crear una lista desplegable con las dos opciones de vista de mapa, el View Spinner. Hay que crear un fichero de layout que contenga un View de este tipo.


6

– Para implementar el Spinner tenemos que crear un ArrayAdapter e introducirle las cadenas que debe de mostrar. Para nuestro caso vamos a usar un recurso ya creado, accediendo a él mediante:

ArrayAdapter.createFromResource(Context, resourceId, spinnerClassId);

– Para el parámetro spinnerClassId debemos introducir un id de android.R.layout.Ids (que sea para Spinner).

– Al adaptador del Spinner habrá que cconfigurarle también el layout del objeto cuando sus elementos están desplegados. Habrá que llamar al método setDropDownViewResource y pasarle el valor R.layout.IdSpinnerDropdown.

– Para añadir el adaptador al Spinner se llama a setAdapter y para configurar el elemento seleccionado de inicio se llama a setSelection.


7

- GPS en Android.

- Descripción de las clases para la geolocalización.

Para poder crear operaciones sobre un mapa del estilo de búsquedas, señalizaciones, navegación, necesitamos de una serie de clases que nos den los datos de localización del usuario y de los elementos que usaremos en esas operaciones. Las clases que vamos a usar para nuestra aplicación serán GeoPoint, GeoCoder, Address, Location, LocationListener, LocationManager. Veremos a continuación una breve explicación de cada clase.

- GeoPoint.

Ésta clase representa un punto en el mapa, con su latitud y longitud. Éstos datos se guardan en formato de microgrados (tipo int). El constructor de la clase es:

new GeoPoint(latitud,longitud)

Los dos métodos que se suelen usar para recoger la latitud y la longitud son getLatitudeE6() y getLongitudeE6().

- GeoCoder.

Con GeoCoder podemos encontrar el lugar (dirección) asociado a un punto del mapa, o viceversa. El constructor de GeoCoder es:

new Geocoder( Contexto )

Nosotros operaremos con GeoCoder en el sentido nombre de lugar → geoposición. Para ello usaremos el método getFromLocationName(nombreLugar, maxResultados). Éste método devuelve una lista de direcciones asociadas al nombre que hemos dado.


8

- Address.

Es la clase que contiene una dirección que devuelve GeoCoder (devuelve una lista de Address). Sólo usaremos de ésta clase los métodos getLatitude() y getLongitude(), que devuelve la latitud y longitud de una dirección. Aunque el objeto que contiene un Address tiene muchos más datos pertenecientes a una dirección (país, provincia, ciudad, código postal, bloque, piso). Y todos ellos pueden ser accedidos mediante métodos get.

- Location.

Esta clase representa una localización en el mapa que ha sido recogida por el GPS en un tiempo determinado. Para acceder a la latitud y longitud que guarda (tipo double en grados) usaremos los métodos getLatitude() y getLongitude().

Desde Location también podemos saber la altitud, la orientación, el proveedor de la localización y más datos respecto de una localización exacta.

- LocationListener.

Es la interfaz que deberemos de implementar para poder crear y tratar eventos que provengan del GPS con actualizaciones de la posición del usuario. Al crear la clase que implementa la interfaz, deberemos declarar los siguientes métodos:

– public void onStatusChanged(String provider, int status, Bundle extras): Para ejecutar algún proceso cuando cambia el estado del GPRS.

– public void onProviderEnabled(String provider) : Para ejecutar algún proceso cuando se habilita el GPS.

– public void onProviderDisabled(String provider): Para ejecutar algún proceso cuando se deshabilita el GPS.

– public void onLocationChanged(Location location): Para ejecutar algún proceso cuando el GPS informa de una nueva localización.

Nosotros sólo usaremos en nuestra aplicación el evento de cambio de localización. El constructor de la clase será el constructor vacío (por defecto).

- LocationManager

Es la clase que se encarga de crear una conexión con uno de los proveedores GPS de que dispongo el móvil. Para poder crear esta conexión deberemos de escribir el siguiente


9

código:

LocationControl = (LocationManager)getSystemService(Context.LOCATION_SERVICE);

LocationControl.requestLocationUpdates("gps", minTimeInMiliseconds, minMeters, LocationListener);

Como vemos no creamos un objeto del tipo LocationManager con un constructor, sino que llamamos al método getSystemService para que la aplicación nos devuelve el servicio LOCATION_SERVICE. Tras esto sólo debemos de crear las actualizaciones sobre el GPS y asociarlas con nuestro LocationListener.

Para poder parar las actualizaciones deberemos de llamar a:

LocationControl.removeUpdates(LocationListener);

- Ejercicio. GPS en la aplicación del curso.

- Ejercicio 13:

Crear el proceso de búsqueda de un lugar que ha sido escrito por el usuario en el cuadro de texto de la actividad mapa, ver el lugar en el mapa y mostrar un diálogo, para preguntar al usuario si desea añadirlo, escribiendo un nombre para el lugar. Pistas:

– Hay que crear un objeto del tipo Geocoder que sea público a la clase y un objeto lista de Address también público a la clase.

– Implementar el método de onClick del botón de buscar y el método de onKey del cuadro de texto. Deberán recoger el texto escrito y pasárselo a un método que buscará por el lugar.

– Dentro del método de búsqueda, guardar los datos buscados por el objeto GeoCoder en el objeto lista Address y recoger el primer objeto Address de ella.

– Animar el mapa hasta la posición del objeto Address. Configurando también el zoom que deseamos.

– Llamar a un método, pasando el texto buscado, que cree el diálogo.

– Para que el diálogo contenga una línea de texto, se puede añadir al diálogo un objeto EditText con el método setView.

– Si el usuario añade el lugar, se crea un nuevo OverlayItem y se añade a la lista de lugares (refrescar el mapa tras esto).


0

- Ejercicio 14:

Crear la clase que implementa un Overlay de tipo amigo. Esta clase ha de extender de la clase Overlay. Pistas:

– La clase debe de tener los métodos: AmigoOverlay(MapView, GeoPoint, String) getGeoPunto() getNombreAmigo() getNombreAmigo() draw(Canvas, MapView, boolean) drawAmigo(Canvas, MapView, boolean) drawNombre(Canvas, MapView, boolean) getPinturaDentro() getPinturaBorde() getPinturaTexto() onTap(GeoPint, MapView)

– La clase ha de contener 3 variables públicas, una por cada parámetro de entrada del constructor.

– Para los métodos de dibujado usar el siguiente código (se explicarán al terminar el ejercicio).

/**Método que dibuja al icono que representa al amigo

* * @param canvas El lienzo donde vamos a dibujar. * @param mapa El mapa donde se va a dibujar. * @param shadow Define si queremos dibujar una sombra o no. */ private void drawAmigo(Canvas canvas, MapView mapa, boolean shadow){

//Declaramos un punto y pasamos de coordenadas a píxeles de pantalla Point puntoOverlay = new Point(); mapa.getProjection().toPixels(mGeoPunto,puntoOverlay);

amigo.

//Si no se dibuja la sombra if (!shadow) {

//Dibujamos en el punto calculado el Bitmap de la imagen del

canvas.drawBitmap(mAmigo, puntoOverlay.x -

mAmigo.getWidth()/2, puntoOverlay.y - mAmigo.getHeight(),null); }

}

/** Método que dibuja la etiqueta con el nombre del amigo.

* * @param canvas El lienzo donde vamos a dibujar. * @param mapa El mapa donde se va a dibujar. * @param shadow Define si queremos dibujar una sombra o no. */ private void drawNombre(Canvas canvas, MapView mapa, boolean shadow){

//Si no se dibuja la sombra.


1

if (!shadow) { //Primero determinamos la relacion pixel-pantalla con las

coordenadas.

Point puntoOverlay = new Point(); mapa.getProjection().toPixels(mGeoPunto,puntoOverlay);

//Configuramos la ventana que mostrara el texto.

int windowW = 25; int windowH = 25; //A más largo el texto, más longitud de etiqueta necesitaremos for(int i=0;i<mEtiqueta.length();i++)

windowW+=5; //Vamos a crear el rectángulo donde irá el nombre del amigo RectF infoWindowRect = new RectF(0,0,windowW,windowH); int winOffsetX = puntoOverlay.x-windowW/2; int winOffsetY = puntoOverlay.y-windowH-mAmigo.getHeight(); infoWindowRect.offset(winOffsetX, winOffsetY);

//Dibujamos el interior de la ventana. canvas.drawRoundRect(infoWindowRect, 5, 5,

getPinturaDentro()); //Dibujamos el borde de la ventana. canvas.drawRoundRect(infoWindowRect, 5, 5, getPinturaBorde());

//Dibujamos el nombre del amigo.

int txtOffX = 10; int txtOffY = 15; //Bibujamos el nombre de amigo dentro del rectángulo canvas.drawText(mEtiqueta, winOffsetX+txtOffX,

winOffsetY+txtOffY, getPinturaTexto()); }

}

/**Método que devuelve el interior de un rectángulo

* * @return El relleno del rectángulo */ public Paint getPinturaDentro() {

Paint pinturaDentro = new Paint(); pinturaDentro.setARGB(225, 75, 75, 75); //gray pinturaDentro.setAntiAlias(true);

return pinturaDentro;

}

/** Método que devuelve el borde del rectángulo * * @return El borde del rectángulo */ public Paint getPinturaBorde() {

Paint pinturaBorde = new Paint(); pinturaBorde.setARGB(255, 255, 255, 255); pinturaBorde.setAntiAlias(true); pinturaBorde.setStyle(Style.STROKE); pinturaBorde.setStrokeWidth(2);

return pinturaBorde;

}


2

/** Método que devuelve el estilo de la letra para el texto

* * @return El estilo del texto */ public Paint getPinturaTexto() {

Paint pinturaTexto = new Paint(); pinturaTexto.setARGB(255, 255, 255, 255); pinturaTexto.setAntiAlias(true);

return pinturaTexto;

}

– En el método draw habrá que llamar a los métodos drawAmigo, drawNombre.

– En el método onTap copiar el siguiente código y rellenarlo creando un diálogo de tipo AlertDialog que nes de dos opciones, para enviar un correo o para borrar el amigo.

/**Método obligatorio de implementar en la clase. Implementa el evento de pulsación sobre el Overlay del mapa.

* * @param point Punto pulsado. * @param mapa El mapa al que pertenece el Overlay. */ @Override public boolean onTap(GeoPoint point, final MapView mapa) {

final List<Overlay> overlays = mapa.getOverlays(); boolean encontrado = false; int index = 0; //Creamos el punto pulsado y la zona a pulsar. Además le asignamos

al punto pulsado //la proyeccion del Geopunto que se pulso en la pantalla. RectF zonaParaPulsar; Point puntoPulsado = new Point(); mapa.getProjection().toPixels(point, puntoPulsado); Point puntoDeOverlay = new Point();

//mientras no encontremos el punto y haya puntos que comrpobar

while(!encontrado && index<overlays.size()){ //Definimos el tamaño del rectangulo de la chincheta. zonaParaPulsar = new RectF(); zonaParaPulsar.set(-mAmigo.getWidth()/2,-

mAmigo.getHeight(),mAmigo.getWidth()/2,0); try

{ //RELLENAR AQUÍ CON EL ALERTDIALOG.

} catch(Exception exc) {

//NADA } index++;

} return false;

}


3

- Ejercicio 15:

Crear los objetos necesarios para usar el gps del móvil (objetos de tipo location). Pistas:

– Primero, hay que crear una clase que implemente la interfaz LocationListener. Esta clase contendrá los métodos onStatusChanged(String, int, Bundle), onProviderEnabled(String), onProviderDisabled(String) y onLocationChanged(Location).

– Sólo hay que implementar el funcionamiento de onLocationChanged(Location). Para ello debemos crear una variable pública que guarde localizaciones (de tipo Location). En el método hay que comprobar si la localización ha sobrepasado una distancia que elijamos y entonces asignar la nueva localización a nuestra variable pública.

Segundo, crear variables públicas para los objetos del tipo LocationListener y LocationManager. Crear los eventos de actualización de GPS con el método requestLocationUpdates del objeto LocationManager.


4

- Bases de datos en Android.

- Creación de una base de datos.

Las bases de datos en Android se basan en el sistema SQLite3, y para poder crear una base de datos en Android tenemos que crear una clase para ello. Esta clase tendrá que implementar el funcionamiento de las clases SQLiteOpenHelper y SQLiteDatabase. La primera clase se usa para administrar la base de datos, y podríamos decir que la segunda clase es la base de datos en sí.

Por lo tanto lo primero que tiene que tener una clase para funcionar como base de datos, es la implementacion de SQLiteOpenHelper. Para ello hemos de declarar la siguiente clase privada.

private static class DataBaseHelper extends SQLiteOpenHelper{

DataBaseHelper(Context context) {

super(Contexto, NOMBRE_BASEDATOS, null, VERSION_BASEDATOS); }

@Override

public void onCreate(SQLiteDatabase db) {

CREACION DE TABLAS VACÍAS }

@Override public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

BORRADO DE LAS TABLAS onCreate(db);

} }

Los métodos de la clase creada tienen las siguientes funcionalidades:

– DataBaseHelper: Constructor de la clase al que se le pasa el contexto donde se va a usar la base de datos. Se llama al constructor de la clase padre pasando el contexto, el nombre de la base de datos y la versión de la base de datos.

– OnCreate: Éste método es llamado cuando se ejecuta el constructor de la clase. Aquí debemos de crear las tablas de la base de datos. El parámetro de entrada es la base de datos, tendremos que usar el método execSQL( sentenciaSQL ) propio del objeto tipo SQLiteDataBase para añadirle las tablas.

– OnUpgrade: Éste método es llamado si, al ejecutar el constructor de la clase, la versión de la base de datos guardada en disco, es anterior a la versión de la base de datos que contiene la aplicación.- Se llama al borrado de tablas usando de nuevo execSQL ( sentenciaSQL ) y se llama a onCreate para crear las nuevas tablas vacías.


5

Segundo, el constructor de nuestra clase sólo necesitará como parámetro de entrada el contexto de la actividad que vamos a usar. La clase tendrá una variable pública para SQLiteOpenHelper(DataBaseHelper) y otra para SQLiteDatabase. Tercero, hay que implementar un método que abrirá la base de datos para ser accedida, dentro de éste método tendremos que inicializar el objeto SQLiteOpenHelper y tras esto llamar al método getWritableDatabase de ese objeto para crear el objeto tipo SQLiteDatabase. También hay que implementar un método de cierre, que llame al método close del objeto tipo SQLiteOpenHelper. Cuarto, crear todos los métodos necesarios para la administración de la base de datos. Para ello, la clase SQLiteDataBase nos da una series de métodos que listamos a continuación:

• insert( String table, null, ContentValues valores).

• update(String table, ContentValues values, String whereClause, String[] whereArgs )

• query( String table, String[] columns, String selectionArgs, String groupBy, String having, String orderBy )

Para los métodos insert y update los valores devueltos serán booleanos con el resultado de la operación (éxito o fallo). El método query devolverá un objeto del tipo Cursor que contendrá los datos sacados de la consulta, esta clase funciona como un iterador que recorre la lista de elementos que cumplan con la consulta. La case ContentValues, es una clase contenedora, para poder introducir los pares códigoColumna y valorColumna, para añadir un par usaremos el método put( código, valor). Lo normal, es crear métodos, dentro de nuestra clase para la base de datos, que tengan como entrada los parámetros sobre los que trabajaremos en la base de datos y que retornen el resultado de cada uno de los métodos listados anteriormente, como ejemplo, vemos el caso de un método que usa el insert:

public boolean nuevoLugar(String usuario, String nombreLugar, int latitud, int longitud){

ContentValues valoresIniciales = new ContentValues(); valoresIniciales.put(CLAVE_NOMBRE_LUGAR, nombreLugar); valoresIniciales.put(CLAVE_LATITUD, latitud); valoresIniciales.put(CLAVE_LONGITUD, longitud); valoresIniciales.put(CLAVE_USUARIO, usuario);

return mBd.insert(TABLA_LUGARES, null, valoresIniciales)>0; }

Como podemos ver, hemos usado la clase ContentValues para agregar las parejas columna-valor, y tras ello realizamos el insert en la base de datos, retornando si el resultado si el resultado ha sido > 0 (el insert se ha realizado correctamente).


6

- Uso de bases de datos.

Para poder usar nuestra base de datos en cualquier clase debemos de seguir un proceso fijo que se explica a continuación:

1. Creamos el objeto de nuestra base de datos.

2. Llamamos a su método abre.

3. Con la base de datos abierta, trabajamos sobre ella (operaciones insert, update, query, etc.). Si vamos a realizar una operación query debemos de crear un objeto Cursor que guarde el resultado de dicho query. Un objeto Cursor guarda los datos de una query y tiene los siguientes métodos para trabajar con él:

1. getCount(): Con éste método podemos saber cuántas filas de la base de datos nos han sido devueltas.

2. moveToFirst(): Método que hay que llamar siempre, antes de empezar a recorrer el cursor por filas

3. getTiPo(int columna): Método que te devuelve la columna i con el tipo Tipo.

4. close(): Método que hay que llamar cuando se acaba de trabajar sobre un cursor.

4. El último paso es cerrar la base de datos, llamando al método que hayamos creado para tal caso.

- Ejercicio. Base de datos de la aplicación del curso. Finalizando la aplicación.

- Ejercicio 16:

Crear la clase que implemente nuestra base de datos local. Pistas:

– Vamos a usar las siguientes constantes que contienen las declaraciones de creación de tabla y de claves de columnas.

/**

* Constantes que nos ayudarán en el uso de la BD.

*/ private static final String NOMBRE_BASEDATOS = "baseDatosCurso"; private static final int VERSION_BASEDATOS = 4; private static final String CREAR_TABLA_USUARIOS = "create table

tablaUsuarios (usuario text primary key not null, password text not null);";


7

private static final String CREAR_TABLA_OPCIONES = "create table tablaOpciones (usuario text primary key not null, vistaSatelite integer not null, " +

null);"; "radioAmigos integer not null, tiempoActualizacion integer not

private static final String CREAR_TABLA_LUGARES = "create table tablaLugares (nombre text primary key not null, latitud integer not null, longitud integer not null," +

"usuario text not null);"; private static final String TABLA_USUARIOS = "tablaUsuarios"; private static final String TABLA_OPCIONES = "tablaOpciones"; private static final String TABLA_LUGARES = "tablaLugares"; public static final String CLAVE_USUARIO = "usuario"; public static final String CLAVE_PASSWORD = "password"; public static final String CLAVE_VISTA = "vistaSatelite"; public static final String CLAVE_RADIO = "radioAmigos"; public static final String CLAVE_TIEMPO_ACTUALIZACION =

"tiempoActualizacion"; public static final String CLAVE_NOMBRE_LUGAR = "nombre"; public static final String CLAVE_LATITUD = "latitud"; public static final String CLAVE_LONGITUD = "longitud";

– Necesitaremos 3 variables públicas, una para la clase que extienda a

SQLiteOpenHelper, otra para la clase SQLiteDatabase y una última para el contexto de la actividad que usará la base de datos.

– Hay que crear una clase privada dentro de nuestra clase de la base de datos. Ésta clase extenderá a SQLiteOpenHelper y contendrá los métodos:

DataBaseHelper(Context): constructor de la clase. onCreate(SQLiteDatabase): método que crea la base de datos. Hay que crear cada una de las tablas. onUpgrade(SQLiteDataBase,int, int): método que se ejecuta si el programa tiene una nueva versión de la base de datos con respecto a la guardada en el móvil. Hay que borrar todas las tablas y llamar a onCreate.

– El constructor de la clase sólo se encargará de guardar el contexto de la actividad que use la base de datos.

– Crear los métodos para abrir y cerrar la base de datos.

– Crear métodos para poder acceder a las tablas, insertar datos nuevos y editar datos ya existentes.

- Ejercicio 17;

Completar la actividad de presentación de la aplicación, cambiando la lógica del diálogo que se muestra al pulsar sobre el botón entrar. Hay que comprobar que el usuario introducido es el correcto, para ello debemos acceder al servidor SOAP y a la base de datos local. Pistas:

– Si, desde el ejercicio 5, al pulsar el botón de aceptar en el diálogo de la actividad de presentación, entrábamos directamente en la actividad del mapa. Ahora


8

tenemos que comprobar el usuario con el servidor y con nuestra base de datos. Para ello nos basaremos en el siguiente código (Copiar al proyecto):

/** 17

* Método que comprueba si existe el usuario en el servidor y si no lo añade. Tras saber que el usuario

* está en el servidor, arranca la actividad del mapa pasándole el usuario y password del usuario de la aplicación.

* * @param usuario * @param password */ private void compruebaUsuario(String usuario, String password){

datos. //Vamos a cargar las opciones para este usuario, desde la base de

//Si el usario no existiera en el servidor, lo crearíamos. int resultado = mConSOAP.checkUser(usuario, password); switch(resultado){

//Si el usuario existe en el servidor. case 1:

Toast.makeText(AplicacionCurso.this, "Acceso correcto! Abriendo el mapa...", Toast.LENGTH_SHORT).show();

//Abrimos la actividad del mapa. conectaActividadMapa(usuario, password);

break;

//Si el usuario no existe en el servidor.

case -2: Toast.makeText(AplicacionCurso.this, "El usuario no existe, se

añadirá al servidor y se cargarán valores por defecto en la aplicación", Toast.LENGTH_SHORT).show();

//Añadimos el usuario en el servidor resultado = mConSOAP.addUser(usuario, password); if(resultado<1){

//Error al intentar añadir el usuario. Toast.makeText(AplicacionCurso.this, "Error en el acceso

al servidor, inténtelo de nuevo.",

}

else{

actividad del mapa.

Toast.LENGTH_SHORT).show();

//Se ha añadido el usuario al servidor, abrimos la

conectaActividadMapa(usuario, password);

} break;

//Si la contraseña de usuario es incorrecta

case -3: Toast.makeText(AplicacionCurso.this, "Contraseña incorrecta!

Introduzcala de nuevo.",

break; Toast.LENGTH_SHORT).show();

//Error al acceder al servidor case -1:

Toast.makeText(AplicacionCurso.this, "Error en el acceso al servidor, inténtelo de nuevo.",


9

break; }

}

Toast.LENGTH_SHORT).show();

/** 17 * Método que comprueba que el usuario tiene una cuenta en local. Si no la

tiene le carga los valores de opciones * por defecto. * * @param usuario Usuario de la aplicación. * @param password Contraseña del usuario. */ private void conectaActividadMapa(String usuario, String password){

}

– Crear una variable pública del tipo ConectaSoap para poder conectarnos al servidor y que se usará en los métodos antes mencionados.

– Rellenar el código del método conectaActividadMapa con el acceso a la base de datos para comprobar el usuario y si la comprobación es correcta, lanzar la actividad llamando al método lanzaActividad que ya teníamos creado.

- Ejercicio 18:

Crear en la clase de la actividad mapa una variable pública del tipo ConectaSoap. En el evento onOptionsItemSelected llamar, en el caso de haber pulsado el botón de añadir amigo, al método muestraDialogoAmigoNuevo. Crear el método muestraDialogoAmigoNuevo que muestra un diálogo del tipo AlertDialog con un EditText en él, el diálogo dará la opción de añadir el amigo. Añadir el amigo al nombre de usuario en el servidor. Pistas:

– Para el caso del botón de aceptar del diálogo, copiar el siguiente código:

//Creamos el evento de pulsación del botón aceptar.

constructor.setPositiveButton(R.string.aceptar, new DialogInterface.OnClickListener() {

public void onClick(DialogInterface dialog, int which) {

if(editAmigo.getText().length()>0){ int resultado = mConSOAP.addFriend(mUsuario,

mPassword, editAmigo.getText().toString()); //Devuelve 1 si la operación se ha realizado

correctamente, -4 si el nombre de amigo es igual al nuestro, // -5 si el amigo ya existe, en otro caso se ha

producido un error en la operacion. switch(resultado){

case 1: Toast.makeText(ActividadMapa.this,

R.string.amigoExito, Toast.LENGTH_SHORT).show(); break; case -4:


0

Toast.makeText(ActividadMapa.this, R.string.nomAmigoIgual, Toast.LENGTH_SHORT).show();

break; case -5:

Toast.makeText(ActividadMapa.this, R.string.amigoYaExiste, Toast.LENGTH_SHORT).show();

break; default:

Toast.makeText(ActividadMapa.this, R.string.falloOperacion, Toast.LENGTH_SHORT).show();

break;

}

else{

} dialog.dismiss();

Toast.makeText(ActividadMapa.this, "Escribe un nombre de usuario", Toast.LENGTH_SHORT).show();

} }

});

- Ejercicio 19:

Rellenar el método onActivityResult. Comprobar los datos que nos devuelve la actividad lista y, si ha habido cambios,guardarlos en la base de datos. Pista:

– Recordar que si se ha borrado la lista de lugares no hay que añadir la lista a los

overlays del mapa.

- Ejercicio 20:

Crear el código necesario para que cuando se pulse el botón de cambio de búsqueda se cambie el tipo de búsqueda entre amigo y lugar. Pista:

– Crear variable pública booleana que marque si estamos buscando un lugar o un amigo.

– Comprobar la variable cada vez que se busque un texto en la barra de búsqueda.

– Falta por implementar el método que busca en los overlays de amigo. Usar un ListIterator para recorrer los overlays del mapa y el método getClass para reconocer el tipo del overlay.

- Ejercicio 21:

Crear el código para poder borrar y agregar lugares usando la base de datos de la


1

aplicación. Pista:

– Al abrir la actividad mapa hay que comprobar los lugares guardados en la base de datos y añadirlos al mapa.

– En el método onActivityResult si se resetea la lista de lugares, hacerlo también en la base de datos.

– Al añadir un lugar al mapa lo añadimos también a la base de datos.

– Crear un método en la clase base de datos para recoger los lugares que tenga guardados.

- Ejercicio 22:

Crear una clase privada a la clase de la actividad mapa que extienda de Thread y que implemente la búsuqeda de amigos en el servidor, añadiéndolos al mapa. Pista:

– Crear un objeto manejador Handler público a la clase mapa, para ejecutar código en el hilo principal desde el hilo que lo llame.

– Crear éste hilo cuando se pulse sobre buscar amigos en el menú.

– Copiar el siguiente código para el método run de la clase tipo hilo y rellenar la parte que falta de los accesos al mapa.

/** * Método que se ejecuta al llamar a start() en el objeto hilo.

*/

public void run(){

//Añadimos los otros overlays que había en el mapa. Lo hacemos mediante un manejador, para poder

//acceder desde este hilo al principal. mManejador.post(new Runnable() {

public void run() { //RELLENAR

} });

//Vamos a recoger los amigos del servidor SOAP final ArrayList<String> amigos; if(mRadioAmigos>0)

amigos = mConSOAP.getFriendsByDistance(mUsuario, mPassword, mRadioAmigos);

else

amigos = mConSOAP.getFriends(mUsuario, mPassword);

String amigo; GeoPoint g;

//Recorremos los amigos recogidos del servidor y los añadimos si tenemos la visibilidad activada.


2

for(int i=0;i<amigos.size();i=i+2){

//RELLENAR

} }

- Ejercicio 23:

Agregar un timer que ejecute un proceso de búsqueda de usuario cada cierto tiempo. Pista:

– Usar la clase Runnable para crear el proceso a ejecutar (nueva variable pública de tipo Runnable).

– El proceso será el mismo que el del ejercicio 22.

– Para ejecutar el objeto Runnable como si fuera un timer, necesitares llamarlo con el manejador que creamos en el ejercicio 22, usar el método postDelayed marcando el tiempo que queremos que espere.

– Hay que devolver en la actividad lista, cuando se salvan las opciones en ella, el intervalo en el que se ejecutará dicho timer.

– Al lanzar la actividad lista, habrá que eliminar el timer con el método removeCallBack en el Handler.

– Hacemos lo mismo cada vez que se llame al hilo de buscar amigos, al final del proceso del hilo se volverá a crear.

Para completar el código de la aplicación copiar el siguiente código en la clase que recibe los eventos del LocationListener:

//23 Guardamos la posición en el servidor SOAP.

mLocalAnterior50m = location; Double latitud = location.getLatitude()*1000000; Double longitud = location.getLongitude()*1000000;

if(mConSOAP.addUserLocation(mUsuario,

mPassword, latitud.intValue(), longitud.intValue())<0) Toast.makeText(ActividadMapa.this, "Problema al

subir la posición actual al servidor.", Toast.LENGTH_SHORT);

Agregar también, estos dos métodos a la clase de la actividad mapa.

/**23 Método que devuelve el usuario de la aplicación.

* * @return El usuario que está usando la actividad en el momento. */ public static String getUsuario(){

return mUsuario; }


3

/**23 Método que devuelve la contraseña del usuario de la aplicación.

* * @return El password del usuario que está usando la actividad en el

momento. */ public static String getPassword(){

return mPassword; }

- Ejercicio 24:

Acabar la clase de la actividad lista con la conexión al servidor para cambiar el usuario, cuando el usuario pulse sobre dicha opción en la lista. Pista:

– Rellenar el método onClick del evento del botón aceptar del diálogo para cambiar el usuario.

- Ejercicio 25:

Copiar el siguiente método en la actividad mapa.

/**25 Método que se ejecuta cuando cerramos la aplicación.

* */ protected void onDestroy() {

mMapa.destroyDrawingCache(); mMapOverlays.clear(); mMiPosicion.disableMyLocation(); mLocationControl.removeUpdates(mLocationListener); mManejador.removeCallbacks(mUpdateTimeTask); super.onDestroy();

}


4

- Extra 1: El simulador de GPS y cómo crear rutas para él.

El simulador de GPS es una de las funcionalidades más importantes del SDK de Android, nos permite comunicar localizaciones al móvil, como de un GPS se tratara.

Para usar el simulador de GPS, debemos de ir, en Eclipse, a la vista del DDSM, y en él buscar la pestaña de Emulator control y en ella buscar la pestaña kml. En esta pestaña añadiremos el archivo que deseemos y podremos dirigirnos a las localizaciones que se nos carguen clickeando sobre ellas o pulsando sobre el botón play.

Aquí se explicará cómo usar archivos kml. Para crear rutas en archivos kml usaremos Google Earth. En él usando la funcionalidad de Directions podemos crear una ruta desde un punto a otro. Cuando el programa cree la ruta, pulsamos sobre Route y la salvamos con extensión kml.

Éste archivo kml no es compatible con el emulador de Android. Hay que transformarlo en uno compatible, para ello, abrimos la web http://ge2adt.appspot.com/ en el navegador y tras introducir nuestro usuario de Google, le pasamos el archivo kml de Google Earth. El archivo resultante será un archivo compatible con el emulador de Android.

- Extra 2: Configurar regiones para el funcionamiento del simulador GPS.

Para que el simulador GPS funcione correctamente deberemos de configurar Eclipse para la localización americana. Añadiremos en el fichero Eclipse.ini de la carpeta de Eclipse el comando – Duser.language=en.

Arrancando Eclipse con esta configuración no deberíamos de tener más problemas, pero si los tuviéramos nos aseguraremos de que el emulador está configurado en la región americana y como también lo está en el tiempo americano.

http://ge2adt.appspot.com/

Curso Android

Documents

Transcript of Curso Android