Événements push

À ce stade, nous avons vu comment abonner un utilisateur et envoyer un message push. L'étape suivante consiste à recevoir ce message push sur l'appareil de l'utilisateur et à afficher une notification (ainsi qu'à effectuer toute autre tâche que nous souhaitons réaliser).

L'événement push

Lorsqu'un message est reçu, un événement push est envoyé à votre service worker.

Le code permettant de configurer un écouteur d'événements push doit être assez semblable à tout autre écouteur d'événements que vous écririez 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 partie la plus étrange de ce code pour la plupart des développeurs qui découvrent les service workers est la variable self. self est couramment utilisé dans les Web Workers, dont fait partie un service worker. self fait référence au champ d'application global, un peu comme window sur une page Web. Toutefois, pour les nœuds de calcul Web et les service workers, self fait référence au nœud de calcul lui-même.

Dans l'exemple ci-dessus, self.addEventListener() peut être considéré comme l'ajout d'un écouteur d'événements au service worker lui-même.

Dans l'exemple d'événement push, nous vérifions s'il existe des données et affichons un message dans la console.

Il existe d'autres façons d'analyser les données d'un événement 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()

La plupart des utilisateurs se servent de json() ou de text() en fonction de ce qu'ils attendent de leur application.

Cet exemple montre comment ajouter un écouteur d'événements push et comment accéder aux données, mais il manque deux fonctionnalités très importantes. Elle n'affiche pas de notification et n'utilise pas event.waitUntil().

Attendre jusqu'à

L'une des choses à comprendre à propos des service workers est que vous n'avez que peu de contrôle sur le moment où le code du service worker va s'exécuter. Le navigateur décide quand l'activer et quand l'arrêter. La seule façon d'indiquer au navigateur que vous êtes très occupé à effectuer des tâches importantes est de transmettre une promesse à la méthode event.waitUntil(). Le navigateur maintiendra ainsi le service worker en cours d'exécution jusqu'à ce que la promesse que vous avez transmise soit résolue.

Avec les événements push, vous devez également afficher une notification avant que la promesse que vous avez transmise ne soit résolue.

Voici un exemple simple d'affichage d'une notification :

self.addEventListener('push', function(event) {
    const promiseChain = self.registration.showNotification('Hello, World.');

    event.waitUntil(promiseChain);
});

L'appel de self.registration.showNotification() est la méthode qui affiche une notification à l'utilisateur et renvoie une promesse qui sera résolue une fois la notification affichée.

Pour que cet exemple soit aussi clair que possible, j'ai attribué cette promesse à une variable appelée promiseChain. Il est ensuite transmis à event.waitUntil(). Je sais que c'est très détaillé, mais j'ai vu un certain nombre de problèmes qui ont abouti à une mauvaise compréhension de ce qui doit être transmis à waitUntil() ou à des chaînes de promesses non respectées.

Voici un exemple plus complexe, avec une requête réseau pour les données et le suivi de l'événement push avec Analytics :

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);
});

Ici, nous appelons une fonction qui renvoie une promesse pushReceivedTracking(), qui, pour les besoins de l'exemple, peut prétendre envoyer une requête réseau à notre fournisseur d'analyse. Nous envoyons également une requête réseau, obtenons la réponse et affichons une notification en utilisant les données de la réponse pour le titre et le message de la notification.

Nous pouvons nous assurer que le service worker reste actif pendant l'exécution de ces deux tâches en combinant ces promesses avec Promise.all(). La promesse obtenue est transmise à event.waitUntil(), ce qui signifie que le navigateur attendra que les deux promesses soient terminées avant de vérifier qu'une notification a été affichée et de mettre fin au service worker.

La raison pour laquelle nous devons nous intéresser à waitUntil() et à son utilisation est que l'un des problèmes les plus courants auxquels les développeurs sont confrontés est que lorsque la chaîne de promesses est incorrecte ou interrompue, Chrome affiche cette notification "par défaut" :

Image de la notification par défaut dans Chrome

Chrome n'affiche la notification "Ce site a été mis à jour en arrière-plan" que lorsqu'un message push est reçu et que l'événement push dans le service worker n'affiche pas de notification une fois que la promesse transmise à event.waitUntil() est terminée.

La principale raison pour laquelle les développeurs sont confrontés à ce problème est que leur code appelle souvent self.registration.showNotification(), mais qu'ils ne font rien de la promesse qu'il renvoie. Cela entraîne l'affichage intermittent de la notification par défaut. Par exemple, nous pourrions supprimer le retour pour self.registration.showNotification() dans l'exemple ci-dessus, mais nous risquerions de voir cette notification.

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);
});

Vous pouvez voir qu'il est facile de passer à côté.

N'oubliez pas : si vous voyez cette notification, vérifiez vos chaînes de promesses et event.waitUntil().

Dans la section suivante, nous allons voir comment styliser les notifications et quel contenu nous pouvons afficher.

Étapes suivantes

Ateliers de programmation