Beveiligde pushmeldingen verzenden vanuit Azure Notification Hubs

Artikel
06/01/2023

Overzicht

Met ondersteuning voor pushmeldingen in Microsoft Azure krijgt u toegang tot een gebruiksvriendelijke, uitgebreide push-infrastructuur met meerdere platforms, die de implementatie van pushmeldingen voor zowel consumenten- als bedrijfstoepassingen voor mobiele platforms aanzienlijk vereenvoudigt.

Vanwege wettelijke of beveiligingsbeperkingen wil een toepassing soms iets in de melding opnemen dat niet kan worden verzonden via de standaardinfrastructuur voor pushmeldingen. In deze zelfstudie wordt beschreven hoe u dezelfde ervaring kunt bereiken door gevoelige informatie te verzenden via een beveiligde, geverifieerde verbinding tussen het clientapparaat en de back-end van de app.

Op hoog niveau is de stroom als volgt:

De back-end van de app:
- Slaat een beveiligde nettolading op in de back-enddatabase.
- Hiermee wordt de id van deze melding naar het apparaat verzonden (er wordt geen beveiligde informatie verzonden).
De app op het apparaat, wanneer de melding wordt ontvangen:
- Het apparaat maakt contact met de back-end en vraagt de beveiligde nettolading aan.
- De app kan de nettolading weergeven als een melding op het apparaat.

Het is belangrijk te weten dat we in de voorgaande stroom (en in deze zelfstudie) ervan uitgaan dat het apparaat een verificatietoken opslaat in de lokale opslag, nadat de gebruiker zich heeft aangemeld. Dit garandeert een volledig naadloze ervaring, omdat het apparaat de beveiligde nettolading van de melding kan ophalen met behulp van dit token. Als uw toepassing geen verificatietokens op het apparaat opslaat of als deze tokens kunnen worden verlopen, moet de apparaat-app, na ontvangst van de melding, een algemene melding weergeven waarin de gebruiker wordt gevraagd de app te starten. De app verifieert vervolgens de gebruiker en toont de nettolading van de melding.

In deze zelfstudie ziet u hoe u veilig een pushmelding verzendt. De zelfstudie bouwt voort op de zelfstudie Gebruikers waarschuwen , dus u moet eerst de stappen in die zelfstudie voltooien.

Notitie

In deze zelfstudie wordt ervan uitgegaan dat u de Notification Hub hebt gemaakt en geconfigureerd, zoals beschreven in Meldingen verzenden naar Universeel Windows-platform-apps. Houd er ook rekening mee dat Windows Phone 8.1 Windows-referenties (niet Windows Phone) vereist en dat achtergrondtaken niet werken op Windows Phone 8.0 of Silverlight 8.1. Voor Windows Store-toepassingen kunt u alleen meldingen ontvangen via een achtergrondtaak als de app is ingeschakeld voor het vergrendelingsscherm (klik op het selectievakje in appmanifest).

WebAPI-project

Open in Visual Studio het project AppBackend dat u hebt gemaakt in de zelfstudie Gebruikers waarschuwen .

Vervang in Notifications.cs de volledige klasse Notifications door de volgende code. Zorg ervoor dat u de tijdelijke aanduidingen vervangt door uw connection string (met volledige toegang) voor uw Notification Hub en de naam van de hub. U kunt deze waarden ophalen uit de Azure Portal. Deze module vertegenwoordigt nu de verschillende beveiligde meldingen die worden verzonden. In een volledige implementatie worden de meldingen opgeslagen in een database; Voor het gemak slaan we ze in dit geval op in het geheugen.

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

Vervang in NotificationsController.cs de code in de klassedefinitie NotificationsController door de volgende code. Dit onderdeel implementeert een manier voor het apparaat om de melding veilig op te halen en biedt ook een manier (voor de doeleinden van deze zelfstudie) om een beveiligde push naar uw apparaten te activeren. Houd er rekening mee dat we bij het verzenden van de melding naar de Notification Hub alleen een onbewerkte melding verzenden met de id van de melding (en geen echt bericht):

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

Houd er rekening mee dat de Post methode nu geen pop-upmelding verzendt. Er wordt een onbewerkte melding verzonden die alleen de meldings-id bevat en geen gevoelige inhoud. Zorg er ook voor dat u opmerkingen maakt bij de verzendbewerking voor de platforms waarvoor u geen referenties hebt geconfigureerd op uw Notification Hub, omdat deze fouten zullen veroorzaken.

Nu gaan we deze app opnieuw implementeren op een Azure-website om deze toegankelijk te maken vanaf alle apparaten. Klik met de rechtermuisknop op het project AppBackend en selecteer Publiceren.
Selecteer Azure-website als publicatiedoel. Meld u aan met uw Azure-account, selecteer een bestaande of nieuwe website en noteer de eigenschap bestemmings-URL op het tabblad Verbinding . Verderop in deze zelfstudie wordt naar deze URL verwezen als uw back-endeindpunt . Klik op Publish.

Het Windows Phone-project wijzigen

Voeg in het project NotifyUserWindowsPhone de volgende code toe aan App.xaml.cs om de push-achtergrondtaak te registreren. Voeg de volgende regel code toe aan het einde van de OnLaunched()-methode:
```
RegisterBackgroundTask();
```

Voeg in App.xaml.cs de volgende code direct na de OnLaunched() methode toe:

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

Voeg de volgende using instructies toe boven aan het bestand App.xaml.cs:

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

Klik in het menu Bestand in Visual Studio op Alles opslaan.

Het pushachtergrondonderdeel maken

De volgende stap is het maken van het pushachtergrondonderdeel.

Klik in Solution Explorer met de rechtermuisknop op het knooppunt op het hoogste niveau van de oplossing (in dit geval Solution SecurePush ), klik vervolgens op Toevoegen en klik vervolgens op Nieuw project.
Vouw Store-apps uit, klik op Windows Phone Apps en klik vervolgens op Windows Runtime onderdeel (Windows Phone). Geef het project de naam PushBackgroundComponent en klik vervolgens op OK om het project te maken.
Klik in Solution Explorer met de rechtermuisknop op het project PushBackgroundComponent (Windows Phone 8.1), klik vervolgens op Toevoegen en vervolgens op Klasse. Geef de nieuwe klasse PushBackgroundTask.csde naam . Klik op Toevoegen om de klasse te genereren.

Vervang de volledige inhoud van de PushBackgroundComponent naamruimtedefinitie door de volgende code, waarbij u de tijdelijke aanduiding {back-end endpoint} vervangt door het back-endeindpunt dat is verkregen tijdens het implementeren van uw back-end:

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

Klik in Solution Explorer met de rechtermuisknop op het project PushBackgroundComponent (Windows Phone 8.1) en klik vervolgens op NuGet-pakketten beheren.
Klik aan de linkerkant op Online.
Typ Http Client in het zoekvak.
Klik in de lijst met resultaten op Microsoft HTTP-clientbibliotheken en klik vervolgens op Installeren. Voltooi de installatie.
Typ nu Json.net in het zoekvak van NuGet. Installeer het Json.NET-pakket en sluit vervolgens het venster NuGet Package Manager.

Voeg de volgende using -instructies toe aan het begin van het PushBackgroundTask.cs bestand:

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;

Klik in Solution Explorer in het project NotifyUserWindowsPhone (Windows Phone 8.1) met de rechtermuisknop op Verwijzingen en klik vervolgens op Verwijzing toevoegen.... Schakel in het dialoogvenster Reference Manager het selectievakje naast PushBackgroundComponent in en klik vervolgens op OK.
Dubbelklik in Solution Explorer op Package.appxmanifest in het project NotifyUserWindowsPhone (Windows Phone 8.1). Stel onder Meldingende optie Pop-up mogelijk in op Ja.
Klik in Package.appxmanifest op het menu Declaraties bovenaan. Klik in de vervolgkeuzelijst Beschikbare declaraties op Achtergrondtaken en klik vervolgens op Toevoegen.
Schakel in Package.appxmanifest onder Eigenschappen de optie Pushmelding in.
In Package.appxmanifest, onder App-instellingen, typt u PushBackgroundComponent.PushBackgroundTask in het veld Toegangspunt .
Klik in het menu Bestand op Alles opslaan.

De toepassing uitvoeren

Ga als volgt te werk om de toepassing uit te voeren:

Voer in Visual Studio de AppBackend-web-API-toepassing uit. Er wordt een ASP.NET webpagina weergegeven.
Voer in Visual Studio de Windows Phone-app NotifyUserWindowsPhone (Windows Phone 8.1) uit. De Windows Phone emulator wordt uitgevoerd en de app wordt automatisch geladen.
Voer in de gebruikersinterface van de App NotifyUserWindowsPhone een gebruikersnaam en wachtwoord in. Dit kan elke tekenreeks zijn, maar ze moeten dezelfde waarde hebben.
Klik in de gebruikersinterface van de App NotifyUserWindowsPhone op Aanmelden en registreren. Klik vervolgens op Push verzenden.

Delen via