Si alguna vez habéis usado Google Analytics o si algún conocido os ha hablado de ello, sabréis que es la herramienta de recolección de estadísticas más informativa del momento. Este servicio gratuito de Google fue diseñado para recolectar información para los webmaster en sus páginas web, llegando a convertirse en imprescindible. Con ella podemos saber qué cantidad de visitas y páginas vistas recibimos al día, qué páginas se han visto cada día y en cuántas ocasiones… incluso la procedencia de los visitantes de la web. Sinceramente, es una herramienta tremenda y puede llegar a abrumar la cantidad de información que puede brindar.
Esto está muy bien, pero ¿qué pasa si nosotros queremos recolectar información sobre el uso de nuestra aplicación? Hace tiempo el equipo de Google creó una librería para Android que permite hacer esto, basándose en Google Analytics. Podremos saber qué partes son las más visitadas de nuestra aplicación, qué eventos se generan con más frecuencia. ¡Y de una forma realmente simple!
¿Quieres saber más? ¡Comencemos!
Creación de la cuenta de Google Analytics
Para poder comprobar que todo lo que vamos a hacer funciona deberemos tener una cuenta de Google Analytics. Dicha cuenta se va a vincular a una cuenta de Google, por lo que quizá nos interese crear una cuenta de prueba o crear una cuenta específicamente para las aplicaciones que creemos. Una vez tengamos dicha cuenta de Google vamos a crear una cuenta de Google Analytics siguiendo este link.
Tras completar la creación de nuestra cuenta de Google Analytics y ver la página principal de la cuenta, pulsaremos en Añadir una cuenta nueva. En la siguiente página pulsaremos en Regístrese. Veremos lo siguiente:
Completaremos el formulario, con una salvedad a como se haría para una página web. En el campo de la URL no vamos a poder poner una URL de una página real, así que vamos a poner una URL falsa pero que sea lo suficientemente descriptiva para saber a qué le estamos haciendo el seguimiento. Por ejemplo en este caso de ejemplo será http://analytics.vidasconcurrentes.com. El nombre de la cuenta es lo que vamos a ver en el panel principal, así que es para nosotros y elegimos el nombre que mejor nos venga. Luego seleccionamos España y zona horaria GMT+02:00 (en nuestro caso). Continuamos la creación poniendo un nombre y apellido además del pais de procedencia, aceptamos las condiciones de servicio de Google Analytics y finalmente creamos la cuenta.
Ahora veremos un código Javascript que en nuestro caso vamos a pasar por alto, ya que no vamos a crear el seguimiento para una página web. Lo que a nosotros nos interesa únicamente es el identificador de la cuenta, que tiene la siguiente forma: UA-xxxxxxxxx-y (donde las x y la y son números). Una vez lo tengamos, es el momento de comenzar con nuestra ya clásica aplicación de prueba.
Descargar la librería
Comenzamos descargando la librería de Google Analytics. Para ello vamos a la página de descargas de Google Analytics Mobile. Seleccionamos la opción de Android, y guardamos el fichero comprimido.
Dentro de dicho fichero comprimido tenemos un proyecto de ejemplo sobre cómo hacer funcionar la librería, y la librería en sí. A nosotros sólo nos interesa la librería (libGoogleAnalytics.jar), así que la descomprimimos en un directorio que vayamos a tener a mano (como el escritorio).
El siguiente paso es comenzar con la aplicación.
Creando la aplicación de prueba
Abrimos nuestro Eclipse configurado con el Android SDK, y creamos un nuevo proyecto. Para esta entrada, por ejemplo, podemos configurarlo con las siguientes opciones:
- Project Name: GoogleAnalyticsTest
- Build Target: 2.1-update
- Application Name: GoogleAnalyticsTest
- Package Name: com.vidasconcurrentes.googleanalyticstest
- Create Activity: GoogleAnalyticsTestActivity
- Min SDK Version: 7
Una vez tengamos el proyecto, vamos a crear el directorio donde incluiremos la librería de Google Analytics. Para ello, hacemos click derecho sobre el proyecto y seleccionamos New > Folder. Llamaremos a nuestro nuevo directorio lib. Una vez esté creado pegamos en su interior la librería de Analytics (libGoogleAnalytics.jar). El siguiente paso consiste en enlazar dicha librería al proyecto. Para ello hacemos click derecho en el proyecto y seleccionamos Properties. En la ventana emergente que obtenemos seleccionamos Java Build Path de la lista izquierda y posteriormente elegimos la pestaña Libraries del panel derecho. Pulsamos en Add JARs… y seleccionamos la librería que acabamos de añadir. El resultado será este:
Ahora sí, es el momento de comenzar con el código.
Para este ejemplo vamos a crear una aplicación muy sencilla. Dicha aplicación se va a componer de tres actividades. La primera será la principal y contendrá dos botones. Cada uno de los botones, al ser pulsado, disparará una nueva actividad. Vamos a realizar el seguimiento de las pulsaciones de los botones y las vistas de todas las actividades.
Comenzamos creando las dos nuevas actividades, llamadas UnoActivity y DosActivity:
public class UnoActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
}
public class DosActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
}
Lo siguiente, antes de que se nos olvide, es añadir dichas actividades al AndroidManifest.xml. Si no lo hiciéramos obtendríamos una Fatal Exception si quisiéramos ejecutar una de las nuevas Activity. En este caso vamos a hacerlo ayudándonos de la interfaz gráfica que nos brinda Eclipse, por simplificar las cosas. Abrimos el fichero AndroidManifest.xml y pulsamos en la pestaña Application (las pestañas están abajo). Una vez allí, nos fijamos en la parte de abajo a la izquierda, en un panel etiquetado como Application Nodes. Veremos esto:
Aquí vemos las actividades que conforman nuestro proyecto. Para añadir una nueva sólo tenemos que pulsar en Add… y en el panel que se nos abre a la derecha, donde pone Name, pulsar en Browse y buscar la actividad que deseamos añadir. Una vez hayamos añadido las dos podemos continuar.
Vamos a crear el layout que va a mostrar nuestra actividad principal, que podemos copiar y pegar de aquí a main.xml:
<?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"
>
<Button android:text="Actividad 1" android:layout_gravity="center" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="20dip" android:id="@+id/boton_actividad_uno"></Button>
<Button android:text="Actividad 2" android:layout_gravity="center" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="20dip" android:id="@+id/boton_actividad_dos"></Button>
</LinearLayout>
Con este layout tendremos algo así:
Ahora vamos a darle la funcionalidad a los botones para comprobar que vamos a pasar de una actividad a otra. Añadimos este código al final del código actual de GoogleAnalyticsTestActivity:
botonUno.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(GoogleAnalyticsTestActivity.this, UnoActivity.class));
}
});
botonDos.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
startActivity(new Intent(GoogleAnalyticsTestActivity.this, DosActivity.class));
}
});
Podemos comprobar que funciona como esperamos, ejecutando. Una vez tenemos la aplicación es momento de añadir los códigos para hacer el seguimiento de su uso. Queremos saber cuántas veces se ve la aplicación principal, cuántas veces se pulsa cada botón y cuántas veces se ve cada una de las actividades que se disparan con los botones. Puede parecer una tontería ver esto último, porque las pulsaciones de un botón y las visitas a su actividad asociada van a ser lo mismo. Aún así, lo vamos a hacer para ilustrar los ejemplos.
Comenzamos creando el objeto que nos va a servir para realizar el seguimiento. Lo añadimos a la clase GoogleAnalyticsTestActivity como atributo:
public static GoogleAnalyticsTracker tracker;
Lo creamos como público y estático para poder acceder a él desde otras clases. Sería interesante crearnos una clase aparte que contuviera dicho objeto, pero para este ejemplo vamos a servirnos de esto.
Lo siguiente es iniciar el tracker. Para ello, en el onCreate() de la actividad principal, ponemos:
tracker = GoogleAnalyticsTracker.getInstance();
tracker.startNewSession("UA-xxxxxxxx-y", 10, this);
Con esto, estamos obteniendo el singleton del tracker e iniciando la sesión con nuestro ID de Analytics, en el contexto marcado por this. El número 10 significa que el tracker debe guardar toda la información que se vaya generando, y que cada 10 segundos mande lo que haya almacenado. En caso de no poner un número en dicha función estamos diciendo que vamos a hacer dichos envíos manualmente. Para ello usaríamos la función dispatch().
Es importante el siguiente paso. Cuando no queramos usar más este tracker (por ejemplo cuando cerremos la aplicación) debemos parar de recolectar estadísticas. Para ello vamos a añadir la siguiente función a la actividad principal, GoogleAnalyticsTestActivity:
@Override
protected void onDestroy() {
tracker.dispatch();
super.onDestroy();
tracker.stopSession();
}
Con la primera linea nos aseguramos de mandar toda la info que quedase por mandar.
Ahora que tenemos esto creado, podemos añadir los seguimientos que queremos. Comenzamos con la actividad principal. Añadimos después de haber iniciado el tracker la siguiente línea:
tracker.trackPageView("/actividad_principal");
Tan simple como eso. La librería se encarga de almacenar este seguimiento hasta que llegue el siguiente dispatch() (ya sea automático o manual). Ahora vamos a añadir el track de eventos a los botones. Para ello, en cada uno de los métodos onClick() de los botones, antes de ejecutar la nueva actividad, vamos a poner un código como este:
tracker.trackEvent("Categoria", "Accion", "Etiqueta", 0);
En dichos campos podemos poner lo que queramos que sea descriptivo para nosotros. Por ejemplo, en Categoría podríamos poner Botones. En Acción podríamos poner Pulsado y en Etiqueta podríamos poner el nombre del botón que se ha pulsado o algo similar. El número 0 representado arriba es un valor que queremos darle a dicho evento. Para estos parámetros es mejor trastear con diferentes combinaciones de nombres y valores para posteriormente comprobar en Google Analytics qué información recibimos y poder elegir lo que más nos interese.
Lo siguiente, y último, será añadir a cada una de las actividades que hemos creado el seguimiento de sus visitas. Vamos a mostrar dos ejemplos, uno con cada Activity. Comenzamos con UnoActivity, añadiendo lo siguiente al final de su onCreate():
GoogleAnalyticsTestActivity.tracker.trackPageView("/actividad_uno");
Con esto añadimos una visita a la página /actividad_uno. Ahora vamos a DosActivity, y al final de su onCreate() ponemos:
GoogleAnalyticsTestActivity.tracker.trackPageView("/actividad_principal/actividad_dos");
Con esto lo que ilustramos es que vamos a poder hacer una jerarquía lógica de las partes vistas, de modo que no tengamos tres páginas vistas distintas, sino saber que una va dentro de otra.
Falta el último detalle: los permisos. Necesitamos que nuestra aplicación pueda comprobar el estado de la conexión y pueda conectarse a Internet para mandar la información. Por tanto, abrimos el fichero AndroidManifest.xml y antes del cierre de </manifest> añadimos:
<uses-permission android:name="android.permission.INTERNET" /> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
Una vez hemos llegados aquí es momento de probar que lo que hemos hecho funciona.
Para mostrarlo, vamos a hacer una ejecución con un orden específico. Lo que haremos será:
- Abrimos la aplicación (esto es una visita a /actividad_principal).
- Pulsamos en el botón de la Actividad 1 (esto es un evento para ese botón y una visita a /actividad_uno).
- Pulsamos el botón Back de nuestro dispositivo para ir a la actividad anterior.
- Pulsamos en el botón de la Actividad 2 (esto es un evento para ese botón y una visita a /actividad_principal/actividad_dos).
- Pulsamos el botón Back y volvemos a la actividad principal.
- Volvemos a pulsar el botón Back, con lo que cerramos la aplicación.
Hay que fijarse en que, cuando estamos en una actividad y volvemos atrás (a la actividad anterior), no ejecutamos el método onCreate() sino onResume(). Por esta razón, lo que deberíamos obtener no son 3 visitas a /actividad_principal sino sólo 1.
Una vez realizada la ejecución sólo nos falta comprobar que dicha ejecución ha funcionado correctamente y ha enviado los datos que queríamos. Lo único malo es que Google Analytics no se lleva del todo bien con eso de la información en directo, así que es probable que pasen hasta 24hrs hasta que se reflejen en nuestro panel dichos datos. Para ello vamos a nuestra página de Google Analytics, y pulsamos en el link de la cuenta que creamos para esta aplicación. Veremos esto:
En esta imagen vemos un tick verde. Esto significa que la cuenta ha comenzado a recibir información. En caso de tener un triángulo de warning lo que significa es que aún no ha recibido datos. Ahora podemos pulsar en Ver informe y después de navegar un poco por las vistas que nos brinda Analytics (que son muchísimas), podremos ver cosas como estas:
Las páginas visitadas:
Los eventos recibidos:
En mi caso, mis eventos tenían como categoría Botones, como acción BotonPulsado y como etiqueta el nombre del botón. Si vemos el evento que tenemos, podemos verlo:
Con esto hemos comprobado que funciona y damos por finalizada la entrada.
En esta entrada hemos visto cómo integrar Google Analytics en nuestras aplicaciones para recolectar información de los usuarios de forma anónima. Esto puede ser muy útil, permitiéndonos ver qué partes de la aplicación se usan más o se usan menos, si es necesario remodelar algo que se usa mucho y queremos hacerlo más inmediato… en definitiva, es algo que deberíamos incluir en todas nuestras aplicaciones para ver cómo se comporta la gente con nuestra aplicación. Sería interesante avisar a los usuarios de que los permisos de Internet (en caso de no ser para otra cosa) van a ser para enviar estadísticas anónimas de uso. E incluso sería interesante pedir al usuario si quiere enviar esa información anónima en su primera ejecución.
Por lo que hemos mostrado es una carga de programación muy baja, y sólo nos ocupa 42KB en nuestro proyecto. Es una pequeña inversión para toda la información de valor que podemos obtener.
¡Un saludo para los lectores!