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

2
32546

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í:

dependencies {  
    compile 'com.android.support:appcompat-v7:+'  
  
    compile files('libs/volley.jar')  
} 

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

@LargeTest  
public class VolleyRequestTest extends AndroidTestCase{  
  
    public void testVolleyWithSources() throws InterruptedException {  
        //Como la llamada es asíncrona, vamos a usar CountDownLatch para esperar a que termine la llamada  
        final CountDownLatch latch = new CountDownLatch(1);  
        //Workaround para asignar el valor de la respuesta dentro de un objeto  
        //anónimo y poder comprobar el resultado una vez que el callback a terminado.  
        final String[] responseBody = new String[1];  
  
        final RequestQueue requestQueue = Volley.newRequestQueue(getContext());  
        requestQueue.start();  
        StringRequest request = new StringRequest(  
            Request.Method.GET,  
            "http://www.autentia.com",  
            new Response.Listener < String>() {  
                @Override  
                public void onResponse(String response) {  
                    responseBody[0] = response;  
                    latch.countDown();  
                }  
            },  
            new Response.ErrorListener() {  
                @Override  
                public void onErrorResponse(VolleyError error) {  
                    latch.countDown();  
                }  
            }  
        );  
        requestQueue.add(request);  
  
        //Bloqueamos el hilo hasta que el callback llame a latch.countDown  
        latch.await();  
  
        //Comprobamos la petición.  
        assertNotNull(responseBody[0]);  
        assertTrue(responseBody[0].contains("autentia"));  
    }  
} 

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:

<?xml version="1.0" encoding="UTF-8"?>  
<project name="buil-with-sources" default="help">  
  
<!-- Importamos el build.xml del proyecto para tener disponible todas las tareas -->  
<import file="build.xml" />  
  
<!-- Definimos nuestra propia tarea que lo que va a hacer es copiar los .java al jar -->  
<target name="-pre-compile">  
    <echo message="Copying sources" />  
    <copy todir="${out.classes.absolute.dir}">  
        <fileset dir="${source.absolute.dir}" />  
    </copy>  
</target>  
  
</project> 

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

ant jar -f build-withsources.xml  

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:

buildscript {  
    repositories {  
        mavenCentral()  
    }  
    dependencies {  
        classpath 'com.android.tools.build:gradle:0.8.+'  
    }  
}  

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.

apply plugin: 'maven'  
  
uploadArchives {  
    repositories {  
        mavenDeployer {  
           //Donde queremos desplegar el artefacto  
           repository(url: "http://192.168.0.109:8080/repository/snapshots") {  
                authentication(userName: "www.autentia.com", password: "www.adictosaltrabajo.com")  
           }  
  
           //Evitamos que el plugin añada un timestamp en la generación del fichero  
           uniqueVersion = false;  
  
           //Información del artefacto. Son por estas propiedades por las que luego añadiremos la dependencia.  
           pom.groupId = "com.adictosaltrabajo"  
           pom.artifactId = "volley"  
           pom.version = "0.1-SNAPSHOT"  
        }  
    }  
}  

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.

//En este caso estaríamos usando /Users/fjarroyo/.m2/repository (directorio por defecto de maven)  
repository(url: "file://${System.env.HOME}/.m2/repository/")  

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’

//comienzo del script del fichero build.gradle del proyecto Volley  
apply plugin: 'android-library'  
//fichero que acabamos de crear  
apply from: 'install.gradle'  
//el script continua 

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

repositories {  
    //Si hemos desplegado la librería en un repositorio remoto, tenemos que decirle a gradle donde se encuentra ese repositorio  
    //En mi caso, el acceso al repositorio es público dentro de mi red local, por lo que no indico credenciales.  
    maven {  
        url "http://192.168.0.109:8080/repository/snapshots"  
    }  
  
    //Si la hemos desplegado en local, gradle nos proporciona un método para facilitarnos las cosas  
    mavenLocal()  
}  

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

dependencies {  
    //otras dependencias..  
  
    compile 'com.adictosaltrabajo:volley:0.1-SNAPSHOT@aar'  
    //compile  groupId:artifactId:version@tipo  
} 

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.
apply plugin: 'maven'  
  
//Tarea que va a generar el jar con los fuentes  
task sourcesJar(type: Jar) {  
    classifier = 'sources'  
    //especificamos donde se encuentrar los fuentes del proyecto.  
    from android.sourceSets.main.java.srcDirs  
}  
  
uploadArchives {  
  
    artifacts {  
        //Añadimos a los artefactos de despliegue, el artefacto de la tarea encargada de generar los fuentes  
        archives sourcesJar  
    }  
  
    repositories {  
        mavenDeployer {  
            repository(url: "http://192.168.0.109:8080/repository/snapshots") {  
                authentication(userName: "www.autentia.com", password: "www.adictosaltrabajo.com")  
            }  
  
            uniqueVersion = false;  
  
            pom.groupId = "com.adictosaltrabajo"  
            pom.artifactId = "volley"  
            pom.version = "0.1-SNAPSHOT"  
        }  
    }  
}  
//Hacemos que la tarea de despliegue, dependa de la de generación de fuentes  
uploadArchives.dependsOn sourcesJar

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

DEJA UNA RESPUESTA

Por favor ingrese su comentario!

He leído y acepto la política de privacidad

Por favor ingrese su nombre aquí

Información básica acerca de la protección de datos

  • Responsable:
  • Finalidad:
  • Legitimación:
  • Destinatarios:
  • Derechos:
  • Más información: Puedes ampliar información acerca de la protección de datos en el siguiente enlace:política de privacidad