Até aqui, abordamos como inscrever um usuário e enviar uma mensagem push. A próxima etapa é receber essa mensagem push no dispositivo do usuário e exibir uma notificação (além de realizar qualquer outra tarefa que você queira).
O evento de push
Quando uma mensagem é recebida, um evento de push é enviado no service worker.
O código para configurar um listener de eventos push é bem parecido com qualquer outro listener de eventos que você escreveria em 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.');
}
});
A parte mais estranha desse código para a maioria dos desenvolvedores que não conhecem os service workers é a variável
self. self é usado com frequência em Web Workers, como é o caso de um service worker. self se refere ao
escopo global, como window em uma página da Web. No entanto, para workers da Web e service workers,
self se refere ao próprio worker.
No exemplo acima, self.addEventListener() pode ser considerado como a adição de um listener de eventos ao
próprio service worker.
No exemplo de evento push, verificamos se há dados e mostramos algo no console.
Há outras maneiras de analisar dados de um evento de push:
// 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()
A maioria das pessoas usa json() ou text(), dependendo do que esperam do aplicativo.
Este exemplo demonstra como adicionar um listener de eventos de push e como acessar dados, mas
faltam duas funcionalidades muito importantes. Ele não mostra uma notificação e não
usa event.waitUntil().
Esperar até
Uma das coisas que você precisa entender sobre os service workers é que você tem pouco controle sobre quando
o código do service worker será executado. O navegador decide quando ativá-lo e quando
encerrá-lo. A única maneira de dizer ao navegador "Ei, estou muito ocupado fazendo coisas
importantes" é transmitir uma promessa para o método event.waitUntil(). Com isso, o navegador vai
manter o service worker em execução até que a promessa transmitida seja resolvida.
Com eventos push, há um requisito adicional: você precisa exibir uma notificação antes que a promessa transmitida seja resolvida.
Veja um exemplo básico de como mostrar uma notificação:
self.addEventListener('push', function(event) {
const promiseChain = self.registration.showNotification('Hello, World.');
event.waitUntil(promiseChain);
});
Chamar self.registration.showNotification() é o método que mostra uma notificação ao usuário e retorna uma promessa que será resolvida quando a notificação for exibida.
Para manter este exemplo o mais claro possível, atribuí essa promessa a uma
variável chamada promiseChain. Em seguida, ele é transmitido para event.waitUntil(). Sei que isso é
muito detalhado, mas já vi vários problemas que culminaram como resultado de
um mal-entendido sobre o que deve ser transmitido para waitUntil() ou como resultado de cadeias de promessas
rompidas.
Um exemplo mais complicado com uma solicitação de rede para dados e o rastreamento do evento de push com o Analytics pode ser assim:
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);
});
Aqui, estamos chamando uma função que retorna uma promessa pushReceivedTracking(),
que, para fins de exemplo, podemos fingir que fará uma solicitação de rede
para nosso provedor de análise. Também estamos fazendo uma solicitação de rede, recebendo a
resposta e mostrando uma notificação usando os dados de resposta para o título e a
mensagem da notificação.
Podemos garantir que o service worker seja mantido ativo enquanto as duas tarefas são realizadas combinando
essas promessas com Promise.all(). A promessa resultante é transmitida para event.waitUntil(),
o que significa que o navegador vai esperar até que as duas promessas sejam concluídas antes de verificar se uma notificação
foi exibida e encerrar o service worker.
O motivo pelo qual devemos nos preocupar com waitUntil() e como usá-lo é que um dos problemas mais comuns que os desenvolvedores enfrentam é que, quando a cadeia de promessas está incorreta/interrompida, o Chrome mostra esta notificação "padrão":
O Chrome só vai mostrar a notificação "Este site foi atualizado em segundo plano" quando uma
mensagem push for recebida e o evento push no service worker não mostrar uma
notificação depois que a promessa transmitida para event.waitUntil() for concluída.
O principal motivo para os desenvolvedores serem afetados por isso é que o código deles
costuma chamar self.registration.showNotification(), mas eles não fazem
nada com a promessa que ele retorna. Isso resulta de forma intermitente na exibição da notificação padrão. Por exemplo, poderíamos remover o retorno de
self.registration.showNotification() no exemplo acima e correríamos o risco de ver essa
notificação.
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);
});
É fácil deixar passar.
Não se esqueça: se você receber essa notificação, verifique as cadeias de promessas e event.waitUntil().
Na próxima seção, vamos analisar o que podemos fazer para estilizar as notificações e que conteúdo podemos mostrar.
A seguir
- Visão geral das notificações push da Web
- Como o push funciona
- Como inscrever um usuário
- UX de permissão
- Como enviar mensagens com bibliotecas de push da Web
- Protocolo de push da Web
- Como processar eventos de push
- Como mostrar uma notificação
- Comportamento das notificações
- Padrões comuns de notificação
- Perguntas frequentes sobre notificações push
- Problemas comuns e como informar bugs