Cómo añadir Volley (librería de Android) en Android Studio

2
26115

Cómo añadir Volley(librería de Android) en Android Studio

0. Índice de contenidos.

1. Introducción

Volley es una librería para realizar peticiones http que fue presentada en el pasado Google I/0 2013.

Si hemos necesitado realizar conexiones http en alguna de las aplicaciones Android que hayamos desarrollado, seguramente hayamos usado urlConnection o httpClient o incluso los más aventurados quizás hayan usado Ion de Koush o la implementación de Android de RestTemplate de la gente de Spring

El problema de usar alguna de las dos primeras es que tienes que tener en cuenta la versión de Android en la que se está ejecutando tu aplicación porque las implementaciones de ambas tienen bastantes bugs. Por debajo de la 2.2 deberías usar httpClient y por encima urlConnection.

El «problema» de usar las dos últimas es que no son oficiales. Habrá quien tenga en cuenta esto y habrá quien no. También habrá quien diga que este tutorial va de importar una librería que no se distribuye aún con el sdk de Android

Sabiendo un poco en el contexto que nos movemos os describo brevemente las principales características de Volley.

  • Realiza las peticiones de forma asíncrona. Ya no más NetworkOnMainThreadException ;P
  • Gestiona una cola de descargas con prioridad. También podemos cancelar las peticiones
  • Caché de peticiones. También nos permite usar nuestra propia caché implementando una interfaz.
  • Toolbox de las peticiones más comunes: Json, etc… También para establecer imágenes de internet en nuestros ImageView…
  • Tiene en cuenta la versión de Android para usar urlConnection y httpConnection de forma transparente para nosotros.
  • Previsiblemente acabará incluyendose en el sdk o en alguna de las librerías de soporte de Google.

Como véis es una librería muy completa, aunque el ámbito del tutorial sólo va a llegar a importar el módulo :P.

Por si queréis echar un vistazo a la presentación de la librería en el Google IO, podéis verla aquí o en el canal de Youtube de Google Developers

2. Entorno

  • Hardware
    • Mackbook Pro
      • Intel Core i7 2Ghz
      • 8GB RAM
      • 250GB SSD
      • Sistema Operativo: Mac OS X (10.9)
  • Software
    • Android Studio 0.4.2
    • Git
    • Volley
    • Apache Ant 1.9.2
    • Gradle 1.10

3. Manos a la obra.

Volley viene preparado para compilar el proyecto con Ant y en las últimas versiones también con Gradle.

3.1 Descarga del proyecto.

Como hemos dicho en la introducción, Google aún no distribuye la librería a través del sdk de Android, por lo que lo tendremos que descargar por nuestra cuenta. Para ello, vamos a usar git para clonar el repositorio de Volley y tener una copia del código fuente en nuestro equipo.

Desde un terminal con git instalado hacemos: git clone https://android.googlesource.com/platform/frameworks/volley

Cuando termine tendremos en la carpeta que hayamos hecho el clone una nueva carpeta con el nombre volley y con el código fuente necesario para que podamos contruir la librería.

3.2 Con Apache Ant.

Lo que vamos a hacer con Ant es generar un jar que luego podremos añadir como dependencia en el proyecto Android en el que necesitemos usarlo.

Vamos a ver el contenido de proyecto:

Ejecutamos android update project -p . (el punto al final también hay que añadirlo) para modificar el proyecto con los datos locales: por ejemplo donde se encuentra nuestra instalación del sdk.

Y una vez que tenemos el proyecto listo, lo compilamos con Ant para generar un jar. Ejecutamos ant jar.

Si todo ha ido bien y tenemos un bonito BUILD SUCCESFUL entonces tendremos un jar llamado volley.jar en el directorio bin que podremos usar para importar en Android Studio.

3.2.1 Importando el proyecto.

Para usar la librería creamos una carpeta lib y copiamos el jar que acabamos de generar en esa carpeta.

Las últimas versiones de Android Studio vienen ya configuradas para que use esa carpeta como dependencias (como ocurría con Eclipse). Si no es nuestro caso, añadimos la dependencia nosotros a mano o a través del asistente de Android Studio. Nos tiene que quedar el fichero build.gralde así:

Como ya podemos usar Volley vamos hacer un test que lo corrobore 😛

3.2.2 Generacion de jar con código fuente.

En muchas ocasiones nos interesa poder ver el código de las clases que estamos usando incluso cuando estamos esa librería no es nuestra. Hay ocasiones en las que el entorno es capaz de acceder al código fuente sin que nosotros tengamos que hacer nada (descargándoselo de internet…). Hay otras ocasiones en las que el entorno (en este caso Android Studio) nos permite seleccionar dónde se encuentra el código fuente para que luego podamos verlo desde el entorno.

Si somos nosotros los que hemos generado el jar de Volley, tendremos el código fuente y podremos adjuntarlo desde el directorio donde hayamos hecho el clone, pero si vamos a compartir el código (por ejemplo en Bitbucket o Github) quizás nos interese generar un jar que también lleve los fuentes.

Lo que vamos a hacer es añadir una tarea de ant en medio del proceso de generación del jar de Android cuando este se construye por medio de Ant. Con la liberación de Android Studio, se está liberando un plugin de Android para Gradle de tal forma que se va a dejar de usar Ant para construir los proyectos a favor de Gradle, pero de momento, podemos usar Ant con Volley.

Cada proyecto tiene un fichero build.xml con información sobre como construir la aplicación. Este fichero tiene una referencia a un fichero build.xml que se encuentra en el directorio tools/ant de vuestro sdk de Android y es en este último fichero donde se encuentran las tareas de Ant comunes a la construcción de una aplicación o librería de Android.

Si miramos ese fichero nos encontraremos una línea como la siguiente:

Como podéis ver, cuando se llama a la fase de compilación, esta depende de una fase llamada -pre-compile que por defecto está vacía, pero que han añadido para que nosotros podamos personalizarla y añadir nuestras necesidades al proceso de construccción de la aplicación.

Lo que vamos a hacer es crear una tarea en la que copiemos los fuentes de la aplicación en el jar resultante.

  • Creamos un fichero build-with-sources.xml en el directorio donde hayamos clonado el repositorio de Volley
  • Añadimos nuestro build-with-sources.xml con la tarea para copiar los fuentes
  • Volvemos a llamar a ant jar para que nos vuelva a generar el jar que ya incluirá los fuentes.

El contenido de build-with-sources.xml es el siguiente:

Una vez que tengamos el fichero en el directorio de Volley, volvemos a llamar a ant jar especificando el nuevo fichero de build.

Cuanto termina de compilar, veréis que hay un mensaje en la fase de -pre-compile

Para comprobar que se ha generado bien, hacemos jar -tf bin/volley.jar. Veréis que hay archivos .java en el jar.

Ahora solo tenemos que añadir volley.jar a nuestro proyecto Android como hemos hecho antes o remplazar el jar si ya lo habíamos añadido.

3.3 Con Gradle.

Ahora vamos a cambiar un poco el enfoque. Vamos a usar Gradle, para generar la libería e instalarla en un repositorio local que luego usaremos para importar la librería en nuestro proyecto. Al final del tutorial, en las conclusiones comentaré qué ventajas e inconvienientes veo a cada método.

Como vamos a usar gradle, tenemos que fijarnos en el fichero build.gradle. Primero nos tenemos que asegurar que existan estas líneas en el fichero:

Comento esto porque si estamos usando una versión antigua del repositorio de Volley, no existirán y tendréis que añadirlas a mano para poder construir la librería.
Lo que significan es que están indicando a Gradle qué versión del plugin de Android para Gradle usar y dónde puede encontrarlo. Así que cuando más adelante en el fichero se encuentre esta línea: apply plugin: ‘android-library’, gradle sepa que hacer.

Vamos a ver que tareas nos permite ejecutar el plugin de Android. Ejecutamos gradle tasks en un terminal y obtenemos algo como lo siguiente:

Ejecutamos gradle clean build para generar una versión de Release y cuando termine deberíamos tener un mensaje de «BUILD SUCCESFULL». Una vez terminado podemos ver que Gradle nos ha generado una carpeta Build en el directorio del proyecto con los recursos y las clases que ha necesitado para constuir la librería. Si miramos dentro de esa carpeta veremos otra carpeta con nombre «libs» en donde se encuentra la librería generada.

Ahora bien, podríamos añadir la librería a nuestro proyecto igual que hemos hecho antes con la versión jar, pero vamos a cambiar el enfoque. Lo que vamos a hacer es añadir el plugin de Maven para gradle en el fichero de configuración del proyecto de tal forma que podamos instalar la librería en un repositorio de artefactos. En mi caso vamos a desplegar la librería en un Apache Archiva montado en otro equipo para hacer la prueba aunque también os voy a poner cómo instalarla en el repositorio local de maven.

Para evitar tocar lo máximo posible el fichero build.gradle de Volley y evitar posibles conflictos cuando actualicemos el proyecto, crearemos otro archivo que referenciaremos desde build.gradle.

Vamos a crear un archivo con nombre install.gradle con la configuración necesaria para desplegar la librería.

Si en vez de un repositorio remoto, quisiesemos instalarla en un repositorio local solo tenemos que cambiar la dirección de la propiedad repository. En este caso no necesitamos credenciales.

Antes de ejecutar la tarea, añadimos la referencia a nuestro script en el fichero build.gradle. Añadimos en el fichero la línea apply from: ‘install.gradle’

El siguiente paso es ejecutar la tarea: Ejecutamos gradle uploadArchives y veremos como al final de la ejecución, gradle nos muestra una traza de la tarea.

Y si navegamos en nuestro Archiva también seremos capaces de verlo:

Bueno, pues ya que por fin tenemos lista la libería, vamos a ver cómo tendríamos que configurar nuestro proyecto de Android para usar la librería.

Lo primero que tenemos que hacer es configurar el repositorio donde se encuentra la librería

Y para usar la librería, añadimos la dependencia.

NOTA, cada vez que modifiquemos el fichero build.gradle desde Android Studio, nos tenemos que acordar de darle al botón para sincronizar el proyecto con los ficheros de gradle.

Para probar que hemos añadido bien la dependencia, podemos probar el mismo test que hay en la parte de integración con Apache Ant.

3.3.1 Generacion de paquete con código fuente.

Y ahora, igual que con ant, vamos a generar un jar con los fuentes, pero a diferencia de ant, vamos a generar un paquete con la librería y otro con los fuentes.

  • Crearemos una nueva tarea sourcesJar.
  • Modificamos la tarea uploadArchives para indicarle que coga el jar resultante de sourcesJar.
  • Indicamos que uploadArchives depende de sourcesJar, de tal manera que siempre desplegaremos la librería con su paquete con el código fuente.

NOTA: El mecanismo para descarga de fuentes de forma automática por Android Studio ha sido liberado con la versión 0.4.6, pero parece ser que aún no va del todo fino.

4. Conclusiones

Estas son solo dos formas en las que podemos incorporar Volley a nuestro proyecto, pero no son únicas. Se podrían combinar entre ellas, podriamos usar maven (no el plugin de maven para Gradle) para hacer hacer el despliegue…

Las ventajas que veo a cada método son:

  • Generación de jar y añadido de la librería copiandola a mano en libs
    • Permitimos que desarrolladores que no tengan acceso a un repositorio privado puedan compilar el proyecto
  • Generación con gradle y despliegue con plugin de maven para gradle.
    • Evitamos subir librerías al contol de versiones.
    • Separamos código fuente de binarios.
    • Si tenemos varios proyectos que use Volley, no tenemos que copiar la librería en todos, solo añadir la dependencia
    • Es el mecanismo estandar de Gradle

Para cualquier comentario, duda o sugerencia, tenéis el formulario que aparece a continuación.

Un saludo.

2 Comentarios

Dejar respuesta

Please enter your comment!
Please enter your name here