Hasta este punto, vimos cómo suscribir a un usuario y enviar un mensaje push. El siguiente paso es recibir este mensaje push en el dispositivo del usuario y mostrar una notificación (así como realizar cualquier otra tarea que queramos hacer).
El evento push
Cuando se reciba un mensaje, se enviará un evento de envío en tu service worker.
El código para configurar un objeto de escucha de eventos push debería ser bastante similar a cualquier otro objeto de escucha de eventos que escribirías en JavaScript:
self.addEventListener('push', function(event) {
if (event.data) {
console.log('This push event has data: ', event.data.text());
} else {
console.log('This push event has no data.');
}
});
La parte más extraña de este código para la mayoría de los desarrolladores que no conocen los service workers es la variable
self. self se usa de uso frecuente en Web Workers, que es un service worker. self hace referencia al alcance global, algo así como window en una página web. Sin embargo, para los trabajadores web y de servicio,
self hace referencia al trabajador en sí.
En el ejemplo anterior, se puede considerar que self.addEventListener() agrega un objeto de escucha de eventos al service worker.
En el ejemplo del evento push, verificamos si hay datos y mostramos algo en la consola.
Existen otras formas de analizar los datos de un evento de envío:
// Returns string
event.data.text()
// Parses data as JSON string and returns an Object
event.data.json()
// Returns blob of data
event.data.blob()
// Returns an arrayBuffer
event.data.arrayBuffer()
La mayoría de las personas usan json() o text() según lo que esperan de su aplicación.
En este ejemplo, se muestra cómo agregar un objeto de escucha de eventos push y cómo acceder a los datos, pero faltan
dos funciones muy importantes. No muestra una notificación ni usa event.waitUntil().
Esperar hasta
Un aspecto que debes comprender sobre los service workers es que tienes poco control sobre cuándo
se ejecutará su código. El navegador decide cuándo activarlo y cuándo
finalizarlo. La única forma de decirle al navegador "Oye, estoy muy ocupado haciendo cosas importantes" es pasar una promesa al método event.waitUntil(). Con esto, el navegador mantendrá el service worker en ejecución hasta que se resuelva la promesa que pasaste.
Con los eventos push, hay un requisito adicional: debes mostrar una notificación antes de que se resuelva la promesa que pasaste.
Este es un ejemplo básico de cómo mostrar una notificación:
self.addEventListener('push', function(event) {
const promiseChain = self.registration.showNotification('Hello, World.');
event.waitUntil(promiseChain);
});
Llamar a self.registration.showNotification() es el método que muestra una notificación al usuario y devuelve una promesa que se resolverá una vez que se haya mostrado la notificación.
Para que este ejemplo sea lo más claro posible, asigné esta promesa a una
variable llamada promiseChain. Luego, se pasa a event.waitUntil(). Sé que esto es muy detallado, pero vi varios problemas que se produjeron como resultado de no comprender qué se debe pasar a waitUntil() o como resultado de cadenas de promesas rotas.
Un ejemplo más complicado con una solicitud de red para obtener datos y hacer un seguimiento del evento push con Analytics podría verse de la siguiente manera:
self.addEventListener('push', function(event) {
const analyticsPromise = pushReceivedTracking();
const pushInfoPromise = fetch('/api/get-more-data')
.then(function(response) {
return response.json();
})
.then(function(response) {
const title = response.data.userName + ' says...';
const message = response.data.message;
return self.registration.showNotification(title, {
body: message
});
});
const promiseChain = Promise.all([
analyticsPromise,
pushInfoPromise
]);
event.waitUntil(promiseChain);
});
Aquí llamamos a una función que devuelve una promesa pushReceivedTracking(),
que, para el ejemplo, podemos simular que realizará una solicitud de red
a nuestro proveedor de estadísticas. También realizamos una solicitud de red, obtenemos la respuesta y mostramos una notificación con los datos de la respuesta para el título y el mensaje de la notificación.
Podemos asegurarnos de que el service worker se mantenga activo mientras se realizan estas dos tareas combinando
estas promesas con Promise.all(). La promesa resultante se pasa a event.waitUntil(),
lo que significa que el navegador esperará hasta que ambas promesas hayan finalizado antes de verificar que se haya mostrado una notificación
y de finalizar el service worker.
El motivo por el que debemos preocuparnos por waitUntil() y cómo usarlo es que uno de los problemas más comunes que enfrentan los desarrolladores es que, cuando la cadena de promesas es incorrecta o está rota, Chrome mostrará esta notificación "predeterminada":
Chrome solo mostrará la notificación "Este sitio se actualizó en segundo plano" cuando se reciba un mensaje push y el evento push en el service worker no muestre una notificación después de que finalice la promesa que se pasó a event.waitUntil().
El motivo principal por el que los desarrolladores se ven afectados por esto es que su código suele llamar a self.registration.showNotification(), pero no hacen nada con la promesa que devuelve. Esto hace que, de forma intermitente, se muestre la notificación predeterminada. Por ejemplo, podríamos quitar el valor que se muestra para
self.registration.showNotification() en el ejemplo anterior y correríamos el riesgo de ver esta
notificación.
self.addEventListener('push', function(event) {
const analyticsPromise = pushReceivedTracking();
const pushInfoPromise = fetch('/api/get-more-data')
.then(function(response) {
return response.json();
})
.then(function(response) {
const title = response.data.userName + ' says...';
const message = response.data.message;
self.registration.showNotification(title, {
body: message
});
});
const promiseChain = Promise.all([
analyticsPromise,
pushInfoPromise
]);
event.waitUntil(promiseChain);
});
Como ves, es fácil pasar por alto este detalle.
Solo recuerda que, si ves esa notificación, debes revisar tus cadenas de promesas y event.waitUntil().
En la siguiente sección, veremos qué podemos hacer para aplicar diseño a las notificaciones y qué contenido podemos mostrar.
Próximos pasos
- Descripción general de las notificaciones push web
- Cómo funciona la tecnología push
- Cómo suscribir a un usuario
- UX de permisos
- Envía mensajes con bibliotecas de Web Push
- Protocolo de Web Push
- Cómo controlar eventos push
- Cómo mostrar una notificación
- Comportamiento de las notificaciones
- Patrones de notificaciones comunes
- Preguntas frecuentes sobre las notificaciones push
- Problemas habituales y cómo informar errores