Tengo algunas preguntas sobre el uso de Volley en mis proyectos:

1. ¿Se puede usar esta biblioteca en cualquier proyecto Java o solo en Android?
2. Veo varias ramas aquí y no hay documentación sobre con qué rama comenzar. ¿Con qué rama debo usar para comenzar?
3. ¿Cómo integra esta biblioteca en su propio proyecto? ¿Qué enfoque es mejor: hacer Volley como un proyecto de biblioteca independiente y girar un jar y ponerlo en su proyecto o copiar todo el código fuente dentro de su proyecto?

$ git clone https://android.googlesource.com/platform/frameworks/volley
$ cd volley
$ android update project -p .
$ ant jar

Luego, copie bin/volley.jaren su libs/carpeta y listo.

fuente

En la lección de Volley , Google da instrucciones de agregar Volley a nuestro proyecto como un proyecto de la Biblioteca de Android o como un .jararchivo.

Aquí se explica cómo crear el .jararchivo Volley con Android Studio o Eclipse :

NOTA:

En ambos casos, sugiero cambiar el nombre del .jararchivo a la fecha de la última confirmación de Volley, es decir volley_20150319.jar, para mantener el control de versiones simple.

Android Studio:

1. Clona el repositorio de Volley a través de Git.
2. Importa el proyecto en Android Studio. (Normalmente selecciono el archivo gradle del proyecto cuando importo en Android Studio)
3. Construye el proyecto. (Tuve que cambiar la configuración de compilación de Gradle para reflejar las últimas herramientas de compilación y la versión de Gradle, pero generalmente está actualizado).
4. En su explorador de archivos, navegue hasta [your local path to volley]/build/intermediate/bundles/
5. En las carpetas debugy releaseencontrará un archivo JAR llamado classes.jar.
6. Copie cualquier archivo JAR en su libs/carpeta.
7. Gradle sync, y ya está.

Eclipse:

1. Clona el repositorio de Volley a través de Git.
2. Importe el proyecto en eclipse.
3. Haga clic derecho en el proyecto y seleccione Exportar ...
4. Seleccione el archivo Java / JAR .
5. Solo nos interesa la carpeta src y nada más. La forma más fácil de asegurarse de que solo esté seleccionada es anular la selección del proyecto y luego seleccionar la carpeta src que se encuentra dentro.
6. Marque la opción Exportar archivos de clase y recursos generados .
7. OPCIONAL: si desea que el Javadoc esté visible, seleccione también los recursos de Exportar archivos fuente Java .
8. Cree el archivo JAR y póngalo en su libs/carpeta.

1) ¿Esta biblioteca también se puede usar como biblioteca de red en proyectos Java normales O O es estrictamente solo para Android

Es solo para Android, ya que depende de las clases específicas de Android. Puedes decir esto mirando el código fuente, para cosas comoRequestQueue .

2) Veo varias ramas aquí y no hay documentación sobre con qué rama comenzar. ¿Con qué rama debo usar para comenzar?

Las instrucciones de la presentación de Google I | O eran simplemente clonar el gitrepositorio, que se extraería de la masterrama de forma predeterminada.

3) ¿Cómo integrar esta biblioteca en su propio proyecto? ¿Qué enfoque es mejor: hacer Volley como un proyecto de biblioteca independiente y girar un jar y ponerlo en su proyecto o copiar todo el código fuente dentro de su proyecto?

Las instrucciones de la presentación de Google I | O fueron agregar el código fuente a su proyecto. Personalmente, considero que este es un enfoque extraño.

puedes descargar el volley.jar

Fuente: AndroidHive

copia el Volley.jara libs

Luego

Haga clic derecho en volley.jar ->Agregar como biblioteca

La biblioteca Volley ahora está publicada por el Proyecto de Código Abierto de Android:

dependencies {
    implementation 'com.android.volley:volley:1.1.0'
}

ACTUALIZACIÓN: Volley ahora es oficial y está disponible a través del JCenter. Aquí se explica cómo importarlo:

compile 'com.android.volley:volley:1.0.0'

CAMINO PRIVADO:

Si está utilizando Gradle, puede importar Volley desde aquí .

dependencies {
    compile 'com.mcxiaoke.volley:library:1.0.+'
}

Nota

Este es un espejo no oficial (con algunas correcciones de errores menores, consulte el Registro de cambios para más detalles). Para la biblioteca de Android Volley , el código fuente se sincronizará periódicamente con el repositorio oficial de Volley.

Muchas maneras

Dado que hay muchas respuestas sobre un enfoque único, pero ninguna que compara las diferentes formas de poner en marcha la volea, también puse mis dos centavos. Siéntase libre de editar / mejorar esta respuesta también.

Agregarlo como biblioteca - (solución rápida)

1. Descárguelo de: androidhive
2. Ponlo en tu [MyProjectPath]/app/libs/carpeta
3. En Android Studio right-clicken él y seleccioneAdd As Library...

Archivos de origen de git - (una solución bastante oficial)

1. Descargue / instale el cliente git (si aún no lo tiene en su sistema) (otra visita a través de git clone https://github.com/git/git... sry bad one, pero no pudo resistir ^^)
2. Ejecutar git clone https://android.googlesource.com/platform/frameworks/volley

3. Copie la comcarpeta desde dentro [path_where_you_typed_git_clone]/volley/srca su app/src/main/javacarpeta de proyectos (o integre en su lugar, si ya tiene una carpeta com allí !! ;-))

   Los archivos aparecen inmediatamente en Android Studio. Para Eclipse, deberá hacerlo right-clicken la srccarpeta y presionar refresh(o F5) primero.

   Hacerlo a través de git es lo que se sugiere oficialmente en los tutoriales de Android ( mira aquí ).

Gradle a través de un espejo "no oficial" - (solución dinámica)

1. En el src/build.gradlearchivo de su proyecto, agregue la siguiente dependencia de voley:

       dependencies {
           compile fileTree(dir: 'libs', include: ['*.jar'])
           // ...
   
           compile 'com.mcxiaoke.volley:library:1.+'
       }

2. Haga clic en el Try Againque debería aparecer inmediatamente en la parte superior del archivo, o simplemente Buildsi no

   La "ventaja" principal aquí es que esto mantendrá la versión actualizada para usted, mientras que en los otros dos casos tendría que actualizar manualmente volley.

   En el "lado negativo" no es oficialmente de Google, sino un espejo semanal de terceros.

   Pero ambos puntos son realmente relativos a lo que necesitaría / desearía. Además, si no desea actualizaciones, simplemente coloque la versión deseada allí, por ejemplo compile 'com.mcxiaoke.volley:library:1.0.7'.

Si usa GIT para su propia gestión de código, ¿por qué no simplemente agregarlo como un submódulo al proyecto ...

git submodule add https://android.googlesource.com/platform/frameworks/volley -b master Volley

De esa manera, a medida que se actualiza la base del código Volley, es fácil de actualizar ...

git submodule git pull

Puede ampliar la clase principal de Volley en su propio proyecto para modificarla, lo que le evita tener que codificar sus cambios cada vez que se actualiza el marco de Volley.

Aquí hay un pequeño inicio rápido para una solicitud de Volley Http. Es extremadamente fácil de integrar.

• Necesita una solicitud de Volley RequestQueue amplia:

  1. private static RequestQueue reqQueue;

Puede ponerlo en su clase de Aplicación y hacer que esté estáticamente disponible a través de getRequestQueue ().

• Entonces ya puede usar el método RequestQueue.add () para ejecutar la primera solicitud con Volley.

  2. reqQueue.add(...)

• Use JsonObjectRequest para consultar un solo objeto, use JsonArrayRequest para consultar una lista de objetos.

  queue.add(new JsonArrayRequest(URL, new Listener<JSONArray>() {
  
      @Override
      public void onResponse(JSONArray response) {
          //SUCCESS
      }}, new ErrorListener() {
  
      @Override
      public void onErrorResponse(VolleyError error) {
          //ERROR
      }}));

• Recuerde configurar el encabezado Http Expires correctamente en el lado del servidor para que Volley pueda utilizar su función de almacenamiento en caché integrada

Aquí otra forma con Android Studio ang Gradle:

Necesita el siguiente en su build.gradle de su proyecto (en el nivel de estructura de su aplicación):

repositories {
    maven {
        url 'https://github.com/Goddchen/mvn-repo/raw/master/'
    }
    mavenCentral()
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    // You must install or update the Support Repository through the SDK manager to use this dependency.
    compile 'com.android.support:support-v4:20.+'
    compile 'com.android:volley:1.+'
}

Primero clona el proyecto de Git

$git clone https://android.googlesource.com/platform/frameworks/volley

• importar volea en eclipse.
• Haga clic derecho en su proyecto-> Propiedad-> android
• Agregue biblioteca-> elija volley (si no ve la volley allí, haga clic con el botón derecho en la biblioteca volley, vaya a la propiedad y android y haga clic en la biblioteca)
• después de agregar volley como biblioteca, puede comenzar a usarlo en su aplicación.

Algunas clases básicas de voley que debes saber son

• RequestQueue
• JsonArrayRequest
• JsonObjectRequest

Para usar volley primero, necesita crear un objeto de RequestQueue

RequestQueue mQueue = Volley.newRequestQueue(getApplicationContext());

Segundo:> haga una solicitud utilizando JsonArrayRequest o JsonObjectRequest

JsonArrayRequest mJsonRequest = new JsonArrayRequest(url, 
            new Listener<JSONArray>() {

                @Override
                public void onResponse(JSONArray response) {
                    // here you can parse response and use accordingly
                }
            }, new ErrorListener() {

                @Override
                public void onErrorResponse(VolleyError error) {
                    // here you will receive errors and show proper message according to error type

                }
            });

y finalmente puso la solicitud en cola. es decir

mQueue.add(mJsonRequest);

También te sugiero que hagas un Singleton de RequestQuery.

Agregar un volley jar (o cualquier jar) a Android Studio 1.0.2 ahora es considerablemente más fácil. Desde fuera de Android Studio, copie volley.jaren <yourproject>/app/libs(que ya debería existir). Debido a que la configuración predeterminada de Gradle incluye esta línea:

 compile fileTree(dir: 'libs', include: ['*.jar'])

... todo está configurado ahora. Es posible que eso no parezca así porque la vista predeterminada Estructura del proyecto (File -> Project Structure)no muestra el libsdirectorio. Para verlo, debe usar el control giratorio justo encima de la vista Estructura del proyecto para cambiar Androida Project.

Puede ver que funciona al compilar la aplicación (puede que no sea necesario) y luego comenzar a escribir un código como este:

 RequestQueue request

Verás que Android Studio te pide que lo completes RequestQueue (com.android.volley).

También es bastante fácil obtener un aar de depuración si esa es su preferencia.

git clone https://android.googlesource.com/platform/frameworks/volley

Luego, haga un nuevo proyecto de estudio de Android (solo un proyecto de aplicación normal) en un directorio diferente. Una vez que esté completo, agregue un nuevo submódulo (Archivo | Nuevo módulo). Elija la opción de importar el proyecto existente y apúntelo al directorio donde desprotegió la descarga. Una vez hecho esto, puede crear su módulo y creará un archivo aar.

Usando eclipse Luna tienes que:

• clonarlo desde GIT.
• corte (copie y elimine) la carpeta COM debajo de la carpeta JAVA debajo de la carpeta SRC como en el proyecto normal de Android.
• cambie el objetivo de project.properties a 15 en lugar de 8.
• construir el proyecto
• exporte el proyecto como archivo jar, incluida la fuente; use la herramienta de exportación.
• mantenga en el jar exportado solo la carpeta COM y la carpeta META-INF, elimine todas las demás carpetas; use la herramienta zip para eliminar el contenido del jar.
• usa este frasco como tu proyecto de volley jar.
• coloque el volley jar en la carpeta lib de su proyecto de Android de destino.

Si está utilizando Android Studio, lo que debería hacer es poner esta línea en el archivo gradle

compile 'com.mcxiaoke.volley:library:1.0.15'

Si desea utilizar el método GET, debería tener algo así.

private void weatherData() {
    JsonObjectRequest jsonObjReq = new JsonObjectRequest(
        Request.Method.GET,
        "URL with JSON data",
        new Response.Listener<JSONObject>() {
             @Override
             public void onResponse(JSONObject response) {
                 try {
                      //Your code goes here      
                 } catch (JSONException e) {
                      Log.e("TAG", e.toString());
                 }
             }
        }, 
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
            }
        });
    // Adding request to request queue
    AppController.getInstance().addToRequestQueue(jsonObjReq);
}

Pero si desea publicar datos en el servidor, debe construir una biblioteca HashMap y Volley que convierta esos valores de clave / par en objetos JSON antes de publicarlos en el servidor. Aquí hay un ejemplo.

final HashMap<String, String> postParams = new HashMap<String, String>();
postParams.put("username", username);
postParams.put("password", password);

Response.Listener<JSONObject> listener;
Response.ErrorListener errorListener;
final JSONObject jsonObject = new JSONObject(postParams);

JsonObjectRequest jsonObjReq = new JsonObjectRequest(
    "YOUR URL WITH JSON DATA", 
    jsonObject,
    new com.android.volley.Response.Listener<JSONObject>() {
        @Override
        public void onResponse(JSONObject response) {
            Log.d("TAG", response.toString());
            try {
                if (response.getString("status").equals("fail")) {

                } else if (response.getString("status").equals("success")) {

                } catch (JSONException e) {
                     Log.e("TAG", e.toString())
                }
            }
        }, 
        new com.android.volley.Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
             //VolleyLog.d("TAG", "Error: " + error.getMessage());
            //pDialog.dismiss();

        }
    }) {
        @Override
        public String getBodyContentType() {
            return "application/json; charset=utf-8";
        }
    };
    // Adding request to request queue
    AppController.getInstance().addToRequestQueue(jsonObjReq, tag_json_obj);

    VolleySingleton.getInstance(getApplicationContext()).
    addToRequestQueue(jsonObjRequest);
 }

Cloné el proyecto Volley y agregué archivos de configuración que permiten construir la biblioteca con Gradle.

• Gradle ready clon de Google Android Volley

Con esto, puede instalar la biblioteca en su repositorio local de Maven y hacer referencia a ella desde un proyecto de Android a través de Gradle.

Requisitos

1. Maven
2. Gradle

Cómo utilizar

1. Clonar mi repositorio
2. Construye e instala la biblioteca Volley
3. Hacer referencia a la biblioteca en un proyecto de Android

Corrección de errores

Tenga en cuenta que existen varios clones que tienen mejoras para la biblioteca . Puede ser necesario integrarlos y compilar su versión privada mejorada de la biblioteca.

Beneficios

Además de la biblioteca en sí, el script de compilación genera JavaDoc y genera archivos .

Me enfrenté a un problema cuando la biblioteca de soporte figuraba en la segunda línea. Reordenar estas dos declaraciones funcionó para mí.

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.mcxiaoke.volley:library:1.0.6'
    compile 'com.android.support:support-v4:20.+'
}

Volley se puede agregar como un submódulo git en su repositorio de proyecto actual. Este submódulo git apuntará al repositorio git oficial de Volley. Por lo tanto, puede obtener actualizaciones del repositorio oficial de git simplemente actualizando el puntero de submódulo.

Además, si agrega Volley como módulo de biblioteca en su proyecto principal, puede personalizarlo fácilmente. También será muy útil para fines de depuración.

Para lograr esto, siga los pasos a continuación:

Paso I

Agregue volea como submódulo en el proyecto de aplicación de Android GIT Repo. git submodule add -b master https://android.googlesource.com/platform/frameworks/volley Libraries / Volley

Paso II

En settings.gradle, agregue lo siguiente para agregar volley como módulo de proyecto de estudio. incluye el proyecto ': Volley' (': Volley'). projectDir = nuevo archivo ('../ Libraries / Volley')

Paso III

En app / build.gradle, agregue la siguiente línea para compilar el proyecto de compilación Volley (': Volley')

¡Eso es todo! Volley ha sido agregado con éxito en el proyecto.

Cada vez que desee obtener el último código del repositorio oficial de Volley de Google, simplemente ejecute el siguiente comando

git submodule foreach git pull

Para obtener información más detallada: https://gitsubmoduleasandroidtudiomodule.blogspot.in/

Código de muestra de GIT Repo: https://github.com/arpitratan/AndroidGitSubmoduleAsModule

Para futuros lectores

Me encanta trabajar con Volley . Para ahorrar tiempo de desarrollo, traté de escribir una pequeña y útil biblioteca Gloxey Netwok Manager para configurar Volley con mi proyecto. Incluye el analizador JSON y otros métodos diferentes que ayudan a verificar la disponibilidad de la red.

La biblioteca proporciona ConnectionManager.classen qué diferentes métodos para Volley String y Volley JSON están disponibles. Puede realizar solicitudes de GET, PUT, POST, DELETE con o sin encabezado. Puede leer la documentación completa aquí .

Simplemente ponga esta línea en su archivo gradle.

dependencias {

   compile 'io.gloxey.gnm:network-manager:1.0.1'

}