Ho alcune domande sull'utilizzo di Volley nei miei progetti:

1. Questa libreria può essere utilizzata in qualsiasi progetto Java o solo Android?
2. Vedo più rami qui e nessuna documentazione su quale ramo debba iniziare. Quale ramo dovrei usare per iniziare?
3. Come integri questa libreria nel tuo progetto? Quale approccio è migliore: creare Volley come un progetto di libreria autonomo e far girare un barattolo e inserirlo nel progetto o copiare tutto il codice sorgente all'interno del progetto?

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

Quindi, copia bin/volley.jarnella tua libs/cartella e via!

fonte

Nella lezione Volley , Google indica se aggiungere Volley al nostro progetto come progetto di libreria Android o come file.jar file.

Ecco come creare il .jarfile Volley utilizzando Android Studio o Eclipse :

NOTA:

In entrambi i casi suggerisco di rinominare il .jarfile con la data dell'ultimo commit di Volley, cioè volley_20150319.jarper mantenere il controllo delle versioni semplice.

Android Studio:

1. Clona il repository Volley tramite Git.
2. Importa il progetto in Android Studio. (Di solito seleziono il file gradle del progetto durante l'importazione in Android Studio)
3. Costruisci il progetto. (Ho dovuto modificare le impostazioni di build gradle per riflettere gli ultimi strumenti di build e la versione gradle, ma di solito è aggiornata).
4. Nel tuo file explorer, vai a [your local path to volley]/build/intermediate/bundles/
5. In entrambe le debuge releasecartelle troverete un file JAR chiamatoclasses.jar .
6. Copia uno dei file JAR nella tua libs/cartella.
7. Gradle sync e il gioco è fatto.

Eclisse:

1. Clona il repository Volley tramite Git.
2. Importa il progetto in eclipse.
3. Fare clic con il pulsante destro del mouse sul progetto e selezionare Esporta ...
4. Seleziona il file Java / JAR .
5. Siamo interessati solo alla cartella src e nient'altro. Il modo più semplice per assicurarsi che sia selezionato solo è deselezionare il progetto e quindi selezionare la cartella src all'interno.
6. Seleziona l'opzione Esporta file di classe e risorse generati .
7. FACOLTATIVO: Se vuoi che Javadoc sia visibile, seleziona anche le risorse Esporta file sorgente Java .
8. Crea il file JAR e mettilo nella tua libs/cartella.

1) Questa libreria può essere utilizzata anche come libreria di rete in normali progetti Java O è rigorosamente solo per Android

È solo per Android, poiché dipende dalle classi specifiche di Android. Puoi dirlo guardando il codice sorgente, per cose comeRequestQueue .

2) Vedo più rami qui e nessuna documentazione su quale ramo debba iniziare. Quale ramo dovrei usare per iniziare?

Le istruzioni dalla presentazione di Google I | O erano di clonare semplicemente il gitrepository, che sarebbe stato estratto dal masterramo per impostazione predefinita.

3) Come integrare questa libreria nel tuo progetto? Qual è l'approccio migliore: creare Volley come progetto di libreria autonomo e far girare un barattolo e inserirlo nel progetto o copiare tutto il codice sorgente all'interno del progetto?

Le istruzioni della presentazione di Google I | O erano di aggiungere il codice sorgente al tuo progetto. Personalmente, trovo che questo sia un approccio bizzarro.

puoi scaricare il file volley.jar

Fonte: AndroidHive

copia il file Volley.jarin libs

Poi

Fare clic con il pulsante destro del mouse su volley.jar ->Aggiungi come libreria

La libreria Volley è ora pubblicata dal progetto Android Open Source:

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

AGGIORNAMENTO: Volley è ora ufficiale ed è disponibile tramite JCenter. Ecco come importarlo:

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

MODO DEPRICATO:

Se stai usando Gradle, puoi importare Volley da qui .

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

Nota

Questo è un mirror non ufficiale (con qualche correzione di bug minore, vedi Changelog per i dettagli.) Per la libreria di android volley , il codice sorgente si sincronizzerà periodicamente con il repository ufficiale di volley.

Molti modi

Poiché ci sono molte risposte su un singolo approccio, ma nessuna che confronta i diversi modi per far funzionare il tiro al volo, ho anche messo i miei due centesimi. Sentiti libero di modificare / migliorare anche questa risposta.

Aggiungilo come libreria - (soluzione rapida)

1. Scaricalo da: androidhive
2. Mettilo nella tua [MyProjectPath]/app/libs/cartella
3. In Android Studio right-clicksu di esso e selezionaAdd As Library...

File sorgente da git - (una soluzione piuttosto ufficiale)

1. Scarica / installa il client git (se non lo hai ancora sul tuo sistema) (altrimenti tramitegit clone https://github.com/git/git ... sry bad one, ma non hai resistito ^^)
2. Eseguire git clone https://android.googlesource.com/platform/frameworks/volley

3. Copia la comcartella dall'interno nella cartella dei [path_where_you_typed_git_clone]/volley/srctuoi progetti app/src/main/java(o integrala invece, se hai già una cartella com lì !! ;-))

   I file vengono visualizzati immediatamente in Android Studio. Per Eclipse dovrai prima right-clicksulla srccartella e premere refresh(o F5).

   Farlo tramite git è ciò che è ufficialmente suggerito nei tutorial di Android ( guarda qui ).

Gradle tramite uno specchio "non ufficiale" - (soluzione dinamica)

1. Nel src/build.gradlefile del tuo progetto aggiungi la seguente dipendenza di volley:

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

2. Fare clic su quello Try Againche dovrebbe apparire subito nella parte superiore del file, o semplicemente Buildin caso contrario

   Il "vantaggio" principale qui è che questo manterrà la versione aggiornata per te, mentre negli altri due casi dovresti aggiornare manualmente il volley.

   Sul "lato negativo" non è ufficialmente da google, ma uno specchio settimanale di terze parti.

   Ma entrambi questi punti sono davvero relativi a ciò di cui avresti bisogno / vorresti. Inoltre, se non vuoi aggiornamenti, metti semplicemente la versione desiderata lì, ad es compile 'com.mcxiaoke.volley:library:1.0.7'.

Se usi GIT per la tua gestione del codice, perché non aggiungerlo semplicemente come sottomodulo al progetto ...

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

In questo modo, quando la base del codice di Volley viene aggiornata, è semplice aggiornare ...

git submodule git pull

Puoi estendere la classe Volley principale nel tuo progetto per la modifica, il che ti evita di dover perdere tempo con la codifica delle modifiche ogni volta che il framework Volley viene aggiornato.

Ecco un piccolo Quickstart per una richiesta Volley Http, è estremamente facile da integrare.

• Hai bisogno di una Volley RequestQueue a livello di applicazione:

  1. private static RequestQueue reqQueue;

Potresti metterlo nella tua classe Application e renderlo staticamente disponibile tramite getRequestQueue ().

• Quindi puoi già utilizzare il metodo RequestQueue.add () per eseguire la prima richiesta con Volley.

  2. reqQueue.add(...)

• Utilizzare JsonObjectRequest per eseguire una query per un singolo oggetto, utilizzare JsonArrayRequest per eseguire una query per un elenco di oggetti.

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

• Ricordati di impostare correttamente l'intestazione Http Expires sul tuo server in modo che Volley possa utilizzare la sua funzione di cache integrata

Ecco un altro modo con Android Studio ang Gradle:

Hai bisogno del prossimo nel tuo build.gradle del tuo progetto (nel livello della struttura della tua app):

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.+'
}

Prima clona il progetto da Git

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

• import volley in eclissi.
• Fare clic con il tasto destro sul progetto-> Proprietà-> Android
• Aggiungi libreria-> scegli volley (se non vedi volley lì, fai clic sulla libreria di volley, vai alla proprietà e Android e fai clic sulla libreria)
• dopo aver aggiunto volley come libreria puoi iniziare a usarlo nella tua applicazione.

Alcune classi base di volley che dovresti conoscere sono

• RequestQueue
• JsonArrayRequest
• JsonObjectRequest

Per usare prima il volley devi creare l'oggetto di RequestQueue

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

Secondo -> effettua una richiesta utilizzando 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

                }
            });

e infine mettere la richiesta in coda. vale a dire

mQueue.add(mJsonRequest);

Inoltre ti suggerirei di creare un singleton di RequestQuery.

Aggiungere un barattolo Volley (o qualsiasi barattolo) ad Android Studio 1.0.2 è ora notevolmente più semplice. Dall'esterno di Android Studio, copia volley.jarin <yourproject>/app/libs(che dovrebbe già esistere). Perché l'impostazione predefinita di Gradle include questa riga:

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

... ora è tutto pronto. Potrebbe non sembrare così perché la visualizzazione predefinita della struttura del progetto (File -> Project Structure)non mostra la libsdirectory. Per vederlo, è necessario utilizzare la casella di selezione appena sopra la vista Struttura del progetto per passare Androida Project.

Puoi vedere che funziona compilando l'app (potrebbe non essere necessario) e quindi iniziando a digitare un codice come questo:

 RequestQueue request

Vedrai che Android Studio ti richiede il completamento RequestQueue (com.android.volley).

È anche abbastanza facile ottenere un debug aar costruito se questa è la tua preferenza.

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

Quindi crea un nuovo progetto Android Studio (solo un normale progetto di app) in una directory diversa. Al termine, aggiungi un nuovo sottomodulo (File | Nuovo modulo). Scegli l'opzione di importazione del progetto esistente e indirizzala alla directory in cui hai estratto volley. Una volta fatto, puoi creare il tuo modulo e creerà un file aar.

Usando eclipse Luna devi:

• clonalo da GIT.
• taglia (copia ed elimina) la cartella COM nella cartella JAVA sotto la cartella SRC come nel normale progetto Android.
• cambia il target project.properties su 15 invece di 8.
• costruire il progetto.
• esportare il progetto come file jar inclusa la sorgente - utilizzare lo strumento di esportazione.
• mantieni nel jar esportato solo la cartella COM e la cartella META-INF, elimina tutte le altre cartelle - usa lo strumento zip per eliminare il contenuto del jar.
• usa questo barattolo come progetto del tuo barattolo Volley.
• metti il ​​vaso Volley nella cartella lib del tuo progetto Android di destinazione.

Se stai usando Android Studio, dovresti inserire questa riga nel file gradle

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

Se vuoi usare il metodo GET dovresti avere qualcosa del genere.

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);
}

Ma se vuoi inserire dati nel server, allora dovresti costruire una libreria HashMap e Volley converte quei valori chiave / coppia in oggetti JSON prima di pubblicarli nel server. Ecco un esempio.

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);
 }

Ho clonato il progetto Volley e aggiunto i file di configurazione che permettono di costruire la libreria con Gradle.

• Clone pronto per Gradle di Google Android Volley

Con questo puoi installare la libreria nel tuo repository Maven locale e farvi riferimento da un progetto Android tramite Gradle.

Requisiti

1. Esperto di
2. Gradle

Come usare

1. Clona il mio repository
2. Crea e installa la libreria Volley
3. Fare riferimento alla libreria in un progetto Android

Correzioni di bug

Tieni presente che ci sono vari cloni là fuori che hanno miglioramenti per la libreria . Potrebbe essere necessario integrarli e compilare la versione privata avanzata della libreria.

Benefici

Oltre alla libreria stessa, lo script di compilazione genera JavaDoc e archivi di sorgenti .

Ho riscontrato un problema quando la libreria di supporto era elencata nella seconda riga. Riordinare queste due affermazioni ha funzionato per me.

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

Volley può essere aggiunto come sottomodulo git nel repository del progetto corrente. Questo sottomodulo git punterà al repository git ufficiale di Volley. Quindi puoi ottenere aggiornamenti dal repository git ufficiale semplicemente aggiornando il puntatore del sottomodulo.

Inoltre, se aggiungi Volley come modulo libreria nel tuo progetto principale, puoi personalizzarlo facilmente. Sarà molto utile anche per scopi di debug.

Per ottenere ciò, segui i passaggi seguenti:

Fase I:

Aggiungi volley come sottomodulo nel progetto di applicazioni Android GIT Repo. git sottomodulo aggiungi -b master https://android.googlesource.com/platform/frameworks/volley Libraries / Volley

Fase II:

In settings.gradle, aggiungi quanto segue per aggiungere volley come modulo di progetto in studio. include il progetto ': Volley' (': Volley'). projectDir = new File ('../ Libraries / Volley')

Fase III:

In app / build.gradle, aggiungi la seguente riga per compilare il progetto di compilazione Volley (': Volley')

Sarebbe tutto! Volley è stato aggiunto con successo al progetto.

Ogni volta che desideri ottenere il codice più recente dal repository ufficiale di Volley di Google, esegui il comando seguente

git submodule foreach git pull

Per informazioni più dettagliate: https://gitsubmoduleasandroidtudiomodule.blogspot.in/

Codice di esempio Repo GIT: https://github.com/arpitratan/AndroidGitSubmoduleAsModule

Per futuri lettori

Amo lavorare con Volley . Per risparmiare tempo di sviluppo ho provato a scrivere una piccola e pratica libreria Gloxey Netwok Manager per configurare Volley con il mio progetto. Include il parser JSON e diversi altri metodi che aiutano a verificare la disponibilità della rete.

La libreria fornisce i ConnectionManager.classdiversi metodi per le richieste Volley String e Volley JSON . Puoi effettuare richieste di GET, PUT, POST, DELETE con o senza intestazione. Puoi leggere la documentazione completa qui .

Metti semplicemente questa riga nel tuo file gradle.

dipendenze {

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

}