Cómo enviar notificaciones desde tus aplicaciones Android

¡Comparte nuestro contenido!

Una de las características más típicas de una aplicación Android, es la capacidad de enviar notificaciones de tipo push. Una notificación push, es simplemente una forma de enviar datos de un agente de usuario a un servidor o de un agente de usuario hacia otro. En nuestro caso, nuestro aplicación hará la función de agente de usuario o de servidor según lo necesitemos, siendo el sistema operativo el receptor de nuestros datos. ¿Listo para saber cómo hacerlo? ¡Manos a la obra!

¡Primero diseñemos una aplicación base!

Comencemos abriendo Android Studio y con la opción Create New project, comencemos un proyecto nuevo.

A continuación, seleccionamos un Empty Activity y después presionamos el botón Next.

El Name de nuestro proyecto será MiNotificador, el Language como siempre es Java y el Minimum SDK será API 21: Android 5.0 (Lollipop) Después presionamos el botón Finish.

Cuando Android Studio termine de crear todo el proyecto, lo primero será utilizar la Palette. En la categoría Text encontraremos los objetos TextView, Plain Text y Number. De estos objetos arrastraremos hacia nuestro activity 2, 1 y 1 respectivamente, tal y como muestra la imagen.

Ahora, nos movemos a la categoría Buttons y arrastramos un objeto Button hacia nuestro activity.

Después en el Project Manager, abrimos la carpeta res, luego abrimos la carpeta values y con un doble click abrimos el archivo strings.xml, en el crearemos 2 cadenas texto para los TextView y una para el Button. Estas deben quedar debajo de la cadena llamada app_name.

<string name="lblNombre">Nombre</string>
<string name="lblEdad">Edad</string>
<string name="btnAceptar">Aceptar y Notificar</string>

El resultado debe ser el siguiente.

A continuación, seleccionamos el primer TextView y en la pestaña Attributes buscamos su propiedad text, en ella escribimos:

@string/lblNombre

Que es el nombre de la cadena de texto para el nombre. Tal como se ve en la imagen.

Hacemos lo mismo para el otro TextView, asignando la cadena correspondiente a la edad.

También lo hacemos con el botón.

Para el objeto PlainText, borramos el contenido de su propiedad text, y cambiamos su propiedad id, el objeto ahora será txtNombre. presionamos Enter después de escribir.

Y confirmamos el nombre en la ventana de diálogo Rename con el botón Refactor.

Para el objeto Number, cambiamos su propiedad id a txtEdad, presionamos Enter al terminar.

Y confirmamos en la ventana Rename al presionar el botón Refactor.

Para el objeto Button, cambiamos su propiedad textSize a 24sp. También cambiamos su propiedad id a btnAceptar.

No olvidemos presionar el botón Refactor en la ventana de diálogo Rename.

Para terminar el diseño, vamos al Component Tree, ahí tomamos nuestros objetos uno por uno. Presionamos el botón derecho del ratón sobre el primero, seleccionamos la opción Constraint y luego la opción parent top. Con esto fijamos la posición de nuestro objeto con respecto al bode superior de nuestro activity.

Repetimos el mismo paso, pero esta vez la opción a elegir es parent start, para fijar la posición de nuestro objeto con respecto al borde lateral izquierdo. Esto lo repetimos por cada objeto que este debajo del ConstraintLayout.

¡Es hora de programar nuestra aplicación!

Vamos a trabajar en el archivo java. Haremos una aplicación sencilla que revise los campos de texto y nos avise con un Toast cuando falta algún dato o nos mande una notificación si no falta ninguno (pero esa parte la dejaremos para la siguiente sección)

Primero declaremos las variables para nuestras dos cajas de texto y el botón.

private EditText txtNombre;
private EditText txtEdad;
private Button btnAceptar;

Inmediatamente, instanciamos nuestros objetos dentro del método onCreate, debemos recordar que cada uno apuntará a un objeto correspondiente en el activity.

txtNombre = (EditText) findViewById(R.id.txtNombre);
txtEdad = (EditText) findViewById(R.id.txtEdad);
btnAceptar = (Button) findViewById(R.id.btnAceptar);

Así va nuestro código al momento.

A continuación, con setOnClickListener le asignamos un escucha de click a nuestro botón. Los escuchas de click típicos dependen de la clase View y su método OnClickListener. El método onClick debe ser añadido automáticamente por Android Studio.

btnAceptar.setOnClickListener(new View.OnClickListener(){
   @override
   public void onClick(View v){
   }
});

Dentro de ese método onClick, es donde vamos a trabajar. Primero creamos una variable de tipo String para el nombre, mismo que capturamos del objeto txtNombre.

String nombre = txtNombre.getText().toString();

Luego creamos una variable tipo Integer para la edad, su valor inicial es 0.

Integer edad = 0;

También necesitamos un String para el mensaje de advertencia y un boolean para saber cuando tenemos los campos llenos (true) y cuando no lo están (false)

String mensaje = "";
boolean enviar = true;

Si la longitud de texto de la caja txtEdad es mayor de cero, entonces significa que tenemos un valor captura, así que es hora de actualizar nuestra variable edad. No olvidemos usar Integer.parseInt para hacer el casting necesario.

if(txtEdad.lenght()>0) edad = Integer.parseInt(txtEdad.getText().toString());

Pero, si la edad nunca cambio, es decir se quedo en cero, entonces significa que la caja de texto no tiene ningún valor escrito, así que cambiamos la bandera a falso y generamos el aviso correspondiente.

if(edad==0){
   enviar = false;
   mensaje="Escriba la edad, por favor.\n";
}

Hacemos lo mismo con la variable del nombre.

if(nombre.length()==0){
   enviar = false;
   mensaje+="Escriba el nombre, por favor.";
}

Si la bandera nunca cambio a falso, entonces estamos listos para comenzar con la notificación, aunque por el momento sólo dejaremos un pequeño comentario.

if(enviar){ /* Aquí regresaremos luego */ }

Si la bandera cambio a falso, enviamos los mensajes capturados con los errores por medio de un Toast.

if(!enviar)
   Toast.makeText(getApplicationContext(), mensaje, Toast.LENGTH_SHORT).show();

Nuestro código va así al momento.

Quizá habrán notado que no use un else en toda esa parte del código. La respuesta es muy sencilla. En las últimas versiones de la Developer Google Console, la sugerencia más común que he obtenido en mis aplicaciones, es precisamente la recomendación de no usarlo, así que normalmente cuando desarrollo para Android hago lo posible por no usarlo.

¡Hagamos que nuestra aplicación mande notificaciones!

Para simplificar un poco las cosas y reutilizar el proceso de notificación donde sea necesario, vamos a crear un método al que llamaremos Notificar con tres parámetros: una variable de tipo String para el título de la notificación, otro String para el mensaje de la notificación y una variable de tipo int para identificar cada notificación por separado con un número diferente por cada llamada.

public void Notificar(String titulo, String mensaje, int notID){
}

Con NotificationCompat.Builder creamos al objeto que se encargará de construir la notificación con todos sus componentes.

NotificationCompat.Builder creador;

Necesitamos ponerle un identificador a nuestro canal, ya que desde Android 8 es necesario para enviar notificaciones, el id puede ser cualquiera.

String canalID = "MiCanal01";

Capturamos el contexto de la aplicación para simplificar algunas líneas de código.

Context contexto = getApplicationContext();

Con la clase NotificationManager, creamos el gestor para las notificaciones.

NotificationManager notificador = (NotificationManager) getSystemService(contexto.NOTIFICATION_SERVICE);

Instanciamos el creador de las notificaciones usando el contexto de la aplicación y el id definido.

creador = new NotificationCompat.Builder(contexto, canalID);

Si el dispositivo en el que nuestra aplicación se va a ejecutar tiene Android 8 o superior, necesitamos definir más detalles del canal aparte del id. Para lograrlo, tenemos las constantes Build.VERSION.SDK_INT que indica el número de versión del SDK y la constante Build.VERSION_CODES.O nos indica que la versión de Android, siendo la O referencia a Oreo.

if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){

Primero definimos el nombre del canal.

String canalNombre = "Mensajes";

Le ponemos una descripción sencilla a nuestro canal.

String canalDescribe = "Canal de mensajes";

Definimos la importancia de nuestras notificaciones al nivel más alto, con esto logramos que siempre aparezca en el área de notificaciones.

int importancia = NotificationManager.IMPORTANCE_HIGH;

Con la clase NotificationChannel, definimos el canal usando el id, su nombre y el nivel de importancia.

NotificationChannel miCanal = new NotificationChannel(canalID, canalNombre, importancia)

Le agregamos su descripción.

miCanal.setDescription(canalDescribe);

Con el método enableLights hacemos que se enciendan las luces de nuestro dispositivo al recibir la notificación.

miCanal.enableLights(true);

Si el dispositivo lo soporta, podemos cambiar el color de las luces.

miCanal.setLightColor(Color.BLUE);

Activamos la vibración del dispositivo.

miCanal.enableVibration(true);

Pasamos el canal con toda su información al notificador.

notificador.createNotificationChannel(miCanal);

Instanciamos nuevamente el creador de las notificaciones para que acepte los datos extra que añadimos y cerramos el if que teníamos abierto.

   creador = new NotificationCompat.Builder(contexto, canalID);
}

Para continuar, necesitamos dos iconos. Uno pequeño de 48×48 píxeles y uno más grande de 192×192 píxeles. Estos iconos, los depositaremos en el ResourceManager.

Al hacer eso, nos aparecerá una ventana de diálogo, presionamos el botón Next.

Finalmente, presionamos Import en la siguiente ventana de diálogo.

El icono grande, lo cargamos como un Bitmap utilizando su id que se encuentra en R.drawable. La clase BitmapFactory a través de su método decodeResource permite precisamente eso.

Bitmap iconoNotifica = BitmapFactory.decodeResource(contexto.getResources(), R.drawable.notifica_icon);

Obtenemos el id del icono pequeño directo de R.drawable

int iconoSmall = R.drawable.notifica_small;

Aplicamos el icono pequeño al creador de notificaciones.

creador.setSmallIcon(iconoSmall);

Luego aplicamos el icono grande.

creador.setLargeIcon(iconoNotifica);

Enseguida, le ponemos el título a nuestra notificación utilizando el parámetro designado en la declaración del método Notificar.

creador.setContentTitle(titulo);

Hacemos lo mismo con el contenido del mensaje.

creador.setContentText(mensaje);

Dado que nuestra notificación tendrá más de una línea de texto en el cuerpo del mensaje, con el método setStyle lo convertimos en un texto grande con NotificationCompat.BigTextStyle.

creador.setStyle(new NotificationCompat.BigTextStyle().bigText(mensaje));

Le pasamos el id del canal.

creador.setChannelId(canalID);

Y por último, hacemos que la notificación aparezca con el método notify. Este método utiliza el id de la notificación y el objeto creador que acabamos de configurar.

notificador.notify(notID, creador.build());

Este es el código completo del método Notificar.

 // Método que crea y envía la notificación
    public void Notificar(String titulo, String mensaje, int notID){
        NotificationCompat.Builder creador;
        String canalID = "MiCanal01";
        Context contexto = getApplicationContext();
        NotificationManager notificador = (NotificationManager) getSystemService(contexto.NOTIFICATION_SERVICE);
        creador = new NotificationCompat.Builder(contexto, canalID);
        // Si nuestro dispositivo tiene Android 8 (API 26, Oreo) o superior
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O){
            String canalNombre = "Mensajes";
            String canalDescribe = "Canal de mensajes";
            int importancia = NotificationManager.IMPORTANCE_HIGH;
            NotificationChannel miCanal = new NotificationChannel(canalID, canalNombre, importancia);
            miCanal.setDescription(canalDescribe);
            miCanal.enableLights(true);
            miCanal.setLightColor(Color.BLUE); // Esto no lo soportan todos los dispositivos
            miCanal.enableVibration(true);
            notificador.createNotificationChannel(miCanal);
            creador = new NotificationCompat.Builder(contexto, canalID);
        }
        Bitmap iconoNotifica = BitmapFactory.decodeResource(contexto.getResources(), R.drawable.notifica_icon);
        int iconoSmall = R.drawable.notifica_small;
        creador.setSmallIcon(iconoSmall);
        creador.setLargeIcon(iconoNotifica);
        creador.setContentTitle(titulo);
        creador.setContentText(mensaje);
        creador.setStyle(new NotificationCompat.BigTextStyle().bigText(mensaje));
        creador.setChannelId(canalID);
        notificador.notify(notID, creador.build());
    }

Para finalizar, vamos a regresar al onClick de nuestro botón, justo donde dejamos esta línea de código:

if(enviar){ /* Aquí regresaremos luego */ }

Quitemos el comentario, es tiempo de terminar esta parte del código. Lo primero es definir el título que llevará nuestra notificación.

String titulo = "Notificación de MiNotificador";

Definimos el mensaje, incluyendo los datos que obtuvimos de las cajas de texto.

mensaje = "Datos obtenidos son:\n";
mensaje+= "Nombre: " + nombre + ", Edad: " + edad.toString();

Le ponemos un valor al id de la notificación, en este caso será 1. Si necesitamos que otra parte de nuestra aplicación lance una notificación, necesitamos aumentar este valor + 1

int notificaID = 1;

Hacemos la llamada a nuestro método Notificar con los datos que acabamos de definir.

Notificar(titulo, mensaje, notificaID);

Debe quedar así:

Probando el resultado final

Es hora de probar todo el código que acabamos de escribir. Observe el vídeo.

DESCARGA EL CÓDIGO FUENTE PARA PROBAR

¿Te ha resultado? Déjanos saber en los comentarios aquí abajo, en nuestra cuenta de twitter @cablenaranja7 o en nuestra página de facebook.

Xamus Dyson

Docente, IT Manager, Blogger & Developer. Escribo por diversión, educo por pasión. | Grandstanding is not my thing.

www.cablenaranja.com

¡Comparte nuestro contenido!