Hola, les saluda Miguel y en esta ocasión les traigo otro nuevo tutorial.
Índice
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:
- Programación automática de solicitudes de red.
- Varias conexiones de red simultáneas.
- Almacenamiento en caché de respuesta de memoria y disco transparente con coherencia de caché HTTP estándar.
- Soporte para la priorización de solicitudes.
- API de solicitud de cancelación. Puede cancelar una sola solicitud o puede establecer bloques o alcances de solicitudes para cancelar.
- Facilidad de personalización, por ejemplo, para reintentos y retrocesos.
- Orden fuerte que facilita completar correctamente su interfaz de usuario con datos obtenidos de forma asincrónica de la red.
- Herramientas de depuración y seguimiento.
Por lo tanto, Volley es una biblioteca extremadamente útil para llamar a la API REST
y transmitir datos de red. Sin embargo, Volley no es adecuado para grandes descargas u operaciones de transmisión, ya que almacena todas las respuestas en la memoria durante el análisis.
Por favor considere otras alternativas como Download Manager si está buscando operaciones de transmisión.
1. Configuración
Asegúrese de haber instalado Android Studio y el SDK necesario para el desarrollo. DirÃgete a build.gradle (Module: app)
y agrega el siguiente código dentro de las dependencias:
implementation 'com.android.volley:volley:1.1.1'
Sincroniza el archivo gradle
y espera a que termine. Agregue el siguiente permiso en el AndroidManifest.xml
. Necesitaremos acceso a Internet para enviar datos de red.
<uses-permission android:name="android.permission.INTERNET"/>
Pasemos a la siguiente sección para poner en marcha su proyecto de Android.
2. Implementación
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.
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;
Inicialice las siguientes variables dentro de su clase.
private static RequestSingleton instance; private RequestQueue requestQueue; private static Context ctx;
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; }
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; }
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:
-
Timeout
– Especifica el tiempo de espera del socket en milisegundos por cada reintento -
Number Of Retries
– Número de veces que se intenta reintentar -
Back Off Multiplier
– Un multiplicador que se usa para determinar el tiempo exponencial establecido en socket para cada reintento
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
.
Request
.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
Añadir comentario