Mam kilka pytań dotyczących używania Volley w moich projektach:

1. Czy ta biblioteka może być używana w dowolnym projekcie Java lub tylko w systemie Android?
2. Widzę tutaj wiele gałęzi i nie ma dokumentacji, od której ma się zacząć. Od której gałęzi powinienem zacząć?
3. Jak zintegrować tę bibliotekę ze swoim własnym projektem? Jakie podejście jest lepsze: stwórz Volley jako samodzielny projekt biblioteki i zakręć słoik i umieść go w swoim projekcie lub skopiuj cały kod źródłowy do swojego projektu?

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

Następnie skopiuj bin/volley.jardo swojego libs/folderu i gotowe!

źródło

W lekcji Volley Google instruuje, czy dodać Volley do naszego projektu jako projekt biblioteki systemu Android lub jako plik.jar plik.

Oto jak utworzyć .jarplik Volley za pomocą Android Studio lub Eclipse :

UWAGA:

W obu przypadkach sugeruję zmianę nazwy .jarpliku na datę ostatniego zatwierdzenia Volleya, tj. volley_20150319.jarAby zachować prostotę wersjonowania.

Android Studio:

1. Sklonuj repozytorium Volley przez Git.
2. Zaimportuj projekt do Android Studio. (Zwykle wybieram plik gradle projektu podczas importowania w Android Studio)
3. Zbuduj projekt. (Musiałem zmienić ustawienia kompilacji gradle, aby odzwierciedlić najnowsze narzędzia do kompilacji i wersję gradle, ale zwykle jest aktualna).
4. W eksploratorze plików przejdź do [your local path to volley]/build/intermediate/bundles/
5. W obu folderach debugi releaseznajdziesz plik JAR o nazwieclasses.jar .
6. Skopiuj dowolny plik JAR do swojego libs/folderu.
7. Synchronizacja Gradle i gotowe.

Zaćmienie:

1. Sklonuj repozytorium Volley przez Git.
2. Zaimportuj projekt do Eclipse.
3. Kliknij projekt prawym przyciskiem myszy i wybierz Eksportuj ...
4. Wybierz plik Java / JAR .
5. Interesuje nas tylko folder src i nic więcej. Najłatwiejszym sposobem upewnienia się, że tylko on jest zaznaczony, jest odznaczenie projektu, a następnie zaznaczenie znajdującego się w nim folderu src .
6. Zaznacz opcję Eksportuj wygenerowane pliki klas i zasoby .
7. OPCJONALNIE: jeśli chcesz, aby Javadoc był widoczny, wybierz również zasoby Eksportuj pliki źródłowe Java .
8. Utwórz plik JAR i umieść go w swoim libs/folderze.

1) Czy ta biblioteka może być również używana jako biblioteka sieciowa w normalnych projektach Java, czy też jest przeznaczona wyłącznie dla systemu Android

Jest przeznaczony tylko dla Androida, ponieważ zależy od klas specyficznych dla Androida. Możesz to stwierdzić, patrząc na kod źródłowy, na przykładRequestQueue .

2) Widzę tutaj wiele oddziałów i nie ma dokumentacji, od której ma zacząć. Od której gałęzi powinienem zacząć?

Instrukcje z prezentacji Google I | O miały po prostu sklonować gitrepozytorium, które masterdomyślnie pobierze z gałęzi.

3) Jak zintegrować tę bibliotekę ze swoim własnym projektem? Jakie podejście jest lepsze: stwórz Volley jako samodzielny projekt biblioteki i zakręć słoik i umieść go w swoim projekcie lub skopiuj cały kod źródłowy do swojego projektu?

Instrukcje z prezentacji Google I | O dotyczyły dodania kodu źródłowego do twojego projektu. Osobiście uważam, że jest to dziwne podejście.

możesz pobrać plik volley.jar

Źródło: AndroidHive

skopiuj Volley.jardo libs

Następnie

Kliknij prawym przyciskiem myszy volley.jar ->Dodaj jako bibliotekę

Biblioteka Volley jest teraz publikowana przez Android Open Source Project:

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

AKTUALIZACJA: Volley jest teraz oficjalna i jest dostępna za pośrednictwem JCenter. Oto jak go zaimportować:

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

SPOSÓB PRZECENIONY:

Jeśli używasz Gradle, możesz zaimportować Volley z tego miejsca .

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

Uwaga

To jest nieoficjalny serwer lustrzany (z drobnymi poprawkami, szczegóły w Dzienniku zmian ). Dla biblioteki android volley kod źródłowy będzie okresowo synchronizowany z oficjalnym repozytorium volley.

Wiele sposobów

Ponieważ istnieje wiele odpowiedzi na temat jednego podejścia, ale żadna nie porównuje różnych sposobów na rozpoczęcie gry w siatkówkę, włożę również moje dwa centy. Zapraszam do edycji / poprawiania również tej odpowiedzi.

Dodaj jako bibliotekę - (szybkie rozwiązanie)

1. Pobierz go z: androidhive
2. Umieść go w swoim [MyProjectPath]/app/libs/ folderze
3. W Android Studio right-clickna nim i wybierzAdd As Library...

Pliki źródłowe z git - (raczej oficjalne rozwiązanie)

1. Pobierz / zainstaluj klienta git (jeśli jeszcze go nie masz w systemie) (w innym przypadku za pośrednictwemgit clone https://github.com/git/git innym przypadku ... sry zły, ale nie mogłem się oprzeć ^^)
2. Wykonać git clone https://android.googlesource.com/platform/frameworks/volley

3. Skopiuj comfolder z wewnątrz [path_where_you_typed_git_clone]/volley/srcdo app/src/main/javafolderu projektów (lub zamiast tego zintegruj go, jeśli masz już tam folder com !! ;-))

   Pliki pojawiają się natychmiast w Android Studio. Dla Eclipse trzeba będzie right-clickna srcfolder i naciśnij refresh(lub F5) po raz pierwszy.

   Robienie tego przez git jest oficjalnie sugerowane w samouczkach Androida ( patrz tutaj ).

Gradle przez „nieoficjalne” lustro - (rozwiązanie dynamiczne)

1. W src/build.gradlepliku projektu dodaj następującą zależność volley:

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

2. Kliknij, Try Againktóry powinien od razu pojawić się na górze pliku, a Buildjeśli nie , po prostu go

   Główną "zaletą" jest to, że dzięki temu wersja będzie dla Ciebie aktualna, podczas gdy w pozostałych dwóch przypadkach będziesz musiał ręcznie zaktualizować salwę.

   Z drugiej strony, nie pochodzi on oficjalnie od Google, ale z cotygodniowego lustra strony trzeciej.

   Ale oba te punkty są naprawdę związane z tym, czego potrzebujesz / chcesz. Jeśli nie chcesz aktualizacji, po prostu umieść tam żądaną wersję, np compile 'com.mcxiaoke.volley:library:1.0.7'.

Jeśli używasz GIT do własnego zarządzania kodem, możesz po prostu dodać go jako moduł podrzędny do projektu ...

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

W ten sposób, gdy baza kodu Volley jest aktualizowana, aktualizacja jest łatwa ...

git submodule git pull

Możesz rozszerzyć główną klasę Volley we własnym projekcie w celu modyfikacji, dzięki czemu nie będziesz musiał martwić się kodowaniem zmian za każdym razem, gdy zostanie zaktualizowany framework Volley.

Oto mały przewodnik Szybki start dla żądania HTTP Volley, jest niezwykle łatwy do zintegrowania.

• Potrzebujesz aplikacji Volley RequestQueue:

  1. private static RequestQueue reqQueue;

Możesz umieścić go w swojej klasie Application i udostępnić statycznie za pomocą metody getRequestQueue ().

• Wtedy możesz już użyć metody RequestQueue.add () do wykonania pierwszego żądania z Volley.

  2. reqQueue.add(...)

• Użyj JsonObjectRequest, aby zapytać o pojedynczy obiekt, użyj JsonArrayRequest, aby zapytać o listę obiektów.

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

• Pamiętaj, aby poprawnie ustawić nagłówek Http Expires po stronie serwera, aby Volley mógł korzystać ze zintegrowanej funkcji buforowania

Oto inny sposób z Android Studio i Gradle:

Potrzebujesz następnego w pliku build.gradle projektu (na poziomie struktury aplikacji):

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

Najpierw sklonuj projekt z Git

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

• import salwy w zaćmieniu.
• Kliknij prawym przyciskiem myszy swój projekt-> Property-> android
• Dodaj bibliotekę-> wybierz salę (jeśli nie widzisz tam volleya, bibliotekę salwy prawym kliknięciem, goto property oraz bibliotekę android i kliknij)
• po dodaniu volleya jako biblioteki możesz zacząć używać go w swojej aplikacji.

Oto kilka podstawowych rodzajów siatkówki, o których powinieneś wiedzieć

• RequestQueue
• JsonArrayRequest
• JsonObjectRequest

Aby użyć volleya, musisz najpierw stworzyć obiekt RequestQueue

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

Po drugie -> wykonaj żądanie za pomocą JsonArrayRequest lub 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

                }
            });

i wreszcie umieść wniosek w kolejce. to znaczy

mQueue.add(mJsonRequest);

Sugerowałbym również utworzenie Singletona of RequestQuery.

Dodanie słoika Volley (lub dowolnego słoika) do Android Studio 1.0.2 jest teraz znacznie łatwiejsze. Spoza Android Studio skopiuj volley.jardo <yourproject>/app/libs(który powinien już istnieć). Ponieważ domyślna konfiguracja Gradle zawiera ten wiersz:

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

... wszystko jest gotowe. Może się tak nie wydawać, ponieważ domyślny widok struktury projektu (File -> Project Structure)nie pokazuje libskatalogu. Aby go zobaczyć, musisz użyć pokrętła tuż nad widokiem struktury projektu, aby przejść Androiddo Project.

Możesz zobaczyć, że to działa, budując aplikację (może nie być konieczne), a następnie zaczynając wpisywać kod podobny do tego:

 RequestQueue request

Zobaczysz, że Android Studio monituje o zakończenie RequestQueue (com.android.volley).

Bardzo łatwo jest również zbudować plik aar do debugowania, jeśli takie są twoje preferencje.

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

Następnie utwórz nowy projekt Android Studio (zwykły projekt aplikacji) w innym katalogu. Po zakończeniu dodaj nowy moduł podrzędny (Plik | Nowy moduł). Wybierz opcję importu istniejącego projektu i skieruj go do katalogu, w którym wypisałeś salwę. Gdy to zrobisz, możesz stworzyć swój moduł i utworzy plik aar.

Używając Eclipse Luna musisz:

• sklonuj go z GIT.
• wytnij (skopiuj i usuń) folder COM w folderze JAVA poniżej folderu SRC, jak w zwykłym projekcie Android.
• zmień target project.properties na 15 zamiast 8.
• zbudować projekt.
• wyeksportuj projekt jako plik jar wraz ze źródłem - użyj narzędzia eksportu.
• zachowaj w wyeksportowanym jar tylko folder COM i folder META-INF, usuń wszystkie inne foldery - użyj narzędzia zip, aby usunąć zawartość słoika.
• użyj tego słoika jako projektu słoika Volley.
• umieść jar Volley w folderze lib docelowego projektu systemu Android.

Jeśli używasz Android Studio, powinieneś umieścić tę linię w pliku gradle

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

Jeśli chcesz użyć metody GET, powinieneś mieć coś takiego.

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

Ale jeśli chcesz publikować dane na serwerze, powinieneś skonstruować bibliotekę HashMap i Volley, która konwertuje te wartości klucza / pary na obiekty JSON przed wysłaniem ich na serwer. Oto przykład.

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

Sklonowałem projekt Volley i dodałem pliki konfiguracyjne, które pozwalają budować bibliotekę za pomocą Gradle.

• Gotowy do Gradle klon Google Android Volley

Dzięki temu możesz zainstalować bibliotekę w swoim lokalnym repozytorium Maven i odwoływać się do niej z projektu Android za pośrednictwem Gradle.

Wymagania

1. Maven
2. Gradle

Jak używać

1. Sklonuj moje repozytorium
2. Zbuduj i zainstaluj bibliotekę Volley
3. Odwołaj się do biblioteki w projekcie systemu Android

Bugfixes

Należy pamiętać, że istnieją różne klony, które mają ulepszenia w bibliotece . Konieczne może być ich zintegrowanie i skompilowanie prywatnej rozszerzonej wersji biblioteki.

Korzyści

Oprócz samej biblioteki skrypt budujący generuje JavaDoc i archiwa źródeł .

Napotkałem problem, gdy biblioteka wsparcia była wymieniona w drugiej linii. Zmiana kolejności tych dwóch stwierdzeń działała dla mnie.

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

Volley można dodać jako podmoduł git w bieżącym repozytorium projektu. Ten podmoduł git będzie wskazywał na oficjalne repozytorium git Volley. W związku z tym możesz uzyskać aktualizacje z oficjalnego repozytorium git, po prostu aktualizując wskaźnik podmodułu.

Co więcej, jeśli dodasz Volley jako moduł biblioteki w swoim głównym projekcie, możesz go łatwo dostosować. Będzie to również bardzo przydatne do debugowania.

Aby to osiągnąć, wykonaj poniższe czynności:

I krok:

Dodaj salwę jako moduł podrzędny w projekcie aplikacji na Androida GIT Repo. git submodule add -b master https://android.googlesource.com/platform/frameworks/volley Libraries / Volley

Etap II:

W settings.gradle dodaj następujące elementy, aby dodać salwę jako moduł projektu studyjnego. include ': Volley' project (': Volley'). projectDir = new File ('../ Libraries / Volley')

Krok III:

W app / build.gradle dodaj następujący wiersz, aby skompilować projekt kompilacji Volley (': Volley')

To byłoby wszystko! Volley został pomyślnie dodany do projektu.

Za każdym razem, gdy chcesz uzyskać najnowszy kod z oficjalnego repozytorium Google Volley, po prostu uruchom poniższe polecenie

git submodule foreach git pull

Bardziej szczegółowe informacje: https://gitsubmoduleasandroidtudiomodule.blogspot.in/

Przykładowy kod GIT Repo: https://github.com/arpitratan/AndroidGitSubmoduleAsModule

Dla przyszłych czytelników

Uwielbiam pracować z Volley . Aby zaoszczędzić czas na rozwój, próbowałem napisać małą, poręczną bibliotekę Gloxey Netwok Manager, aby skonfigurować Volley z moim projektem. Zawiera parser JSON i różne inne metody, które pomagają sprawdzić dostępność sieci.

Biblioteka zapewnia, ConnectionManager.classw których są dostępne różne metody dla żądań Volley String i Volley JSON . Możesz wysyłać żądania GET, PUT, POST, DELETE z nagłówkiem lub bez. Możesz przeczytać pełną dokumentację tutaj .

Po prostu umieść tę linię w swoim pliku gradle.

zależności {

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

}