Wysyłanie bezpiecznych powiadomień wypychanych z usługi Azure Notification Hubs

Artykuł
06/01/2023

Omówienie

Obsługa powiadomień wypychanych na platformie Microsoft Azure umożliwia dostęp do łatwej w użyciu, wieloplatformowej, skalowanej w poziomie infrastruktury wypychania, co znacznie upraszcza implementację powiadomień wypychanych zarówno dla aplikacji konsumenckich, jak i dla przedsiębiorstw dla platform mobilnych.

Ze względu na ograniczenia prawne lub ograniczenia zabezpieczeń czasami aplikacja może chcieć uwzględnić coś w powiadomieniu, którego nie można przekazać za pośrednictwem standardowej infrastruktury powiadomień wypychanych. W tym samouczku opisano sposób osiągnięcia tego samego środowiska przez wysyłanie poufnych informacji za pośrednictwem bezpiecznego, uwierzytelnionego połączenia między urządzeniem klienckim a zapleczem aplikacji.

Na wysokim poziomie przepływ jest następujący:

Zaplecze aplikacji:
- Przechowuje bezpieczny ładunek w bazie danych zaplecza.
- Wysyła identyfikator tego powiadomienia do urządzenia (żadne bezpieczne informacje nie są wysyłane).
Aplikacja na urządzeniu podczas odbierania powiadomienia:
- Urządzenie kontaktuje się z zapleczem żądającym bezpiecznego ładunku.
- Aplikacja może wyświetlić ładunek jako powiadomienie na urządzeniu.

Należy pamiętać, że w poprzednim przepływie (i w tym samouczku) przyjęto założenie, że urządzenie przechowuje token uwierzytelniania w magazynie lokalnym po zalogowaniu się użytkownika. Gwarantuje to całkowicie bezproblemowe środowisko, ponieważ urządzenie może pobrać bezpieczny ładunek powiadomienia przy użyciu tego tokenu. Jeśli aplikacja nie przechowuje tokenów uwierzytelniania na urządzeniu lub jeśli te tokeny mogą zostać wygasłe, aplikacja urządzenia po otrzymaniu powiadomienia powinna wyświetlić ogólne powiadomienie z monitem użytkownika o uruchomienie aplikacji. Następnie aplikacja uwierzytelnia użytkownika i wyświetla ładunek powiadomień.

W tym samouczku przedstawiono sposób bezpiecznego wysyłania powiadomień wypychanych. Samouczek jest oparty na samouczku Powiadamianie użytkowników , dlatego najpierw należy wykonać kroki opisane w tym samouczku.

Uwaga

W tym samouczku założono, że centrum powiadomień zostało utworzone i skonfigurowane zgodnie z opisem w temacie Wysyłanie powiadomień do aplikacji platforma uniwersalna systemu Windows. Należy również pamiętać, że Windows Phone 8.1 wymaga poświadczeń systemu Windows (nie Windows Phone), a zadania w tle nie działają na Windows Phone 8.0 lub Silverlight 8.1. W przypadku aplikacji ze Sklepu Windows powiadomienia można otrzymywać za pośrednictwem zadania w tle tylko wtedy, gdy aplikacja jest włączona na ekranie blokady (kliknij pole wyboru w programie Appmanifest).

Projekt WebAPI

W programie Visual Studio otwórz projekt AppBackend utworzony w samouczku Powiadamianie użytkowników .

W pliku Notifications.cs zastąp całą klasę Notifications następującym kodem. Pamiętaj, aby zastąpić symbole zastępcze parametrami połączenia (z pełnym dostępem) dla centrum powiadomień i nazwą centrum. Te wartości można uzyskać z Azure Portal. Ten moduł reprezentuje teraz różne bezpieczne powiadomienia, które zostaną wysłane. W pełnej implementacji powiadomienia będą przechowywane w bazie danych; dla uproszczenia w tym przypadku przechowujemy je w pamięci.

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

W pliku NotificationsController.cs zastąp kod wewnątrz definicji klasy NotificationsController następującym kodem. Ten składnik implementuje sposób bezpiecznego pobierania powiadomienia przez urządzenie, a także umożliwia (na potrzeby tego samouczka) wyzwalanie bezpiecznego wypychania do urządzeń. Należy pamiętać, że podczas wysyłania powiadomienia do centrum powiadomień wysyłamy tylko nieprzetworzone powiadomienie z identyfikatorem powiadomienia (bez rzeczywistego komunikatu):

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

Pamiętaj, że Post metoda nie wysyła teraz wyskakujących powiadomień. Wysyła nieprzetworzone powiadomienie zawierające tylko identyfikator powiadomienia, a nie zawartość wrażliwą. Upewnij się również, że oznaczono jako komentarz operację wysyłania dla platform, dla których nie masz skonfigurowanych poświadczeń w centrum powiadomień, ponieważ spowodują one błędy.

Teraz ponownie wdrożymy tę aplikację w witrynie internetowej platformy Azure, aby była dostępna ze wszystkich urządzeń. Kliknij prawym przyciskiem myszy projekt AppBackend i wybierz polecenie Publikuj.
Wybierz pozycję Witryna internetowa platformy Azure jako element docelowy publikowania. Zaloguj się przy użyciu konta platformy Azure i wybierz istniejącą lub nową witrynę internetową i zanotuj właściwość docelowego adresu URL na karcie Połączenie . W dalszej części tego samouczka użyjemy tego adresu URL jako punktu końcowego zaplecza . Kliknij przycisk Opublikuj.

Modyfikowanie projektu Windows Phone

W projekcie NotifyUserWindowsPhone dodaj następujący kod do pliku App.xaml.cs, aby zarejestrować zadanie wypychania w tle. Dodaj poniższy wiersz kodu na końcu metody OnLaunched():
```
RegisterBackgroundTask();
```

Nadal w pliku App.xaml.cs dodaj następujący kod bezpośrednio po metodzie 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();
    }
}

Dodaj następujące using instrukcje w górnej części pliku App.xaml.cs:

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

W menu Plik programu Visual Studio kliknij polecenie Zapisz wszystko.

Tworzenie składnika w tle wypychania

Następnym krokiem jest utworzenie składnika wypychania w tle.

W Eksplorator rozwiązań kliknij prawym przyciskiem myszy węzeł najwyższego poziomu rozwiązania (Rozwiązanie SecurePush w tym przypadku), a następnie kliknij przycisk Dodaj, a następnie kliknij pozycję Nowy projekt.
Rozwiń węzeł Aplikacje ze sklepu, a następnie kliknij pozycję Aplikacje Windows Phone, a następnie kliknij pozycję składnik środowisko wykonawcze systemu Windows (Windows Phone). Nadaj projektowi nazwę PushBackgroundComponent, a następnie kliknij przycisk OK , aby utworzyć projekt.
W Eksplorator rozwiązań kliknij prawym przyciskiem myszy projekt PushBackgroundComponent (Windows Phone 8.1), a następnie kliknij przycisk Dodaj, a następnie kliknij pozycję Klasa. Nadaj nowej klasie PushBackgroundTask.csnazwę . Kliknij przycisk Dodaj , aby wygenerować klasę.

Zastąp całą zawartość PushBackgroundComponent definicji przestrzeni nazw następującym kodem, zastępując symbol zastępczy {back-end endpoint} punktem końcowym zaplecza uzyskanym podczas wdrażania zaplecza:

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

W Eksplorator rozwiązań kliknij prawym przyciskiem myszy projekt PushBackgroundComponent (Windows Phone 8.1), a następnie kliknij pozycję Zarządzaj pakietami NuGet.
Po lewej stronie kliknij opcję Online.
W polu Wyszukaj wpisz ciąg Klient HTTP.
Na liście wyników kliknij pozycję Biblioteki klienta HTTP firmy Microsoft, a następnie kliknij przycisk Zainstaluj. Ukończ instalację.
W polu Wyszukaj w menedżerze pakietów NuGet wpisz ciąg Json.net. Zainstaluj pakiet Json.NET , a następnie zamknij okno Menedżer pakietów NuGet.

Dodaj następujące using instrukcje w górnej PushBackgroundTask.cs części pliku:

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;

W Eksplorator rozwiązań w projekcie NotifyUserWindowsPhone (Windows Phone 8.1) kliknij prawym przyciskiem myszy pozycję Odwołania, a następnie kliknij polecenie Dodaj odwołanie.... W oknie dialogowym Menedżer odwołań zaznacz pole wyboru obok pozycji PushBackgroundComponent, a następnie kliknij przycisk OK.
W Eksplorator rozwiązań kliknij dwukrotnie plik Package.appxmanifest w projekcie NotifyUserWindowsPhone (Windows Phone 8.1). W obszarze Powiadomienia ustaw opcję Obsługa wyskakowania na wartość Tak.
Nadal w pliku Package.appxmanifest kliknij menu Deklaracje w górnej części strony. Na liście rozwijanej Dostępne deklaracje kliknij pozycję Zadania w tle, a następnie kliknij przycisk Dodaj.
W pliku Package.appxmanifest w obszarze Właściwości zaznacz pole Powiadomienie wypychane.
W pliku Package.appxmanifest w obszarze Ustawienia aplikacji wpisz PushBackgroundComponent.PushBackgroundTask w polu Punkt wejścia .
W menu Plik kliknij polecenie Zapisz wszystko.

Uruchamianie aplikacji

Aby uruchomić aplikację, wykonaj następujące czynności:

W programie Visual Studio uruchom aplikację internetowego interfejsu API AppBackend . Zostanie wyświetlona ASP.NET strona internetowa.
W programie Visual Studio uruchom aplikację NotifyUserWindowsPhone (Windows Phone 8.1) Windows Phone. Emulator Windows Phone jest uruchamiany i ładuje aplikację automatycznie.
W interfejsie użytkownika aplikacji NotifyUserWindowsPhone wprowadź nazwę użytkownika i hasło. Może to być dowolny ciąg, ale muszą być tymi samymi wartościami.
W interfejsie użytkownika aplikacji NotifyUserWindowsPhone kliknij pozycję Zaloguj się i zarejestruj. Następnie kliknij pozycję Wyślij wypychanie.

Udostępnij za pośrednictwem