Volley

Volley adalah library HTTP yang mempermudah dan, yang terpenting, mempercepat
networking untuk aplikasi Android. Volley tersedia di GitHub.

Volley menawarkan manfaat-manfaat berikut:

• Penjadwalan otomatis permintaan jaringan.

• Beberapa koneksi jaringan serentak.
• Caching respons disk dan memori transparan dengan koherensi cache HTTP
standar.
• Dukungan untuk pemrioritasan permintaan.
• API permintaan pembatalan. Anda bisa membatalkan satu permintaan, atau
menetapkan blok atau cakupan permintaan untuk dibatalkan.
• Kemudahan kustomisasi, misalnya, untuk mencoba ulang dan backoff.
• Pemesanan kuat yang memudahkan pengisian UI Anda dengan benar
menggunakan data yang diambil secara asinkron dari jaringan.
• Fitur proses debug dan penelusuran.

Volley unggul di operasi tipe RPC yang digunakan untuk mengisi UI, seperti
mengambil halaman hasil penelusuran sebagai data terstruktur. Volley terintegrasi
secara mudah dengan protokol apa pun dan memberi performa terbaik dengan
dukungan untuk string raw, gambar, dan JSON. Dengan memberikan dukungan
bawaan untuk fitur yang Anda butuhkan, dengan Volley, Anda tidak perlu menulis
kode boilerplate, sehingga Anda dapat berkonsentrasi pada logika yang spesifik
untuk aplikasi Anda.

Volley tidak cocok untuk operasi download atau streaming yang besar karena Volley
menyimpan semua respons dalam memori selama penguraian. Untuk operasi
download besar, pertimbangkan untuk menggunakan alternatif
seperti DownloadManager.

Library Volley inti dikembangkan di GitHub dan berisi pipeline pengiriman

permintaan utama serta seperangkat utilitas yang berlaku secara umum, dan
tersedia di "toolbox" Volley. Cara termudah untuk menambahkan Volley ke project
Anda adalah dengan menambahkan dependensi berikut ke file build.gradle aplikasi
Anda:

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

Anda juga bisa meng-clone repositori Volley dan menjadikannya sebagai project
library:

1. Git meng-clone repositori dengan mengetik kode berikut ini di command line:

2. git clone https://github.com/google/volley

3. Impor sumber yang didownload ke project aplikasi Anda sebagai modul

library Android seperti yang dijelaskan dalam Membuat Library Android.

Mengirim permintaan sederhana

Pada level tinggi, Anda menggunakan Volley dengan membuat RequestQueue dan
meneruskannya objek Request. RequestQueue mengelola thread pekerja untuk
menjalankan operasi jaringan, membaca dari dan menulis ke cache, serta mengurai
respons. Permintaan akan melakukan penguraian respons mentah dan Volley akan
menangani pengiriman respons yang diurai kembali ke thread utama untuk
dikirimkan.

Pelajaran ini menjelaskan cara mengirim permintaan menggunakan metode

praktis Volley.newRequestQueue, yang akan menyiapkan RequestQueue untuk Anda.
Lihat pelajaran selanjutnya, Menyiapkan RequestQueue, untuk mengetahui informasi
cara menyiapkan file RequestQueue sendiri.

Pelajaran ini juga menjelaskan cara menambahkan permintaan ke RequestQueue dan

membatalkan permintaan.

Menambahkan izin INTERNET

Untuk menggunakan Volley, Anda harus menambahkan
izin android.permission.INTERNET ke manifes aplikasi Anda. Tanpanya, aplikasi Anda
tidak akan bisa terhubung ke jaringan.

Menggunakan newRequestQueue
Volley menyediakan metode praktis Volley.newRequestQueue yang akan
menyiapkan RequestQueue untuk Anda, menggunakan nilai default, dan memulai
antrean. Contoh:

KotlinJava
 final TextView textView = (TextView) findViewById(R.id.text);
// ...

// Instantiate the RequestQueue.

RequestQueue queue = Volley.newRequestQueue(this);
String url ="http://www.google.com";

// Request a string response from the provided URL.

StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
new Response.Listener<String>() {
@Override
public void onResponse(String response) {
// Display the first 500 characters of the response string.
textView.setText("Response is: "+ response.substring(0,500));
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
textView.setText("That didn't work!");
}
});

// Add the request to the RequestQueue.

queue.add(stringRequest);

Volley selalu memberikan respons yang diurai pada thread utama. Berjalan di thread
utama adalah hal yang praktis untuk mengisi kontrol UI dengan data yang diterima,
sebab Anda bisa bebas memodifikasi kontrol UI langsung dari pengendali respons.
Namun hal tersebut sangat penting bagi banyak semantik penting yang disediakan
oleh library, terutama yang berkaitan dengan pembatalan permintaan.

Lihat Menyiapkan RequestQueue untuk mengetahui deskripsi terkait cara

menyiapkan RequestQueue sendiri, bukan menggunakan metode
praktis Volley.newRequestQueue.

Mengirim permintaan
Untuk mengirimkan permintaan, cukup buat satu dan tambahkan
ke RequestQueue dengan add(), seperti yang ditunjukkan di atas. Setelah ditambahkan,
permintaan akan bergerak melalui pipeline, dilayani, dan respons mentahnya
diuraikan dan dikirim.

Saat Anda memanggil add(), Volley akan menjalankan satu thread pemrosesan
cache dan kumpulan thread pengiriman jaringan. Saat Anda menambahkan
permintaan ke antrean, permintaan akan diambil oleh thread cache dan
diprioritaskan: jika permintaan dapat dilayani dari cache, respons yang di-cache akan
diuraikan pada thread cache dan respons yang diuraikan akan dikirimkan di thread
utama. Jika permintaan tidak dapat dilayani dari cache, permintaan akan
ditempatkan di antrean jaringan. Thread jaringan pertama yang tersedia akan
mengambil permintaan dari antrean, melakukan transaksi HTTP, menguraikan
respons pada thread pekerja, menulis respons ke cache, dan memposting respons
yang diurai kembali ke thread utama untuk dikirimkan.

Perhatikan bahwa operasi mahal seperti pemblokiran I/O dan penguraian/dekode

dilakukan pada thread pekerja. Anda bisa menambahkan permintaan dari thread
mana pun, tetapi respons akan selalu dikirimkan di thread utama.

Gambar 1 menggambarkan proses permintaan:

Gambar 1. Proses permintaan.

Membatalkan permintaan
Untuk membatalkan permintaan, panggil cancel() pada objek Request Anda. Setelah
dibatalkan, Volley menjamin agar pengendali respons Anda tidak akan pernah
dipanggil. Dalam praktiknya ini berarti Anda bisa membatalkan semua permintaan
yang tertunda dalam metode onStop() aktivitas dan Anda tidak perlu membuang
pengendali respons dengan centang untuk getActivity() == null,
baik onSaveInstanceState() sudah dipanggil, atau boilerplate defensif lainnya.

Untuk memanfaatkan perilaku ini, Anda biasanya harus melacak semua permintaan
yang sedang berlangsung agar dapat membatalkannya di waktu yang tepat. Ada
cara yang lebih mudah: Anda dapat mengaitkan objek tag dengan setiap permintaan.
Nantinya Anda bisa menggunakan tag ini untuk memberikan cakupan permintaan
untuk dibatalkan. Misalnya, Anda dapat memberi tag semua permintaan
dengan Activity yang dibuat atas namanya, dan
memanggil requestQueue.cancelAll(this) dari onStop(). Selain itu, Anda bisa memberi tag
semua permintaan gambar thumbnail di tab ViewPager dengan masing-masing tab
dan membatalkan dengan geser untuk memastikan bahwa tab baru tidak ditunda
oleh permintaan dari yang lain.

Berikut adalah contoh yang menggunakan nilai string untuk tag:

1. Tentukan tag dan tambahkan ke permintaan Anda.

KotlinJava
public static final String TAG = "MyTag";
StringRequest stringRequest; // Assume this exists.
RequestQueue requestQueue; // Assume this exists.

// Set the tag on the request.

stringRequest.setTag(TAG);

// Add the request to the RequestQueue.

requestQueue.add(stringRequest);

2. Dalam metode onStop() aktivitas Anda, batalkan semua permintaan yang

memiliki tag ini.
KotlinJava
@Override
protected void onStop () {
super.onStop();
if (requestQueue != null) {
requestQueue.cancelAll(TAG);
}
}

Berhati-hatilah saat membatalkan permintaan. Jika Anda bergantung pada

pengendali respons untuk melanjutkan status atau memulai proses lain, Anda
harus memperhitungkannya. Sekali lagi, pengendali respons tidak akan
dipanggil
Menyiapkan RequestQueue

Tutorial sebelumnya menunjukkan cara menggunakan metode

praktis Volley.newRequestQueue untuk menyiapkan RequestQueue dengan
memanfaatkan perilaku default Volley. Tutorial ini memberikan panduan dengan
langkah-langkah yang jelas untuk membuat RequestQueue sehingga Anda dapat
menyediakan perilaku kustom Anda sendiri.

Tutorial ini juga menjelaskan praktik yang direkomendasikan untuk

membuat RequestQueue sebagai singleton sehingga RequestQueue dapat bertahan
sepanjang waktu penggunaan aplikasi Anda.

Menyiapkan jaringan dan cache

RequestQueue memerlukan dua hal untuk melakukan tugasnya: jaringan untuk
membawa permintaan, dan cache untuk menangani penyimpanan data ke dalam
cache. Tersedia implementasi standar untuknya di toolbox
Volley: DiskBasedCache menyediakan cache satu file per respons dengan indeks
dalam memori, dan BasicNetwork menyediakan transportasi jaringan berdasarkan
klien HTTP pilihan Anda.

BasicNetwork adalah penerapan jaringan default Volley. BasicNetwork harus

diinisialisasi dengan klien HTTP yang digunakan aplikasi untuk terhubung ke
jaringan. Biasanya, klien ini adalah HttpURLConnection.

Cuplikan berikut menunjukkan langkah-langkah yang diperlukan dalam

menyiapkan RequestQueue:

KotlinJava
RequestQueue requestQueue;

// Instantiate the cache

Cache cache = new DiskBasedCache(getCacheDir(), 1024 * 1024); // 1MB cap

// Set up the network to use HttpURLConnection as the HTTP client.

Network network = new BasicNetwork(new HurlStack());

// Instantiate the RequestQueue with the cache and network.

requestQueue = new RequestQueue(cache, network);

// Start the queue

requestQueue.start();

String url ="http://www.example.com";

 // Formulate the request and handle the response.
StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
new Response.Listener<String>() {
@Override
public void onResponse(String response) {
// Do something with the response
}
},
new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
// Handle error
}
});

// Add the request to the RequestQueue.

requestQueue.add(stringRequest);

// ...

Jika hanya perlu membuat permintaan satu kali dan tidak ingin meninggalkan
kumpulan thread, Anda dapat membuat RequestQueue di mana pun Anda
membutuhkannya lalu memanggil stop() pada RequestQueue setelah respons atau
error kembali, menggunakan metode Volley.newRequestQueue() yang dijelaskan
dalam Mengirim Permintaan Sederhana. Namun, kasus penggunaan yang lebih
umum adalah membuat RequestQueue sebagai singleton agar tetap berjalan
sepanjang waktu penggunaan aplikasi Anda, seperti yang dijelaskan di bagian
berikutnya.

Menggunakan pola singleton

Jika aplikasi Anda terus-menerus menggunakan jaringan, cara yang paling efisien
mungkin adalah menyiapkan satu instance RequestQueue yang akan bertahan
sepanjang waktu penggunaan aplikasi. Anda dapat melakukannya dengan berbagai
cara. Pendekatan yang direkomendasikan adalah mengimplementasikan class
singleton yang mengenkapsulasi RequestQueue dan fungsionalitas Volley lainnya.
Pendekatan lainnya adalah membuat subclass Application dan
menyiapkan RequestQueue di Application.onCreate(). Namun, pendekatan ini tidak
disarankan; singleton statis dapat memberikan fungsi yang sama dengan cara yang
lebih modular.

Konsep utamanya adalah, RequestQueue harus dibuat instance-nya dengan

konteks Application, bukan konteks Activity. Hal ini memastikan RequestQueue akan
bertahan sepanjang waktu penggunaan aplikasi Anda, bukan dibuat ulang setiap kali
aktivitas dibuat ulang (misalnya, saat pengguna memutar perangkat).
Berikut adalah contoh class singleton yang menyediakan
fungsionalitas RequestQueue dan ImageLoader:

KotlinJava
public class MySingleton {
private static MySingleton instance;
private RequestQueue requestQueue;
private ImageLoader imageLoader;
private static Context ctx;

private MySingleton(Context context) {

ctx = context;
requestQueue = getRequestQueue();

imageLoader = new ImageLoader(requestQueue,

new ImageLoader.ImageCache() {
private final LruCache<String, Bitmap>
cache = new LruCache<String, Bitmap>(20);

@Override
public Bitmap getBitmap(String url) {
return cache.get(url);
}

@Override
public void putBitmap(String url, Bitmap bitmap) {
cache.put(url, bitmap);
}
});
}

public static synchronized MySingleton getInstance(Context context) {

if (instance == null) {
instance = new MySingleton(context);
}
return instance;
}

public RequestQueue getRequestQueue() {

if (requestQueue == null) {
// getApplicationContext() is key, it keeps you from leaking the
// Activity or BroadcastReceiver if someone passes one in.
requestQueue = Volley.newRequestQueue(ctx.getApplicationContext());
}
return requestQueue;
}
 public <T> void addToRequestQueue(Request<T> req) {
getRequestQueue().add(req);
}

public ImageLoader getImageLoader() {

return imageLoader;
}
}

Berikut beberapa contoh tentang menjalankan operasi RequestQueue menggunakan

class singleton:

KotlinJava
// Get a RequestQueue
RequestQueue queue = MySingleton.getInstance(this.getApplicationContext()).
getRequestQueue();

// ...

// Add a request (in this example, called stringRequest) to your RequestQueue.

MySingleton.getInstance(this).addToRequestQueue(stringRequest);