Comment utiliser le service WNS pour transmettre des notifications Push brutes à une application de l’écran de verrouillage (HTML)

Article
12/11/2015

[ Cet article est destiné aux développeurs de Windows 8.x et Windows Phone 8.x qui créent des applications Windows Runtime. Si vous développez une application pour Windows 10, voir la Documentation ]

Cette rubrique vous explique comment utiliser le service de notification Windows (WNS) et les notifications Push brutes pour recevoir des notifications réseau en arrière-plan dans une application Windows Runtime sur l’écran de verrouillage. Cette rubrique vous guide tout au long du processus visant à inscrire un canal de notification Push et à l’envoyer à votre serveur, à inscrire une tâche en arrière-plan à activer à partir d’une notification Push brute, à envoyer une notification Push brute au canal et à activer la tâche en arrière-plan.

Ce que vous devez savoir

Technologies

Windows.Networking.PushNotifications

Permet les communications réseau en arrière-plan à l’aide de notifications Push brutes.

Prérequis

Les informations suivantes concernent les applications Windows Runtime connectées ou réseau qui dépendent de connexions réseau utilisant des notifications Push brutes pour être connectées en permanence. Cette rubrique concerne les applications écrites en JavaScript sur Windows 8.1, Windows Phone 8.1 et Windows Server 2012 R2.

La connectivité réseau en arrière-plan utilisant les notifications Push brutes est prise en charge par une application JavaScript, les applications écrites en C++/XAML et les applications utilisant .NET Framework 4.5 en C#, VB.NET ou C++ managé. Pour plus d’informations sur les tâches réseau en arrière-plan relatives aux applications JavaScript, voir Définition de tâches en arrière-plan pour les besoins de votre application.

Instructions

Utilisation du service WNS pour transmettre des notifications Push brutes à une application de l’écran de verrouillage

Il n’est pas nécessaire que les applications utilisant WNS soient en cours d’exécution pour recevoir des notifications Push. Les utilisateurs peuvent avoir l’impression qu’elles sont exécutées alors qu’elles ne le sont pas. Par exemple, une application de météo peut toujours afficher les dernières informations météorologiques dans une vignette dynamique mise à jour. Vous pouvez également utiliser WNS pour afficher des notifications à l’écran à l’attention des utilisateurs lorsque d’importants événements se produisent. Un événement d’actualité exclusive constitue un bon exemple. Tout périphérique exécutant Windows 8.1, Windows Phone 8.1 ou Windows Server 2012 R2 avec une connexion à Internet peut utiliser les services WNS. Les notifications WNS sont généralement remises dès qu’elles sont envoyées.

Bien que le service WNS contribue à l’affichage des vignettes dynamiques et des notifications sur l’écran d’accueil de Windows 8.1, vous pouvez également l’utiliser pour prendre en charge des scénarios de connectivité en temps réel (VoIP, messagerie instantanée et messagerie électronique, par exemple). L’ajout d’une application utilisant WNS à l’écran de verrouillage peut servir à activer une tâche en arrière-plan. Ce type de tâche fait partie du code de l’application s’exécutant lorsque l’application se trouve en arrière-plan (et non au premier plan).

Voici quelques exemples de tâche en arrière-plan pouvant être activée via une notification WNS :

Appel de l’API de badge de notification pour incrémenter l’icône du badge d’une application de messagerie sur l’écran de verrouillage afin d’indiquer la réception d’un nouveau message
Appel de l’API de toast de modification pour générer une notification relative à une application VoIP afin de signaler un appel entrant à l’utilisateur

Il existe quatre types de notification Push :

Mise à jour de vignette
Mise à jour de badge
Notification toast
Notification brute

Toutes les applications Windows Runtime peuvent utiliser les trois premières notifications Push lorsqu’elles se trouvent au premier plan. Seules les applications de l’écran de verrouillage peuvent recevoir des notifications Push brutes depuis le service WNS. Les notifications brutes permettent à ces applications d’exécuter du code sous forme de tâche en arrière-plan lorsqu’une notification Push brute est transmise par WNS, même si l’application ne se trouve pas au premier plan.

La plupart des applications n’ont pas besoin d’être des applications d’écran de verrouillage et peuvent utiliser le service WNS sans se trouver sur l’écran de verrouillage. WNS peut servir à mettre à jour des vignettes et des badges et générer des notifications toast pour toutes les applications lorsqu’elles se trouvent au premier plan. L’utilisation de WNS avec une application d’écran de verrouillage est plus avancée que dans le cadre de l’affichage de vignettes dynamiques et de la génération de notifications à l’attention des utilisateurs. Avant d’essayer d’utiliser le service WNS avec un écran de verrouillage, les développeurs doivent se familiariser avec la documentation WNS disponible sur MSDN. Pour plus d’informations, voir Vue d’ensemble des notifications Push.

Une clé secrète fournie via le Windows Store est nécessaire pour envoyer des notifications Push au service WNS. Pour plus d’informations sur l’authentification auprès de WNS et la configuration de votre application, voir Comment s’authentifier auprès des services de notifications Push Windows (WNS).

La procédure suivante décrit comment envoyer une notification Push brute à une application d’écran de verrouillage.

Inscrivez-vous à un canal de notification Push WNS et envoyez-le à votre serveur.
Envoyez une notification Push brute correctement mise en forme au service WNS via le canal de notification.
Écrivez une tâche en arrière-plan activée par une notification Push brute.

Les notifications Push brutes sont transmises à une application cliente à l’aide du serveur d’applications d’un développeur. Pour ce faire, une requête HTTP PUSH relative à une charge utile XML correctement formée est envoyée à un canal de notification. Le canal de notification est généré par l’application cliente, envoyé à votre serveur d’applications et utilisé pour envoyer la notification Push. Il est unique à l’instance de votre application sur le compte d’utilisateur sous Windows 8.1.

JJ679947.wedge(fr-fr,WIN.10).gif Inscription à un canal de notification Push et envoi de ce dernier au serveur

Inscrivez-vous à un canal en appelant l’une des méthodes CreatePushNotificationChannelForApplicationAsync sur la classe PushNotificationChannelManager de l’espace de noms Windows.Networking.PushNotifications.

Un canal de notification Push ressemblant à ce qui suit est généré pour votre application :
```
https://db3.notify.windows.com/?token=AQQAAADX3Wr8MA%2fCoZk4n1CmR5ZU7tdic6ksvG4TQq1tiyZtpetjfzuPHSjvliEeqaqJcPuo1jrVnbyCZvnbuU%2byLvZNDONTgUNu6lavpl5EGtWx7iQgpGkyHLbZeosxioQ42Cg%3d
```
Envoyez le canal à votre serveur. Les canaux expirent au bout de 30 jours. Il existe donc des meilleures pratiques à observer :
- Inscrivez-vous à un nouveau canal de notification Push à chaque démarrage de votre application et envoyez-le au serveur afin qu’il remplace le canal précédemment associé à l’utilisateur.
- Si l’ordinateur local est allumé en permanence, exécutez une tâche en arrière-plan afin de renouveler le canal de temps à autre avant qu’il n’arrive à expiration. Cette opération fait référence à ce que l’on appelle un minuteur de maintenance.

JJ679947.wedge(fr-fr,WIN.10).gif Enregistrement d’une tâche en arrière-plan activée par une notification Push brute

Pour créer une tâche en arrière-plan s’exécutant à la réception d’une notification Push brute, vous devez spécifier le fichier source JavaScript contenant le code à activer par la tâche en arrière-plan. Pour ce faire, assurez-vous que le manifeste de votre application pointe sur le fichier source de la tâche en arrière-plan. Le manifeste de l’application doit contenir le nom du fichier source JavaScript pour la tâche en arrière-plan.

L’exemple qui suit ajoute des extensions pour une tâche en arrière-plan PushNotifyTask sous l’élément <Application> dans le manifeste d’une application.
```
  <Extensions>
    <Extension Category="windows.backgroundTasks" StartPage="js\backgroundTask.js">
      <BackgroundTasks>
        <Task Type="pushNotification" />
      </BackgroundTasks>
    </Extension>
  </Extensions>
```

L’application doit ouvrir le canal pour les notifications Push brutes.

L’exemple suivant indique comment ouvrir un canal pour une notification Push brute.


    // Open the channel. See the "Push and Polling Notifications" sample for more detail
    function openNotificationsChannel() {
        var channelOperation = pushNotifications.PushNotificationChannelManager.createPushNotificationChannelForApplicationAsync();
        WinJS.log && WinJS.log("Opening a channel...", "sample", "status");
        return channelOperation.then(function (newChannel) {
            WinJS.log && WinJS.log("Channel request succeeded!", "sample", "status");
            document.getElementById("scenario1ChannelOutput").value = newChannel.uri;
            SdkSample.channel = newChannel;
        },
            function (error) {
                WinJS.log && WinJS.log("Could not create a channel (error number: " + error.number + ")", "sample", "error");
            }
        );
    }

Vous devez également inscrire, au niveau de l’application, la tâche en arrière-plan à activer à la réception d’une notification Push brute.

L’exemple suivant indique comment enregistrer une tâche en arrière-plan dans le contexte des notifications Push brutes.

    // Register the background task for raw notifications
    //
    function registerBackgroundTask() {
        var taskBuilder = new background.BackgroundTaskBuilder();
        var trigger = new background.PushNotificationTrigger();
        taskBuilder.setTrigger(trigger);
        taskBuilder.taskEntryPoint = sampleTaskEntryPoint;
        taskBuilder.name = sampleTaskName;

        try {
            var task = taskBuilder.register();
            task.addEventListener("completed", backgroundTaskComplete);
            WinJS.log && WinJS.log("Background task registered", "sample", "status");
        } catch (e) {
            WinJS.log && WinJS.log("Registration error: " + e.message, "sample", "error");
            unregisterBackgroundTask();
        }
    }

    function unregisterBackgroundTask() {
        var iter = background.BackgroundTaskRegistration.allTasks.first();
        while (iter.hasCurrent) {
            var task = iter.current.value;
            if (task.name === sampleTaskName) {
                task.unregister(true);
                return true;
            }
            iter.moveNext();
        }
        return false;
    }

Il vous faut également fournir le code de la fonction exécutée lors du déclenchement de la tâche en arrière-plan.

Pour plus d’informations sur la manière d’écrire une tâche en arrière-plan pour recevoir des notifications réseau en arrière-plan qui utilisent les notifications Push brutes, voir Comment écrire une tâche en arrière-plan pour les notifications Push brutes.

Remarque

Vous ne pouvez pas référencer les éléments de l’interface utilisateur de votre application dans une tâche en arrière-plan car ils ne sont pas en cours d’exécution. Cela signifie que les éventuels rappels pour le transport réseau ne doivent pas être mis en affinité avec le Cloisonnement de threads unique (STA, Single Thread Apartment) de l’interface utilisateur. Tout objet ayant une affinité avec le STA d’interface utilisateur (également appelé STA d’application) ne doit pas être accessible par les tâches en arrière-plan.

Lorsque votre code s’exécute au sein de la tâche en arrière-plan, vous pouvez configurer votre application afin qu’elle s’active, synchroniser l’état entre le client et le serveur et générer une notification à l’attention de l’utilisateur.

Les notifications Push brutes sont similaires aux notifications de badge et par vignette. Leur différence essentielle réside dans le fait que la charge utile d’une notification Push brute ne contient pas d’attributs mettant à jour certaines parties de l’interface utilisateur Windows 8.1. Elle est uniquement constituée de données contextuelles transmises directement à votre application lorsque la tâche en arrière-plan est activée. Votre application doit comprendre le format des données de contexte envoyées par le serveur.

Pour que votre serveur puisse envoyer une notification Push brute, vous devez d’abord observer les points suivants :

JJ679947.wedge(fr-fr,WIN.10).gif Envoyer une notification Push brute au canal et activer la tâche en arrière-plan

Assurez-vous d’avoir enregistré votre application sur le Windows Store et que vous disposez d’une clé privée et d’un SID de package.
Écrivez du code sur votre serveur d’applications en vue de l’authentification auprès du service WNS, à l’aide de la clé privée et du SID de package, avant d’envoyer une notification Push à partir du serveur.
Créez une notification Push brute WNS de façon appropriée et envoyez une requête HTTP POST au canal de notification que vous avez précédemment reçu de l’application Windows Runtime. La requête HTTP POST doit inclure plusieurs en-têtes HTTP supplémentaires :
- X-WNS-Type=wns/raw
- Content-Type=application/octet-stream
- Authorization=La chaîne « Bearer », un espace, puis le jeton d’autorisation reçu à l’étape d’authentification
Le corps de la requête HTTP POST doit inclure tout contexte que vous souhaitez fournir à l’application cliente lorsqu’elle exécute la tâche en arrière-plan déclenchée par la réception de la notification Push brute. La charge utile de la notification brute ne peut pas contenir plus de 5 Ko de données.

Lorsque le client reçoit la notification, la tâche en arrière-plan est activée et la charge utile de données spécifiée est transmise et accessible via le code de la tâche en arrière-plan de l’application.

Étapes précédentes

Pour plus d’informations sur la manière de créer une application de l’écran de verrouillage pour recevoir des notifications réseau en arrière-plan qui utilisent les notifications Push brutes, voir Démarrage rapide : créer une application de l’écran de verrouillage qui utilise les notifications Push brutes en arrière-plan.

Étapes ultérieures

Pour plus d’informations sur la manière d’écrire une tâche en arrière-plan pour recevoir des notifications réseau en arrière-plan qui utilisent les notifications Push brutes, voir Comment écrire une tâche en arrière-plan pour les notifications Push brutes.

Pour plus d’informations sur les recommandations et la liste de vérification pour l’utilisation des notifications Push brutes, voir

Recommandations et liste de vérification sur les notifications brutes.