Senden sicherer Pushbenachrichtigungen aus Azure Notification Hubs

Artikel
06/01/2023

Übersicht

Durch die Unterstützung von Pushbenachrichtigungen in Microsoft Azure haben Sie Zugriff auf eine benutzerfreundliche, plattformübergreifende und horizontal skalierte Pushinfrastruktur, die die Implementierung von Pushbenachrichtigungen sowohl für Endbenutzer- als auch für Unternehmensanwendungen für mobile Plattformen erheblich vereinfacht.

Es kann vorkommen, dass eine Anwendung etwas in die Benachrichtigung einschließen möchte, dass aufgrund gesetzlicher oder sicherheitsbedingter Einschränkungen nicht über die Standardinfrastruktur von Pushbenachrichtigungen übertragen werden kann. In diesem Lernprogramm wird beschrieben, wie Sie die gleiche Funktionalität erzielen, indem Sie vertrauliche Informationen über eine sichere authentifizierte Verbindung zwischen dem Clientgerät und dem App-Back-End senden.

Der generelle Ablauf sieht folgendermaßen aus:

Das App-Back-End:
- Speichert die sichere Nutzlast in einer Back-End-Datenbank.
- Sendet die ID dieser Benachrichtigung an das Gerät (es werden keine sicheren Informationen gesendet).
Bei Erhalt der Benachrichtigung reagiert die App auf dem Gerät folgendermaßen:
- Das Gerät kontaktiert das Back-End und fordert die sichere Nutzlast an.
- Die App kann die Nutzlast als Benachrichtigung auf dem Gerät anzeigen.

Beachten Sie, dass im obigen Ablauf (und in diesem Tutorial) angenommen wird, dass das Gerät ein Authentifizierungstoken im lokalen Speicher speichert, nachdem sich der Benutzer angemeldet hat. Dies gewährleistet einen vollständig nahtlosen Ablauf, da das Gerät mit diesem Token die sichere Nutzlast der Benachrichtigung abrufen kann. Wenn Ihre Anwendung keine Authentifizierungstoken auf dem Gerät speichert oder diese Token ablaufen können, sollte die Geräte-App nach Erhalt der Benachrichtigung eine generische Benachrichtigung anzeigen, in der der Benutzer zum Starten der App aufgefordert wird. Anschließend authentifiziert die App den Benutzer und zeigt die Nutzlast der Benachrichtigung an.

Dieses Tutorial zeigt, wie Sie sichere Pushbenachrichtigungen senden. Es baut auf dem Tutorial Benachrichtigen von Benutzern auf. Daher sollten Sie die Schritte in diesem Tutorial zuerst durchführen.

Hinweis

In diesem Tutorial wird davon ausgegangen, dass Sie Ihre Notification Hub-Instanz wie unter Senden von Benachrichtigungen an Apps für Universelle Windows-Plattform beschrieben erstellt und konfiguriert haben. Beachten Sie außerdem, dass für Windows Phone 8.1 Anmeldedaten für Windows (nicht Windows Phone) erforderlich sind und dass Hintergrundaufgaben in Windows Phone 8.0 oder Silverlight 8.1 nicht funktionieren. Bei Windows Store-Anwendungen können nur dann Benachrichtigungen über eine Hintergrundaufgabe empfangen werden, wenn für die App der Sperbildschirmaktiviert ist (klicken Sie auf das Kontrollkästchen im AppManifest).

WebAPI-Projekt

Öffnen Sie in Visual Studio das Projekt AppBackend , das Sie im Lernprogramm Benachrichtigen von Benutzern erstellt haben.

Ersetzen Sie in der Datei „Notifications.cs“ die gesamte Notifications -Klasse durch den folgenden Code. Stellen Sie sicher, dass Sie die Platzhalter durch Ihre Verbindungszeichenfolge (mit vollständigem Zugriff) für Ihr Notification Hub und den Hub-Namen ersetzen. Diese Werte erhalten Sie im Azure-Portal. Dieses Modul stellt nun die unterschiedlichen sicheren Benachrichtigungen dar, die gesendet werden. In einer vollständigen Implementierung werden die Benachrichtigungen in einer Datenbank gespeichert; der Einfachheit halber speichern wir Sie in diesem Fall im Speicher.

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

Ersetzen Sie in der Datei "NotificationsController.cs" den Code innerhalb der NotificationsController -Klassendefinition durch den folgenden Code. Durch diese Komponente wird für das Gerät eine Möglichkeit zum sicheren Abrufen der Benachrichtigung implementiert, und sie ermöglicht außerdem (zu Lernzwecken in diesem Lernprogramm) das Auslösen einer sicheren Pushbenachrichtigung an Ihre Geräte. Beachten Sie, dass wenn Sie die Benachrichtigung an das Notification Hub senden, nur eine reine Benachrichtigung mit der ID der Benachrichtigung (und nicht der tatsächlichen Meldung) gesendet wird.

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

Beachten Sie, dass die Post -Methode jetzt keine Popupbenachrichtigung sendet. Es wird eine reine Benachrichtigung gesendet, die nur die Benachrichtigungs-ID und keine vertraulichen Inhalte enthält. Kommentieren Sie auch unbedingt den Sendevorgang für die Plattformen, für die Sie keine Anmeldeinformationen in Ihrem Notification Hub konfiguriert haben, da diese zu Fehlern führen.

Nun werden wir diese App erneut auf einer Azure-Website bereitstellen, damit von allen Geräten darauf zugegriffen werden kann. Klicken Sie mit der rechten Maustaste auf das Projekt AppBackend, und wählen Sie Veröffentlichen.
Wählen Sie die Azure-Website als Ihr Veröffentlichungsziel aus. Melden Sie sich mit Ihrem Azure-Konto an, wählen Sie eine vorhandene oder neue Website, und notieren Sie sich die Ziel-URL-Eigenschaft auf der Registerkarte Verbindung. Diese URL wird später in diesem Lernprogramm als Back-End-Endpunkt bezeichnet. Klicken Sie auf Veröffentlichen.

Ändern des Windows Phone-Projekts

Fügen Sie im Projekt NotifyUserWindowsPhone den folgenden Code zur Datei App.xaml.cs hinzu, um die Push-Hintergrundaufgabe zu registrieren. Fügen Sie am Ende der OnLaunched() -Methode folgenden Code hinzu:
```
RegisterBackgroundTask();
```

Fügen Sie in "App.xaml.cs" den folgenden Code direkt nach der OnLaunched() -Methode ein:

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

Fügen Sie die folgenden using -Anweisungen am Anfang der Datei "App.xaml.cs" hinzu:

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

Klicken Sie im Menü Datei in Visual Studio auf Alles speichern.

Erstellen der Push-Hintergrundkomponente

Im nächsten Schritt erstellen Sie die Push-Hintergrundkomponente.

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Knoten der obersten Ebene der Projektmappe (in diesem Fall Solution SecurePush). Klicken Sie dann auf Hinzufügen und Neues Projekt.
Erweitern Sie Store-Apps, und klicken Sie anschließend auf Windows Phone-Apps und Komponente für Windows-Runtime (Windows Phone) . Benennen Sie das Projekt PushBackgroundComponent, und klicken Sie dann auf OK, um das Projekt zu erstellen.
Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt PushBackgroundComponent (Windows Phone 8.1) , und klicken Sie dann auf Hinzufügen und Klasse. Geben Sie der neuen Klasse den Namen PushBackgroundTask.cs. Klicken Sie auf Hinzufügen , um die Klasse zu erstellen.

Ersetzen Sie den gesamten Inhalt der Namespacedefinition PushBackgroundComponent durch den folgenden Code, und ersetzen Sie dabei den Platzhalter {back-end endpoint} durch den Back-End-Endpunkt, den Sie bei der Bereitstellung des Back-Ends abgerufen haben:

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

Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt PushBackgroundComponent (Windows Phone 8.1) , und klicken Sie dann auf NuGet-Pakete verwalten.
Klicken Sie auf der linken Seite auf Online.
Geben Sie in das Suchfeld den Begriff Http Client ein.
Klicken Sie in der Ergebnisliste auf Microsoft HTTP-Clientbibliotheken und dann auf Installieren. Schließen Sie die Installation ab.
Geben Sie in das NuGet-Suchfeld die Zeichenfolge Json.net ein. Installieren Sie das Json.NET -Paket, und schließen Sie dann das Fenster des NuGet-Paket-Managers.

Fügen Sie am Anfang der Datei PushBackgroundTask.cs die folgenden using-Anweisungen hinzu:

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;

Klicken Sie im Projektmappen-Explorer im Projekt NotifyUserWindowsPhone (Windows Phone 8.1) mit der rechten Maustaste auf Verweise, und klicken Sie dann auf Verweis hinzufügen. Aktivieren Sie im Dialogfeld „Verweis-Manager“ das Kontrollkästchen neben PushBackgroundComponent, und klicken Sie dann auf OK.
Doppelklicken Sie im Projektmappen-Explorer im Projekt NotifyUserWindowsPhone (Windows Phone 8.1) auf Package.appxmanifest. Legen Sie unter Benachrichtigungen die Einstellung Toastfähig auf Ja fest.
Klicken Sie in Package.appxmanifest im oberen Bereich auf das Menü Deklarationen. Klicken Sie im Dropdownmenü Verfügbare Deklarationen auf Hintergrundaufgaben, und klicken Sie dann auf Hinzufügen.
Aktivieren Sie in Package.appxmanifest unter Eigenschaften die Option Pushbenachrichtigung.
Geben Sie in Package.appxmanifest unter App-Einstellungen die Zeichenfolge PushBackgroundComponent.PushBackgroundTask in das Feld Einstiegspunkt ein.
Klicken Sie im Menü Datei auf Alle speichern.

Ausführen der Anwendung

Gehen Sie zum Ausführen der Anwendung folgendermaßen vor:

Führen Sie in Visual Studio die Web-API-Anwendung AppBackend aus. Daraufhin wird eine ASP.NET-Webseite angezeigt.
Führen Sie in Visual Studio die Windows Phone-App NotifyUserWindowsPhone (Windows Phone 8.1) aus. Der Windows Phone-Emulator wird ausgeführt und lädt die App automatisch.
Geben Sie in der UI der NotifyUserWindowsPhone -App einen Benutzernamen und das Kennwort ein. Dies kann eine beliebige Zeichenfolge sein, beide müssen jedoch denselben Wert haben.
Klicken Sie auf der Benutzeroberfläche der App NotifyUserWindowsPhone auf Log in and register. Klicken Sie anschließend auf Send push.

Share via