Samouczek: wysyłanie powiadomień do określonych urządzeń z aplikacjami platforma uniwersalna systemu Windows

Omówienie

W tym samouczku pokazano, jak używać usługi Azure Notification Hubs do emisji powiadomień o wiadomościach powodujących niezgodność. W tym samouczku omówiono aplikacje ze Sklepu Windows lub Windows Phone 8.1 (inne niż Silverlight). Jeśli celujesz Windows Phone 8.1 Silverlight, zobacz Powiadomienia wypychane do określonych urządzeń Windows Phone przy użyciu usługi Azure Notification Hubs.

Z tego samouczka dowiesz się, jak za pomocą usługi Azure Notification Hubs wypychać powiadomienia do określonych urządzeń z systemem Windows z aplikacją platformy platforma uniwersalna systemu Windows (UWP). Po ukończeniu samouczka możesz zarejestrować się w celu uzyskania interesujących Cię kategorii wiadomości. Powiadomienia wypychane będą otrzymywane tylko dla tych kategorii.

Aby włączyć scenariusze emisji, dołącz co najmniej jeden tag podczas tworzenia rejestracji w centrum powiadomień. Po wysłaniu powiadomień do tagu wszystkie urządzenia zarejestrowane dla tagu otrzymają powiadomienie. Aby uzyskać więcej informacji na temat tagów, zobacz Routing i wyrażenia tagów.

W tym samouczku wykonasz następujące zadania:

Wymagania wstępne

Przed rozpoczęciem tego samouczka wykonaj kroki podane w artykule Samouczek: wysyłanie powiadomień do aplikacji platformy uniwersalnej systemu Windows przy użyciu usługi Azure Notification Hubs.

Dodawanie wyboru kategorii do aplikacji

Pierwszym krokiem jest dodanie elementów interfejsu użytkownika do istniejącej strony głównej, co umożliwi użytkownikom wybieranie kategorii do zarejestrowania. Wybrane kategorie są przechowywane na urządzeniu. Po uruchomieniu aplikacji zostanie utworzona rejestracja urządzenia w centrum powiadomień z wybranymi kategoriami jako tagami.

1. Otwórz plik projektu MainPage.xaml , a następnie skopiuj następujący kod w elemecie Grid :

   <Grid>
       <Grid.RowDefinitions>
           <RowDefinition/>
           <RowDefinition/>
           <RowDefinition/>
           <RowDefinition/>
           <RowDefinition/>
       </Grid.RowDefinitions>
       <Grid.ColumnDefinitions>
           <ColumnDefinition/>
           <ColumnDefinition/>
       </Grid.ColumnDefinitions>
       <TextBlock Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2"  TextWrapping="Wrap" Text="Breaking News" FontSize="42" VerticalAlignment="Top" HorizontalAlignment="Center"/>
       <ToggleSwitch Header="World" Name="WorldToggle" Grid.Row="1" Grid.Column="0" HorizontalAlignment="Center"/>
       <ToggleSwitch Header="Politics" Name="PoliticsToggle" Grid.Row="2" Grid.Column="0" HorizontalAlignment="Center"/>
       <ToggleSwitch Header="Business" Name="BusinessToggle" Grid.Row="3" Grid.Column="0" HorizontalAlignment="Center"/>
       <ToggleSwitch Header="Technology" Name="TechnologyToggle" Grid.Row="1" Grid.Column="1" HorizontalAlignment="Center"/>
       <ToggleSwitch Header="Science" Name="ScienceToggle" Grid.Row="2" Grid.Column="1" HorizontalAlignment="Center"/>
       <ToggleSwitch Header="Sports" Name="SportsToggle" Grid.Row="3" Grid.Column="1" HorizontalAlignment="Center"/>
       <Button Name="SubscribeButton" Content="Subscribe" HorizontalAlignment="Center" Grid.Row="4" Grid.Column="0" Grid.ColumnSpan="2" Click="SubscribeButton_Click"/>
   </Grid>
   

2. W Eksplorator rozwiązań kliknij prawym przyciskiem myszy projekt, wybierz pozycję Dodaj>klasę. W obszarze Dodaj nowy element nadaj klasie nazwę Powiadomienia, a następnie wybierz pozycję Dodaj. W razie potrzeby dodaj public modyfikator do definicji klasy.

3. Dodaj następujące using instrukcje do nowego pliku:

   using Windows.Networking.PushNotifications;
   using Microsoft.WindowsAzure.Messaging;
   using Windows.Storage;
   using System.Threading.Tasks;
   

4. Skopiuj następujący kod do nowej klasy Notifications:

   private NotificationHub hub;
   
   public Notifications(string hubName, string listenConnectionString)
   {
       hub = new NotificationHub(hubName, listenConnectionString);
   }
   
   public async Task<Registration> StoreCategoriesAndSubscribe(IEnumerable<string> categories)
   {
       ApplicationData.Current.LocalSettings.Values["categories"] = string.Join(",", categories);
       return await SubscribeToCategories(categories);
   }
   
   public IEnumerable<string> RetrieveCategories()
   {
       var categories = (string) ApplicationData.Current.LocalSettings.Values["categories"];
       return categories != null ? categories.Split(','): new string[0];
   }
   
   public async Task<Registration> SubscribeToCategories(IEnumerable<string> categories = null)
   {
       var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
   
       if (categories == null)
       {
           categories = RetrieveCategories();
       }
   
       // Using a template registration to support notifications across platforms.
       // Any template notifications that contain messageParam and a corresponding tag expression
       // will be delivered for this registration.
   
       const string templateBodyWNS = "<toast><visual><binding template=\"ToastText01\"><text id=\"1\">$(messageParam)</text></binding></visual></toast>";
   
       return await hub.RegisterTemplateAsync(channel.Uri, templateBodyWNS, "simpleWNSTemplateExample",
               categories);
   }
   

   Ta klasa używa magazynu lokalnego do przechowywania kategorii wiadomości, które mają być odbierane przez to urządzenie. Zamiast wywoływać metodę RegisterNativeAsync, wywołaj metodę RegisterTemplateAsync, aby przeprowadzić rejestrację na potrzeby kategorii przy użyciu rejestracji szablonu.

   Jeśli chcesz zarejestrować więcej niż jeden szablon, podaj nazwę szablonu, na przykład simpleWNSTemplateExample. Nadaj nazwy szablonom, aby można było je aktualizować lub usuwać. Możesz zarejestrować więcej niż jeden szablon, aby mieć jeden dla wyskakujące powiadomienia i jeden dla kafelków.

   Uwaga

   W usłudze Notification Hubs urządzenie może zarejestrować wiele szablonów przy użyciu tego samego tagu. W takim przypadku przychodzący komunikat przeznaczony dla tagu powoduje dostarczenie wielu powiadomień do urządzenia — jeden dla każdego szablonu. Ten proces umożliwia wyświetlanie tego samego komunikatu w wielu powiadomieniach wizualnych, takich jak znaczek i wyskakujące powiadomienie w aplikacji ze Sklepu Windows.

   Aby uzyskać więcej informacji, zobacz Szablony.

5. W pliku projektu App.xaml.cs dodaj następującą właściwość do App klasy:

   public Notifications notifications = new Notifications("<hub name>", "<connection string with listen access>");
   

   Ta właściwość służy do tworzenia wystąpienia klasy Notifications i uzyskiwania do niego dostępu.

   W kodzie zamień symbole zastępcze <hub name> i <connection string with listen access> na uzyskane wcześniej wartości: nazwę centrum powiadomień i parametry połączenia DefaultListenSharedAccessSignature.

   Uwaga

   Ponieważ poświadczenia dystrybuowane przy użyciu aplikacji klienckiej nie są zazwyczaj zabezpieczone, przy użyciu aplikacji klienckiej dystrybuuj wyłącznie klucz dostępu do nasłuchiwania. Dostęp do nasłuchiwania umożliwia aplikacji rejestrowanie powiadomień, ale nie może ona modyfikować istniejących rejestracji ani wysyłać powiadomień. Klucz pełnego dostępu jest używany w zabezpieczonej usłudze zaplecza do wysyłania powiadomień oraz zmiany istniejących rejestracji.

6. W pliku MainPage.xaml.cs dodaj następujący wiersz:

   using Windows.UI.Popups;
   

7. W pliku MainPage.xaml.cs dodaj następującą metodę:

   private async void SubscribeButton_Click(object sender, RoutedEventArgs e)
   {
       var categories = new HashSet<string>();
       if (WorldToggle.IsOn) categories.Add("World");
       if (PoliticsToggle.IsOn) categories.Add("Politics");
       if (BusinessToggle.IsOn) categories.Add("Business");
       if (TechnologyToggle.IsOn) categories.Add("Technology");
       if (ScienceToggle.IsOn) categories.Add("Science");
       if (SportsToggle.IsOn) categories.Add("Sports");
   
       var result = await ((App)Application.Current).notifications.StoreCategoriesAndSubscribe(categories);
   
       var dialog = new MessageDialog("Subscribed to: " + string.Join(",", categories) + " on registration Id: " + result.RegistrationId);
       dialog.Commands.Add(new UICommand("OK"));
       await dialog.ShowAsync();
   }
   

   Ta metoda tworzy listę kategorii i używa klasy Notifications do przechowywania listy w magazynie lokalnym. Ponadto rejestruje ona odpowiednie tagi w centrum powiadomień. Po zmianie kategorii rejestracja zostanie ponownie utworzona przy użyciu nowych kategorii.

Aplikacja może teraz przechowywać zestaw kategorii w magazynie lokalnym na urządzeniu. Aplikacja rejestruje się w centrum powiadomień za każdym razem, gdy użytkownik zmieni wybór kategorii.

Rejestrowanie do otrzymywania powiadomień

W tej sekcji rejestrujesz się w centrum powiadomień przy uruchamianiu przy użyciu kategorii przechowywanych w magazynie lokalnym.

1. Aby użyć notifications klasy do subskrybowania na podstawie kategorii, otwórz plik App.xaml.cs , a następnie zaktualizuj metodę InitNotificationsAsync .

   // *** Remove or comment out these lines ***
   //var channel = await PushNotificationChannelManager.CreatePushNotificationChannelForApplicationAsync();
   //var hub = new NotificationHub("your hub name", "your listen connection string");
   //var result = await hub.RegisterNativeAsync(channel.Uri);
   
   var result = await notifications.SubscribeToCategories();
   

   Ten proces gwarantuje, że po uruchomieniu aplikacji pobiera kategorie z magazynu lokalnego. Następnie żąda rejestracji tych kategorii. Metoda została utworzona InitNotificationsAsync w ramach samouczka Wysyłanie powiadomień do platforma uniwersalna systemu Windows aplikacji przy użyciu usługi Azure Notification Hubs.

2. W pliku projektu MainPage.xaml.cs dodaj następujący kod do OnNavigatedTo metody:

   protected override void OnNavigatedTo(NavigationEventArgs e)
   {
       var categories = ((App)Application.Current).notifications.RetrieveCategories();
   
       if (categories.Contains("World")) WorldToggle.IsOn = true;
       if (categories.Contains("Politics")) PoliticsToggle.IsOn = true;
       if (categories.Contains("Business")) BusinessToggle.IsOn = true;
       if (categories.Contains("Technology")) TechnologyToggle.IsOn = true;
       if (categories.Contains("Science")) ScienceToggle.IsOn = true;
       if (categories.Contains("Sports")) SportsToggle.IsOn = true;
   }
   

   Ten kod aktualizuje stronę główną w oparciu o stan poprzednio zapisanych kategorii.

Aplikacja jest teraz ukończona. Może przechowywać zestaw kategorii w magazynie lokalnym urządzenia. Gdy użytkownicy zmieniają wybór kategorii, zapisane kategorie są używane do rejestrowania się w centrum powiadomień. W następnej sekcji zdefiniujesz zaplecze, które może wysyłać do tej aplikacji powiadomienia w odpowiednich kategoriach.

Uruchamianie aplikacji platformy UNIWERSALNEJ systemu Windows

1. W programie Visual Studio naciśnij klawisz F5, aby skompilować i uruchomić aplikację. Interfejs użytkownika aplikacji udostępnia zestaw przełączników pozwalających wybrać kategorie do zasubskrybowania.

   

2. Włącz co najmniej jeden przełączanie kategorii, a następnie wybierz pozycję Subskrybuj.

   Aplikacja konwertuje wybrane kategorie na tagi i żąda nowej rejestracji urządzenia dla wybranych tagów z centrum powiadomień. Aplikacja wyświetla zarejestrowane kategorie w oknie dialogowym.

   

Tworzenie aplikacji konsolowej do wysyłania otagowanych powiadomień

W tej sekcji wyślesz najważniejsze wiadomości w formie oznaczonych tagami powiadomień szablonu z aplikacji konsoli .NET.

1. W programie Visual Studio utwórz nową aplikację konsoli języka Visual C#:

   1. W menu wybierz pozycję Plik>nowy>projekt.
   2. W obszarze Utwórz nowy projekt wybierz pozycję Aplikacja konsolowa (.NET Framework) dla języka C# na liście szablonów, a następnie wybierz pozycję Dalej.
   3. wprowadź nazwę aplikacji.
   4. W polu Rozwiązanie wybierz pozycję Dodaj do rozwiązania, a następnie wybierz pozycję Utwórz , aby utworzyć projekt.

2. Wybierz pozycję Narzędzia> Menedżerapakietów NuGetKonsola menedżera> pakietów, a następnie w oknie konsoli uruchom następujące polecenie:

   Install-Package Microsoft.Azure.NotificationHubs
   

   Ta akcja dodaje odwołanie do zestawu SDK usługi Azure Notification Hubs przy użyciu pakietu Microsoft.Azure.NotificationHubs .

3. Otwórz plik Program.cs i dodaj następującą using instrukcję:

   using Microsoft.Azure.NotificationHubs;
   

4. W klasie Program dodaj następującą metodę lub zastąp ją, jeśli już istnieje:

   private static async void SendTemplateNotificationAsync()
   {
       // Define the notification hub.
       NotificationHubClient hub = NotificationHubClient.CreateClientFromConnectionString("<connection string with full access>", "<hub name>");
   
       // Apple requires the apns-push-type header for all requests
       var headers = new Dictionary<string, string> {{"apns-push-type", "alert"}};
   
       // Create an array of breaking news categories.
       var categories = new string[] { "World", "Politics", "Business", "Technology", "Science", "Sports"};
   
       // Send the notification as a template notification. All template registrations that contain
       // "messageParam" and the proper tags will receive the notifications.
       // This includes APNS, GCM/FCM, WNS, and MPNS template registrations.
   
       Dictionary<string, string> templateParams = new Dictionary<string, string>();
   
       foreach (var category in categories)
       {
           templateParams["messageParam"] = "Breaking " + category + " News!";
           await hub.SendTemplateNotificationAsync(templateParams, category);
       }
   }
   

   Ten kod wysyła powiadomienie szablonu dla każdego z sześciu tagów w tablicy ciągów. Użycie tagów pozwala zagwarantować, że urządzenia otrzymają powiadomienia tylko dla zarejestrowanych kategorii.

5. W poprzednim kodzie zastąp symbole zastępcze <hub name> i <connection string with full access> wartościami: nazwą centrum powiadomień i parametrami połączenia DefaultFullSharedAccessSignature z pulpitu nawigacyjnego centrum powiadomień.

6. W metodzie Main() dodaj następujące wiersze:

    SendTemplateNotificationAsync();
    Console.ReadLine();
   

7. Skompiluj aplikację konsoli.

Uruchamianie aplikacji konsolowej w celu wysyłania otagowanych powiadomień

Uruchom aplikację utworzoną w poprzedniej sekcji. Powiadomienia dla wybranych kategorii będą wyświetlane jako powiadomienia wyskakujące.

Następne kroki

W tym artykule przedstawiono sposób rozgłaszania ważnych wiadomości według kategorii. Aplikacja zaplecza wypycha otagowane powiadomienia do urządzeń zarejestrowanych w celu odbierania powiadomień dla tego tagu. Aby dowiedzieć się, jak wypychać powiadomienia do określonych użytkowników niezależnie od używanego urządzenia, przejdź do następującego samouczka: