En este momento muchos de vosotros seguro que habréis pensando: “Yo ya he aprendido a usar el control TabWidget en un artículo anterior de tu curso. ¿por qué iba a querer aprender otra forma de utilizar pestañas?“. Pues bien, además de convertirnos instantaneamente en programadores mucho más modernos y elegantes por utilizar fragments para nuestros tabs :), el hecho de enlazar una lista de pestañas con la action bar tiene una serie de ventajas adicionales, relacionadas sobre todo con la adaptación de tu interfaz a distintos tamaños y configuraciones de pantalla. Así, por ejemplo, si Android detecta que hay suficiente espacio disponible en la action bar, integrará las pestañas dentro de la propia action bar de forma que no ocupen espacio extra en la pantalla. Si por el contrario no hubiera espacio suficiente colocaría las pestañas bajo la action bar como de costumbre. Más tarde veremos un ejemplo gráfico de esto, pero ahora empecemos.

Lo primero que debemos hacer será crear un nuevo fragment para albergar el contenido de cada una de las pestañas que tendrá nuestra aplicación. Como ya vimos en el artículo dedicado a los fragments, necesitaremos crear como mínimo una pareja de ficheros para cada fragment, el primero para el layout XML y el segundo para su código java asociado. Para el caso de ejemplo de este artículo, que partirá del ya construido en el artículo anterior, incluiré tan sólo dos pestañas, y los ficheros asociados a ellas los llamaré de la siguiente forma:

Pestaña 1:

• Tab1Fragment.java
• fragment1.xml

Pestaña 2:

• Tab2Fragment.java
• fragment2.xml

La interfaz de los fragmets será mínima para no complicar el ejemplo, y contendrán únicamente una etiqueta de texto “Tab 1″ o “Tab 2″ para poder diferenciarlas. Por ejemplo para la pestaña 1 tendríamos un fichero fragment1.xml con el siguiente contenido:

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

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

</LinearLayout>

Por su parte, su clase java asociada Tab1Fragment.java no tendrá ninguna funcionalidad, por lo que el código se limita a inflar el layout y poco más:

package net.sgoliver.android.actionbartabs;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class Tab1Fragment extends Fragment {
	@Override
	public View onCreateView(LayoutInflater inflater,
			ViewGroup container, Bundle savedInstanceState) {
		return inflater.inflate(R.layout.fragment1, container, false);
	}
}

Con esto ya tendríamos preparado el contenido de nuestras pestañas, y nos quedaría añadirlas a nuestra aplicación, enlazarlas con la action bar, y asignarles un listener desde el que poder responder a los eventos que se produzcan.

Vamos a empezar por el último paso, crear el listener. Como he comentado, este listener debe contener el código asociado a los eventos clásicos de las pestañas  (normalmente la selección, reselección, o deselección de pestañas) y entre otras cosas tendrá que encargarse de mostrar en cada momento el fragment correspondiente a la pestaña seleccionada. Hay muchas formas de implementar este listener, y sé que la que yo voy a mostrar aquí no es la mejor de todas, pero sí es de las más sencillas para empezar. Vamos a crear nuestro listener creando una nueva clase que extienda de ActionBar.TabListener, en mi caso la llamaré MiTabListener (en un alarde de genialidad). Dentro de esta clase tendremos que sobrescribir los métodos de los eventos onTabSelected(), onTabUnselected() y onTabReselected(). Creo que el nombre de cada uno explica por sí solo lo que hacen. Veamos primero el código:

package net.sgoliver.android.actionbartabs;

import android.app.ActionBar;
import android.app.Fragment;
import android.app.FragmentTransaction;
import android.app.ActionBar.Tab;
import android.util.Log;

public class MiTabListener implements ActionBar.TabListener {

	private Fragment fragment;

	public MiTabListener(Fragment fg)
	{
		this.fragment = fg;
	}

	@Override
	public void onTabReselected(Tab tab, FragmentTransaction ft) {
		Log.i("ActionBar", tab.getText() + " reseleccionada.");
	}

	@Override
	public void onTabSelected(Tab tab, FragmentTransaction ft) {
		Log.i("ActionBar", tab.getText() + " seleccionada.");
		ft.replace(R.id.contenedor, fragment);
	}

	@Override
	public void onTabUnselected(Tab tab, FragmentTransaction ft) {
		Log.i("ActionBar", tab.getText() + " deseleccionada.");
		ft.remove(fragment);
	}
}

Para solucionar esto, y con la intención de facilitar aún más la tarea de seguir los tutoriales, he decidido crear un proyecto en GitHub donde iré añadiendo todos los proyectos de ejemplo desarrollados en los diferentes artículos del curso. De esta forma, además de seguir contando con la posibilidad de descargar todo el código en un ZIP, podréis acceder y consultar online cada fichero de cada proyecto del curso.

Al final de cada artículo colocaré el enlace al proyecto de ejemplo correspondiente en GitHub (ojo, aún no están todos, estoy en pleno proceso de actualización). Al pulsarlo, accederéis a una página similar a la de la siguiente imagen (click para ampliar):

Mediante el botón “ZIP” (marcador 2) podréis descargar el código completo del curso en formato ZIP, y para visualizar online el contenido de cualquier fichero o carpeta no tendréis más que pulsar sobre él en el listado de la parte inferior (marcador 1). Si accedéis por ejemplo a algún fichero de código veréis algo como lo siguiente (click para ampliar):

Por otro lado, si tenéis usuario de GitHub y accedéis con él también podréis activar las opciones de seguimiento del proyecto (Watch) o  marcarlo como favorito (Star) (marcador 3). Y por supuesto, como cualquier otro proyecto de GitHub, también podréis crear vuestro propio fork para trabajar sobre él (marcador 4).

En fin, espero que esto os ayude a seguir el curso más fácilmente que antes. Saludos.

Me enorgullece comprobar cómo el número de visitas totales se ha duplicado respecto al año pasado, llegando en esta ocasión hasta casi las 900,000 visitas, con casi 400.000 visitantes únicos, un 110% superior al 2011. El número de páginas vistas también se duplica respecto al dato anterior, sobrepasando los 2,5 millones de páginas.

El número de páginas vistas por visita se ha reducido ligeramente, de 2.92 a 2.88, probablemente debido a la reorganización de las páginas del blog dedicadas al Curso de Programación Android, aunque de cualquier forma habrá que trabajar en este dato durante 2013. Sin embargo, el tiempo medio por visita ha aumentado casi un 11,68% llegando casi a los 6 minutos.

Por último, el porcentaje de rebote practicamente se mantiene respecto al año pasado quedando en un 53.37%, un 0.21% mejor que e 2011.

Si miramos ahora la procedencia de los visitantes del blog, el panorama es exactamente el mismo que en 2011, salvo Estados Unidos que ha caido un puesto:

Una vez más, mi más sincero agradecimiento a los lectores de América central y del Sur por seguirme desde el otro lado del charco.

Por otro lado, las páginas más visitadas en el año 2012 han vuelto a ser con gran diferencia las dedicadas al Curso de Programación Android, especialmente el índice de contenidos, la sección dedicada a la obtención del curso en formato PDF, y los artículos iniciales sobre la instalación y configuración del entorno de desarrollo para Android, la estructura de un proyecto Android, y la creación de una aplicación Android sencilla de ejemplo.

En definitiva, unos números que jamás hubiera imaginado cuando comencé a escribir este blog, que han mejorado enormemente en los dos últimos años gracias a la gran acogida del Curso de Programación Android que continúo publicando y mejorando poco a poco, y que espero que siga creciendo durante este nuevo año 2013 que acabamos de recibir. Muchas gracias a todos por vuestro apoyo y colaboración, y espero seguir dando motivos este 2013 para que sigáis visitando mi humilde morada en la web. Feliz 2013!

En este último artículo de la serie nos vamos a centrar en los eventos del mapa que podemos capturar y tratar, en la creación y gestión de marcadores, y en el dibujo de lineas y polígonos sobre el mapa.

Sin más preámbulos, comencemos con los eventos. Si hacemos un poco de memoria, con la versión anterior de la API debíamos crear una nueva capa (overlay) para capturar los eventos principales de pulsación. Sin embargo, el nuevo componente de mapas soporta directamente los eventos de click, click largo y movimiento de cámara y podemos implementarlos de la forma habitual, mediante su método set correspondiente.

Así por ejemplo, podríamos implementar el evento de onclick llamando al método setOnMapClickListener() con un nuevo listener y sobrescribir el método onMapClick(). Este método recibe como parámetro, en forma de objeto LatLng, las coordenadas de latitud y longitud sobre las que ha pulsado el usuario. Si quisiéramos traducir estas coordenadas física en coordenadas en pantalla podríamos utilizar un objeto Projection (similar al que ya comentamos para la API v1), obteniéndolo a partir del mapa a través del método getProjection() y posteriormente llamando a toScreenLocation() para obtener las coordenadas (x,y) de pantalla donde el usuario pulsó.

Así, por ejemplo, si quisiéramos mostrar un Toast con todos estos datos cada vez que se pulse sobre el mapa podríamos hacer lo siguiente:

mapa.setOnMapClickListener(new OnMapClickListener() {
	public void onMapClick(LatLng point) {
		Projection proj = mapa.getProjection();
		Point coord = proj.toScreenLocation(point);

		Toast.makeText(
			MainActivity.this,
			"Click\n" +
			"Lat: " + point.latitude + "\n" +
			"Lng: " + point.longitude + "\n" +
			"X: " + coord.x + " - Y: " + coord.y,
			Toast.LENGTH_SHORT).show();
	}
});

De forma similar podríamos implementar el evento de pulsación larga, con la única diferencia de que lo asignaríamos mediante setOnMapLongClickListener() y sobrescribiríamos el método onMapLongClick().

mapa.setOnMapLongClickListener(new OnMapLongClickListener() {
	public void onMapLongClick(LatLng point) {
		Projection proj = mapa.getProjection();
		Point coord = proj.toScreenLocation(point);

		Toast.makeText(
			MainActivity.this,
			"Click Largo\n" +
			"Lat: " + point.latitude + "\n" +
			"Lng: " + point.longitude + "\n" +
			"X: " + coord.x + " - Y: " + coord.y,
			Toast.LENGTH_SHORT).show();
	}
});

Así, cuando el usuario hiciera una pulsación larga sobre el mapa veríamos los datos en pantalla de la siguiente forma:

También podremos capturar el evento de cambio de cámara, de forma que podamos realizar determinadas acciones cada vez que el usuario se mueve manualmente por el mapa, desplazándolo, haciendo zoom, o modificando la orientación o el ángulo de visión. Este evento lo asignaremos al mapa mediante su método setOnCameraChangeListener() y sobrescribiendo el método onCameraChange(). Este método recibe como parámetro un objeto CameraPosition, que ya vimos en el artículo anterior, por lo que podremos recuperar de él todos los datos de la cámara en cualquier momento.

De esta forma, si quisiéramos mostrar un Toast con todos los datos podríamos hacer lo siguiente:

mapa.setOnCameraChangeListener(new OnCameraChangeListener() {
	public void onCameraChange(CameraPosition position) {
		Toast.makeText(
			MainActivity.this,
			"Cambio Cámara\n" +
			"Lat: " + position.target.latitude + "\n" +
			"Lng: " + position.target.longitude + "\n" +
			"Zoom: " + position.zoom + "\n" +
			"Orientación: " + position.bearing + "\n" +
			"Ángulo: " + position.tilt,
			Toast.LENGTH_SHORT).show();
	}
});

Hecho esto, cada vez que el usuario se mueva por el mapa veríamos lo siguiente:

El siguiente tema importante que quería tratar en este artículo es el de los marcadores. Rara es la aplicación Android que hace uso de mapas sin utilizar también este tipo de elementos para resaltar determinados puntos en el mapa. Si recordamos el artículo sobre la API v1, vimos cómo podíamos añadir marcadores añadiendo una nueva capa (overlay) al mapa y dibujando nuestro marcador como parte de su evento draw(). En la nueva versión de la API tendemos toda esta funcionalidad integrada en la propia vista de mapa, y agregar un marcador resulta tan sencillo como llamar al método addMarker() pasándole la posición en forma de objeto LatLng y el texto a mostrar en la ventana de información del marcador. En nuestra aplicación de ejemplo añadiremos un menú de forma que cuando lo pulsemos se añada automáticamente un marcador sobre España con el texto “Pais: España“. Veamos cómo escribir un método auxiliar que nos ayuda a hacer esto pasándole las coordenadas de latitud y longitud:

private void mostrarMarcador(double lat, double lng)
{
    mapa.addMarker(new MarkerOptions()
        .position(new LatLng(lat, lng))
        .title("Pais: España"));
}

Así de sencillo, basta con llamar al método addMarker() pasando como parámetro un nuevo objeto MarkerOptions sobre el que establecemos la posición del marcador (método position()) y el texto a incluir en la ventana de información del marcador (métodos title() para el título y snippet() para el resto del texto). Si ejecutamos la aplicación de ejemplo y pulsamos el menú “Marcadores” aparecerá el siguiente marcador sobre el mapa (la ventana de información aparece si además se pulsa sobre el marcador):

Además de facilitarnos la vida con la inclusión de marcadores en el mapa también tendremos ayuda a la hora de capturar el evento de pulsación sobre un marcador, ya que podremos asignar al mapa dicho evento como cualquiera de los comentados anteriormente. En este caso el evento se asignará al mapa mediante el método setOnMarkerClickListener() y sobrescribiremos el método onMarkerClick(). Dicho método recibe como parámetro el objeto Marker pulsado, de forma que podamos identificarlo accediendo a su información (posición, título, texto, …). Veamos un ejemplo donde mostramos un toast con el título del marcador pulsado:

mapa.setOnMarkerClickListener(new OnMarkerClickListener() {
	public boolean onMarkerClick(Marker marker) {
		Toast.makeText(
			MainActivity.this,
			"Marcador pulsado:\n" +
			marker.getTitle(),
			Toast.LENGTH_SHORT).show();

		return false;
	}
});

Con el código anterior, si pulsamos sobre el marcador de España aparecerá el siguiente mensaje informativo:

Todo lo explicado sobre marcadores corresponde al comportamiento por defecto de la API, sin embargo también es posible por supuesto personalizar determinadas cosas, como por ejemplo el aspecto de los marcadores. Esto se sale un poco de este artículo, donde pretendía describir los temas más básicos, pero para quien esté interesado tan sólo decir que mediante los métodos icon() y anchor() del objeto MakerOptions que hemos visto antes es posible utilizar una imagen personalizada para mostrar como marcador en el mapa. En la documentación oficial (en inglés) podéis encontrar un ejemplo de cómo hacer esto.

Como último tema, vamos a ver cómo dibujar líneas y polígonos sobre el mapa, elementos muy comunmente utilizados para trazar rutas o delimitar zonas del mapa. Para realizar esto en la versión 2 de la API vamos a actuar una vez más directamente sobre la vista de mapa, sin necesidad de añadir overlays o similares, y ayudándonos de los objetos PolylineOptions y PolygonOptions respectivamente.

Para dibujar una linea lo primero que tendremos que hacer será crear un nuevo objeto PolylineOptions sobre el que añadiremos utilizando su método add() las coordenadas (latitud-longitud) de todos los puntos que conformen la linea. Tras esto estableceremos el grosor y color de la linea llamando a los métodos width() y color() respectivamente, y por último añadiremos la linea al mapa mediante su método addPolyline() pasándole el objeto PolylineOptions recién creado.

En nuestra aplicación de ejemplo he añadido un nuevo menú para dibujar un rectángulo sobre España. Veamos cómo queda:

private void mostrarLineas()
{
	//Dibujo con Lineas

	PolylineOptions lineas = new PolylineOptions()
	        .add(new LatLng(45.0, -12.0))
	        .add(new LatLng(45.0, 5.0))
	        .add(new LatLng(34.5, 5.0))
	        .add(new LatLng(34.5, -12.0))
	        .add(new LatLng(45.0, -12.0));

	lineas.width(8);
	lineas.color(Color.RED);

	mapa.addPolyline(lineas);
}

Ejecutando esta acción en el emulador veríamos lo siguiente:

Pues bien, esto mismo podríamos haberlo logrado mediante el dibujo de polígonos, cuyo funcionamiento es muy similar. Para ello crearíamos un nuevo objeto PolygonOptions y añadiremos las coordenadas de sus puntos en el sentido de las agujas del reloj. En este caso no es necesario cerrar el circuito (es decir, que la primera coordenada y la última fueran iguales) ya que se hace de forma automática. Otra diferencia es que para polígonos el ancho y color de la linea los estableceríamos mediante los métodos strokeWidth() y strokeColor(). Además, el dibujo final del polígono sobre el mapa lo haríamos mediante addPolygon(). En nuestro caso quedaría como sigue:

//Dibujo con polígonos

PolygonOptions rectangulo = new PolygonOptions()
              .add(new LatLng(45.0, -12.0),
            	   new LatLng(45.0, 5.0),
            	   new LatLng(34.5, 5.0),
            	   new LatLng(34.5, -12.0),
            	   new LatLng(45.0, -12.0));

rectangulo.strokeWidth(8);
rectangulo.strokeColor(Color.RED);

mapa.addPolygon(rectangulo);

El resultado al ejecutar la acción en el emulador debería ser exactamente igual que el anterior.

Puedes consultar y/o descargar el código completo de los ejemplos desarrollados en este artículo accediendo a la pagina del curso en GitHub.

Y con esto habríamos concluido la serie de tres artículos destinados a describir el funcionamiento básico de la nueva API v2 de Google Maps para Android. Espero haber aclarado las dudas principales a la hora de comenzar a utilizar la nueva API. Tampoco descarto algún artículo adicional para comentar temas algo más avanzados sobre esta API, pero eso será más adelante.

En esta segunda entrega vamos a hacer un repaso de las opciones básicas de los nuevos mapas:  elegir el tipo de mapa a mostrar, movernos por él de forma programática, y obtener los datos de la posición actual. Como aplicación de ejemplo (que podéis descargar al final de este artículo), tomaremos como base la ya creada en el artículo anterior, a la que añadiremos varias opciones de menú para demostrar el funcionamiento de algunas funciones del mapa.

Si hacemos un poco de memoria, recordaremos cómo en la antigua versión de la API de Google Maps era bastante poco homogéneo el acceso y modificación de determinados datos del mapa. Por ejemplo, la consulta de la posición actual o la configuración del tipo de mapa se hacían directamente sobre el control MapView, mientras que la manipulación de la posición y el zoom se hacían a través del controlador asociado al mapa (MapController). Además, el tratamiento de las coordenadas y las unidades utilizadas eran algo peculiares, teniendo estar continuamente convirtiendo de grados a microgrados y de estos a objetos GeoPoint, etc.

Con la nueva API, todas las operaciones se realizarán directamente sobre un objeto GoogleMap, el componente base de la API. Accederemos a este componente llamando al método getMap() del fragmento MapFragment que contenga nuestro mapa. Podríamos hacerlo de la siguiente forma:

import com.google.android.gms.maps.GoogleMap;
...
GoogleMap mapa = ((SupportMapFragment) getSupportFragmentManager()
                          .findFragmentById(R.id.map)).getMap();

Una vez obtenida esta referencia a nuestro objeto GoogleMap podremos realizar sobre él la mayoría de las acciones básicas del mapa.

Así, por ejemplo, para modificar el tipo de mapa mostrado podremos utilizar una llamada a su método setMapType(), pasando como parámetro el tipo de mapa:

• MAP_TYPE_NORMAL
• MAP_TYPE_HYBRID
• MAP_TYPE_SATELLITE
• MAP_TYPE_TERRAIN

Para nuestro ejemplo voy a utilizar una variable que almacene el tipo de mapa actual (del 0 al 3) y habilitaremos una opción de menú para ir alternando entre las distintas opciones. Quedaría de la siguiente forma:

private void alternarVista()
{
	vista = (vista + 1) % 4;

	switch(vista)
	{
		case 0:
			mapa.setMapType(GoogleMap.MAP_TYPE_NORMAL);
			break;
		case 1:
			mapa.setMapType(GoogleMap.MAP_TYPE_HYBRID);
			break;
		case 2:
			mapa.setMapType(GoogleMap.MAP_TYPE_SATELLITE);
			break;
		case 3:
			mapa.setMapType(GoogleMap.MAP_TYPE_TERRAIN);
			break;
	}
}

En cuanto al movimiento sobre el mapa, con esta nueva versión de la API vamos a tener mucha más libertad que con la anterior versión, ya que podremos mover libremente nuestro punto de vista (o cámara, como lo han llamado los chicos de Android) por un espacio 3D. De esta forma, ya no sólo podremos hablar de latitud-longitud (target) y zoom, sino también de orientación (bearing) y ángulo de visión (tilt). La manipulación de los 2 últimos parámetros unida a posibilidad actual de ver edificios en 3D de muchas ciudades nos abren un mundo de posibilidades.

El movimiento de la cámara se va a realizar siempre mediante la construcción de un objeto CameraUpdate con los parámetros necesarios. Para los movimientos más básicos como la actualización de la latitud y longitud o el nivel de zoom podremos utilizar la clase CameraUpdateFactory y sus métodos estáticos que nos facilitará un poco el trabajo.

Así por ejemplo, para cambiar sólo el nivel de zoom podremos utilizar los siguientes métodos para crear nuestro CameraUpdate:

• CameraUpdateFactory.zoomIn(). Aumenta en 1 el nivel de zoom.
• CameraUpdateFactory.zoomOut(). Disminuye en 1 el nivel de zoom.
• CameraUpdateFactory.zoomTo(nivel_de_zoom). Establece el nivel de zoom.

Por su parte, para actualizar sólo la latitud-longitud de la cámara podremos utilizar:

• CameraUpdateFactory.newLatLng(lat, long). Establece la lat-lng expresadas en grados.

Si queremos modificar los dos parámetros anteriores de forma conjunta, también tendremos disponible el método siguiente:

• CameraUpdateFactory.newLatLngZoom(lat, long, zoom). Establece la lat-lng y el zoom.

Para movernos lateralmente por el mapa (panning) podríamos utilizar los métodos de scroll:

• CameraUpdateFactory.scrollBy(scrollHorizontal, scrollVertical). Scroll expresado en píxeles.

Tras construir el objeto CameraUpdate con los parámetros de posición tendremos que llamar a los métodos moveCamera() o animateCamera() de nuestro objeto GoogleMap, dependiendo de si queremos que la actualización de la vista se muestre directamente o de forma animada.

Con esto en cuenta, si quisiéramos por ejemplo centrar la vista en España con un zoom de 5 podríamos hacer lo siguiente:

CameraUpdate camUpd1 =
	CameraUpdateFactory.newLatLng(new LatLng(40.41, -3.69));

mapa.moveCamera(camUpd1);

Además de los movimientos básicos que hemos comentado, si queremos modificar los demás parámetros de la cámara o varios de ellos simultaneamente tendremos disponible el método más general CameraUpdateFactory.newCameraPosition() que recibe como parámetro un objeto de tipo CameraPosition. Este objeto los construiremos indicando todos los parámetros de la posición de la cámara a través de su método Builder() de la siguiente forma:

LatLng madrid = new LatLng(40.417325, -3.683081);
CameraPosition camPos = new CameraPosition.Builder()
	    .target(madrid)   //Centramos el mapa en Madrid
	    .zoom(19)         //Establecemos el zoom en 19
	    .bearing(45)      //Establecemos la orientación con el noreste arriba
	    .tilt(70)         //Bajamos el punto de vista de la cámara 70 grados
	    .build();

CameraUpdate camUpd3 =
	CameraUpdateFactory.newCameraPosition(camPos);

mapa.animateCamera(camUpd3);

Como podemos comprobar, mediante este mecanismo podemos modificar todos los parámetros de posición de la cámara (o sólo algunos de ellos) al mismo tiempo. En nuestro caso de ejemplo hemos centrado la vista del mapa sobre el parque de El Retiro de Madrid, con un nivel de zoom de 19, una orientación de 45 grados para que el noreste esté hacia arriba y un ángulo de visión de 70 grados de forma que veamos en 3D el monumento a Alfonso XII en la vista de mapa NORMAL. En la siguiente imagen vemos el resultado:

Como podéis ver, en esta nueva versión de la API se facilita bastante el posicionamiento dentro del mapa, y el uso de las clases CameraUpdate y CameraPosition resulta bastante intuitivo.

Bien, pues ya hemos hablado de cómo modificar nuestro punto de vista sobre el mapa, pero si el usuario se mueve de forma manual por él, ¿cómo podemos conocer en un momento dado la posición de la cámara?

Pues igual de fácil, mediante el método getCameraPosition(), que nos devuelve un objeto CameraPosition como el que ya conocíamos. Accediendo a los distintos métodos y propiedades de este objeto podemos conocer con exactitud la posición de la cámara, la orientación y el nivel de zoom.

CameraPosition camPos = mapa.getCameraPosition();

LatLng coordenadas = camPos.target;
double latitud = coordenadas.latitude;
double longitud = coordenadas.longitude;

float zoom = camPos.zoom;
float orientacion = camPos.bearing;
float angulo = camPos.titl;

En nuestra aplicación de ejemplo, que podéis descargar al final del artículo, he añadido una nueva opción de menú que muestra en un mensaje toast la latitud y longitud actual de la vista de mapa.

Y con esto habríamos terminado de describir las acciones básicas de configuración y movimiento sobre el mapa. En los próximos artículos veremos más opciones, como la forma de añadir marcadores o dibujar sobre el mapa.

Puedes consultar y/o descargar el código completo de los ejemplos desarrollados en este artículo accediendo a la pagina del curso en GitHub.

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

Al margen de las novedades generales, como desarrolladores ¿qué diferencias nos vamos a encontrar con respecto a la API anterior a la hora de desarrollar nuestras aplicaciones Android?

Pues la principal será el componente que utilizaremos para la inclusión de mapas en nuestra aplicación. Si recordamos la anterior versión de la API, para incluir un mapa en la aplicación debíamos utilizar un control de tipo MapView, que además requería que su actividad contenedora fuera del tipo MapActivity. Con la nueva API nos olvidaremos de estos dos componentes y pasaremos a tener sólo uno, un nuevo tipo específico de fragment llamado MapFragment. Esto nos permitirá entre otras cosas añadir uno [o varios, esto también es una novedad] mapas a cualquier actividad, sea del tipo que sea, y contando por supuesto con todas las ventajas del uso de fragments. Nota importante: dado que el nuevo control de mapas se basa en fragments, si queremos mantener la compatibilidad con versiones de Android anteriores a la 3.0 tendremos que utilizar la librería de soporte android-support. Más adelante veremos más detalles sobre esto.

Además de esta novedad, la integración de la API con los Google Play Services y la Consola de APIs de Google, harán que los preparativos del entorno, las librerías utilizadas, y el proceso de obtención de la API Key de Google Maps sean un poco distintos a los que ya vimos en los artículos dedicados la primera versión.

Pues bien, en este nuevo artículo del Curso de Programación Android vamos a describir los pasos necesarios para hacer uso de la nueva versión de la API de mapas de Google (Google Maps Android API v2).

Como en los artículos previos donde aprendimos a utilizar la API v1, en este caso también será necesario realizar algunos preparativos y tareas previas antes de poder empezar a utilizarlos en nuestras aplicaciones.

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

Tras pulsar el botón de Install y aceptar la licencia correspondiente el paquete quedará instalado en nuestro sistema, concretamente en la ruta: <carpeta-sdk-android>/extras/google/google_play_services/. Recordemos esto porque nos hará falta más adelante.

El siguiente paso será obtener una API Key para poder utilizar el servicio de mapas de Google en nuestra aplicación. Este paso ya lo comentamos en los artículos sobre la API v1, pero en este caso el procedimiento será algo distinto. La nueva API de mapas de Android se ha integrado por fin en la Consola de APIs de Google (una herramienta de la que ya hablamos por ejemplo en los artículos dedicados a Google Cloud Messaging), por lo que el primer paso será acceder a ella. Una vez hemos accedido, tendremos que crear un nuevo proyecto desplegando el menú superior izquierdo y seleccionando la opción “Create…”.

Aparecerá entonces una ventana que nos solicitará el nombre del proyecto. Introducimos algún nombre descriptivo y aceptamos sin más.

Una vez creado el proyecto, accederemos a la opción “Services” del menú izquierdo. Desde esta ventana podemos activar o desactivar cada uno de los servicios de Google que queremos utilizar. En este caso sólo activaremos el servicio llamado “Google Maps Android API v2″ pulsando sobre el botón ON/OFF situado justo a su derecha.

Una vez activado aparecerá una nueva opción en el menú izquierdo llamada “API Access”. Accediendo a dicha opción tendremos la posibilidad de obtener nuestra nueva API Key que nos permita utilizar el servicio de mapas desde nuestra aplicación particular.

Para ello, pulsaremos el botón “Create new Android key…”. Esto nos llevará a un cuadro de diálogo donde tendremos que introducir algunos datos identificativos de nuestra aplicación. En concreto necesitaremos dos: la huella digital (SHA1) del certificado con el que firmamos la aplicación, y el paquete java utilizado. El segundo no tiene misterio, pero el primero requiere alguna explicación. Toda aplicación Android debe ir firmada para poder ejecutarse en un dispositivo, tanto físico como emulado. Este proceso de firma es uno de los pasos que tenemos que hacer siempre antes de distribuir públicamente una aplicación.  Adicionalmentes, durante el desarrollo de la misma, para realizar pruebas y la depuración del código, aunque no seamos conscientes de ello también estamos firmado la aplicación con un “certificado de pruebas”. Podemos saber en qué carpeta de nuestro sistema está almacenado este certificado accediendo desde Eclipse al menú Window /Preferences y accediendo a la sección Android / Build.

Como se puede observar, en mi caso el certificado de pruebas está en la ruta “C:\Users\Salvador\.android\debug.keystore”. Pues bien, para obtener nuestra huella digital SHA1 deberemos acceder a dicha ruta desde la consola de comando de Windows y ejecutar los siguientes comandos:

C:\>cd C:\Users\Salvador\.android\

C:\Users\Salvador\.android>"C:\Program Files\Java\jdk1.7.0_07\bin\keytool.exe" -list -v -keystore debug.keystore -alias androiddebugkey -storepass android -keypass android

Suponiendo que tu instalación de Java está en la ruta “C:\Program Files\Java\jdk1.7.0_07“. Si no es así sólo debes sustituir ésta por la correcta. Esto nos deberá devolver varios datos del certificado, entre ellos la huella SHA1.

Pues bien, nos copiamos este dato y lo añadimos a la ventana de obtención de la API Key donde nos habíamos quedado antes, y a continuación separado por un punto y coma añadimos el paquete java que vayamos a utilizar en nuestra aplicación, que en mi caso será “net.sgoliver.android.mapasapi2″.

Pulsamos el botón “Create” y ya deberíamos tener nuestra API Key generada, podremos verla en la pantalla siguiente dentro del apartado “Key for Android Apps (with certificates)”. Apuntaremos también este dato para utilizarlo más tarde.

Con esto ya habríamos concluido los preparativos iniciales necesarios para utilizar el servicio de mapas de Android en nuestras propias aplicaciones, por lo que empecemos a crear un proyecto de ejemplo en Eclipse.

Abriremos Eclipse y crearemos un nuevo proyecto estandar de Android, en mi caso lo he llamado “android-mapas-api2″. Recordemos utilizar para el proyecto el mismo paquete java que hemos indicado durante la obtención de la API key.

Tras esto lo primero que haremos será añadir al fichero AndroidManifest.xml la API Key que acabamos de generar. Para ello añadiremos al fichero, dentro de la etiqueta <application>, un nuevo elemento <meta-data> con los siguientes datos:

...
<application>
...
    <meta-data android:name="com.google.android.maps.v2.API_KEY"
               android:value="api_key"/>
...
</application>

Como valor del parámetro android:value tendremos que poner nuestra API Key recien generada.

Siguiendo con el AndroidManifest, también tendremos que incluir una serie de permisos que nos permitan hacer uso de los mapas. En primer lugar tendremos que definir y utilizar un permiso llamado “tu.paquete.java.permission.MAPS_RECEIVE”, en mi caso quedaría de la siguiente forma:

<permission
      android:name="net.sgoliver.android.mapasapi2.permission.MAPS_RECEIVE"
      android:protectionLevel="signature"/>

<uses-permission android:name="net.sgoliver.android.mapasapi2.permission.MAPS_RECEIVE"/>

Además, tendremos que añadir permisos adicionales que nos permitan acceder a los servicios web de Google, a Internet, y al almacenamiento externo del dispositivo (utilizado para la caché de los mapas):

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="com.google.android.providers.gsf.permission.READ_GSERVICES"/>

Por último, dado que la API v2 de Google Maps Android utiliza OpenGL ES versión 2, deberemos especificar también dicho requisito en nuestro AndroidManifest añadiendo un nuevo elemento <uses-feature>:

<uses-feature android:glEsVersion="0x00020000"
              android:required="true"/>

Una vez hemos configurado todo lo necesario en el AndroidManifest, y antes de escribir nuestro código, tenemos que seguir añadiendo elementos externos a nuestro proyecto. El primero de ellos será referenciar desde nuestro proyecto la librería con el SDK de Google Play Services que nos descargamos al principio de este tutorial. Para ello, desde Eclipse podemos importar la librería a nuestro conjunto de proyectos mediante la opción de menú “File / Import… / Existing Android Code Into Workspace”. Como ya dijimos este paquete se localiza en la ruta “<carpeta-sdk-android>/extras/google/google_play_services/libproject/google-play-services_lib“.

Tras seleccionar la ruta correcta dejaremos el resto de opciones con sus valores por defecto y pulsaremos Finish para que Eclipse importe esta librería a nuestro conjunto de proyectos.

El siguiente paso será referenciar esta librería desde nuestro proyecto de ejemplo. Para ello iremos a sus propiedades pulsando botón derecho / Properties sobre nuestro proyecto y accediendo a la sección Android de las preferencias. En dicha ventana podemos añadir una nueva librería en la sección inferior llamada Library. Cuando pulsamos el botón “Add…” nos aparecerá la librería recien importada y podremos seleccionarla directamente, añadiéndose a nuestra lista de librerías referenciadas por nuestro proyecto.

Como último paso de configuración de nuestro proyecto, si queremos que nuestra aplicación se pueda ejecutar desde versiones “antiguas” de Android (concretamente desde la versión de Android 2.2) deberemos asegurarnos de que nuestro proyecto incluye la librería android-support-v4.jar, que debería aparecer si desplegamos las sección “Android Dependencies” o la carpeta “lib” de nuestro proyecto.

Las versiones más recientes de ADT incluyen por defecto esta librería en nuestros proyectos, pero si no está incluida podéis hacerlo mediante la opción del menú contextual “Android Tools / Add Support Library…”  sobre el proyecto, o bien de forma manual.

Y con esto hemos terminado de configurar todo lo necesario. Ya podemos escribir nuestro código. Y para este primer artículo sobre el tema nos vamos a limitar a mostrar un mapa en la pantalla principal de la aplicación. En artículos posteriores veremos como añadir otras opciones o elementos al mapa.

Para esto tendremos simplemente que añadir el control correspondiente al layout de nuestra actividad principal. En el caso de la nueva API v2 este “control” se añadirá en forma de fragment (de ahí que hayamos tenido que incluir la librería android-support para poder utilizarlos en versiones de Android anteriores a la 3.0) de un determinado tipo (concretamente de la nueva clase com.google.android.gms.maps.SupportMapFragment), quedando por ejemplo de la siguiente forma:

<?xml version="1.0" encoding="utf-8"?>
<fragment xmlns:android="http://schemas.android.com/apk/res/android"
        android:id="@+id/map"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        class="com.google.android.gms.maps.SupportMapFragment"/>

Por supuesto, dado que estamos utilizando fragments, la actividad principal también tendrá que extender a FragmentActivity (en vez de simplemente Activity como es lo “normal”). Usaremos también la versión de FragmentActivity incluida en la librería android-support para ser compatibles con la mayoría de las versiones Android actuales.

public class MainActivity extends android.support.v4.app.FragmentActivity {

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

...
}

Con esto, ya podríamos ejecutar y probar nuestra aplicación. En mi caso las pruebas las he realizado sobre un dispositivo físico con Android 2.2 ya que por el momento parece haber algunos problemas para hacerlo sobre el emulador. Por tanto tendréis que conectar vuestro dispositivo  al PC mediante el cable de datos e indicar a Eclipse que lo utilice para la ejecución de la aplicación.

Si ejecutamos el ejemplo deberíamos ver un mapa en la pantalla principal de la aplicación, sobre el que nos podremos mover y hacer zoom con los gestos habituales o utilizando los controles de zoom incluidos por defecto sobre el mapa.

Con este artículo espero haber descrito todos los pasos necesarios para comenzar a utilizar los servicios de mapas de Google utilizando su nueva API Google Maps Android v2. Si tenéis cualquier duda o propuesta de mejora no dudéis en escribirlo en los comentarios.

Como habéis podido comprobar hay muchos preparativos que hacer, aunque ninguno de ellos de excesiva dificultad. En los próximos artículos aprenderemos a utilizar más características de la nueva API.

Puedes consultar y/o descargar el código completo de los ejemplos desarrollados en este artículo accediendo a la pagina del curso en GitHub.

Como en el caso de las AsyncTask, la utilización de un IntentService va a ser tan sencilla como extender una nueva clase de IntentService e implementar su método onHandleIntent(). Este método recibe como parámetro un Intent, que podremos utilizar para pasar al servicio los datos de entrada necesarios.

A diferencia de las AsyncTask, un IntentService no proporciona métodos que se ejecuten en el hilo principal de la aplicación y que podamos aprovechar para “comunicarnos” con nuestra interfaz durante la ejecución. Éste es el motivo principal de que los IntentService sean una opción menos utilizada a la hora de ejecutar tareas que requieran cierta vinculación con la interfaz de la aplicación. Sin embargo tampoco es imposible su uso en este tipo de escenarios ya que podremos utilizar por ejemplo mensajes broadcast (y por supuesto su BroadcastReceiver asociado capaz de procesar los mensajes) para comunicar eventos al hilo principal, como por ejemplo la necesidad de actualizar controles de la interfaz o simplemente para comunicar la finalización de la tarea ejecutada. En este artículo veremos cómo implementar este método para conseguir una aplicación de ejemplo similar a la que construimos en el artículo anterior utilizando AsyncTask.

Empezaremos  extendiendo una nueva clase derivada de IntentService, que para ser originales llamaremos MiIntentService. Lo primero que tendremos que hacer será implementar un constructor por defecto. Este constructor lo único que hará será llamar al constructor de la clase padre pasándole el nombre de nuestra nueva clase.

A continuación implementaremos el método onHandleIntent(). Como ya hemos indicado, este método será el que contenga el código de la tarea a ejecutar en segundo plano. Para simular una tarea de larga duración utilizaremos el mismo bucle que ya vimos en el artículo anterior con la novedad de que esta vez el número de iteraciones será variable, de forma que podamos experimentar con cómo pasar datos de entrada a través del Intent recibido como parámetro en onHandleIntent(). En nuestro caso de ejemplo pasaremos un sólo dato de entrada que indique el número de iteraciones. Por tanto, lo primero que haremos será obtener este dato a partir del Intent mediante el método getIntExtra(). Una vez conocemos el número de iteraciones, tan sólo nos queda ejecutar el bucle y comunicar el progreso tras cada iteración.

Como ya hemos comentado, para comunicar este progreso vamos a hacer uso de mensajes broadcast. Para enviar este tipo de mensajes necesitamos construir un Intent, asociarle un nombre de acción determinada que lo identifique mediante setAction(), e incluir los datos que necesitemos comunicar añadiendo tantos extras como sean necesarios mediante el método putExtra(). Los nombres de las acciones se suelen preceder con el paquete java de nuestra aplicación de forma que nos aseguremos que es un identificador único. En nuestro caso lo llamaremos “net.sgoliver.intent.action.PROGRESO” y lo definiremos como atributo estático de la clase para mayor comodidad, llamado ACTION_PROGRESO. Por su parte, los datos a comunicar en nuestro ejemplo será solo el nivel de progreso, por lo que sólo añadiremos un extra a nuestro intent con dicho dato. Por último enviaremos el mensaje llamando al método sendBroadcast() pasándole como parámetro el intent recién creado. Veamos cómo quedaría el código completo.

public class MiIntentService extends IntentService {

	public static final String ACTION_PROGRESO =
		"net.sgoliver.intent.action.PROGRESO";
	public static final String ACTION_FIN =
		"net.sgoliver.intent.action.FIN";

	public MiIntentService() {
	        super("MiIntentService");
    	}

	@Override
	protected void onHandleIntent(Intent intent)
	{
		int iter = intent.getIntExtra("iteraciones", 0);

		for(int i=1; i<=iter; i++) {
			tareaLarga();

			//Comunicamos el progreso
			Intent bcIntent = new Intent();
			bcIntent.setAction(ACTION_PROGRESO);
			bcIntent.putExtra("progreso", i*10);
			sendBroadcast(bcIntent);
		}

		Intent bcIntent = new Intent();
		bcIntent.setAction(ACTION_FIN);
		sendBroadcast(bcIntent);
	}

	private void tareaLarga()
    	{
    		try {
    			Thread.sleep(1000);
    		} catch(InterruptedException e) {}
    	}
}

Como podéis comprobar también he añadido un nuevo tipo de mensaje broadcast (ACTION_FIN), esta vez sin datos adicionales, para comunicar a la aplicación principal la finalización de la tarea en segundo plano.

Además de la implementación del servicio, recordemos que también tendremos que declararlo en el AndroidManifest.xml, dentro de la sección <application>:

<service android:name=".MiIntentService"></service>

Y con esto ya tendríamos implementado nuestro servicio. El siguiente paso será llamar al servicio para comenzar su ejecución. Esto lo haremos desde una actividad principal de ejemplo en la que tan sólo colocaremos una barra de progreso y un botón para lanzar el servicio. El código del botón para ejecutar el servicio será muy sencillo, tan sólo tendremos que crear un nuevo intent asociado a la clase MiIntentService, añadir los datos de entrada necesarios mediante putExtra() y ejecutar el servicio llamando a startService() pasando como parámetro el intent de entrada. Como ya dijimos, el único dato de entrada que pasaremos será el número de iteraciones a ejecutar.

btnEjecutar.setOnClickListener(new OnClickListener() {

	@Override
	public void onClick(View v) {
		Intent msgIntent = new Intent(MainActivity.this, MiIntentService.class);
		msgIntent.putExtra("iteraciones", 10);
		startService(msgIntent);
	}
});

Con esto ya podríamos ejecutar nuestra aplicación y lanzar la tarea, pero no podríamos ver el progreso de ésta ni saber cuándo ha terminado porque aún no hemos creado el BroadcastReceiver necesario para capturar los mensajes broadcast que envía el servicio durante su ejecución.

Para ello, como clase interna a nuestra actividad principal definiremos una nueva clase que extienda a BroadcastReceiver y que implemente su método onReceive() para gestionar los mensajes ACTION_PROGRESO y ACTION_FIN que definimos en nuestro IntentService. En el caso de recibirse ACTION_PROGRESO extraeremos el nivel de progreso del intent recibido y actualizaremos consecuentemente la barra de progreso mediante setProgress(). En caso de recibirse ACTION_FIN mostraremos un mensaje Toast informando de la finalización de la tarea.

public class ProgressReceiver extends BroadcastReceiver {

	@Override
	public void onReceive(Context context, Intent intent) {
		if(intent.getAction().equals(MiIntentService.ACTION_PROGRESO)) {
			int prog = intent.getIntExtra("progreso", 0);
			pbarProgreso.setProgress(prog);
		}
		else if(intent.getAction().equals(MiIntentService.ACTION_FIN)) {
			Toast.makeText(MainActivity.this, "Tarea finalizada!", Toast.LENGTH_SHORT).show();
		}
	}
}

Pero aún no habríamos terminado dado, ya que aunque hayamos implementado nuestro BroadcastReceiver, éste no tendrá ningún efecto a menos que lo registremos con la aplicación y lo asociemos a los tipos de mensaje que deberá tratar (mediante un IntentFilter). Para hacer esto, al final del método onCreate() de nuestra actividad principal crearemos un IntentFilter al que asociaremos mediante addAction() los dos tipos de mensaje broadcast que queremos capturar, instanciaremos nuestro BroadcastReceiver y lo registraremos mediante registerReceiver(), al que pasaremos la instancia creada y el filtro de mensajes.

IntentFilter filter = new IntentFilter();
filter.addAction(MiIntentService.ACTION_PROGRESO);
filter.addAction(MiIntentService.ACTION_FIN);
ProgressReceiver rcv = new ProgressReceiver();
registerReceiver(rcv, filter);

Y con esto sí habríamos concluido nuestra aplicación de ejemplo. Si ejecutamos la aplicación en el emulador y pulsamos el botón de comenzar la tarea veremos cómo la barra de progreso comienza a avanzar hasta el final, momento en el que deberá aparecer el mensaje toast indicando la finalización de la tarea.

Android IntentService

Como siempre, podéis descargar el código completo de la aplicación de ejemplo construida en este artículo.

Obviamente, éstos son el tipo de errores que nadie quiere ver al utilizar su aplicación, y en este artículo y los siguientes vamos a ver varias formas de evitarlo utilizando procesos en segundo plano para ejecutar las operaciones de larga duración. En este primer artículo de la serie nos vamos a centrar en dos de las alternativas más directas a la hora de ejecutar tareas en segundo plano en Android:

1. Crear nosotros mismos de forma explícita un nuevo hilo para ejecutar nuestra tarea.
2. Utilizar la clase auxiliar AsyncTask proporcionada por Android.

Mi idea inicial para este artículo era obviar la primera opción, ya que normalmente la segunda solución nos es más que suficiente, y además es mas sencilla y más limpia de implementar. Sin embargo, si no comentamos al menos de pasada la forma de crear “a mano” nuevos hilos y los problemas que surgen, quizá no se viera demasiado claro las ventajas que tiene utilizar las AsyncTask. Por tanto, finalmente voy a pasar muy rápidamente por la primera opción para después centrarnos un poco más en la segunda. Además, aprovechando el tema de la ejecución de tareas en segundo plano, vamos a ver también cómo utilizar un control (el ProgressBar) y un tipo de diálogo (el ProgressDialog) que no vimos en los primeros temas del curso dedicados a la interfaz de usuario.

Y para ir paso a paso, vamso a empezar por crear una aplicación de ejemplo en cuya actividad principal colocaremos un control ProgressBar (en mi caso llamado pbarProgreso) y un botón (btnSinHilos) que ejecute una tarea de larga duración. Para simular una operación de larga duración vamos a ayudarnos de un método auxiliar que lo único que haga sea esperar 1 segundo, mediante una llamada a Thread.sleep().

private void tareaLarga()
{
    try {
        Thread.sleep(1000);
    } catch(InterruptedException e) {}
}

Haremos que nuestro botón ejecute este método 10 veces, de forma que nos quedará una ejecución de unos 10 segundos en total:

btnSinHilos.setOnClickListener(new OnClickListener() {
	@Override
	public void onClick(View v) {
		pbarProgreso.setMax(100);
		pbarProgreso.setProgress(0);

		for(int i=1; i<=10; i++) {
			tareaLarga();
			pbarProgreso.incrementProgressBy(10);
		}

		Toast.makeText(MainHilos.this, "Tarea finalizada!",
				Toast.LENGTH_SHORT).show();
	}
});

Como veis, aquí todavía no estamos utilizando nada especial, por lo que todo el código se ejecutará en el hilo principal de la aplicación. En cuanto a la utilización del control ProgressBar vemos que es muy sencilla y no requiere apenas configuración. En nuestro caso tan sólo hemos establecido el valor máximo que alcanzará (el valor en el que la barra de progreso estará rellena al máximo) mediante el método setMax(100), posteriormente la hemos inicializado al valor mínimo mediante una llamada a setProgress(0) de forma que inicialmente aparezca completamente vacía, y por último en cada iteración del bucle incrementamos su valor en 10 unidades llamando a incrementProgressBy(10), de tal forma que tras la décima iteración la barra llegue al valor máximo de 100 que establecimos antes. Finalmente mostramos un mensaje Toast para informar de la finalización de la tarea. Pues bien, ejecutemos la aplicación, pulsemos el botón, y veamos qué ocurre.

No era eso lo que esperábamos ¿verdad? Lo que ha ocurrido es que desde el momento que hemos pulsado el botón para ejecutar la tarea, hemos bloqueado completamente el resto de la aplicación, incluida la actualización de la interfaz de usuario, que ha debido esperar a que ésta termine mostrando directamente la barra de progreso completamente llena. En definitiva, no hemos sido capaces de ver el progreso de la tarea. Pero como decíamos, este efecto puede empeorar. Probemos ahora a pulsar el botón de la tarea y mientras ésta se ejecuta realicemos cualquier acción sobre la pantalla, un simple click sobre el fondo nos basta. Veamos qué ocurre ahora.

Vemos cómo al intentar hacer cualquier acción sobre la aplicación Android nos ha advertido con un mensaje de error que la aplicación no responde debido a que se está ejecutando una operación de larga duración en el hilo principal. El usuario debe elegir entre esperar a que termine de ejecutarla o forzar el cierre de la aplicación. Pues bien, estos son los efectos que vamos a intentar evitar. La opción más inmediata que nos proporciona Android, al igual que otras plataformas, es crear directamente hilos secundarios dentro de los cuales ejecutar nuestras operaciones costosas. Esto lo conseguimos en Android instanciando un objeto de la clase Thread. El constructor de la clase Thread recibe como parámetro un nuevo objeto Runnable que debemos construir implementando su método run(), dentro del cual vamos a realizar nuestra tarea de larga duración. Hecho esto, debemos llamar al método start() del objeto Threaddefinido para comenzar la ejecución de la tarea en segundo plano.

new Thread(new Runnable() {
    public void run() {
        //Aquí ejecutamos nuestras tareas costosas
    }
}).start();

Hasta aquí todo sencillo y relativamente limpio. Los problemas aparecen cuando nos damos cuenta que desde este hilo secundario que hemos creado no podemos hacer referencia directa a componentes que se ejecuten en el hilo principal, entre ellos los controles que forman nuestra interfaz de usuario, es decir, que desde el método run() no podríamos ir actualizando directamente nuestra barra de progreso de la misma forma que lo hacíamos antes. Para solucionar esto, Android proporciona varias alternativas, entre ellas la utilización del método post() para actuar sobre cada control de la interfaz, o la llamada al método runOnUiThread() para “enviar” operaciones al hilo principal desde el hilo secundario [Nota: Sí, vale, sé que no he nombrado la opción de los Handler, pero no quería complicar más el tema por el momento]. Ambas opciones requieren como parámetro un nuevo objeto Runnable del que nuevamente habrá que implementar su método run() donde se actúe sobre los elementos de la interfaz. Por ver algún ejemplo, en nuestro caso hemos utilizado el método post() para actuar sobre el control ProgressBar, y el método runOnUiThread()para mostrar el mensaje toast.

new Thread(new Runnable() {
    public void run() {
    	pbarProgreso.post(new Runnable() {
		public void run() {
			pbarProgreso.setProgress(0);
		}
	});

	for(int i=1; i<=10; i++) {
		tareaLarga();
		pbarProgreso.post(new Runnable() {
	   		public void run() {
	   			pbarProgreso.incrementProgressBy(10);
	    		}
	    	});
	}

	runOnUiThread(new Runnable() {
	    public void run() {
	        Toast.makeText(MainHilos.this, "Tarea finalizada!",
				Toast.LENGTH_SHORT).show();
	    }
	});
    }
}).start();

Utilicemos este código dentro de un nuevo botón de nuestra aplicación de ejemplo y vamos a probarlo en el emulador.

Ahora sí podemos ver el progreso de nuestra tarea reflejado en la barra de progreso. La creación de un hilo secundario nos ha permitido mantener el hilo principal libre de forma que nuestra interfaz de usuario de actualiza sin problemas durante la ejecución de la tarea en segundo plano. Sin embargo miremos de nuevo el código anterior. Complicado de leer, ¿verdad? Y eso considerando que tan sólo estamos actualizando un control de nuestra interfaz. Si el número de controles fuera mayor, o necesitáramos una mayor interacción con la interfaz el código empezaría a ser inmanejable, difícil de leer y mantener, y por tanto también más propenso a errores. Pues bien, aquí es donde Android llega en nuestra ayuda y nos ofrece la clase AsyncTask, que nos va a permitir realizar esto mismo pero con la ventaja de no tener que utilizar artefactos del tipo runOnUiThread() y de una forma mucho más organizada y legible. La forma básica de utilizar la clase AsyncTaskconsiste en crear una nueva clase que extienda de ella y sobrescribir varios de sus métodos entre los que repartiremos la funcionalidad de nuestra tarea. Estos métodos son los siguientes:

• onPreExecute(). Se ejecutará antes del código principal de nuestra tarea. Se suele utilizar para preparar la ejecución de la tarea, inicializar la interfaz, etc.
• doInBackground(). Contendrá el código principal de nuestra tarea.
• onProgressUpdate(). Se ejecutará cada vez que llamemos al método publishProgress() desde el método doInBackground().
• onPostExecute(). Se ejecutará cuando finalice nuestra tarea, o dicho de otra forma, tras la finalización del método doInBackground().
• onCancelled(). Se ejecutará cuando se cancele la ejecución de la tarea antes de su finalización normal.

Estos métodos tienen una particularidad esencial para nuestros intereses. El método doInBackground() se ejecuta en un hilo secundario (por tanto no podremos interactuar con la interfaz), pero sin embargo todos los demás se ejecutan en el hilo principal, lo que quiere decir que dentro de ellos podremos hacer referencia directa a nuestros controles de usuario para actualizar la interfaz. Por su parte, dentro de doInBackground() tendremos la posibilidad de llamar periódicamente al método publishProgress() para que automáticamente desde el método onProgressUpdate() se actualice la interfaz si es necesario. Al extender una nueva clase de AsyncTaskindicaremos tres parámetros de tipo:

1. El tipo de datos que recibiremos como entrada de la tarea en el método doInBackground().
2. El tipo de datos con el que actualizaremos el progreso de la tarea, y que recibiremos como parámetro del método onProgressUpdate() y que a su vez tendremos que incluir como parámetro del método publishProgress().
3. El tipo de datos que devolveremos como resultado de nuestra tarea, que será el tipo de retorno del método doInBackground() y el tipo del parámetro recibido en el método onPostExecute().

En nuestro caso de ejemplo, extenderemos de AsyncTask indicando los tipos Void, Integer y Booleanrespectivamente, lo que se traducirá en que:

• doInBackground() no recibirá ningún parámetro de entrada (Void).
• publishProgress() y onProgressUpdate() recibirán como parámetros datos de tipo entero (Integer).
• doInBackground() devolverá como retorno un dato de tipo booleano y onPostExecute() también recibirá como parámetro un dato del dicho tipo (Boolean).

Dicho esto, cómo repartiremos la funcionalidad de nuestra tarea entre los distintos métodos. Pues sencillo, en onPreExecute() inicializaremos la barra de progreso estableciendo su valor máximo y poniéndola a cero para comenzar. En doInBackground() ejecutaremos nuestro bucle habitual llamando a publishProgress() tras cada iteración indicando el progreso actual. En onProgressUpdate() actualizaremos el estado de la barra de progreso con el valor recibido como parámetro. y por último en onPostExecute() mostraremos el mensaje Toast de finalización de la tarea. Veamos el código completo:

private class MiTareaAsincrona extends AsyncTask {

	@Override
	protected Boolean doInBackground(Void... params) {

		for(int i=1; i<=10; i++) {
			tareaLarga();

			publishProgress(i*10);

			if(isCancelled())
				break;
		}

		return true;
	}

	@Override
	protected void onProgressUpdate(Integer... values) {
		int progreso = values[0].intValue();

		pbarProgreso.setProgress(progreso);
	}

	@Override
	protected void onPreExecute() {
		pbarProgreso.setMax(100);
		pbarProgreso.setProgress(0);
	}

	@Override
	protected void onPostExecute(Boolean result) {
		if(result)
			Toast.makeText(MainHilos.this, "Tarea finalizada!",
					Toast.LENGTH_SHORT).show();
	}

	@Override
	protected void onCancelled() {
		Toast.makeText(MainHilos.this, "Tarea cancelada!",
				Toast.LENGTH_SHORT).show();
	}
}

Si observamos con detenimiento el código, la única novedad que hemos introducido es la posibilidad de cancelar la tarea en medio de su ejecución. Esto se realiza llamando al método cancel() de nuestra AsyncTask (para lo cual añadiremos un botón más a nuestra aplicación de ejemplo, además del nuevo que añadiremos para comenzar la tarea). Dentro de la ejecución de nuestra tarea en doInBackground() tendremos además que consultar periodicamente el resultado del método isCancelled() que nos dirá si el usuario ha cancelado la tarea (es decir, si se ha llamado al método cancel()), en cuyo caso deberemos de terminar la ejecución lo antes posible, en nuestro caso de ejemplo simplemente saldremos del bucle con la instrucción break. Además, tendremos en cuenta que en los casos que se cancela la tarea, tras el método doInBackground() no se llamará a onPostExecute() sino al método onCancelled(), dentro del cual podremos realizar cualquier acción para confirma la cancelación de la tarea. En nuestro caso mostraremos un mensaje Toast informando de ello.

Mucho mejor que las alternativas anteriores, verdad? Pero vamos a mostrar una opción más. Si queremos que el usuario pueda ver el progreso de nuestra tarea en segundo plano, pero no queremos que interactúe mientras tanto con la aplicación tenemos la opción de mostrar la barra de progreso dentro de un diálogo. Android nos proporciona directamente un componente de este tipo en forma de un tipo especial de diálogo llamado ProgressDialog.

Configurar un cuadro de diálogo de este tipo es muy sencillo. Para ello vamos a añadir un botón más a nuestra aplicación de ejemplo, donde inicializaremos el diálogo y lanzaremos la tarea en segundo plano. Para inicializar el diálogo comenzaremos por crear un nuevo objeto ProgressDialog pasándole como parámetro el contexto actual. Tras esto estableceremos su estilo: STYLE_HORIZONTAL para una barra de progreso tradicional, o STYLE_SPINNER para un indicador de progreso de tipo indeterminado.

ProgressDialog horizontal

ProgressDialog spinner

Lo siguiente será especificar el texto a mostrar en el diálogo, en nuestro caso el mensaje “Procesando…“, y el valor máximo de nuestro progreso, que lo mantendremos en 100. Por último indicaremos si deseamos que el diálogo sea cancelable, es decir, que el usuario pueda cerrarlo pulsando el botón Atrás del teléfono. Para nuestro ejemplo activaremos esta propiedad para ver cómo podemos cancelar también nuestra tarea en segundo plano cuando el usuario cierra el diálogo. Tras la configuración del diálogo lanzaremos la AsyncTask del ejemplo anterior, que tendremos que modificar ligeramente para adaptarla al nuevo diálogo. Veamos el código por ahora:

btnAsyncDialog.setOnClickListener(new OnClickListener() {

	@Override
	public void onClick(View v) {

		pDialog = new ProgressDialog(MainHilos.this);
		pDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
		pDialog.setMessage("Procesando...");
		pDialog.setCancelable(true);
		pDialog.setMax(100);

		tarea2 = new MiTareaAsincronaDialog();
		tarea2.execute();
	}
});

La AsyncTask será muy similar a la que ya implementamos. De hecho el método doInBackground() no sufrirá cambios.

En onProgressUpdate() la única diferencia será que actualizaremos el progreso llamando al método setProgress() del ProgressDialog en vez de la ProgressBar.

El código de onPreExecute() sí tendrá algún cambio más. Aprovecharemos este método para implementar el evento onCancel del diálogo, dentro del cual cancelaremos también la tarea en segundo plano llamando al método cancel(). Además, inicializaremos el progreso del diálogo a 0 y lo mostraremos al usuario mediante el método show().

Por último, en el método onPostExecute() además de mostrar el Toast de finalización, tendremos que cerrar previamente el diálogo llamando a su método dismiss().

Veamos el código completo de la AsyncTask modificada para usar el nuevo ProgressDialog.

private class MiTareaAsincronaDialog extends AsyncTask {

    	@Override
    	protected Boolean doInBackground(Void... params) {

    		for(int i=1; i<=10; i++) {
			tareaLarga();

			publishProgress(i*10);

			if(isCancelled())
				break;
		}

    		return true;
    	}

    	@Override
    	protected void onProgressUpdate(Integer... values) {
    		int progreso = values[0].intValue();

    		pDialog.setProgress(progreso);
    	}

    	@Override
    	protected void onPreExecute() {

    		pDialog.setOnCancelListener(new OnCancelListener() {
			@Override
			public void onCancel(DialogInterface dialog) {
				MiTareaAsincronaDialog.this.cancel(true);
			}
		});

    		pDialog.setProgress(0);
    		pDialog.show();
    	}

    	@Override
    	protected void onPostExecute(Boolean result) {
    		if(result)
    		{
    			pDialog.dismiss();
    			Toast.makeText(MainHilos.this, "Tarea finalizada!",
					Toast.LENGTH_SHORT).show();
    		}
    	}

    	@Override
    	protected void onCancelled() {
    		Toast.makeText(MainHilos.this, "Tarea cancelada!",
				Toast.LENGTH_SHORT).show();
    	}
    }

Si ahora ejecutamos nuestro proyecto y pulsamos sobre el último botón incluido veremos cómo el diálogo aparece por encima de nuestra actividad mostrando el progreso de la tarea asíncrona. Tras finalizar, el diálogo desaparece y se muestra el mensaje toast de finalización. Si en cambio, se pulsa el botón Atrás del dispositivo antes de que la tarea termine el diálogo se cerrará y se mostrará el mensaje de cancelación.

Y con esto habríamos concluido este primer artículo sobre hilos y tareas en segundo plano. Os dejo a continuación el vídeo de demostración de la aplicación de ejemplo construida durante el tema, y como siempre el código fuente completo del ejemplo.

Demo – Hilos y AsyncTask en Android