Transmitir datos de red usando Volley en Android

Hola, les saluda Miguel y en esta ocasión les traigo otro nuevo tutorial.

Una biblioteca HTTP que facilita la creación de redes para aplicaciones de Android y lo que es más importante, más rápida

Al leer este artículo, aprenderá a llamar a la API REST directamente desde una aplicación de Android. Usaremos una biblioteca HTTP llamada Volley que es oficialmente compatible con Android.

Según los comentarios de uno de los lectores, Google se ha alejado de esta biblioteca y ya no la actualiza activamente. La última versión es el 17 de julio de 2018. Tenga esto en cuenta si planea usarla dentro de su proyecto.

Según la documentación oficial.

«Volley sobresale en las operaciones de tipo RPC que se utilizan para completar una interfaz de usuario, como buscar una página de resultados de búsqueda como datos estructurados.

Se integra fácilmente con cualquier protocolo y viene listo para usar con soporte para cadenas sin procesar, imágenes y JSON.

Al proporcionar soporte integrado para las funciones que necesita, Volley lo libera de escribir código repetitivo y le permite concentrarse en la lógica que es específica de su aplicación».

La documentación enumera los siguientes beneficios:

implementation 'com.android.volley:volley:1.1.1'

<uses-permission android:name="android.permission.INTERNET"/>

Estaremos configurando una clase RequestQueue que sirve como servicio a nuestra aplicación. Creemos una nueva clase llamada RequestSingleton.java. Se recomienda encarecidamente utilizar el enfoque singleton, que es mucho más eficiente.

Importar

Agregue la siguiente importación a la clase.

import android.content.Context;
import android.graphics.Bitmap;

import com.android.volley.DefaultRetryPolicy;
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;

Inicialización

Inicialice las siguientes variables dentro de su clase.

private static RequestSingleton instance;
private RequestQueue requestQueue;
private static Context ctx;

Objeto singleton

Crea un método sincronizado llamado getInstance. Pasamos por un objeto Context como parámetro. Llamaremos a este método para obtener el singleton.

public static synchronized RequestSingleton getInstance(Context context) {
      if (instance == null) {
           instance = new RequestSingleton(context);
      }
      return instance;
}

Constructor

Crea el constructor para RequestSingleton con la siguiente inicialización. (Verá un error como getRequestQueue. La función aún no está implementada.)

private RequestSingleton(Context context) {
ctx = context;
requestQueue = getRequestQueue();
}

Implementar lo que falta método getRequestQueue con el siguiente código.

public RequestQueue getRequestQueue() {
if (requestQueue == null) {
requestQueue = Volley.newRequestQueue(ctx.getApplicationContext());
       }
       return requestQueue;
}

Método de solicitud genérico

Una vez que haya terminado, continúe agregando la siguiente función genérica para asegurarse de que nuestro singleton pueda admitir todo tipo de Request.

public <T> void addToRequestQueue(Request<T> req) {
//retry policy

    getRequestQueue().add(req);
}

Puede configurar el RetryPolicy para evitar que se agote el tiempo de espera si la llamada a la API tarda bastante en finalizar. Agregue lo siguiente debajo del comentario para establecer el tiempo de espera en un segundo.

req.setRetryPolicy(new DefaultRetryPolicy(
       1000, 
       DefaultRetryPolicy.DEFAULT_MAX_RETRIES, 
       DefaultRetryPolicy.DEFAULT_BACKOFF_MULT))

Acepta los siguientes parámetros:

StringRequest

Regresar a MainActivity.java y agregue una nueva función. Acepta un parámetro de entrada de cadena. Probemos un simple GET llamar usando el incorporado StringRequest. Crear un nuevo objeto StringRequest.

Habrá dos eventos de escucha, en los que obtendrá la respuesta con éxito o la solicitud ha fallado. Agregue el objeto a través del método addToRequestQueue.

public void ConnectURL(String url) {
        // 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!" + error);
            }
        });

        // Add the request to the RequestQueue.
        RequestSingleton.getInstance(this).addToRequestQueue(stringRequest);
    }

Hacer una llamada a ConnectURL y pasar una URL válida. Debería poder ver los comentarios del servidor.

JSONObjectRequest

Si vas a hacer una solicitud POST con datos JSON, necesitará construir un JSONObject antemano. Agregue la siguiente importación en la parte superior de su proyecto.

import org.json.JSONException;
import org.json.JSONObject;

Cree una nueva función e inicialice una JSONObject. Necesitas llamar la función put para insertar los datos en él. Es necesario envolverlo dentro de un bloque try-catch para capturar el error JSONException.

Modifique los datos en consecuencia en función de la entrada aceptada del POST llamada. Incluso puede pasarlo a través de los parámetros de entrada de la función.

El resto de la implementación es similar a StringRequest, con la única excepción de que pasará el jsonObj variable al crear el JsonObjectRequest.

public void ConnectURLJson(String jsonUrl) {
        JSONObject jsonObj;
        try {
            jsonObj = new JSONObject();
            jsonObj.put("name", "wfng");
            jsonObj.put("age", 123);
        } catch (JSONException e) {
            throw new RuntimeException(e);
        }
        JsonObjectRequest jsonObjectRequest = new JsonObjectRequest
                (Request.Method.POST, jsonUrl, jsonObj, new Response.Listener<JSONObject>() {

                    @Override
                    public void onResponse(JSONObject response) {
                        textView.setText("Response: " + response.toString());
                    }
                }, new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        textView.setText("JSON That didn't work!" + error);
                    }
                });
        RequestSingleton.getInstance(this).addToRequestQueue(jsonObjectRequest);
    }

Puede probarlo llamando al ConnectURLJson función y pasar una URL válida.

JSONObjectRequest con imagen

Enviar datos de imágenes es un poco complicado y requiere una conversión a Base64. En primer lugar, obtenga el mapa de bits respectivo de su ImageView o cualquier archivo local.

Conviértalo en matrices de bytes y codifíquelo a través de la función java.util.Base64. Ahora está en formato de cadena y puede agregarlo fácilmente al JSONObject.

 public void ConnectURLImage(String imageUrl) {
        Bitmap bitmap = ((BitmapDrawable) mImageView.getDrawable()).getBitmap();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
        byte[] imageInByte = baos.toByteArray();
        String encodedString = java.util.Base64.getEncoder().encodeToString(imageInByte);
   
        JSONObject jsonObj;
        try {
            jsonObj = new JSONObject();
            jsonObj.put("image", encodedString);
        } catch (JSONException e) {
            throw new RuntimeException(e);
        }   
        JsonObjectRequest jsonObjectRequest = new JsonObjectRequest
                    (Request.Method.POST, imageUrl, jsonObj, new Response.Listener<JSONObject>() {

                        @Override
                        public void onResponse(JSONObject response) {
                            textView.setText("Response: " + response.toString());
                        }
                    }, new Response.ErrorListener() {
                        @Override
                        public void onErrorResponse(VolleyError error) {
                            textView.setText("Image That didn't work!" + error);
                        }
                    });
            RequestSingleton.getInstance(this).addToRequestQueue(jsonObjectRequest);
    }

La cadena codificada debe decodificarse en el servidor de nuevo en el formato correcto.

3. Conclusión

Recapitulemos lo que hemos aprendido hoy. Comenzamos con una configuración simple agregando la biblioteca dentro del archivo gradle. Luego, agregamos el permiso de Internet requerido dentro AndroidManifest.xml.

En la parte de implementación, probamos tres formas diferentes. La primera es una simple llamada GET usando StringRequest.

Fue seguido por una llamada POST que acepta un JSONObject. Por último, también intentamos enviar datos de imágenes en forma de cadena Base64.

Gracias por leer este artículo. Espero verte de nuevo en el próximo artículo