Eventos push

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":

Imagem da notificação padrão no Chrome

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

Code labs