Pengantar untuk Volley

Volley adalah pustaka jaringan yang dikembangkan oleh Google dan diperkenalkan selama Google I/O 2013. Ini dikembangkan karena ketiadaan, di Android SDK, dari kelas jaringan yang mampu bekerja tanpa mengganggu pengalaman pengguna.

Sampai peluncuran Volley, canonical Java class adalah java.net.HttpURLConnection dan Apache org.apache.http.client adalah satu-satunya alat yang tersedia bagi para programmer Android untuk mengembangkan sistem RESTful antara klien dan remote backend.

Kesampingkan sejenak fakta bahwa kedua kelas ini tidak terbebas dari bug, harus dicatat bagaimana segala sesuatu yang melampaui transaksi HTTP sederhana harus ditulis ex novo. Jika Anda ingin menyimpan gambar atau memprioritaskan permintaan, Anda harus mengembangkannya dari awal.

Untungnya, sekarang ada Volley, dibuat dan disesuaikan untuk memenuhi kebutuhan ini.

1. Mengapa Volley?

Hindari HttpUrlConnection dan HttpClient

Pada level API yang lebih rendah (kebanyakan pada Gingerbread dan Froyo), HttpUrlConnection dan HttpClient jauh dari sempurna. Ada beberapa masalah yang diketahui dan bug yang tidak pernah terselesaikan. Selain itu, HttpClient sudah ditinggalkan dalam pembaruan API terakhir (API 22), yang berarti tidak akan lagi dipertahankan dan mungkin dihapus dalam rilis mendatang.

Ini adalah alasan yang cukup untuk memutuskan untuk beralih ke cara yang lebih andal dalam menangani permintaan jaringan Anda.

Dan Hindari AsyncTask Juga

Sejak diperkenalkannya Honeycomb (API 11), sudah wajib untuk melakukan operasi jaringan pada utas yang terpisah, berbeda dari utas utama. Perubahan substansial ini mengarah pada penggunaan masif spesifikasi AsyncTask<Params, Progress, Result>.

Dengan AsyncTask, Anda terlebih dahulu menentukan beberapa tindakan persiapan, seperti definisi konteks, di onPreExecute. Anda kemudian melakukan tugas asynchronous Anda menggunakan metode doInBackground. Akhirnya, Anda menangani hasil di onPostExecute. Ini cukup mudah, jauh lebih mudah daripada implementasi layanan, dan dilengkapi dengan banyak contoh dan dokumentasi.

Masalah utama, bagaimanapun, adalah serialisasi panggilan. Menggunakan kelas AsyncTask, Anda tidak dapat memutuskan permintaan mana yang lebih dulu dan mana yang harus menunggu. Semuanya terjadi FIFO, pertama masuk, pertama keluar.

Masalah muncul, misalnya, ketika Anda harus memuat daftar item yang telah melampirkan thumbnail. Ketika pengguna menggulir ke bawah dan mengharapkan hasil baru, Anda tidak bisa mengatakan aktivitas Anda untuk memuat JSON halaman berikutnya dan hanya kemudian gambar dari yang sebelumnya. Ini bisa menjadi masalah pengalaman pengguna yang serius dalam aplikasi seperti Facebook atau Twitter, di mana daftar item baru lebih penting daripada thumbnail yang terkait dengannya.

Volley bertujuan untuk memecahkan masalah ini dengan menyertakan API pembatalan yang kuat. Anda tidak perlu lagi check-in onPostExecute ketika aktivitas dihancurkan saat melakukan panggilan. Ini membantu menghindari NullPointerException yang tidak diinginkan.

Jauh Lebih Cepat

Beberapa waktu lalu, tim Google melakukan serangkaian pengujian kinerja pada masing-masing metode berbeda yang dapat Anda gunakan untuk membuat permintaan jaringan di Android. Volley mendapat skor hingga sepuluh kali lebih baik daripada alternatif lain ketika digunakan dalam aplikasi RESTful.

Ini Cache Semuanya

Volley secara otomatis membuat cache permintaan dan ini adalah sesuatu yang benar-benar menyelamatkan hidup. Mari kembali sejenak ke contoh yang saya berikan sebelumnya. Anda memiliki daftar item—JSON array katakanlah—dan setiap item memiliki deskripsi dan thumbnail yang terkait dengannya. Sekarang pikirkan apa yang terjadi jika pengguna memutar layar: aktivitas dihancurkan, daftar diunduh lagi, dan begitu pula gambarnya. Singkat cerita, pemborosan sumber daya yang signifikan dan pengalaman pengguna yang buruk.

Volley terbukti sangat berguna untuk mengatasi masalah ini. Ini mengingat panggilan sebelumnya yang dilakukan dan menangani penghancuran aktivitas dan rekonstruksi. Ini cache segalanya tanpa Anda harus khawatir tentang hal itu.

Operasi Metadata Kecil

Volley sangat cocok untuk panggilan kecil, seperti objek JSON, bagian daftar, detail item yang dipilih, dan sebagainya. Ini telah dirancang untuk aplikasi RESTful dan dalam kasus khusus ini memberikan yang terbaik.

Namun, tidak begitu bagus ketika digunakan untuk operasi streaming dan unduhan besar. Bertentangan dengan kepercayaan umum, nama Volley tidak berasal dari kamus olahraga. Ini dimaksudkan sebagai semburan panggilan berulang, dikelompokkan bersama. Entah bagaimana intuitif mengapa pustaka ini tidak berguna ketika, daripada tendangan voli panah, Anda ingin menembakkan bola meriam.

2. Di Bawah Terpal

Volley bekerja pada tiga level berbeda dengan setiap level beroperasi pada utasnya sendiri.

Thread Utama

Di thread utama, konsisten dengan apa yang sudah Anda lakukan dalam spesifikasi AsyncTask, Anda hanya diizinkan untuk mengeluarkan permintaan dan menangani responsnya. Tidak lebih, tidak kurang.

Konsekuensi utamanya adalah Anda benar-benar dapat mengabaikan semua yang terjadi dalam metode doInBackground. Volley secara otomatis mengelola transaksi HTTP dan menangkap kesalahan jaringan yang perlu Anda pedulikan sebelumnya.

Cache dan Thread Jaringan

Saat Anda menambahkan permintaan ke antrean, beberapa hal terjadi di bawah kap mesin. Pertama, Volley memeriksa apakah permintaan dapat dilayani dari cache. Jika bisa, tanggapan yang di-cache dibaca, diurai, dan dikirim. Jika tidak, diteruskan ke utas jaringan.

Pada utas jaringan, round-robin dengan rangkaian utas terus bekerja. Thread jaringan pertama yang tersedia mendetail permintaan, membuat permintaan HTTP, mem-parsing respons, dan menulisnya ke cache. Untuk menyelesaikannya, ia mengirimkan tanggapan yang diurai kembali ke utas utama di mana pendengar Anda menunggu untuk menangani hasilnya.

3. Memulai

Langkah 1: Mengimpor Volley

Volley tidak begitu berguna untuk disiapkan. Sepertinya tidak ada repositori Maven resmi yang tersedia dan ini cukup membingungkan. Anda harus bergantung pada kode sumber resmi. Anda dapat mengimpor Volley salah satu dari beberapa cara.

Pertama-tama, unduh sumber Volley dari repositori. Jika Anda merasa yakin melakukan ini, perintah Git ini dapat melakukan semua pekerjaan untuk Anda:

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

Hingga beberapa minggu yang lalu, Anda bisa membungkus semuanya menggunakan baris perintah ant (android update project -p . dan kemudian ant jar) dan mengimpor pustaka JAR Anda di proyek Android Studio Anda dengan file compile files('libs/volley.jar').

Baru-baru ini, bagaimanapun, Google memperbarui Volley ke Android Studio membangun style, sehingga lebih sulit untuk membuat JAR mandiri. Anda masih bisa melakukannya, tetapi hanya dengan versi pustaka yang lebih lama. Saya pribadi tidak menyarankan Anda untuk menggunakan opsi ini, meskipun ini mungkin tampak paling cepat.

Anda harus mengatur Volley dengan cara klasik, yaitu dengan mengimpor sumber sebagai module. Di Android Studio, dengan proyek Anda dibuka, pilih File > Modul Baru, dan pilih Impor Existing Project yang Ada. Pilih direktori tempat Anda baru mengunduh kode sumber dan konfirmasi. Folder bernama Volley akan muncul di struktur proyek Anda. Android Studio secara otomatis memperbarui file settings.gradle Anda untuk menyertakan modul Volley sehingga Anda hanya perlu menambahkan ke proyek kompilasi dependensi compile project(':volley') dan Anda selesai.

Ada cara ketiga. Anda dapat menambahkan ke bagian dependensi dari file build.gradle baris ini:

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

Ini adalah salinan mirror dari repositori Google resmi, disinkronkan dan diperbarui secara rutin. Ini mungkin cara termudah dan tercepat untuk memulai. Namun, harap diperhatikan, ini adalah repositori Maven tak resmi, tidak ada jaminan dan tidak didukung oleh Google.

Menurut pendapat saya, masih lebih baik untuk berinvestasi beberapa menit lagi untuk mengimpor kode sumber resmi. Dengan cara ini, Anda dapat dengan mudah beralih ke definisi dan implementasi awal sehingga, jika ada keraguan, Anda selalu dapat mengandalkan sumber resmi Volley—dan bahkan mengubahnya jika perlu.

Langkah 2: Menggunakan Volley

Volley kebanyakan bekerja hanya dengan dua kelas, RequestQueue and Request. Anda terlebih dahulu membuat RequestQueue, yang mengelola utas pekerja dan mengirimkan hasil yang diurai kembali ke utas utama. Anda kemudian meneruskannya satu atau lebih objek Request.

Request konstruktor selalu mengambil parameter jenis metode (GET, POST, dll.), URL sumber daya, dan event listener. Kemudian, tergantung pada jenis permintaan, mungkin meminta beberapa variabel lagi.

Dalam contoh berikut, saya membuat objek RequestQueue dengan menerapkan salah satu metode kenyamanan Volley, Volley.newRequestQueue. Ini membuat objek RequestQueue, menggunakan nilai default yang ditentukan oleh Volley.

String url = "http://httpbin.org/html";

// Request a string response
StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
            new Response.Listener<String>() {
    @Override
    public void onResponse(String response) {

        // Result handling 
        System.out.println(response.substring(0,100));

    }
}, new Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {
        
        // Error handling
        System.out.println("Something went wrong!");
        error.printStackTrace();

    }
});

// Add the request to the queue
Volley.newRequestQueue(this).add(stringRequest);

Seperti yang Anda lihat, itu sangat mudah. Anda membuat permintaan dan menambahkannya ke antrean permintaan. Dan selesai.

Perhatikan bahwa sintaks pendengar mirip dengan AsyncTask.onPostExecute, dan itu hanya menjadi onResponse. Ini bukan suatu kebetulan. Pengembang yang bekerja di Volley dengan sengaja membuat API pustaka sangat mirip dengan metode AsyncTask. Ini membuat transisi dari menggunakan AsyncTask ke Volley menjadi jauh lebih mudah.

Jika Anda harus mem-burn beberapa permintaan dalam beberapa aktivitas, Anda harus menghindari menggunakan pendekatan di atas, Volley.newRequestQueue.add. Jauh lebih baik untuk membuat instance antrean permintaan bersama dan menggunakannya di seluruh proyek Anda:

MySingletonClass.getInstance().getRequestQueue().add(myRequest);

Kita akan melihat secara khusus untuk mengembangkan sesuatu seperti ini di tutorial selanjutnya dari seri ini.

4. Masukkan Tangan Anda ke dalam Adonan

Menangani Permintaan Standar

Volley sangat berguna untuk menerapkan tiga jenis permintaan yang sangat umum:

• StringRequest
• ImageRequest
• JsonRequest

Masing-masing kelas ini memperluas kelas Result yang kita gunakan sebelumnya. Kami sudah melihat StringRequest dalam contoh sebelumnya. Mari kita lihat bagaimana cara kerja JsonRequest.

String url = "http://httpbin.org/get?site=code&network=tutsplus";

JsonObjectRequest jsonRequest = new JsonObjectRequest
        (Request.Method.GET, url, null, new Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject response) {
                // the response is already constructed as a JSONObject!
                try {
                    response = response.getJSONObject("args");
                    String site = response.getString("site"),
                            network = response.getString("network");
                    System.out.println("Site: "+site+"\nNetwork: "+network);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {
                error.printStackTrace();
            }
        });

Volley.newRequestQueue(this).add(jsonRequest);

Indah. Bukan? Seperti yang Anda lihat, jenis hasil sudah diatur ke JSONObject. Anda dapat meminta JSONArray juga jika Anda mau, menggunakan JsonArrayRequest, bukan JsonObjectRequest.

Seperti sebelumnya, parameter pertama konstruktor adalah metode HTTP yang digunakan. Anda kemudian memberikan URL untuk mengambil JSON dari. Variabel ketiga dalam contoh di atas adalah null. Ini bagus karena ini menunjukkan bahwa tidak ada parameter yang akan diposkan bersama dengan permintaan. Akhirnya, Anda memiliki pendengar untuk menerima respons JSON dan error listener. Anda dapat mengirimkan null jika Anda ingin mengabaikan kesalahan.

Mengambil gambar membutuhkan sedikit lebih banyak pekerjaan. Ada tiga metode yang mungkin untuk meminta gambar. ImageRequest adalah yang standar. Ini menampilkan gambar yang Anda minta dalam ImageView umum, mengambilnya melalui URL yang disediakan. Semua pengodean dan pengubahan ukuran operasi yang Anda inginkan agar Volley tampil di worker thread. Pilihan kedua adalah kelas ImageLoader, yang dapat Anda anggap sebagai orkestrator dari sejumlah besar ImageRequests, misalnya, untuk mengisi ListView dengan gambar. Opsi ketiga adalah NetworkImageView, yang merupakan semacam pengganti XML untuk item layout ImageView.

Mari kita lihat contoh.

String url = "http://i.imgur.com/Nwk25LA.jpg";
mImageView = (ImageView) findViewById(R.id.image);

ImageRequest imgRequest = new ImageRequest(url,
        new Response.Listener<Bitmap>() {
    @Override
    public void onResponse(Bitmap response) {
        mImageView.setImageBitmap(response);
    }
}, 0, 0, ImageView.ScaleType.FIT_XY, Bitmap.Config.ARGB_8888, new Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {
        mImageView.setBackgroundColor(Color.parseColor("#ff0000"));
        error.printStackTrace();
    }
});

Volley.newRequestQueue(this).add(imgRequest);

Parameter pertama adalah URL gambar dan yang kedua adalah listener untuk hasilnya. Parameter ketiga dan keempat adalah integer, maxWidth dan maxHeight. Anda dapat mengaturnya ke 0 untuk mengabaikan parameter ini. Setelah itu, ImageRequest meminta Anda untuk ScaleType digunakan untuk menghitung ukuran gambar yang dibutuhkan dan untuk format untuk memecahkan kode bitmap. Saya sarankan selalu menggunakan Bitmap.Config.ARGB_8888. Akhirnya, kita memberikan error listener.

Perhatikan bahwa Volley secara otomatis menetapkan prioritas permintaan ini ke LOW.

// Snippet taken from ImageRequest.java, 
// in the Volley source code
@Override
public Priority getPriority() {
    return Priority.LOW;
}

Membuat Permintaan POST

Berpindah dari permintaan GET ke permintaan POST sederhana. Anda perlu mengubah Request.Method di konstruktor dari permintaan dan mengganti metode getParams, mengembalikan Map<String, String> yang tepat, yang berisi parameter permintaan.

String url = "http://httpbin.org/post";

StringRequest postRequest = new StringRequest(Request.Method.POST, url,
        new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                try {
                    JSONObject jsonResponse = new JSONObject(response).getJSONObject("form");
                    String site = jsonResponse.getString("site"),
                            network = jsonResponse.getString("network");
                    System.out.println("Site: "+site+"\nNetwork: "+network);
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        },
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                error.printStackTrace();
            }
        }
) {
    @Override
    protected Map<String, String> getParams()
    {
        Map<String, String>  params = new HashMap<>();
        // the POST parameters:
        params.put("site", "code");
        params.put("network", "tutsplus");
        return params;
    }
};
Volley.newRequestQueue(this).add(postRequest);

Membatalkan Permintaan

Jika Anda ingin membatalkan semua permintaan Anda, tambahkan cuplikan kode berikut ke metode onStop:

@Override
protected void onStop() {
    super.onStop();
    mRequestQueue.cancelAll(new RequestQueue.RequestFilter() {
        @Override
        public boolean apply(Request<?> request) {
            // do I have to cancel this?
            return true; // -> always yes
        }
    });
}

Dengan cara ini, Anda tidak perlu khawatir tentang kemungkinan bahwa pengguna telah menghancurkan aktivitas ketika onResponse dipanggil. NullPointerException akan dibuang dalam kasus seperti itu.

Permintaan POST dan PUT, bagaimanapun, harus dilanjutkan, bahkan setelah pengguna mengubah aktivitas. Kita bisa mencapai ini dengan menggunakan tags. Saat membangun permintaan GET, tambahkan tag ke dalamnya.

// after declaring your request
request.setTag("GET");
mRequestQueue.add(request);

Untuk membatalkan setiap permintaan GET yang tertunda, kami cukup menambahkan baris kode berikut:

mRequestQueue.cancelAll("GET");

Dengan cara ini, Anda hanya membatalkan permintaan GET, membiarkan permintaan lain tidak tersentuh. Perhatikan bahwa Anda sekarang harus menangani secara manual kasus di mana aktivitas tersebut dihancurkan sebelum waktunya.

Mengelola Cookies dan Prioritas Permintaan

Volley tidak menyediakan metode untuk mengatur cookie permintaan, atau prioritasnya. Mungkin akan ada di masa depan, karena itu kelalaian serius. Untuk saat ini, Anda harus memperpanjang kelas Request.

Untuk mengelola cookie, Anda dapat bermain dengan header permintaan, menggunakan metode getHeaders:

public class CustomRequest extends JsonObjectRequest {

    // Since we're extending a Request class
    // we just use its constructor
    public CustomRequest(int method, String url, JSONObject jsonRequest,
                         Response.Listener<JSONObject> listener, Response.ErrorListener errorListener) {
        super(method, url, jsonRequest, listener, errorListener);
    }

    private Map<String, String> headers = new HashMap<>();

    /**
     * Custom class!
     */
    public void setCookies(List<String> cookies) {
        StringBuilder sb = new StringBuilder();
        for (String cookie : cookies) {
            sb.append(cookie).append("; ");
        }
        headers.put("Cookie", sb.toString());
    }

    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        return headers;
    }
    
}

Dengan implementasi ini, Anda dapat langsung memberikan daftar cookie ke permintaan menggunakan setCookies.

// Firstly, you create the list of the cookies,
// conformed to the HTTP conventions
// i.e. key=value
List<String> cookies = new ArrayList<>();
cookies.add("site=code");
cookies.add("network=tutsplus");

// then you invoke your custom method
customRequest.setCookies(cookies);

// and finally add the request to the queue
Volley.newRequestQueue(this).add(customRequest);

Untuk prioritas, Anda juga perlu memperpanjang kelas Request, mengesampingkan metode getPriority. Seperti inilah implementasi yang terlihat:

Priority mPriority;

public void setPriority(Priority priority) {
    mPriority = priority;
}

@Override
public Priority getPriority() {
    // If you didn't use the setPriority method,
    // the priority is automatically set to NORMAL
    return mPriority != null ? mPriority : Priority.NORMAL;
}

Kemudian, pada utas utama, aktifkan baris kode ini untuk menetapkan prioritas permintaan:

customRequest.setPriority(Priority.HIGH);

Anda dapat memilih dari salah satu dari empat kemungkinan status prioritas seperti yang ditunjukkan di bawah ini:

Priority.LOW // images, thumbnails, ...
Priority.NORMAL // residual
Priority.HIGH // descriptions, lists, ...
Priority.IMMEDIATE // login, logout, ...

Kesimpulan

Dalam artikel ini, kita melihat cara kerja pustaka jaringan Volley. Kita pertama kali melihat mengapa dan kapan lebih baik menggunakan Volley daripada solusi lain yang sudah termasuk dalam Android SDK. Kita kemudian menggali jauh ke dalam rincian pustaka, melihat alur kerjanya dan jenis permintaan yang didukung. Akhirnya, kita membuat permintaan sederhana dan menerapkan yang khusus untuk menangani cookie dan prioritas.

Di bagian selanjutnya dari seri ini tentang Volley, kita akan membuat aplikasi sederhana yang memanfaatkan Volley. Saya akan menunjukkan cara membuat aplikasi cuaca untuk Mars, menggunakan data cuaca yang dikumpulkan di Mars oleh Curiosity rover.