Envoyer des notifications Push sécurisées à partir d’Azure Notification Hubs

Article
06/01/2023

Vue d’ensemble

La prise en charge des notifications Push dans Microsoft Azure vous permet d’accéder à une infrastructure Push conviviale, multiplateforme avec montée en charge qui simplifie fortement l’implémentation des notifications Push pour les applications grand public et d’entreprise destinées aux plateformes mobiles.

En raison de contraintes liées à la réglementation ou à la sécurité, une application peut avoir besoin d'inclure dans la notification des informations qui ne peuvent pas être transmises via l'infrastructure de notification Push standard. Ce didacticiel montre comment procéder en envoyant des informations sensibles par l'intermédiaire d'une connexion authentifiée sécurisée entre l'appareil client et le serveur principal de l'application.

Globalement, le processus est le suivant :

Le serveur principal de l'application :
- stocke la charge utile sécurisée dans la base de données principale ;
- envoie l'ID de cette notification à l'appareil (aucune information sécurisée n'est envoyée).
L'application qui se trouve sur l'appareil, lorsqu'elle reçoit la notification :
- L'appareil contacte le serveur principal en demandant la charge utile sécurisée.
- L'application peut afficher la charge utile sous la forme d'une notification sur l'appareil.

Veuillez noter que dans le flux précédent (et dans ce didacticiel), nous partons du principe que l’appareil stocke un jeton d’authentification dans un stockage local, une fois l’utilisateur connecté. Cela simplifie nettement l’expérience, car l’appareil peut récupérer la charge utile sécurisée en utilisant ce jeton. Si votre application ne stocke pas les jetons d'authentification sur l'appareil, ou si ces jetons sont susceptibles d'expirer, lorsque l'application sur l'appareil reçoit la notification, elle doit afficher une notification générique demandant à l'utilisateur de lancer l'application. L'application authentifie alors l'utilisateur et affiche la charge utile de la notification.

Ce tutoriel montre comment envoyer une notification Push en toute sécurité. Il s’appuie sur le tutoriel Envoi de notifications à des utilisateurs. Vous devez donc suivre ce dernier au préalable.

Notes

Ce tutoriel part du principe que vous avez créé et configuré votre hub de notification comme décrit dans Envoyer des notifications aux applications de la plateforme Windows universelle. Notez également que Windows Phone 8.1 nécessite des informations d’identification Windows (pas Windows Phone) et que les tâches en arrière-plan ne fonctionnent pas sur Windows Phone 8.0 ou Silverlight 8.1. Pour les applications Windows Store, vous pouvez recevoir des notifications via une tâche en arrière-plan uniquement si l'écran de verrouillage activé pour l'application (activez la case à cocher dans Appmanifest).

Projet WebAPI

Dans Visual Studio, ouvrez le projet AppBackend que vous avez créé dans le didacticiel Notification des utilisateurs .

Dans le fichier Notifications.cs, remplacez la totalité de la classe Notifications par le code suivant. Veillez à remplacer les espaces réservés par la chaîne de connexion (avec accès complet) de votre hub de notification et par le nom de celui-ci. Ces valeurs sont disponibles dans le portail Azure. Ce module représente maintenant les différentes notifications sécurisées qui seront envoyées. Dans les implémentations complètes, les notifications sont stockées dans une base de données. Par souci de simplification, nous les stockons ici en mémoire.

 public class Notification
 {
     public int Id { get; set; }
     public string Payload { get; set; }
     public bool Read { get; set; }
 }

 public class Notifications
 {
     public static Notifications Instance = new Notifications();

     private List<Notification> notifications = new List<Notification>();

     public NotificationHubClient Hub { get; set; }

     private Notifications() {
         Hub = NotificationHubClient.CreateClientFromConnectionString("{conn string with full access}",     "{hub name}");
     }

     public Notification CreateNotification(string payload)
     {
         var notification = new Notification() {
         Id = notifications.Count,
         Payload = payload,
         Read = false
         };

         notifications.Add(notification);

         return notification;
     }

     public Notification ReadNotification(int id)
     {
         return notifications.ElementAt(id);
     }
 }

Dans le fichier NotificationsController.cs, remplacez le code de la définition de classe NotificationsController par le code suivant. Ce composant permet à l'appareil de récupérer la notification en toute sécurité. Dans l'exemple de ce didacticiel, il vous permet également de déclencher une notification push sécurisée sur vos appareils. Notez que la notification envoyée ici au hub de notification est brute puisqu’elle comporte uniquement son ID (sans message) :

 public NotificationsController()
 {
     Notifications.Instance.CreateNotification("This is a secure notification!");
 }

 // GET api/notifications/id
 public Notification Get(int id)
 {
     return Notifications.Instance.ReadNotification(id);
 }

 public async Task<HttpResponseMessage> Post()
 {
     var secureNotificationInTheBackend = Notifications.Instance.CreateNotification("Secure confirmation.");
     var usernameTag = "username:" + HttpContext.Current.User.Identity.Name;

     // windows
     var rawNotificationToBeSent = new Microsoft.Azure.NotificationHubs.WindowsNotification(secureNotificationInTheBackend.Id.ToString(),
                     new Dictionary<string, string> {
                         {"X-WNS-Type", "wns/raw"}
                     });
     await Notifications.Instance.Hub.SendNotificationAsync(rawNotificationToBeSent, usernameTag);

     // apns
     await Notifications.Instance.Hub.SendAppleNativeNotificationAsync("{\"aps\": {\"content-available\": 1}, \"secureId\": \"" + secureNotificationInTheBackend.Id.ToString() + "\"}", usernameTag);

     // gcm
     await Notifications.Instance.Hub.SendGcmNativeNotificationAsync("{\"data\": {\"secureId\": \"" + secureNotificationInTheBackend.Id.ToString() + "\"}}", usernameTag);

     return Request.CreateResponse(HttpStatusCode.OK);
 }

Notez que la méthode Post n'envoie pas de notification toast. Elle envoie une notification brute qui contient uniquement l’ID de la notification, sans aucun contenu sensible. Veillez également à commenter l'opération d'envoi pour les plateformes pour lesquelles aucune information d'identification n'est configurée sur votre hub de notification, car celles-ci généreront des erreurs.

Nous allons maintenant redéployer cette application sur un site web Azure afin de la rendre accessible à tous les appareils. Cliquez avec le bouton droit sur le projet AppBackend, puis sélectionnez Publier.
Sélectionnez Site web Azure comme cible de publication. Connectez-vous avec votre compte Azure, sélectionnez un site web (nouveau ou existant), puis notez la valeur de la propriété URL de destination dans l’onglet Connexion. Plus loin dans ce didacticiel, nous utiliserons cette URL comme point de terminaison principal . Cliquez sur Publier.

Modifier le projet Windows Phone

Dans le projet NotifyUserWindowsPhone , ajoutez le code suivant à App.xaml.cs afin d'enregistrer la tâche en arrière-plan pour les notifications Push. Ajoutez la ligne de code ci-après à la fin de la méthode OnLaunched() :
```
RegisterBackgroundTask();
```

Toujours dans App.xaml.cs, ajoutez le code ci-dessous juste après la méthode OnLaunched() :

private async void RegisterBackgroundTask()
{
    if (!Windows.ApplicationModel.Background.BackgroundTaskRegistration.AllTasks.Any(i => i.Value.Name == "PushBackgroundTask"))
    {
        var result = await BackgroundExecutionManager.RequestAccessAsync();
        var builder = new BackgroundTaskBuilder();

        builder.Name = "PushBackgroundTask";
        builder.TaskEntryPoint = typeof(PushBackgroundComponent.PushBackgroundTask).FullName;
        builder.SetTrigger(new Windows.ApplicationModel.Background.PushNotificationTrigger());
        BackgroundTaskRegistration task = builder.Register();
    }
}

Ajoutez les instructions using suivantes au début du fichier App.xaml.cs :

using Windows.Networking.PushNotifications;
using Windows.ApplicationModel.Background;

Dans Visual Studio, dans le menu Fichier, cliquez sur Enregistrer tout.

Créer le composant en arrière-plan pour les notifications Push

L’étape suivante consiste à créer le composant en arrière-plan pour les notifications Push.

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le nœud de niveau supérieur de la solution (Solution SecurePush dans le cas présent). Cliquez ensuite sur Ajouter, puis sur Nouveau projet.
Développez Applications du Windows Store et cliquez sur Applications Windows Phone, puis sur Composant Windows Runtime (Windows Phone) . Nommez le projet PushBackgroundComponent, puis cliquez sur OK pour créer le projet.
Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet PushBackgroundComponent (Windows Phone 8.1) . Cliquez ensuite sur Ajouter, puis sur Classe. Nommez la nouvelle classe PushBackgroundTask.cs. Cliquez sur Ajouter pour générer la classe.

Remplacez l’ensemble du contenu de la définition de l’espace de noms PushBackgroundComponent par le code ci-après en remplaçant l’espace réservé {back-end endpoint} par le point de terminaison du serveur principal obtenu lors du déploiement de votre serveur principal :

public sealed class Notification
    {
        public int Id { get; set; }
        public string Payload { get; set; }
        public bool Read { get; set; }
    }

    public sealed class PushBackgroundTask : IBackgroundTask
    {
        private string GET_URL = "{back-end endpoint}/api/notifications/";

        async void IBackgroundTask.Run(IBackgroundTaskInstance taskInstance)
        {
            // Store the content received from the notification so it can be retrieved from the UI.
            RawNotification raw = (RawNotification)taskInstance.TriggerDetails;
            var notificationId = raw.Content;

            // retrieve content
            BackgroundTaskDeferral deferral = taskInstance.GetDeferral();
            var httpClient = new HttpClient();
            var settings = ApplicationData.Current.LocalSettings.Values;
            httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", (string)settings["AuthenticationToken"]);

            var notificationString = await httpClient.GetStringAsync(GET_URL + notificationId);

            var notification = JsonConvert.DeserializeObject<Notification>(notificationString);

            ShowToast(notification);

            deferral.Complete();
        }

        private void ShowToast(Notification notification)
        {
            ToastTemplateType toastTemplate = ToastTemplateType.ToastText01;
            XmlDocument toastXml = ToastNotificationManager.GetTemplateContent(toastTemplate);
            XmlNodeList toastTextElements = toastXml.GetElementsByTagName("text");
            toastTextElements[0].AppendChild(toastXml.CreateTextNode(notification.Payload));
            ToastNotification toast = new ToastNotification(toastXml);
            ToastNotificationManager.CreateToastNotifier().Show(toast);
        }
    }

Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet PushBackgroundComponent (Windows Phone 8.1) , puis cliquez sur Gérer les packages NuGet.
Dans la partie gauche, cliquez sur En ligne.
Dans la zone Rechercher, entrez Client Http.
Dans la liste de résultats, cliquez sur Bibliothèques clientes HTTP Microsoft, puis cliquez sur Installer. Terminez l'installation.
De retour dans la zone Recherche NuGet, tapez Json.net. Installez le package Json.NET , puis fermez la fenêtre du Gestionnaire de package NuGet.

Ajoutez les instructions using suivantes au début du fichier PushBackgroundTask.cs :

using Windows.ApplicationModel.Background;
using Windows.Networking.PushNotifications;
using System.Net.Http;
using Windows.Storage;
using System.Net.Http.Headers;
using Newtonsoft.Json;
using Windows.UI.Notifications;
using Windows.Data.Xml.Dom;

Dans l’Explorateur de solutions, dans le projet NotifyUserWindowsPhone (Windows Phone 8.1) , cliquez avec le bouton droit sur Références, puis cliquez sur Ajouter une référence... . Dans la boîte de dialogue Gestionnaire de références, cochez la case en regard de PushBackgroundComponent, puis cliquez sur OK.
Dans l’Explorateur de solutions, double-cliquez sur Package.appxmanifest dans le projet NotifyUserWindowsPhone (Windows Phone 8.1) . Sous Notifications, définissez Compatible toast sur Oui.
Toujours dans Package.appxmanifest, cliquez en haut sur le menu Déclarations. Dans la liste déroulante Déclarations disponibles, cliquez sur Tâches en arrière-plan, puis cliquez sur Ajouter.
Dans Package.appxmanifest, sous Propriétés, cochez Notification Push.
Dans Package.appxmanifest, sous Paramètres de l’application, tapez PushBackgroundComponent.PushBackgroundTask dans le champ Point d’entrée.
Dans le menu Fichier, cliquez sur Enregistrer tout.

Exécution de l'application

Pour exécuter l'application, procédez comme suit :

Dans Visual Studio, exécutez l'application d'API web AppBackend . Une page web ASP.NET s'affiche.
Dans Visual Studio, exécutez l'application Windows Phone NotifyUserWindowsPhone (Windows Phone 8.1) . L'émulateur Windows Phone s'exécute et charge l'application automatiquement.
Dans l'interface utilisateur de l'application NotifyUserWindowsPhone , entrez un nom d'utilisateur et un mot de passe. La valeur peut être une chaîne quelconque, mais elle doit être identique pour les deux.
Dans l’interface utilisateur de l’application NotifyUserWindowsPhone, cliquez sur Se connecter et s’inscrire. Cliquez ensuite sur Send push.

Partager via