Cómo enviar una solicitud simple

En un nivel alto, puedes usar Volley para crear una RequestQueue y pasarle objetos Request. La RequestQueue administra los subprocesos de trabajo para ejecutar las operaciones de red, leer la caché y escribir en ella, y analizar las respuestas. Las solicitudes analizan las respuestas sin procesar y Volley se encarga de devolver la respuesta analizada al subproceso principal para su entrega.

En esta lección, se describe cómo enviar una solicitud mediante el método de conveniencia Volley.newRequestQueue, que configura una RequestQueue por ti. Consulta la siguiente lección, Cómo configurar una RequestQueue, para obtener información sobre cómo configurar una RequestQueue por tu cuenta.

En esta lección, también se describe cómo agregar una solicitud a una RequestQueue y cómo cancelarla.

Cómo agregar el permiso de INTERNET

Para usar Volley, debes agregar el permiso android.permission.INTERNET al manifiesto de tu app. Sin este permiso, tu app no podrá conectarse a la red.

Cómo usar newRequestQueue

Volley proporciona un método de conveniencia Volley.newRequestQueue, que configura una RequestQueue por ti mediante valores predeterminados y, luego, inicia la cola. Por ejemplo:

Kotlin

    val textView = findViewById<TextView>(R.id.text)
    // ...

    // Instantiate the RequestQueue.
    val queue = Volley.newRequestQueue(this)
    val url = "http://www.google.com"

    // Request a string response from the provided URL.
    val stringRequest = StringRequest(Request.Method.GET, url,
            Response.Listener<String> { response ->
                // Display the first 500 characters of the response string.
                textView.text = "Response is: ${response.substring(0, 500)}"
            },
            Response.ErrorListener { textView.text = "That didn't work!" })

    // Add the request to the RequestQueue.
    queue.add(stringRequest)
    

Java

    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 siempre entrega respuestas analizadas al subproceso principal. La ejecución en el subproceso principal es conveniente para completar los controles de IU con los datos que se reciben, ya que puedes modificar libremente los controles de IU directamente desde tu controlador de respuestas. Sin embargo, es fundamental para muchas de las semánticas importantes que proporciona la biblioteca, en especial para aquellas relacionadas con la cancelación de solicitudes.

Consulta Cómo configurar una RequestQueue para obtener una descripción sobre cómo configurar una RequestQueue por tu cuenta, en lugar de usar el método de conveniencia Volley.newRequestQueue.

Cómo enviar una solicitud

Para enviar una solicitud, simplemente debes crearla y agregarla a la RequestQueue con add(), como se muestra más arriba. Una vez que lo haces, esta pasa por la canalización, se envía, se analiza su respuesta sin procesar y se entrega.

Cuando llamas a add(), Volley ejecuta un subproceso de procesamiento de caché y un conjunto de subprocesos de despacho de redes. Cuando agregas una solicitud a la cola, el subproceso de caché la toma y clasifica: si esta puede realizarse desde la caché, la respuesta almacenada en caché se analiza en el subproceso de caché y la respuesta analizada se entrega en el subproceso principal. Si la solicitud no puede realizarse desde la caché, se coloca en la cola de red. A continuación, el primer subproceso de red disponible toma la solicitud de la cola, realiza la transacción de HTTP, analiza la respuesta en el subproceso de trabajo, escribe la respuesta en la caché y devuelve la respuesta analizada al subproceso principal para su entrega.

Ten en cuenta que las operaciones costosas, como el bloqueo de I/O y el análisis o la decodificación, se realizan en subprocesos de trabajo. Puedes agregar una solicitud desde cualquier subproceso, pero las respuestas siempre se entregarán en el subproceso principal.

En la figura 1, se ilustra el ciclo de vida de una solicitud:

barras del sistema

Figura 1: Ciclo de vida de una solicitud

Cómo cancelar una solicitud

Para cancelar una solicitud, llama al cancel() en tu objeto Request. Una vez que la canceles, Volley garantizará que nunca se llame a tu controlador de respuestas, lo que en la práctica significa que puedes cancelar todas las solicitudes pendientes en el método onStop() de tu actividad y no tienes que llenar tus controladores de respuestas con verificaciones para getActivity() == null, en caso de que ya se haya llamado a onSaveInstanceState(), o bien a otro código estándar defensivo.

A fin de aprovechar este comportamiento, generalmente, deberías registrar todas las solicitudes en curso para poder cancelarlas en el momento adecuado. Existe una manera más fácil de hacerlo: puedes asociar un objeto de etiqueta con cada solicitud y, luego, usar esta etiqueta a fin de proporcionar un grupo de solicitudes para cancelar. Por ejemplo, puedes etiquetar todas las solicitudes con la Activity que las realiza y llamar a requestQueue.cancelAll(this) desde onStop(). De manera similar, puedes etiquetar todas las solicitudes de imágenes en miniatura en una pestaña ViewPager con sus respectivas pestañas y deslizar para cancelarlas a fin de garantizar que ninguna otra solicitud retenga la nueva pestaña.

Aquí tienes un ejemplo en el que se usa un valor de string para la etiqueta:

  1. Define tu etiqueta y agrégala a tus solicitudes.

    Kotlin

        val TAG = "MyTag"
        val stringRequest: StringRequest // Assume this exists.
        val requestQueue: RequestQueue? // Assume this exists.
    
        // Set the tag on the request.
        stringRequest.tag = TAG
    
        // Add the request to the RequestQueue.
        requestQueue?.add(stringRequest)
        

    Java

        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. En el método onStop() de tu actividad, cancela todas las solicitudes que tengan esta etiqueta.

    Kotlin

        protected fun onStop() {
            super.onStop()
            requestQueue?.cancelAll(TAG)
        }
        

    Java

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

    Ten cuidado cuando canceles solicitudes. Si dependes de tu controlador de respuestas para avanzar a un estado o iniciar otro proceso, deberás responder por ello. En este caso, tampoco se llamará al controlador de respuestas.